Example #1
0
        /// <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);
        }
Example #3
0
        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;
        }
Example #4
0
        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;
        }
Example #5
0
 public void Parse_InvalidVersions(string version)
 {
     Assert.Throws <VersionParsingException>(() =>
     {
         DependencyVersion.Parse(version);
     });
 }
Example #6
0
        /// <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));
        }
Example #7
0
        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());
        }
Example #10
0
 // 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"));
        }
Example #13
0
 // 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)
 {
 }
Example #14
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"));
        }
Example #15
0
 /// <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);
 }
Example #16
0
        public void ProcessRecord_DependencyVersionNotSett_DependencyVersionSetToLowestWhenInstallingPackage()
        {
            CreateCmdletWithActivePackageSourceAndProject();

            RunCmdlet();

            DependencyVersion actualDependencyVersion = fakeProject.LastInstallPackageCreated.DependencyVersion;

            Assert.AreEqual(DependencyVersion.Lowest, actualDependencyVersion);
        }
Example #17
0
        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");
        }
Example #18
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));
        }
Example #19
0
        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));
        }
Example #20
0
        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));
        }
Example #21
0
        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);
        }
Example #23
0
        /// <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());
        }
Example #24
0
        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);
        }
Example #26
0
        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);
        }
Example #27
0
        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
        }
Example #28
0
 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)
 {
 }
Example #29
0
        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);
        }
Example #30
0
 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;
                }
            }
        }
Example #32
0
 /// <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());
     }
 }
Example #33
0
        /// <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);
        }
Example #34
0
        /// <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!");
        }
Example #35
0
        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);
        }
Example #36
0
 public IPackage ResolveDependency(PackageDependency dependency, IPackageConstraintProvider constraintProvider, bool allowPrereleaseVersions, bool preferListedPackages, DependencyVersion dependencyVersion)
 {
     return DependencyResolveUtility.ResolveDependencyCore(
         new CoreInteropSourceRepository(_source),
         dependency,
         constraintProvider,
         allowPrereleaseVersions,
         preferListedPackages,
         dependencyVersion); 
 }
Example #37
0
        /// <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);
        }
Example #38
0
 /// <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();
     }
 }
Example #39
0
        /// <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);
 }
Example #41
0
        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);
        }