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 <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 Identity GetUserIdentity(User user)
{
if (string.IsNullOrWhiteSpace(user?.Name))
{
_logger.Minimal("User name missing from profile, falling back to .gitconfig");
return(null);
}
if (string.IsNullOrWhiteSpace(user?.Email))
{
_logger.Minimal("Email missing from profile, falling back to .gitconfig");
return(null);
}
return(new Identity(user.Name, user.Email));
}
private Identity GetUserIdentity(Account githubUser)
{
if (string.IsNullOrWhiteSpace(githubUser?.Name))
{
_logger.Minimal("GitHub user name missing from profile, falling back to .gitconfig");
return(null);
}
if (string.IsNullOrWhiteSpace(githubUser?.Email))
{
_logger.Minimal("GitHub public email missing from profile, falling back to .gitconfig");
return(null);
}
return(new Identity(githubUser.Name, githubUser.Email));
}
private void Visit(SortItemData item)
{
if (_cycleFound)
{
return;
}
if (item.Mark == Mark.Permanent)
{
return;
}
if (item.Mark == Mark.Temporary)
{
_logger.Minimal($"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 ApplyAnUpdate(
IReadOnlyCollection <PackageUpdateSet> updates,
NuGetSources sources)
{
if (!updates.Any())
{
return;
}
var filtered = await _selection
.Filter(updates, p => Task.FromResult(true));
if (!filtered.Any())
{
_logger.Detailed("All updates were filtered out");
return;
}
var candidate = filtered.First();
var reporter = new ConsoleReporter();
_logger.Minimal("Updating " + reporter.Describe(candidate));
await _updateRunner.Update(candidate, sources);
}
private void Visit(SortItemData <T> item)
{
if (_cycleFound)
{
return;
}
if (item.Mark == Mark.Permanent)
{
return;
}
if (item.Mark == Mark.Temporary)
{
_logger.Minimal($"Cannot sort by dependencies, cycle found at item {item}");
_cycleFound = true;
return;
}
item.Mark = Mark.Temporary;
foreach (var dep in NodesDependedOn(item))
{
Visit(dep);
}
item.Mark = Mark.Permanent;
_sortedList.Add(item.Item);
}
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 ApplyUpdates(IReadOnlyCollection <PackageUpdateSet> updates, IFolder workingFolder, NuGetSources sources)
{
await _solutionsRestore.CheckRestore(updates, workingFolder, sources);
foreach (var update in updates)
{
_logger.Minimal("Updating " + Description.ForUpdateSet(update));
await _updateRunner.Update(update, sources);
}
}
private async Task ApplyUpdates(IReadOnlyCollection <PackageUpdateSet> updates, IFolder workingFolder, NuGetSources sources)
{
await _solutionsRestore.CheckRestore(updates, workingFolder, sources);
foreach (var update in updates)
{
var reporter = new ConsoleReporter();
_logger.Minimal("Updating " + reporter.Describe(update));
await _updateRunner.Update(update, sources);
}
}
public static void Log(this INuKeeperLogger logger, LogData data)
{
if (!string.IsNullOrWhiteSpace(data.Terse))
{
logger.Minimal(data.Terse);
}
if (!string.IsNullOrWhiteSpace(data.Info))
{
logger.Normal(data.Info);
}
}
public IReadOnlyCollection <FileInfo> Find(string pattern)
{
try
{
return(_root
.EnumerateFiles(pattern, SearchOption.AllDirectories)
.ToList());
}
catch (Exception ex)
{
_logger.Minimal(ex.Message);
return(new List <FileInfo>());
}
}
public IReadOnlyCollection <IFile> Find(string pattern)
{
try
{
return(_root
.EnumerateFiles(pattern, SearchOption.AllDirectories)
.Select(f => new FileOnDisk(f))
.ToList());
}
catch (IOException ex)
{
_logger.Minimal(ex.Message);
return(new List <IFile>());
}
}
private void LogPackageCounts(int candidates, int filtered, int capped)
{
var message = $"Selection of package updates: {candidates} candidates";
if (filtered < candidates)
{
message += $", filtered to {filtered}";
}
if (capped < filtered)
{
message += $", capped at {capped}";
}
_logger.Minimal(message);
}
public static void Log(this INuKeeperLogger logger, LogData data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (!string.IsNullOrWhiteSpace(data.Terse))
{
logger.Minimal(data.Terse);
}
if (!string.IsNullOrWhiteSpace(data.Info))
{
logger.Normal(data.Info);
}
}
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);
}
}