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