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 Identity GetUserIdentity(Account githubUser)
{
if (string.IsNullOrWhiteSpace(githubUser?.Name))
{
_logger.Terse("GitHub user name missing from profile, falling back to .gitconfig");
return(null);
}
if (string.IsNullOrWhiteSpace(githubUser?.Email))
{
_logger.Terse("GitHub public email missing from profile, falling back to .gitconfig");
return(null);
}
return(new Identity(githubUser.Name, githubUser.Email));
}
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);
}
public async Task ApplyAnUpdate(
IReadOnlyCollection <PackageUpdateSet> updates,
NuGetSources sources)
{
if (!updates.Any())
{
return;
}
var filtered = await _selection
.Filter(updates, p => Task.FromResult(true));
if (!filtered.Any())
{
_logger.Verbose("All updates were filtered out");
return;
}
var candidate = filtered.First();
var reporter = new ConsoleReporter();
_logger.Terse("Updating " + reporter.Describe(candidate));
await _updateRunner.Update(candidate, sources);
}
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);
}
}
private void Visit(SortItemData item)
{
if (_cycleFound)
{
return;
}
if (item.Mark == Mark.Permanent)
{
return;
}
if (item.Mark == Mark.Temporary)
{
_logger.Terse($"Cannot sort packages by dependencies, cycle found at package {item.PackageId}");
_cycleFound = true;
return;
}
item.Mark = Mark.Temporary;
var nodesDependedOn = item.Dependencies
.Select(dep => _data.FirstOrDefault(i => i.PackageId == dep.Id))
.Where(dep => dep != null);
foreach (var dep in nodesDependedOn)
{
Visit(dep);
}
item.Mark = Mark.Permanent;
_sortedList.Add(item.PackageUpdateSet);
}
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 static void Log(this INuKeeperLogger logger, LogData data)
{
if (!string.IsNullOrWhiteSpace(data.Terse))
{
logger.Terse(data.Terse);
}
if (!string.IsNullOrWhiteSpace(data.Info))
{
logger.Info(data.Info);
}
}
public async Task <int> Run(IGitDriver git, RepositoryData repository)
{
GitInit(git, repository);
var sources = _nugetSourcesReader.Read(git.WorkingFolder, _settings.NuGetSources);
var updates = await _updateFinder.FindPackageUpdateSets(
git.WorkingFolder, sources, _settings.AllowedChange);
_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(0);
default:
throw new Exception($"Unknown report mode: '{_settings.ReportMode}'");
}
if (updates.Count == 0)
{
_logger.Terse("No potential updates found. Well done. Exiting.");
return(0);
}
var targetUpdates = await _updateSelection.SelectTargets(repository.Push, updates);
return(await DoTargetUpdates(git, repository, targetUpdates, sources));
}
public IReadOnlyCollection <FileInfo> Find(string pattern)
{
try
{
return(_root
.EnumerateFiles(pattern, SearchOption.AllDirectories)
.ToList());
}
catch (Exception ex)
{
_logger.Terse(ex.Message);
return(new List <FileInfo>());
}
}
private void LogPackageCounts(int potential, int filtered, int capped)
{
var message = $"Selection of package updates: {potential} potential";
if (filtered < potential)
{
message += $", filtered to {filtered}";
}
if (capped < filtered)
{
message += $", capped at {capped}";
}
_logger.Terse(message);
}
private void LogPackageCounts(int candidates, int filtered, int capped)
{
var message = $"Selection of package updates: {candidates} candiates";
if (filtered < candidates)
{
message += $", filtered to {filtered}";
}
if (capped < filtered)
{
message += $", capped at {capped}";
}
_logger.Terse(message);
}
public async Task <bool> MakeUpdatePullRequest(
IGitDriver git,
PackageUpdateSet updateSet,
NuGetSources sources,
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 _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);
git.Checkout(repository.DefaultBranch);
return(true);
}
catch (Exception ex)
{
_logger.Error("Update failed", ex);
return(false);
}
}
public void LogInformationSummary(string data) => _logger.Terse(data);