/// <summary> /// Translates the specified <see cref="DependencyVersion" /> to a <see cref="string"/>. /// </summary> /// <param name="source">The source <see cref="DependencyVersion" />.</param> /// <returns> /// Returns the corresponding <see cref="SqlServerVersions"/>. /// </returns> /// <exception cref="VersionNotRecognizedException">Happens when the specified <see cref="DependencyVersion"/> is not supported.</exception> public string Translate(DependencyVersion source) { switch (source.Major) { case 7: return(SqlServerVersions.SqlServer7.ToString()); case 8: return(SqlServerVersions.SqlServer2000.ToString()); case 9: return(SqlServerVersions.SqlServer2005.ToString()); case 10: if (source.Minor == 0) { return(SqlServerVersions.SqlServer2008.ToString()); } else if (source.Minor == 50) { return(SqlServerVersions.SqlServer2008R2.ToString()); } break; case 11: return(SqlServerVersions.SqlServer2012.ToString()); case 12: return(SqlServerVersions.SqlServer2014.ToString()); case 13: return(SqlServerVersions.SqlServer2016.ToString()); } throw new VersionNotRecognizedException(source.ToString(), $"{SupportedDependencies.SqlServer}: DependencyVersion ({source.ToString()}) not supported!"); }
/// <summary> /// Gets the versions. /// </summary> /// <returns> /// Returns an enumerable with the MongoDb versions. /// </returns> /// <exception cref="NAMEException">Thrown when an unexpected exception happens.</exception> public override async Task <IEnumerable <DependencyVersion> > GetVersions() { var versions = new List <DependencyVersion>(); string connectionString; if (!this.connectionStringProvider.TryGetConnectionString(out connectionString)) { throw new ConnectionStringNotFoundException(this.connectionStringProvider.ToString()); } var connectionStringBuilder = new MongoConnectionStringBuilder(connectionString); byte[] message = this.CreateServerStatusMessagePayload(connectionStringBuilder); foreach (var mongoEndpoint in connectionStringBuilder.Servers) { using (var client = await this.OpenTcpClient(mongoEndpoint.Host, mongoEndpoint.Port, SupportedDependencies.MongoDb.ToString())) { await client.GetStream().WriteAsync(message, 0, message.Length, default(CancellationToken)).ConfigureAwait(false); await Task.Delay(100).ConfigureAwait(false); BSONObject obj = ExtractServerStatusFromResponse(client); versions.Add(DependencyVersion.Parse(obj["version"].stringValue)); } } return(versions); }
public InstallWalker(IPackageRepository localRepository, IPackageRepository sourceRepository, IPackageConstraintProvider constraintProvider, FrameworkName targetFramework, ILogger logger, bool ignoreDependencies, bool allowPrereleaseVersions, DependencyVersion dependencyVersion) : base(targetFramework) { if (sourceRepository == null) { throw new ArgumentNullException("sourceRepository"); } if (localRepository == null) { throw new ArgumentNullException("localRepository"); } if (logger == null) { throw new ArgumentNullException("logger"); } Repository = localRepository; Logger = logger; SourceRepository = sourceRepository; _ignoreDependencies = ignoreDependencies; ConstraintProvider = constraintProvider; _operations = new OperationLookup(); _allowPrereleaseVersions = allowPrereleaseVersions; DependencyVersion = dependencyVersion; CheckDowngrade = true; }
public void Parse_InvalidVersions(string version) { Assert.Throws <VersionParsingException>(() => { DependencyVersion.Parse(version); }); }
/// <summary> /// Parses a dependency from the feed in the format: /// id or id:versionSpec, or id:versionSpec:targetFramework /// </summary> private static Tuple <string, DependencyVersion, string> ParseDependency(string value) { if (String.IsNullOrWhiteSpace(value)) { return(null); } // IMPORTANT: Do not pass StringSplitOptions.RemoveEmptyEntries to this method, because it will break // if the version spec is null, for in that case, the Dependencies string sent down is "<id>::<target framework>". // We do want to preserve the second empty element after the split. string[] tokens = value.Trim().Split(new[] { ':' }); if (tokens.Length == 0) { return(null); } // Trim the id string id = tokens[0].Trim(); // Parse the dependency version DependencyVersion depVer = new DependencyVersion(); if (tokens.Length > 1) { // Parse the version depVer = DependencyVersion.ParseDependencyVersion(tokens[1]); } // Get the target framework, returns empty string if none exists. var targetFramework = (tokens.Length > 2 && !String.IsNullOrEmpty(tokens[2])) ? tokens[2] : String.Empty; return(Tuple.Create(id, depVer, targetFramework)); }
public void Translate_WindowsVersions(WindowsVersions version, string expectedVersion) { IVersionTranslator translator = new WindowsVersionTranslator(); DependencyVersion v = translator.Translate(version.ToString()); Assert.True(v >= DependencyVersionParser.Parse(expectedVersion, false)); }
public void Translate_SqlServerVersions(SqlServerVersions version, string expectedVersion) { IVersionTranslator translator = new SqlServerVersionTranslator(); DependencyVersion v = translator.Translate(version.ToString()); Assert.True(v >= DependencyVersion.Parse(expectedVersion)); }
public void Translate_Versions(SqlServerVersions exptectedVersion, string versionStr) { IVersionTranslator translator = new SqlServerVersionTranslator(); string v = translator.Translate(DependencyVersion.Parse(versionStr)); Assert.True(v == exptectedVersion.ToString()); }
// this ctor is used for unit tests internal InstallWalker(IPackageRepository localRepository, IPackageRepository sourceRepository, ILogger logger, bool ignoreDependencies, bool allowPrereleaseVersions, DependencyVersion dependencyVersion) : this(localRepository, sourceRepository, null, logger, ignoreDependencies, allowPrereleaseVersions, dependencyVersion) { }
public async Task GetVersions_SpecificVersion_UriWithQueryString() { MongoDbVersionResolver resolver = new MongoDbVersionResolver(new StaticConnectionStringProvider($"mongodb://{ Constants.SpecificMongoHostname }:27017/?w=1"), 10000, 10000); var versions = await resolver.GetVersions().ConfigureAwait(false); Assert.Equal(1, versions.Count()); Assert.Equal(versions.First(), DependencyVersion.Parse(Constants.SpecificMongoVersion)); }
public async Task GetVersions_LatestVersion() { MongoDbVersionResolver resolver = new MongoDbVersionResolver(new StaticConnectionStringProvider($"mongodb://{ Constants.LatestMongoHostname }:27017"), 10000, 10000); var versions = await resolver.GetVersions().ConfigureAwait(false); Assert.Equal(1, versions.Count()); Assert.True(versions.First() >= DependencyVersion.Parse("3.0.0")); }
public async Task GetVersions_LatestVersion() { string connectionString = $"amqp://*****:*****@{ Constants.LatestRabbitHostname }:5672/"; IVersionResolver resolver = new RabbitMqVersionResolver(new StaticConnectionStringProvider(connectionString), 10000, 10000); var versions = await resolver.GetVersions().ConfigureAwait(false); Assert.Equal(1, versions.Count()); Assert.True(versions.First() >= DependencyVersion.Parse("3.6.5")); }
/// <summary> /// Initializes a new instance of the <see cref="BootstrapDTOValidator"/> class. /// </summary> public BootstrapDTOValidator() { this.RuleFor(x => x.SupportedProtocols).NotNull(); this.RuleFor(x => x.Hostname).NotEmpty(); this.RuleFor(x => x.NAMEEndpoint).NotEmpty(); this.RuleFor(x => x.NAMEPort).Must(p => p == null || p > 0u); this.RuleFor(x => x.AppVersion).Must(v => DependencyVersion.TryParse(v, out var version)).WithMessage("Version is not valid."); this.RuleFor(x => x.NAMEVersion).Must(v => DependencyVersion.TryParse(v, out var version)).WithMessage("Version is not valid."); this.RuleForEach(x => x.SupportedProtocols).GreaterThan(0u); }
public void ProcessRecord_DependencyVersionNotSett_DependencyVersionSetToLowestWhenInstallingPackage() { CreateCmdletWithActivePackageSourceAndProject(); RunCmdlet(); DependencyVersion actualDependencyVersion = fakeProject.LastInstallPackageCreated.DependencyVersion; Assert.AreEqual(DependencyVersion.Lowest, actualDependencyVersion); }
public async Task GetVersions_SpecificPort() { string connectionString = $"Data Source={ Constants.LatestSqlServerHostname },1433;Initial Catalog=DBTests;Integrated Security=True;"; IVersionResolver resolver = new SqlServerVersionResolver(new StaticConnectionStringProvider(connectionString), 10000, 10000); var versions = await resolver.GetVersions().ConfigureAwait(false); Assert.Equal(1, versions.Count()); Assert.True(versions.First() >= DependencyVersion.Parse("12.0.0"), "The version should be greater than 12.0.0"); }
public async Task GetVersions_WrongEndpoint() { string connectionString = $"http://{ Constants.SpecificServiceHostname }:5000/api/v1"; IVersionResolver resolver = new ServiceVersionResolver(new StaticConnectionStringProvider(connectionString), 0, 5, 10000, 10000); var versions = await resolver.GetVersions().ConfigureAwait(false); Assert.Equal(1, versions.Count()); Assert.Equal(versions.First(), DependencyVersion.Parse(Constants.SpecificServiceVersion)); }
public async Task GetVersions_MultipleConnectionStrings() { string connectionString = $"amqp://*****:*****@{ Constants.SpecificRabbitHostname }:5672/, amqp://gibberish:notneeded@{ Constants.LatestRabbitHostname }:5672/"; IVersionResolver resolver = new RabbitMqVersionResolver(new StaticConnectionStringProvider(connectionString), 10000, 10000); var versions = await resolver.GetVersions().ConfigureAwait(false); Assert.Equal(2, versions.Count()); Assert.Equal(versions.First(), DependencyVersion.Parse(Constants.SpecificRabbitVersion)); }
public void Version_Operators() { var version = new DependencyVersion(3); Assert.True(version > new DependencyVersion(2)); Assert.True(version < new DependencyVersion(4)); Assert.True(version == new DependencyVersion(3)); Assert.True(version <= new DependencyVersion(4)); Assert.True(version <= new DependencyVersion(3)); Assert.True(version >= new DependencyVersion(2)); Assert.True(version >= new DependencyVersion(3)); }
public void Version_Operators() { var version = new DependencyVersion(3); Assert.True(version > new DependencyVersion(2)); Assert.True(version < new DependencyVersion(4)); Assert.True(version == new DependencyVersion(3)); Assert.True(version <= new DependencyVersion(4)); Assert.True(version <= new DependencyVersion(3)); Assert.True(version >= new DependencyVersion(2)); Assert.True(version >= new DependencyVersion(3)); //Assert.Equal(3, (int)parsedVersion.Major); //Assert.Equal(0, (int)parsedVersion.Minor); //Assert.Equal(0, (int)parsedVersion.Patch); }
public PackageDependency Make(dynamic jsonObject) { PackageDependency pd = new PackageDependency(); if (jsonObject.HasProperty("id")) { pd.Id = jsonObject.id; } if (jsonObject.HasProperty("range")) { pd.DependencyVersion = DependencyVersion.ParseDependencyVersion(jsonObject.range); } return(pd); }
/// <summary> /// Read the dependencies from xelement. Returns a list of dependencies /// </summary> /// <param name="containerElement"></param> /// <returns></returns> private static List <PackageDependency> ReadDependencies(XElement containerElement) { // list of dependency var dependencies = containerElement.ElementsNoNamespace("dependency"); return((from element in containerElement.ElementsNoNamespace("dependency") let idElement = element.Attribute("id") // Check that id is not null or empty where idElement != null && !String.IsNullOrEmpty(idElement.Value) // Project a PackageDependency based on that select new PackageDependency { Id = idElement.Value.SafeTrim(), DependencyVersion = DependencyVersion.ParseDependencyVersion(element.GetOptionalAttributeValue("version").SafeTrim()) }).ToList()); }
public async Task NpmApiTest(string endpoint, string package, string expected) { // arrange RegistryDto registry = new RegistryDto { Endpoint = endpoint, IsEnabled = true, IsPublic = true, Kind = EcosystemKind.Npm }; Dependency dependency = new Dependency { Name = package, Kind = EcosystemKind.Npm }; // act DependencyVersion latest = await sut.GetLatestMetaDataAsync(registry, dependency); // assert Assert.Equal(expected, latest.Version); }
public async Task DockerV2Api(string package, string expected) { // arrange RegistryDto registry = new RegistryDto { Endpoint = "https://nexus3.xpa.rbxd.ds/repository/pypi-group/", IsEnabled = true, IsPublic = false, Kind = EcosystemKind.PyPi }; Dependency dependency = new Dependency { Name = package, Id = Guid.NewGuid(), Kind = EcosystemKind.NuGet }; // act DependencyVersion latest = await sut.GetLatestMetaDataAsync(registry, dependency); // assert Assert.Equal(expected, latest.Version); }
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion) { IDependencyResolver dependencyResolver = _repo as IDependencyResolver; if (dependencyResolver != null) { return dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion); } return DependencyResolveUtility.ResolveDependencyCore( _repo, dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion); }
private OperatingSystemDependencyVersion HandleWindowsOperatingSystem() { #if NET45 return(new OperatingSystemDependencyVersion("windows", (uint)Environment.OSVersion.Version.Major, (uint)Environment.OSVersion.Version.Minor, (uint)Environment.OSVersion.Version.Build)); #else string osDescription = RuntimeInformation.OSDescription; string versionPortion = osDescription.Split(new char[] { ' ' }, options: StringSplitOptions.RemoveEmptyEntries).Last(); DependencyVersion version; if (!DependencyVersion.TryParse(versionPortion, out version)) { throw new NAMEException($"Windows: Was not able to extract the version from the OS description ({osDescription})."); } return(new OperatingSystemDependencyVersion("windows", version)); #endif }
public InstallWalker(IPackageRepository localRepository, IPackageRepository sourceRepository, FrameworkName targetFramework, ILogger logger, bool ignoreDependencies, bool allowPrereleaseVersions, DependencyVersion dependencyVersion) : this(localRepository, sourceRepository, constraintProvider: NullConstraintProvider.Instance, targetFramework: targetFramework, logger: logger, ignoreDependencies: ignoreDependencies, allowPrereleaseVersions: allowPrereleaseVersions, dependencyVersion: dependencyVersion) { }
public async Task DockerV2Api(string package, string expected) { // arrange RegistryDto registry = new RegistryDto { Endpoint = "https://registry-1.docker.io/v2/", IsEnabled = true, IsPublic = true, Kind = EcosystemKind.Docker }; Dependency dependency = new Dependency { Name = package, Id = Guid.NewGuid(), Kind = EcosystemKind.NuGet }; // act DependencyVersion latest = await sut.GetLatestMetaDataAsync(registry, dependency); // assert Assert.Equal(expected, latest.Version); }
public InstallWalker(IPackageRepository localRepository, IPackageRepository sourceRepository, FrameworkName targetFramework, ILogger logger, bool ignoreDependencies, bool allowPrereleaseVersions, DependencyVersion dependencyVersion) : this(localRepository, sourceRepository, constraintProvider : NullConstraintProvider.Instance, targetFramework : targetFramework, logger : logger, ignoreDependencies : ignoreDependencies, allowPrereleaseVersions : allowPrereleaseVersions, dependencyVersion : dependencyVersion) { }
/// <summary> /// Gets the dependant manifests. /// </summary> /// <param name="rootDependency">The root dependency.</param> /// <returns> /// . /// </returns> public async Task GetDependantManifests(DependencyVersion rootDependency) { if (rootDependency.ManifestNode == null) { return; } var nextHop = this.HopNumber + 1; if (nextHop == this.MaxHopCount) { return; } var dependencies = rootDependency.ManifestNode[ServiceDependenciesKey]; foreach (var dependency in dependencies.Children) { var dependencyUrl = dependency["value"].Value; // get the next manifest if (string.IsNullOrEmpty(dependencyUrl)) { continue; } var uri = new Uri(dependencyUrl); var endpoint = dependencyUrl.TrimEnd('/') + Constants.MANIFEST_ENDPOINT; try { var manifest = await this.GetManifest(endpoint, true, uri, nextHop); JsonNode manifestJsonNode = Json.Json.Parse(manifest); JsonNode infrastructureDependencies = manifestJsonNode[InfrastructureDependenciesKey]; JsonNode serviceDependencies = manifestJsonNode[ServiceDependenciesKey]; dependency.Add(InfrastructureDependenciesKey, infrastructureDependencies); dependency.Add(ServiceDependenciesKey, serviceDependencies); } catch (Exception e) { dependency["manifest"] = e.Message; } } }
/// <summary> /// From the list of packages <paramref name="packages"/>, selects the package that best /// matches the <paramref name="dependency"/>. /// </summary> /// <param name="packages">The list of packages.</param> /// <param name="dependency">The dependency used to select package from the list.</param> /// <param name="dependencyVersion">Indicates the method used to select dependency. /// Applicable only when dependency.VersionSpec is not null.</param> /// <returns>The selected package.</returns> private static IPackage ResolveDependencyCore( IEnumerable <IPackage> packages, PackageDependency dependency, DependencyVersion dependencyVersion) { // If version info was specified then use it if (dependency.VersionSpec != null) { packages = packages.FindByVersion(dependency.VersionSpec).OrderBy(p => p.Version); return(packages.SelectDependency(dependencyVersion)); } else { // BUG 840: If no version info was specified then pick the latest return(packages.OrderByDescending(p => p.Version) .FirstOrDefault()); } }
/// <summary> /// Tries to parse a <see cref="DependencyVersion" /> from the specified version string. /// </summary> /// <param name="version">The version.</param> /// <param name="acceptWildcards">if set to <c>true</c> the parsing will take into account wildcard parts and possibly return a <see cref="WildcardDependencyVersion"/>.</param> /// <param name="outVersion">The parsed version.</param> /// <returns> /// Returns true if the parsing was successfuly. Otherwise, returns false. /// </returns> /// <exception cref="NAMEException">The JSON returned from the service is not a valid manifest.</exception> public static bool TryParse(string version, bool acceptWildcards, out DependencyVersion outVersion) { outVersion = null; if (version == null) { return(false); } var parsedVersion = ParseVersion(version); if (parsedVersion == null) { outVersion = default(DependencyVersion); return(false); } if (!parsedVersion.Item1.HasValue || !parsedVersion.Item2.HasValue || !parsedVersion.Item3.HasValue) { if (acceptWildcards == false) { return(false); } if (!parsedVersion.Item1.HasValue) { outVersion = new WildcardDependencyVersion(); } else if (!parsedVersion.Item2.HasValue) { outVersion = new WildcardDependencyVersion(parsedVersion.Item1.Value); } else { outVersion = new WildcardDependencyVersion(parsedVersion.Item1.Value, parsedVersion.Item2.Value); } return(true); } outVersion = new DependencyVersion(parsedVersion.Item1.Value, parsedVersion.Item2.Value, parsedVersion.Item3.Value); return(true); }
/// <summary> /// Translates the specified <see cref="OperatingSystemDependencyVersion" /> to an object of type <see cref="WindowsVersions" />. /// </summary> /// <param name="source">The source <see cref="OperatingSystemDependencyVersion" />.</param> /// <returns> /// Returns an instance of type <see cref="WindowsVersions" />. /// </returns> /// <exception cref="VersionNotRecognizedException">Happens when the provided <see cref="OperatingSystemDependencyVersion"/> is not supported.</exception> public string Translate(DependencyVersion source) { //if (source.OperatingSystem != "windows") // throw new VersionNotRecognizedException(source.ToString(), $"Windows: Cannot translate the version ({source.ToString()}) to a WindowsVersions!"); if (source.Major == 6) { switch (source.Minor) { case 0: return(WindowsVersions.WindowsServer2008.ToString()); case 1: return(WindowsVersions.WindowsServer2008R2.ToString()); case 2: return(WindowsVersions.WindowsServer2012.ToString()); case 3: return(WindowsVersions.WindowsServer2012R2.ToString()); } } else if (source.Major == 5) { if (source.Minor == 1) { return(WindowsVersions.WindowsXP.ToString()); } else if (source.Minor == 2) { return(WindowsVersions.WindowsServer2003.ToString()); } } else if (source.Major == 10) { if (source.Minor == 0) { return(WindowsVersions.WindowsServer2016.ToString()); } } throw new VersionNotRecognizedException(source.ToString(), $"Windows: Version ({source.ToString()}) not supported!"); }
public static IPackage ResolveDependencyCore( IPackageRepository repository, PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion) { if (repository == null) { throw new ArgumentNullException("repository"); } if (dependency == null) { throw new ArgumentNullException("dependency"); } IEnumerable<IPackage> packages = repository.FindPackagesById(dependency.Id).ToList(); // Always filter by constraints when looking for dependencies packages = FilterPackagesByConstraints(constraintProvider, packages, dependency.Id, allowPrereleaseVersions); IList<IPackage> candidates = packages.ToList(); if (preferListedPackages) { // pick among Listed packages first IPackage listedSelectedPackage = ResolveDependencyCore( candidates.Where(PackageExtensions.IsListed), dependency, dependencyVersion); if (listedSelectedPackage != null) { return listedSelectedPackage; } } return ResolveDependencyCore(candidates, dependency, dependencyVersion); }
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion) { return DependencyResolveUtility.ResolveDependencyCore( new CoreInteropSourceRepository(_source), dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion); }
/// <summary> /// Parses a dependency from the feed in the format: /// id or id:versionSpec, or id:versionSpec:targetFramework /// </summary> private static Tuple<string, DependencyVersion, string> ParseDependency(string value) { if (String.IsNullOrWhiteSpace(value)) { return null; } // IMPORTANT: Do not pass StringSplitOptions.RemoveEmptyEntries to this method, because it will break // if the version spec is null, for in that case, the Dependencies string sent down is "<id>::<target framework>". // We do want to preserve the second empty element after the split. string[] tokens = value.Trim().Split(new[] { ':' }); if (tokens.Length == 0) { return null; } // Trim the id string id = tokens[0].Trim(); // Parse the dependency version DependencyVersion depVer = new DependencyVersion(); if (tokens.Length > 1) { // Parse the version depVer = DependencyVersion.ParseDependencyVersion(tokens[1]); } // Get the target framework, returns empty string if none exists. var targetFramework = (tokens.Length > 2 && !String.IsNullOrEmpty(tokens[2])) ? tokens[2] : String.Empty; return Tuple.Create(id, depVer, targetFramework); }
/// <summary> /// From the list of packages <paramref name="packages"/>, selects the package that best /// matches the <paramref name="dependency"/>. /// </summary> /// <param name="packages">The list of packages.</param> /// <param name="dependency">The dependency used to select package from the list.</param> /// <param name="dependencyVersion">Indicates the method used to select dependency. /// Applicable only when dependency.VersionSpec is not null.</param> /// <returns>The selected package.</returns> private static IPackage ResolveDependencyCore( IEnumerable<IPackage> packages, PackageDependency dependency, DependencyVersion dependencyVersion) { // If version info was specified then use it if (dependency.VersionSpec != null) { packages = packages.FindByVersion(dependency.VersionSpec).OrderBy(p => p.Version); return packages.SelectDependency(dependencyVersion); } else { // BUG 840: If no version info was specified then pick the latest return packages.OrderByDescending(p => p.Version) .FirstOrDefault(); } }
/// <summary> /// Get the update version for Dependent package, based on the specification of Highest, HighestMinor, HighestPatch and Lowest. /// </summary> /// <param name="repo"></param> /// <param name="identity"></param> /// <param name="updateVersion"></param> /// <param name="names"></param> /// <param name="allowPrerelease"></param> /// <param name="skip"></param> /// <param name="take"></param> /// <returns></returns> public static NuGetVersion GetUpdateVersionForDependentPackage(SourceRepository repo, PackageIdentity identity, DependencyVersion updateVersion, IEnumerable<FrameworkName> names, bool allowPrerelease, int skip = 0, int take = 30) { if (identity == null) { return null; } JObject package = GetJObjectForPackageId(repo, identity.Id, names, allowPrerelease, skip, take); IEnumerable<NuGetVersion> allVersions = GetAllVersionsForPackageId(package); // Find all versions that are higher than the package's current version allVersions = allVersions.Where(p => p > identity.Version).OrderByDescending(v => v); if (updateVersion == DependencyVersion.Lowest) { return allVersions.LastOrDefault(); } else if (updateVersion == DependencyVersion.Highest) { return allVersions.FirstOrDefault(); } else if (updateVersion == DependencyVersion.HighestPatch) { var groups = from p in allVersions group p by new { p.Version.Major, p.Version.Minor } into g orderby g.Key.Major, g.Key.Minor select g; return (from p in groups.First() orderby p.Version descending select p).FirstOrDefault(); } else if (updateVersion == DependencyVersion.HighestMinor) { var groups = from p in allVersions group p by new { p.Version.Major } into g orderby g.Key.Major select g; return (from p in groups.First() orderby p.Version descending select p).FirstOrDefault(); } throw new ArgumentOutOfRangeException("updateVersion"); }
public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion) { // Use the primary repository to look up dependencies. Fallback to the aggregate repository only if we can't find a package here. return _primaryRepository.ResolveDependency (dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion) ?? _dependencyResolver.ResolveDependency (dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion); }
public static IPackage ResolveDependency(object repository, PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion) { IDependencyResolver dependencyResolver = repository as IDependencyResolver; if (dependencyResolver != null) { return dependencyResolver.ResolveDependency(dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion); } return ResolveDependencyCore((IPackageRepository)repository, dependency, constraintProvider, allowPrereleaseVersions, preferListedPackages, dependencyVersion); }