public void Report(PackageLookupResult lookupResult)
{
var highestVersion = lookupResult.Major?.Identity?.Version;
if (highestVersion == null)
{
return;
}
var allowing = lookupResult.AllowedChange == VersionChange.Major
? string.Empty
: $" Allowing {lookupResult.AllowedChange} version updates.";
var highestMatchVersion = lookupResult.Selected()?.Identity?.Version;
var packageId = lookupResult.Major.Identity.Id;
if (highestMatchVersion == null)
{
_logger.Info($"Package {packageId} version {highestVersion} is available but is not allowed.{allowing}");
return;
}
if (highestVersion > highestMatchVersion)
{
_logger.Info($"Selected update of package {packageId} to version {highestMatchVersion}, but version {highestVersion} is also available.{allowing}");
}
else
{
_logger.Verbose($"Selected update of package {packageId} to highest version, {highestMatchVersion}.{allowing}");
}
}
public async Task <IReadOnlyList <Repository> > GetRepositoriesForOrganisation(string organisationName)
{
var repos = await _client.Repository.GetAllForOrg(organisationName);
_logger.Info($"Read {repos.Count} repos for org '{organisationName}'");
return(repos);
}
public override void Log(ILogMessage message)
{
switch (message.Level)
{
case LogLevel.Verbose: _logger.Verbose(message.Message);
break;
case LogLevel.Debug: _logger.Verbose(message.Message);
break;
case LogLevel.Information: _logger.Verbose(message.Message);
break;
case LogLevel.Minimal: _logger.Info(message.Message);
break;
case LogLevel.Warning: _logger.Info(message.Message);
break;
case LogLevel.Error:
_logger.Error(message.Message);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task Invoke(FileInfo file, NuGetSources sources)
{
_logger.Info($"Nuget restore on {file.DirectoryName} {file.Name}");
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
_logger.Info("Cannot run NuGet.exe file restore as OS Platform is not Windows");
return;
}
var nuget = NuGetPath.FindExecutable();
if (string.IsNullOrWhiteSpace(nuget))
{
_logger.Info("Cannot find NuGet exe for solution restore");
return;
}
var sourcesCommandLine = sources.CommandLine("-Source");
var arguments = $"restore {file.Name} {sourcesCommandLine}";
_logger.Verbose($"{nuget} {arguments}");
var processOutput = await _externalProcess.Run(file.DirectoryName, nuget, arguments, ensureSuccess : false);
if (processOutput.Success)
{
_logger.Verbose($"Nuget restore on {file.Name} complete");
}
else
{
_logger.Verbose($"Nuget restore failed on {file.DirectoryName} {file.Name}:\n{processOutput.Output}\n{processOutput.ErrorOutput}");
}
}
public async Task Invoke(PackageInProject currentPackage,
NuGetVersion newVersion, PackageSource packageSource, NuGetSources allSources)
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
_logger.Info("Cannot run NuGet.exe package update as OS Platform is not Windows");
return;
}
var dirName = currentPackage.Path.Info.DirectoryName;
var nuget = NuGetPath.FindExecutable();
if (string.IsNullOrWhiteSpace(nuget))
{
_logger.Info("Cannot find NuGet exe for package update");
return;
}
var sources = allSources.CommandLine("-Source");
var arguments = $"update packages.config -Id {currentPackage.Id} -Version {newVersion} {sources}";
_logger.Verbose(arguments);
await _externalProcess.Run(dirName, nuget, arguments, true);
}
private PackageInProject XmlToPackage(XElement el, PackagePath path, XNamespace ns)
{
try
{
var id = el.Attribute("Include")?.Value;
var version = el.Attribute("Version")?.Value ?? el.Element(ns + "Version")?.Value;
if (string.IsNullOrWhiteSpace(version))
{
_logger.Info($"Skipping package '{id}' with no version specified.");
return(null);
}
var versionParseSuccess = NuGetVersion.TryParse(version, out var nugetVersion);
if (!versionParseSuccess)
{
_logger.Info($"Skipping package '{id}' with version '{version}' that could not be parsed.");
return(null);
}
return(new PackageInProject(new PackageIdentity(id, nugetVersion), path));
}
catch (Exception ex)
{
_logger.Error($"Could not read package from {el} in file {path.FullName}", ex);
return(null);
}
}
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");
}
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 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);
}
}
private async Task <ForkData> FindUserForkOrUpstream(string userName, ForkData pullFork)
{
var userFork = await TryFindUserFork(userName, pullFork);
if (userFork != null)
{
return(userFork);
}
// as a fallback, we want to pull and push from the same origin repo.
var canUseOriginRepo = await IsPushableRepo(pullFork);
if (canUseOriginRepo)
{
_logger.Info($"No fork for user {userName}. Using upstream fork for user {pullFork.Owner} at {pullFork.Uri}");
return(pullFork);
}
NoPushableForkFound(pullFork.Name);
return(null);
}
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 async Task <IReadOnlyList <Organization> > GetOrganizations()
{
var orgs = await _client.Organization.GetAll();
_logger.Info($"Read {orgs.Count} organisations");
return(orgs);
}
public void Clone(Uri pullEndpoint)
{
_logger.Info($"Git clone {pullEndpoint} to {WorkingFolder.FullPath}");
Repository.Clone(pullEndpoint.ToString(), WorkingFolder.FullPath,
new CloneOptions
{
CredentialsProvider = UsernamePasswordCredentials,
OnTransferProgress = OnTransferProgress
});
_logger.Verbose("Git clone complete");
}
private async Task <RepositoryData> BuildGitRepositorySpec(
RepositorySettings repository,
string userName)
{
var pullFork = new ForkData(repository.GithubUri, repository.RepositoryOwner, repository.RepositoryName);
var pushFork = await _forkFinder.FindPushFork(userName, pullFork);
if (pushFork == null)
{
_logger.Info($"No pushable fork found for {repository.GithubUri}");
return(null);
}
return(new RepositoryData(pullFork, pushFork));
}
public async Task <IReadOnlyCollection <PackageUpdateSet> > SelectTargets(
ForkData pushFork,
IReadOnlyCollection <PackageUpdateSet> potentialUpdates)
{
var sorted = _sort.Sort(potentialUpdates)
.ToList();
var filtered = await _updateSelection.Filter(sorted,
p => _existingBranchFilter.CanMakeBranchFor(p, pushFork));
foreach (var updateSet in filtered)
{
_logger.Info($"Selected package update of {updateSet.SelectedId} to {updateSet.SelectedVersion}");
}
return(filtered);
}
public async Task Invoke(FileInfo file)
{
_logger.Info($"Nuget restore on {file.DirectoryName} {file.Name}");
var nuget = NuGetPath.FindExecutable();
var sources = GetSourcesCommandLine(_sources);
var updateCommand = $"cd {file.DirectoryName} & {nuget} restore {file.Name} {sources}";
_logger.Verbose(updateCommand);
var processOutput = await _externalProcess.Run(updateCommand, ensureSuccess : false);
if (processOutput.Success)
{
_logger.Verbose($"Nuget restore on {file.Name} complete");
}
else
{
_logger.Verbose($"Restore failed on {file.DirectoryName} {file.Name}:\n{processOutput.Output}\n{processOutput.ErrorOutput}");
}
}
public async Task <List <PackageUpdateSet> > SelectTargets(
ForkData pushFork,
IEnumerable <PackageUpdateSet> potentialUpdates)
{
var unfiltered = PackageUpdateSort.Sort(potentialUpdates)
.ToList();
var filtered = await ApplyFilters(pushFork, unfiltered);
var capped = filtered
.Take(_maxPullRequests)
.ToList();
LogPackageCounts(unfiltered.Count, filtered.Count, capped.Count);
foreach (var updateSet in capped)
{
_logger.Info($"Selected package update of {updateSet.SelectedId} to {updateSet.SelectedVersion}");
}
return(capped);
}
public void LogMinimal(string data) => _logger.Info(data);