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);
}
}
