public async Task UpdatePackageInProjects( IGitDriver git, PackageUpdateSet updateSet, RepositoryData repository) { try { _logger.Terse(UpdatesLogger.OldVersionsToBeUpdated(updateSet)); git.Checkout(repository.DefaultBranch); // branch var branchName = BranchNamer.MakeName(updateSet); _logger.Verbose($"Using branch name: '{branchName}'"); git.CheckoutNewBranch(branchName); await UpdateAllCurrentUsages(updateSet); var commitMessage = CommitWording.MakeCommitMessage(updateSet); git.Commit(commitMessage); git.Push("nukeeper_push", branchName); var prTitle = CommitWording.MakePullRequestTitle(updateSet); await MakeGitHubPullRequest(updateSet, repository, prTitle, branchName); git.Checkout(repository.DefaultBranch); } catch (Exception ex) { _logger.Error("Update failed", ex); } }
public async Task <int> Run( IGitDriver git, RepositoryData repository, SettingsContainer settings) { GitInit(git, repository); var userSettings = settings.UserSettings; var sources = _nugetSourcesReader.Read(git.WorkingFolder, userSettings.NuGetSources); var updates = await _updateFinder.FindPackageUpdateSets( git.WorkingFolder, sources, userSettings.AllowedChange); _reporter.Report( userSettings.OutputDestination, userSettings.OutputFormat, repository.Pull.Name, userSettings.OutputFileName, updates); if (updates.Count == 0) { _logger.Minimal("No potential updates found. Well done. Exiting."); return(0); } var targetUpdates = await _updateSelection.SelectTargets( repository.Push, updates, settings.PackageFilters); return(await DoTargetUpdates(git, repository, targetUpdates, sources, settings)); }
public async Task Run(IGitDriver git, RepositoryData repository) { GitInit(git, repository); var updates = await FindPackageUpdateSets(git); availableUpdatesReporter.Report(repository.Pull.Name, updates); if (updates.Count == 0) { _logger.Terse("No potential updates found. Well done. Exiting."); return; } var targetUpdates = _updateSelection.SelectTargets(git, updates); if (updates.Count == 0) { _logger.Terse("No updates can be applied. Exiting."); return; } await _solutionsRestore.Restore(git.WorkingFolder); await UpdateAllTargets(git, repository, targetUpdates); _logger.Info($"Done {targetUpdates.Count} Updates"); }
private async Task <(int UpdatesMade, bool?ThresholdReached)> DoTargetUpdates( IGitDriver git, RepositoryData repository, IReadOnlyCollection <PackageUpdateSet> targetUpdates, NuGetSources sources, SettingsContainer settings ) { if (targetUpdates.Count == 0) { return(0, null); } await _solutionRestore.CheckRestore(targetUpdates, settings.WorkingFolder ?? git.WorkingFolder, sources); var(updatesDone, thresholdReached) = await _packageUpdater.MakeUpdatePullRequests(git, repository, targetUpdates, sources, settings); if (updatesDone < targetUpdates.Count) { _logger.Minimal($"Attempted {targetUpdates.Count} updates and did {updatesDone}"); } else { _logger.Normal($"Done {updatesDone} updates"); } return(updatesDone, thresholdReached); }
public async Task <IReadOnlyCollection <PackageUpdateSet> > Filter(IGitDriver git, IReadOnlyCollection <PackageUpdateSet> updates, string baseBranch, string headBranch) { try { var filtered = new List <PackageUpdateSet>(); // commit messages are compared without whitespace because the system tends to add ws. var commitMessages = await git.GetNewCommitMessages(baseBranch, headBranch); var compactCommitMessages = commitMessages.Select(m => new string(m.Where(c => !char.IsWhiteSpace(c)).ToArray())); foreach (var update in updates) { var updateCommitMessage = _collaborationFactory.CommitWorder.MakeCommitMessage(update); var compactUpdateCommitMessage = new string(updateCommitMessage.Where(c => !char.IsWhiteSpace(c)).ToArray()); if (!compactCommitMessages.Contains(compactUpdateCommitMessage)) { filtered.Add(update); } } return(filtered); } #pragma warning disable CA1031 catch (Exception ex) #pragma warning restore CA1031 { _logger.Error($"Failed on existing Commit check for {baseBranch} <= {headBranch}", ex); return(updates); } }
private async Task <int> DoTargetUpdates( IGitDriver git, RepositoryData repository, IReadOnlyCollection <PackageUpdateSet> targetUpdates, NuGetSources sources) { if (targetUpdates.Count == 0) { _logger.Terse("No updates can be applied. Exiting."); return(0); } await _solutionsRestore.Restore(git.WorkingFolder, sources); var updatesDone = await UpdateAllTargets(git, repository, targetUpdates, sources); if (updatesDone < targetUpdates.Count) { _logger.Terse($"Attempted {targetUpdates.Count} updates and did {updatesDone}"); } else { _logger.Info($"Done {updatesDone} updates"); } return(updatesDone); }
public List <PackageUpdateSet> SelectTargets( IGitDriver git, IEnumerable <PackageUpdateSet> potentialUpdates) { var unfiltered = potentialUpdates .OrderByDescending(Priority) .ToList(); var filtered = unfiltered .Where(MatchesIncludeExclude) .Where(up => !HasExistingBranch(git, up)) .ToList(); var capped = filtered .Take(_maxPullRequests) .ToList(); _logger.Terse($"Selection of package updates: {unfiltered.Count} potential, filtered to {filtered.Count} and capped at {capped.Count}"); foreach (var updateSet in capped) { _logger.Info($"Selected package update of {updateSet.SelectedId} to {updateSet.SelectedVersion}"); } return(capped); }
private async Task <int> DoTargetUpdates( IGitDriver git, RepositoryData repository, IReadOnlyCollection <PackageUpdateSet> targetUpdates, NuGetSources sources, SettingsContainer settings) { if (targetUpdates.Count == 0) { _logger.Minimal("No updates can be applied. Exiting."); return(0); } await _solutionsRestore.CheckRestore(targetUpdates, settings.WorkingFolder ?? git.WorkingFolder, sources); var updatesDone = await _packageUpdater.MakeUpdatePullRequests(git, repository, targetUpdates, sources, settings); if (updatesDone < targetUpdates.Count) { _logger.Minimal($"Attempted {targetUpdates.Count} updates and did {updatesDone}"); } else { _logger.Normal($"Done {updatesDone} updates"); } return(updatesDone); }
public async Task <int> MakeUpdatePullRequests( IGitDriver git, RepositoryData repository, IReadOnlyCollection <PackageUpdateSet> updates, NuGetSources sources, SettingsContainer settings) { int totalCount = 0; try { var groups = UpdateConsolidator.Consolidate(updates, settings.UserSettings.ConsolidateUpdatesInSinglePullRequest); foreach (var updateSets in groups) { var updatesMade = await MakeUpdatePullRequests( git, repository, sources, settings, updateSets); totalCount += updatesMade; } } catch (Exception ex) { _logger.Error("Updates failed", ex); } return(totalCount); }
private async Task <int> MakeUpdatePullRequests( IGitDriver git, RepositoryData repository, NuGetSources sources, SettingsContainer settings, IReadOnlyCollection <PackageUpdateSet> updates) { _logger.Normal(UpdatesLogger.OldVersionsToBeUpdated(updates)); git.Checkout(repository.DefaultBranch); // branch var branchName = BranchNamer.MakeName(updates); _logger.Detailed($"Using branch name: '{branchName}'"); git.CheckoutNewBranch(branchName); foreach (var updateSet in updates) { await _updateRunner.Update(updateSet, sources); var commitMessage = CommitWording.MakeCommitMessage(updateSet); git.Commit(commitMessage); } git.Push("nukeeper_push", branchName); var title = CommitWording.MakePullRequestTitle(updates); var body = CommitWording.MakeCommitDetails(updates); await _gitHub.CreatePullRequest(repository, title, body, branchName, settings.SourceControlServerSettings.Labels); git.Checkout(repository.DefaultBranch); return(updates.Count); }
private static async Task GitInit(IGitDriver git, RepositoryData repository) { await git.Clone(repository.Pull.Uri, repository.DefaultBranch); repository.DefaultBranch = repository.DefaultBranch ?? await git.GetCurrentHead(); await git.AddRemote(repository.Remote, repository.Push.Uri); }
public async Task <int> Run( IGitDriver git, RepositoryData repository, SettingsContainer settings) { if (repository == null) { throw new ArgumentNullException(nameof(repository)); } if (git == null) { throw new ArgumentNullException(nameof(git)); } if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (!repository.IsLocalRepo) { await GitInit(git, repository); } var userSettings = settings.UserSettings; var sources = _nugetSourcesReader.Read(settings.WorkingFolder ?? git.WorkingFolder, userSettings.NuGetSources); var updates = await _updateFinder.FindPackageUpdateSets( settings.WorkingFolder ?? git.WorkingFolder, sources, userSettings.AllowedChange, userSettings.UsePrerelease, settings.PackageFilters?.Includes, settings.PackageFilters?.Excludes); _reporter.Report( userSettings.OutputDestination, userSettings.OutputFormat, repository.Pull.Name, userSettings.OutputFileName, updates); if (updates.Count == 0) { _logger.Minimal("No potential updates found. Well done. Exiting."); return(0); } var targetUpdates = _updateSelection.SelectTargets( repository.Push, updates, settings.PackageFilters); return(await DoTargetUpdates(git, repository, targetUpdates, sources, settings)); }
private async Task UpdateAllTargets(IGitDriver git, RepositoryData repository, IEnumerable <PackageUpdateSet> targetUpdates) { foreach (var updateSet in targetUpdates) { await _packageUpdater.UpdatePackageInProjects(git, updateSet, repository); } }
private async Task <int> MakeUpdatePullRequests( IGitDriver git, RepositoryData repository, NuGetSources sources, SettingsContainer settings, IReadOnlyCollection <PackageUpdateSet> updates) { _logger.Normal(UpdatesLogger.OldVersionsToBeUpdated(updates)); await git.Checkout(repository.DefaultBranch); // branch var branchWithChanges = BranchNamer.MakeName(updates, settings.BranchSettings.BranchNamePrefix); _logger.Detailed($"Using branch name: '{branchWithChanges}'"); await git.CheckoutNewBranch(branchWithChanges); foreach (var updateSet in updates) { await _updateRunner.Update(updateSet, sources); var commitMessage = _collaborationFactory.CommitWorder.MakeCommitMessage(updateSet); await git.Commit(commitMessage); } await git.Push(repository.Remote, branchWithChanges); var title = _collaborationFactory.CommitWorder.MakePullRequestTitle(updates); var body = _collaborationFactory.CommitWorder.MakeCommitDetails(updates); string qualifiedBranch; if (!repository.IsFork) //check if we are on a fork, if so qualify the branch name { qualifiedBranch = branchWithChanges; } else { qualifiedBranch = repository.Push.Owner + ":" + branchWithChanges; } var pullRequestRequest = new PullRequestRequest(qualifiedBranch, title, repository.DefaultBranch, settings.BranchSettings.DeleteBranchAfterMerge) { Body = body }; await _collaborationFactory.CollaborationPlatform.OpenPullRequest(repository.Pull, pullRequestRequest, settings.SourceControlServerSettings.Labels); await git.Checkout(repository.DefaultBranch); return(updates.Count); }
private async Task <List <PackageUpdateSet> > FindPackageUpdateSets(IGitDriver git) { // scan for nuget packages var packages = _repositoryScanner.FindAllNuGetPackages(git.WorkingFolder) .ToList(); _logger.Log(EngineReport.PackagesFound(packages)); // look for package updates var updates = await _packageLookup.FindUpdatesForPackages(packages); _logger.Log(EngineReport.UpdatesFound(updates)); return(updates); }
public async Task <int> MakeUpdatePullRequests( IGitDriver git, RepositoryData repository, IReadOnlyCollection <PackageUpdateSet> updates, NuGetSources sources, SettingsContainer settings) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (git == null) { throw new ArgumentNullException(nameof(git)); } if (repository == null) { throw new ArgumentNullException(nameof(repository)); } int totalCount = 0; try { var groups = UpdateConsolidator.Consolidate(updates, settings.UserSettings.ConsolidateUpdatesInSinglePullRequest); foreach (var updateSets in groups) { var updatesMade = await MakeUpdatePullRequests( git, repository, sources, settings, updateSets); totalCount += updatesMade; } } #pragma warning disable CA1031 catch (Exception ex) #pragma warning restore CA1031 { _logger.Error("Updates failed", ex); } return(totalCount); }
public async Task Run(IGitDriver git, RepositoryData repository) { GitInit(git, repository); var updates = await _updateFinder.FindPackageUpdateSets(git.WorkingFolder); _logger.Verbose($"Report mode is {_settings.ReportMode}"); switch (_settings.ReportMode) { case ReportMode.Off: break; case ReportMode.On: // report and continue _availableUpdatesReporter.Report(repository.Pull.Name, updates); break; case ReportMode.ReportOnly: // report and exit _availableUpdatesReporter.Report(repository.Pull.Name, updates); _logger.Info("Exiting after reports only"); return; default: throw new Exception($"Unknown report mode: '{_settings.ReportMode}'"); } if (updates.Count == 0) { _logger.Terse("No potential updates found. Well done. Exiting."); return; } var targetUpdates = await _updateSelection.SelectTargets(repository.Push, updates); if (updates.Count == 0) { _logger.Terse("No updates can be applied. Exiting."); return; } await _solutionsRestore.Restore(git.WorkingFolder); await UpdateAllTargets(git, repository, targetUpdates); _logger.Info($"Done {targetUpdates.Count} Updates"); }
public async Task <int> Run( IGitDriver git, RepositoryData repository, SettingsContainer settings) { GitInit(git, repository); var sources = _nugetSourcesReader.Read(git.WorkingFolder, settings.UserSettings.NuGetSources); var updates = await _updateFinder.FindPackageUpdateSets( git.WorkingFolder, sources, settings.UserSettings.AllowedChange); _logger.Detailed($"Report mode is {settings.UserSettings.ReportMode}"); switch (settings.UserSettings.ReportMode) { case ReportMode.Off: break; case ReportMode.On: // report and continue _availableUpdatesReporter.Report(repository.Pull.Name, updates); break; case ReportMode.ReportOnly: // report and exit _availableUpdatesReporter.Report(repository.Pull.Name, updates); _logger.Normal("Exiting after reports only"); return(0); default: throw new Exception($"Unknown report mode: '{settings.UserSettings.ReportMode}'"); } if (updates.Count == 0) { _logger.Minimal("No potential updates found. Well done. Exiting."); return(0); } var targetUpdates = await _updateSelection.SelectTargets( repository.Push, updates, settings.PackageFilters); return(await DoTargetUpdates(git, repository, targetUpdates, sources, settings)); }
private async Task <int> UpdateAllTargets(IGitDriver git, RepositoryData repository, IEnumerable <PackageUpdateSet> targetUpdates, NuGetSources sources) { var updatesDone = 0; foreach (var updateSet in targetUpdates) { var success = await _packageUpdater.MakeUpdatePullRequest(git, updateSet, sources, repository); if (success) { updatesDone++; } } return(updatesDone); }
public async Task <bool> MakeUpdatePullRequest( IGitDriver git, RepositoryData repository, PackageUpdateSet updateSet, NuGetSources sources, SourceControlServerSettings serverSettings) { try { _logger.Minimal(UpdatesLogger.OldVersionsToBeUpdated(updateSet)); git.Checkout(repository.DefaultBranch); // branch var branchName = BranchNamer.MakeName(updateSet); _logger.Detailed($"Using branch name: '{branchName}'"); git.CheckoutNewBranch(branchName); await _updateRunner.Update(updateSet, sources); var commitMessage = CommitWording.MakeCommitMessage(updateSet); git.Commit(commitMessage); git.Push("nukeeper_push", branchName); var prTitle = CommitWording.MakePullRequestTitle(updateSet); await MakeGitHubPullRequest(updateSet, repository, prTitle, branchName, serverSettings.Labels); git.Checkout(repository.DefaultBranch); return(true); } catch (Exception ex) { _logger.Error("Update failed", ex); return(false); } }
private static void GitInit(IGitDriver git, RepositoryData repository) { git.Clone(repository.Pull.Uri); repository.DefaultBranch = git.GetCurrentHead(); git.AddRemote(repository.Remote, repository.Push.Uri); }
private static bool HasExistingBranch(IGitDriver git, PackageUpdateSet packageUpdateSet) { var qualifiedBranchName = "origin/" + BranchNamer.MakeName(packageUpdateSet); return(git.BranchExists(qualifiedBranchName)); }
public async Task <(int UpdatesMade, bool ThresholdReached)> MakeUpdatePullRequests( IGitDriver git, RepositoryData repository, IReadOnlyCollection <PackageUpdateSet> updates, NuGetSources sources, SettingsContainer settings ) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (git == null) { throw new ArgumentNullException(nameof(git)); } if (repository == null) { throw new ArgumentNullException(nameof(repository)); } var openPrs = await _collaborationFactory.CollaborationPlatform.GetNumberOfOpenPullRequests( repository.Pull.Owner, repository.Pull.Name ); var allowedPrs = settings.UserSettings.MaxOpenPullRequests; if (openPrs >= allowedPrs) { _logger.Normal("Number of open pull requests equals or exceeds allowed number of open pull requests."); return(0, true); } int totalCount = 0; var groups = UpdateConsolidator.Consolidate(updates, settings.UserSettings.ConsolidateUpdatesInSinglePullRequest); foreach (var updateSets in groups) { var(updatesMade, pullRequestCreated) = await MakeUpdatePullRequests( git, repository, sources, settings, updateSets); totalCount += updatesMade; if (pullRequestCreated) { openPrs++; } if (openPrs == allowedPrs) { return(totalCount, true); } } return(totalCount, false); }
private async Task <int> MakeUpdatePullRequests( IGitDriver git, RepositoryData repository, NuGetSources sources, SettingsContainer settings, IReadOnlyCollection <PackageUpdateSet> updates) { _logger.Normal(UpdatesLogger.OldVersionsToBeUpdated(updates)); await git.Checkout(repository.DefaultBranch); // branch var branchWithChanges = BranchNamer.MakeName(updates, settings.BranchSettings.BranchNameTemplate); _logger.Detailed($"Using branch name: '{branchWithChanges}'"); var ditCheckOut = await git.CheckoutNewBranch(branchWithChanges); if (!ditCheckOut) { await git.CheckoutRemoteToLocal(branchWithChanges); } var filteredUpdates = await _existingCommitFilter.Filter(git, updates, repository.DefaultBranch, branchWithChanges); foreach (var filtered in updates.Where(u => !filteredUpdates.Contains(u))) { var commitMessage = _collaborationFactory.CommitWorder.MakeCommitMessage(filtered); _logger.Normal($"Commit '{commitMessage}' already in branch '{branchWithChanges}'"); } var haveUpdates = filteredUpdates.Any(); foreach (var updateSet in filteredUpdates) { var commitMessage = _collaborationFactory.CommitWorder.MakeCommitMessage(updateSet); await _updateRunner.Update(updateSet, sources); await git.Commit(commitMessage); } if (haveUpdates) { await git.Push(repository.Remote, branchWithChanges); string qualifiedBranch; if (!repository.IsFork) //check if we are on a fork, if so qualify the branch name { qualifiedBranch = branchWithChanges; } else { qualifiedBranch = repository.Push.Owner + ":" + branchWithChanges; } bool pullRequestExists = await _collaborationFactory.CollaborationPlatform.PullRequestExists(repository.Pull, qualifiedBranch, repository.DefaultBranch); if (!pullRequestExists) { var title = _collaborationFactory.CommitWorder.MakePullRequestTitle(updates); var body = _collaborationFactory.CommitWorder.MakeCommitDetails(updates); var pullRequestRequest = new PullRequestRequest(qualifiedBranch, title, repository.DefaultBranch, settings.BranchSettings.DeleteBranchAfterMerge) { Body = body }; await _collaborationFactory.CollaborationPlatform.OpenPullRequest(repository.Pull, pullRequestRequest, settings.SourceControlServerSettings.Labels); } else { _logger.Normal($"A pull request already exists for {repository.DefaultBranch} <= {qualifiedBranch}"); } } await git.Checkout(repository.DefaultBranch); return(filteredUpdates.Count); }
public async Task <int> Run(RepositorySettings repository, GitUsernamePasswordCredentials credentials, SettingsContainer settings, User user) { if (repository == null) { throw new ArgumentNullException(nameof(repository)); } if (credentials == null) { throw new ArgumentNullException(nameof(credentials)); } if (settings == null) { throw new ArgumentNullException(nameof(settings)); } DefaultCredentialServiceUtility.SetupDefaultCredentialService(_nugetLogger, true); var repositoryData = await BuildGitRepositorySpec(repository, credentials.Username); if (repositoryData == null) { return(0); } // should perform the remote check for "is this a .NET repo" // (and also not a github fork) // only when we have multiple remote repos // otherwise it's ok to work locally, and check there if (!(settings.SourceControlServerSettings.Scope == ServerScope.Repository || repository.IsLocalRepo)) { var remoteRepoContainsDotNet = await _repositoryFilter.ContainsDotNetProjects(repository); if (!remoteRepoContainsDotNet) { return(0); } } IFolder folder; if (repository.IsLocalRepo) { folder = new Folder(_logger, new DirectoryInfo(Uri.UnescapeDataString(repository.RemoteInfo.LocalRepositoryUri.AbsolutePath))); settings.WorkingFolder = new Folder(_logger, new DirectoryInfo(Uri.UnescapeDataString(repository.RemoteInfo.WorkingFolder.AbsolutePath))); repositoryData.IsLocalRepo = repository.IsLocalRepo; if (!repositoryData.IsFork) //check if we are on a fork. If not on a fork we set the remote to the locally found remote { repositoryData.Remote = repository.RemoteInfo.RemoteName; } } else { folder = !string.IsNullOrWhiteSpace(settings?.UserSettings?.Directory) ? _folderFactory.FolderFromPath(settings.UserSettings.Directory) : _folderFactory.UniqueTemporaryFolder(); settings.WorkingFolder = folder; } if (!string.IsNullOrEmpty(repository.RemoteInfo?.BranchName)) { repositoryData.DefaultBranch = repository.RemoteInfo.BranchName; } repositoryData.IsLocalRepo = repository.IsLocalRepo; IGitDriver git = string.IsNullOrWhiteSpace(settings?.UserSettings?.GitPath) ? new LibGit2SharpDriver(_logger, folder, credentials, user) as IGitDriver : new GitCmdDriver(settings.UserSettings.GitPath, _logger, folder, credentials) as IGitDriver; try { return(await _repositoryUpdater.Run(git, repositoryData, settings)); } finally { if (!repository.IsLocalRepo) { folder.TryDelete(); } } }
public async Task <int> Run(RepositorySettings repository, GitUsernamePasswordCredentials credentials, SettingsContainer settings, User user) { try { var repositoryData = await BuildGitRepositorySpec(repository, credentials.Username); if (repositoryData == null) { return(0); } // should perform the remote check for "is this a .NET repo" // (and also not a github fork) // only when we have multiple remote repos // otherwise it's ok to work locally, and check there if (!(settings.SourceControlServerSettings.Scope == ServerScope.Repository || repository.IsLocalRepo)) { var remoteRepoContainsDotNet = await _repositoryFilter.ContainsDotNetProjects(repository); if (!remoteRepoContainsDotNet) { return(0); } } IFolder folder; if (repository.IsLocalRepo) { folder = new Folder(_logger, new DirectoryInfo(repository.RemoteInfo.LocalRepositoryUri.AbsolutePath)); settings.WorkingFolder = new Folder(_logger, new DirectoryInfo(repository.RemoteInfo.WorkingFolder.AbsolutePath)); repositoryData.IsLocalRepo = repository.IsLocalRepo; if (!repositoryData.IsFork) //check if we are on a fork. If not on a fork we set the remote to the locally found remote { repositoryData.Remote = repository.RemoteInfo.RemoteName; } } else { folder = _folderFactory.UniqueTemporaryFolder(); settings.WorkingFolder = folder; } if (!string.IsNullOrEmpty(repository.RemoteInfo?.BranchName)) { repositoryData.DefaultBranch = repository.RemoteInfo.BranchName; } repositoryData.IsLocalRepo = repository.IsLocalRepo; IGitDriver git = string.IsNullOrWhiteSpace(settings?.UserSettings?.GitPath) ? new LibGit2SharpDriver(_logger, folder, credentials, user) as IGitDriver : new GitCmdDriver(settings.UserSettings.GitPath, _logger, folder, credentials) as IGitDriver; var updatesDone = await _repositoryUpdater.Run(git, repositoryData, settings); if (!repository.IsLocalRepo) { folder.TryDelete(); } return(updatesDone); } #pragma warning disable CA1031 catch (Exception ex) #pragma warning restore CA1031 { _logger.Error($"Failed on repo {repository.RepositoryName}", ex); return(1); } }