private static MyNugetPackage find_dependency_pacakge_using_http_request(MyNugetPackageDependency dependencyPkg, ChocolateyConfiguration configuration) { bool allowPreRelease = configuration.Prerelease; List <MyNugetPackage> totalFoundBestPkgs = new List <MyNugetPackage>(); foreach (string sourceUri in configuration.Sources.Split(';')) { bool isUriOk = Uri.IsWellFormedUriString(sourceUri.Trim(), UriKind.Absolute); if (!isUriOk) { "chocolatey".Log().Debug("Skipping search in unsupported source: '{0}' - Only WEB sources are supported for this command".format_with(sourceUri)); continue; } ChocolateyConfiguration tempConf = configuration.deep_copy(); tempConf.Sources = sourceUri.Trim(); string responseStr = query_for_package_using_http_request(dependencyPkg, tempConf); if (responseStr == null) { continue; } List <MyNugetPackage> foundPackagesList = parseHttpQueryPackageDetailsRequestResponse(dependencyPkg, responseStr); if (foundPackagesList.Count() == 0) { "chocolatey".Log().Debug("Failed to find any 'entry' child nodes of pkg: '{0}' in source: '{1}'".format_with(dependencyPkg.Id, sourceUri)); continue; } // Sort results based on their version so that higher is first foundPackagesList.Sort(delegate(MyNugetPackage x, MyNugetPackage y) { return(y.Version.CompareTo(x.Version)); }); MyNugetPackage bestMatchingPkg = foundPackagesList[0]; //Latest version found if (dependencyPkg.VersionSpec != null) // If want a specific version // Attempt to get the best matching package { bestMatchingPkg = getBestMatchingDependencyPkgFromList(foundPackagesList, dependencyPkg); } if (bestMatchingPkg == null) { "chocolatey".Log().Debug("Failed to determine best package from found 'entry' child nodes of pkg: '{0}' in source: '{1}'".format_with(dependencyPkg.Id, sourceUri)); continue; } totalFoundBestPkgs.Add(bestMatchingPkg); } if (totalFoundBestPkgs.Count() == 0) { "chocolatey".Log().Warn("Failed to find a dependency package '{0}' that satisfies version spec: {1}".format_with(dependencyPkg.Id, dependencyPkg.VersionSpec.ToString())); return(null); } // Sort results based on their version so that higher is first totalFoundBestPkgs.Sort(delegate(MyNugetPackage x, MyNugetPackage y) { return(y.Version.CompareTo(x.Version)); }); return(totalFoundBestPkgs[0]); }
public static void install_package(ChocolateyConfiguration config, string packageId, string version) { if (_service == null) { _service = NUnitSetup.Container.GetInstance <IChocolateyPackageService>(); } var installConfig = config.deep_copy(); installConfig.PackageNames = packageId; installConfig.Version = version; _service.install_run(installConfig); NUnitSetup.MockLogger.Messages.Clear(); }
private IEnumerable <ChocolateyConfiguration> get_packages_from_config(string packageConfigFile, ChocolateyConfiguration config, ConcurrentDictionary <string, PackageResult> packageInstalls) { IList <ChocolateyConfiguration> packageConfigs = new List <ChocolateyConfiguration>(); if (!_fileSystem.file_exists(_fileSystem.get_full_path(packageConfigFile))) { var logMessage = "Could not find '{0}' in the location specified.".format_with(packageConfigFile); this.Log().Error(ChocolateyLoggers.Important, logMessage); var results = packageInstalls.GetOrAdd(packageConfigFile, new PackageResult(packageConfigFile, null, null)); results.Messages.Add(new ResultMessage(ResultType.Error, logMessage)); return(packageConfigs); } var settings = _xmlService.deserialize <PackagesConfigFileSettings>(_fileSystem.get_full_path(packageConfigFile)); foreach (var pkgSettings in settings.Packages.or_empty_list_if_null()) { if (!pkgSettings.Disabled) { var packageConfig = config.deep_copy(); packageConfig.PackageNames = pkgSettings.Id; packageConfig.Sources = string.IsNullOrWhiteSpace(pkgSettings.Source) ? packageConfig.Sources : pkgSettings.Source; packageConfig.Version = pkgSettings.Version; packageConfig.InstallArguments = string.IsNullOrWhiteSpace(pkgSettings.InstallArguments) ? packageConfig.InstallArguments : pkgSettings.InstallArguments; packageConfig.PackageParameters = string.IsNullOrWhiteSpace(pkgSettings.PackageParameters) ? packageConfig.PackageParameters : pkgSettings.PackageParameters; if (pkgSettings.ForceX86) { packageConfig.ForceX86 = true; } if (pkgSettings.AllowMultipleVersions) { packageConfig.AllowMultipleVersions = true; } if (pkgSettings.IgnoreDependencies) { packageConfig.IgnoreDependencies = true; } packageConfigs.Add(packageConfig); } } return(packageConfigs); }
public virtual void set_pin(ChocolateyConfiguration config) { var addingAPin = config.PinCommand.Command == PinCommandType.add; var versionUnspecified = string.IsNullOrWhiteSpace(config.Version); List <IPackage> packages = new List <IPackage>(); // package exists in registry var confList = config.deep_copy(); confList.Input = confList.PinCommand.Name; confList.QuietOutput = true; packages = _packageService.list_run(confList).Select(x => x.Package).ToList(); if (packages.Count == 0) { throw new ApplicationException("Unable to find package named '{0}'{1} to pin. Please check to ensure it is installed.".format_with(config.PinCommand.Name, versionUnspecified ? "" : " (version '{0}')".format_with(config.Version))); } foreach (var package in packages) { var pkgInfo = _packageInfoService.get_package_information(package); bool changeMessage = pkgInfo.IsPinned != addingAPin; if (package is RegistryPackage regp) { regp.RegistryKey.IsPinned = addingAPin; _registryService.set_key_values(regp.RegistryKey, nameof(RegistryApplicationKey.IsPinned)); } else { pkgInfo.IsPinned = addingAPin; _packageInfoService.save_package_information(pkgInfo); } if (changeMessage) { this.Log().Warn("Successfully {0} a pin for {1} v{2}.".format_with(addingAPin ? "added" : "removed", pkgInfo.Package.Id, pkgInfo.Package.Version.to_string())); } else { this.Log().Warn(NO_CHANGE_MESSAGE); } } }
/// <summary> /// Parses command line. Instantiates command if not already instantiated. /// Cannot change command type without creating new instance of CommandContext /// </summary> /// <param name="cmdLine">command line to process</param> /// <param name="diffAtStart">true if configuration comparison starts from start of command line processing, false if after main /// command is executed</param> public IEnumerable <Option> ParseCommandLine2(string cmdLine, bool diffAtStart = false, bool logCalls = false) { var console = LogService.console; console.Info($"> {cmdLine}"); string[] args = ChocolateyOptionSet.SplitArgs(cmdLine); ChocolateyConfiguration config = new ChocolateyConfiguration(); parser = new ChocolateyOptionSet(); if (diffAtStart) { original = config.deep_copy(); } if (parser.Parse(args, new ChocolateyStartupCommand(), config, () => { console.Info("- logInit called."); } )) { console.Info("chocoArgsParse: return on startup"); return(parser); } parser = new ChocolateyOptionSet(); if (parser.Parse(args, new ChocolateyMainCommand(), config)) { console.Info("chocoArgsParse: return on main"); return(parser); } genericArgumentsCount = parser.Count; if (args.Length == 0) { "chocolatey".Log().Info(ChocolateyLoggers.Important, () => "Please run 'choco -?' or 'choco <command> -?' for help menu."); } InstantiateCommand(config.CommandName, logCalls); if (command == null) { return(parser.Skip(genericArgumentsCount)); } LogService.Instance.adjustLogLevels(config.Debug, config.Verbose, config.Trace); if (!diffAtStart) { original = config.deep_copy(); } string phase = "parse"; try { if (!parser.Parse(args.Skip(1), command, config)) { phase = "validation"; command.handle_validation(config); console.Info("config: " + config.CompareWith(original)); // GenericRunner.run logic, see after line: // var command = find_command(config, container, isConsole, parseArgs); if (config.Noop) { if (config.RegularOutput) { this.Log().Info("_ {0}:{1} - Noop Mode _".format_with(ApplicationParameters.Name, command.GetType().Name)); } command.noop(config); } else { this.Log().Debug("_ {0}:{1} - Normal Run Mode _".format_with(ApplicationParameters.Name, command.GetType().Name)); command.run(config); } } } catch (ApplicationException ex) { console.Info($"{phase} failure: " + ex.Message); } return(parser.Skip(genericArgumentsCount)); }