public void VersionLength(string version)
        {
            // Arrange & Act
            var semVer = new NuGetVersion(version);

            Assert.Equal("2.0.0", semVer.ToNormalizedString());
        }
Exemple #2
0
        public void ParseReadsLegacyStyleVersionNumbers(string versionString, string expectedString)
        {
            // Arrange
            var expected = new NuGetVersion(new Version(expectedString), "");

            // Act
            var actual = NuGetVersion.Parse(versionString);

            // Assert
            Assert.Equal(expected.Version, actual.Version);
            Assert.Equal(expected.Release, actual.Release);
        }
        public IQueryable <V2FeedPackage> GetUpdates(
            string packageIds,
            string versions,
            bool includePrerelease,
            bool includeAllVersions,
            string targetFrameworks,
            string versionConstraints)
        {
            if (String.IsNullOrEmpty(packageIds) || String.IsNullOrEmpty(versions))
            {
                return(Enumerable.Empty <V2FeedPackage>().AsQueryable());
            }

            // Workaround https://github.com/NuGet/NuGetGallery/issues/674 for NuGet 2.1 client. Can probably eventually be retired (when nobody uses 2.1 anymore...)
            // Note - it was URI un-escaping converting + to ' ', undoing that is actually a pretty conservative substitution because
            // space characters are never acepted as valid by VersionUtility.ParseFrameworkName.
            if (!string.IsNullOrEmpty(targetFrameworks))
            {
                targetFrameworks = targetFrameworks.Replace(' ', '+');
            }

            var idValues              = packageIds.Trim().ToLowerInvariant().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
            var versionValues         = versions.Trim().Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
            var targetFrameworkValues = String.IsNullOrEmpty(targetFrameworks)
                                            ? null
                                            : targetFrameworks.Split('|').Select(tfx => NuGetFramework.Parse(tfx)).ToList();
            var versionConstraintValues = String.IsNullOrEmpty(versionConstraints)
                                            ? new string[idValues.Length]
                                            : versionConstraints.Split('|');

            if (idValues.Length == 0 || idValues.Length != versionValues.Length || idValues.Length != versionConstraintValues.Length)
            {
                // Exit early if the request looks invalid
                return(Enumerable.Empty <V2FeedPackage>().AsQueryable());
            }

            var versionLookup = idValues.Select((id, i) =>
            {
                NuGetVersion currentVersion;
                if (NuGetVersion.TryParse(versionValues[i], out currentVersion))
                {
                    VersionRange versionConstraint = null;
                    if (versionConstraintValues[i] != null)
                    {
                        if (!VersionRange.TryParse(versionConstraintValues[i], out versionConstraint))
                        {
                            versionConstraint = null;
                        }
                    }
                    return(Tuple.Create(id, Tuple.Create(currentVersion, versionConstraint)));
                }
                return(null);
            })
                                .Where(t => t != null)
                                .ToLookup(t => t.Item1, t => t.Item2, StringComparer.OrdinalIgnoreCase);

            var packages = PackageRepository.GetAll()
                           .Include(p => p.PackageRegistration)
                           .Include(p => p.SupportedFrameworks)
                           .Where(p =>
                                  !p.Deleted && p.Listed && (includePrerelease || !p.IsPrerelease) &&
                                  idValues.Contains(p.PackageRegistration.Id.ToLower()))
                           .OrderBy(p => p.PackageRegistration.Id);

            return(GetUpdates(packages, versionLookup, targetFrameworkValues, includeAllVersions).AsQueryable()
                   .ToV2FeedPackageQuery(GetSiteRoot(), Configuration.Features.FriendlyLicenses));
        }
Exemple #4
0
 public static HijackIndexChange SetLatestToTrue(NuGetVersion version)
 {
     return(new HijackIndexChange(version, HijackIndexChangeType.SetLatestToTrue));
 }
Exemple #5
0
 public static HijackIndexChange UpdateMetadata(NuGetVersion version)
 {
     return(new HijackIndexChange(version, HijackIndexChangeType.UpdateMetadata));
 }
Exemple #6
0
        public EnvironmentInspectionResult InspectEnvironment(
            BoundRestoreCommandUser restorer,
            String sdkPackageID,
            String sdkPackageVErsion
            )
        {
            const String SELF = "self";

            var packageID = this._packageID;

            global::NuGet.Packaging.Core.PackageIdentity selfPackageIdentity = null;
            var projectFile     = this._projectFileLocation;
            var packageIDIsSelf = this._packageIDIsSelf;
            var localRepos      = restorer.LocalRepositories;
            var errors          = new List <String>();

            if (String.IsNullOrEmpty(packageID))
            {
                if (packageIDIsSelf)
                {
                    // Package ID was specified as self
                    if (String.IsNullOrEmpty(projectFile))
                    {
                        errors.Add("NMSBT003");
                    }
                    else
                    {
                        projectFile = Path.GetFullPath(projectFile);
                        // The usage of this task factory comes from the package itself, deduce the package ID
                        selfPackageIdentity = SearchWithinNuGetRepository(
                            projectFile,
                            localRepos
                            .FirstOrDefault(kvp => projectFile.StartsWith(Path.GetFullPath(kvp.Key)))
                            .Value
                            ?.RepositoryRoot
                            );

                        if (selfPackageIdentity == null)
                        {
                            // Failed to deduce this package ID
                            // No PackageID element and no PackageIDIsSelf element either
                            errors.Add("NMSBT004");
                        }
                        else
                        {
                            packageID = selfPackageIdentity.Id;
                        }
                    }
                }
                else
                {
                    // No PackageID element and no PackageIDIsSelf element either
                    errors.Add("NMSBT002");
                }
            }
            else if (packageIDIsSelf)
            {
                packageID = null;
                errors.Add("NMSBT005");
            }

            String packageVersion = null;

            if (!String.IsNullOrEmpty(packageID))
            {
                packageVersion = this._packageVersion;
                if (
                    (String.IsNullOrEmpty(packageVersion) && packageIDIsSelf) ||
                    String.Equals(packageVersion, SELF, StringComparison.OrdinalIgnoreCase)
                    )
                {
                    // Instead of floating version, we need to deduce our version
                    NuGetVersion deducedVersion = null;
                    if (selfPackageIdentity == null)
                    {
                        // <PackageID> was specified normally, and <PackageVersion> was self
                        var localPackage = localRepos.Values
                                           .SelectMany(lr => lr.FindPackagesById(packageID))
                                           .Where(lp => projectFile.StartsWith(lp.ExpandedPath))
                                           .FirstOrDefault();
                        if (localPackage == null)
                        {
                            errors.Add("NMSBT006");
                        }
                        else
                        {
                            deducedVersion = localPackage.Version;
                        }
                    }
                    else
                    {
                        // <PackageIDIsSelf> was specified, and no version was specified
                        deducedVersion = selfPackageIdentity.Version;
                    }

                    packageVersion = deducedVersion?.ToNormalizedString();
                }
            }

            return(new EnvironmentInspectionResult()
            {
                ThisFramework = restorer.ThisFramework.ToString(),
                ThisRuntimeID = restorer.RuntimeIdentifier,
                SDKPackageID = sdkPackageID,
                SDKPackageVersion = sdkPackageVErsion,
                PackageID = packageID,
                PackageVersion = packageVersion,
                Errors = errors.ToArray()
            });
        }
Exemple #7
0
 public static NuGetVersion Prepend(this NuGetVersion version, string releaseLabel)
 {
     return(new NuGetVersion(version.Major, version.Minor, version.Patch, version.Revision,
                             new[] { releaseLabel }.Concat(version.ReleaseLabels), version.Metadata));
 }
Exemple #8
0
        public async Task DotnetToolTests_ToolRestoreWithRuntimeIdentiferGraphPath_SucceedsAsync()
        {
            using (var pathContext = new SimpleTestPathContext())
            {
                string testDirectory    = pathContext.WorkingDirectory;
                var    tfm              = "netcoreapp2.0";
                var    projectName      = "ToolRestoreProject";
                var    workingDirectory = Path.Combine(testDirectory, projectName);
                var    packageSource    = Path.Combine(testDirectory, "packageSource");
                var    rid              = "win-x64";
                var    packageRid       = "win";
                var    packageName      = string.Join("ToolPackage-", tfm, rid);
                var    packageVersion   = NuGetVersion.Parse("1.0.0");
                var    packages         = new List <PackageIdentity>()
                {
                    new PackageIdentity(packageName, packageVersion)
                };

                var package = new SimpleTestPackageContext(packageName, packageVersion.OriginalVersion);
                package.Files.Clear();
                package.AddFile($"tools/{tfm}/{packageRid}/a.dll");
                package.AddFile($"tools/{tfm}/{packageRid}/Settings.json");

                package.PackageType = PackageType.DotnetTool;
                package.UseDefaultRuntimeAssemblies = false;
                package.PackageTypes.Add(PackageType.DotnetTool);
                await SimpleTestPackageUtility.CreatePackagesAsync(packageSource, package);

                _msbuildFixture.CreateDotnetToolProject(testDirectory, projectName, tfm, rid, packageSource, packages);

                // set up rid graph
                var ridGraphPath = Path.Combine(testDirectory, "runtime.json");
                File.WriteAllBytes(ridGraphPath, GetTestUtilityResource("runtime.json"));

                using (var stream = File.Open(Path.Combine(workingDirectory, projectName + ".csproj"), FileMode.Open, FileAccess.ReadWrite))
                {
                    var xml = XDocument.Load(stream);
                    ProjectFileUtils.AddProperty(
                        xml,
                        "RuntimeIdentifierGraphPath",
                        ridGraphPath);

                    ProjectFileUtils.WriteXmlToFile(xml, stream);
                }

                // Act
                var result = _msbuildFixture.RestoreToolProject(workingDirectory, projectName, string.Empty);

                // Assert
                Assert.True(result.ExitCode == 0, result.AllOutput);
                // Verify the assets file
                var lockFile = LockFileUtilities.GetLockFile(Path.Combine(testDirectory, projectName, "project.assets.json"), NullLogger.Instance);
                Assert.NotNull(lockFile);
                Assert.Equal(2, lockFile.Targets.Count);
                var ridTargets = lockFile.Targets.Where(e => e.RuntimeIdentifier != null ? e.RuntimeIdentifier.Equals(rid, StringComparison.CurrentCultureIgnoreCase) : false);
                Assert.Equal(1, ridTargets.Count());
                var toolsAssemblies = ridTargets.First().Libraries.First().ToolsAssemblies;
                Assert.Equal(2, toolsAssemblies.Count);
                Assert.True(toolsAssemblies.Contains($"tools/{tfm}/{packageRid}/a.dll"));
                Assert.True(toolsAssemblies.Contains($"tools/{tfm}/{packageRid}/Settings.json"));
            }
        }
Exemple #9
0
 protected override async Task OkAsync()
 {
     if (InstalledPackages.Count > 0)
     {
         await InstalledPackages.Select(p => NugetHelper.EnsurePackageInstalled(p.Name, NuGetVersion.Parse(p.Version)))
         .WhenAll()
         .ConfigureAwait(false)
         ;
     }
     await base.OkAsync();
 }
Exemple #10
0
        public async Task <IReadOnlyCollection <ChangeSet> > GetChangeSets(IRepositorySource ops)
        {
            _log.WriteLine("Fetching project files");
            var projectFiles = await ops.GetProjectFiles();

            var allPackages = projectFiles.SelectMany(x => x.ListPackages()).Select(x => x.Key).Distinct().ToArray();

            _log.WriteLine("Fetching latest packages");

            var nugetPackages = await Task.WhenAll(_nugetApis.Select(x => x.GetPackageVersions(allPackages, AllowBetaPackages)));

            var latestPackageVersions =
                nugetPackages
                .SelectMany(x => x)
                .GroupBy(x => x.Key)
                .ToDictionary(x => x.Key, x => x.OrderByDescending(y => y.Value.Version).FirstOrDefault().Value);

            HashSet <string> packagesToUpdate = new HashSet <string>();
            var packages = projectFiles.SelectMany(x => x.ListPackages())
                           .GroupBy(x => x.Key)
                           .ToDictionary(x => x.Key, x => x.First().Value);

            foreach (var item in latestPackageVersions)
            {
                var projectVersion = NuGetVersion.Parse(packages[item.Key]);

                var lastVersion = item.Value;
                if (lastVersion.Version > projectVersion)
                {
                    // Major minor versions older than 21 days
                    var shouldUpdateMajorMinor =
                        (lastVersion.Version.Major > projectVersion.Major || lastVersion.Version.Minor > projectVersion.Minor) &&
                        lastVersion.Released <= DateTime.Now.AddDays(-PackagesMustBePublishedForThisManyDays);

                    var shouldUpdatePatch = lastVersion.Version.Major == projectVersion.Major &&
                                            lastVersion.Version.Minor == projectVersion.Minor &&
                                            lastVersion.Version > projectVersion;

                    if (shouldUpdateMajorMinor || shouldUpdatePatch)
                    {
                        packagesToUpdate.Add($"{item.Key}|{item.Value.Version}");
                    }
                }
            }

            var packageGroupings =
                packagesToUpdate
                .Select(x => x.Split('|'))
                .GroupBy(x => PackageGroupings.Select(y => y.GetGroupName(x[0], x[1])).First(y => y != null),
                         x => x[0]);

            var changeSets = new List <ChangeSet>();

            foreach (var group in packageGroupings)
            {
                var message =
                    new StringBuilder($"Auto-update for packages related to '{@group.Key}'");
                message.AppendLine();
                message.AppendLine();

                var groupChangeSet = new ChangeSet
                {
                    BranchName = $"refs/heads/auto-nuget-update/{@group.Key.ToLowerInvariant()}",
                };

                foreach (var package in @group)
                {
                    var packageUpdateMessage =
                        $"Updates package '{package}' to version '{latestPackageVersions[package].Version}'";

                    if (@group.Count() == 1)
                    {
                        message = new StringBuilder(packageUpdateMessage);
                    }
                    else
                    {
                        message.AppendLine(packageUpdateMessage);
                    }

                    foreach (var projectFile in projectFiles)
                    {
                        projectFile.UpdatePackageReference(package,
                                                           latestPackageVersions[package].Version.ToString());
                    }
                }

                foreach (var projectFile in projectFiles)
                {
                    var change = projectFile.ToChange();
                    if (change != null)
                    {
                        groupChangeSet.Changes.Add(change);
                    }

                    projectFile.Reset();
                }

                groupChangeSet.Message = message.ToString();
                changeSets.Add(groupChangeSet);
            }

            return(changeSets);
        }
        public RunStatus AddPackage(string projectPath, string packageName, string frameworkName, NuGetVersion version)
        {
            string projectName = _fileSystem.Path.GetFileName(projectPath);

            string[] arguments = new[] { "add", $"\"{projectName}\"", "package", packageName, "-v", version.ToString(), "-f", $"\"{frameworkName}\"" };

            return(_dotNetRunner.Run(_fileSystem.Path.GetDirectoryName(projectPath), arguments));
        }
 public void ParseThrowsIfStringIsNullOrEmpty()
 {
     ExceptionAssert.ThrowsArgNullOrEmpty(() => NuGetVersion.Parse(null), "value");
     ExceptionAssert.ThrowsArgNullOrEmpty(() => NuGetVersion.Parse(String.Empty), "value");
 }
        public void NuGetVersionKeepsOriginalVersionString(string originalVersion)
        {
            var version = new NuGetVersion(originalVersion);

            Assert.Equal(originalVersion, version.OriginalVersion);
        }
 public void EqualsIsTrueForEmptyRevision()
 {
     NuGetVersion.Parse("1.0.0.0").Equals(SemanticVersion.Parse("1.0.0")).Should().BeTrue();
     SemanticVersion.Parse("1.0.0").Equals(NuGetVersion.Parse("1.0.0.0")).Should().BeTrue();
 }
 public void ParseThrowsIfStringIsNotAValidSemVer(string versionString)
 {
     ExceptionAssert.ThrowsArgumentException(() => NuGetVersion.Parse(versionString),
                                             "value",
                                             String.Format(CultureInfo.InvariantCulture, "'{0}' is not a valid version string.", versionString));
 }
Exemple #16
0
        public void ParseIgnoresLeadingAndTrailingWhitespace(string versionString, string expectedString, string releaseString)
        {
            // Arrange
            var expected = new NuGetVersion(new Version(expectedString), releaseString);

            // Act
            var actual = NuGetVersion.Parse(versionString);

            // Assert
            Assert.Equal(expected.Version, actual.Version);
            Assert.Equal(expected.Release, actual.Release);
        }
Exemple #17
0
        public void ToStringFromStringFormat(string versionString, string specialVersion, string expected)
        {
            // Arrange 
            var version = new Version(versionString);

            // Act
            var semVer = new NuGetVersion(version, specialVersion);

            // Assert
            Assert.Equal(expected, String.Format("{0}", semVer));
        }
        private static async Task <IActionResult> RunInternalAsync(
            HttpRequest request,
            string typeName,
            string typeNamespace,
            ILogger log)
        {
            // Fetch parameters
            var allowPrerelease = ParseQuery(request.Query, "allowPrerelease", false);
            var latestVersion   = ParseQuery(request.Query, "latestVersion", true);
            var page            = ParseQuery(request.Query, "pageIndex", 0);

            // Build query
            var searchText = !string.IsNullOrEmpty(typeName)
                ? $"typeNames:.{typeName}"
                : $"typeNames:{typeNamespace}.";

            // Search
            var indexClient = SearchServiceClient.Indexes.GetClient(Constants.SearchServiceIndexName);

            log.LogInformation("Performing search for {searchText}...", searchText);

            var resultsCollector = new HashSet <PackageDocument>(latestVersion
                ? PackageDocumentEqualityComparer.ByPackageId
                : PackageDocumentEqualityComparer.ByPackageIdAndVersion);

            await indexClient.Documents.ForEachAsync <PackageDocument>(searchText,
                                                                       documentResult =>
            {
                var isPreRelease = documentResult.Document.IsPreRelease.HasValue &&
                                   documentResult.Document.IsPreRelease.Value;
                if (allowPrerelease || !isPreRelease)
                {
                    resultsCollector.Add(documentResult.Document);
                }

                return(resultsCollector.Count <= MaxResults);
            },
                                                                       new SearchParameters
            {
                Filter  = "isListed eq true" + (!allowPrerelease ? " and isPreRelease eq false" : ""),
                OrderBy = new List <string> {
                    "search.score() desc", "packageVersion desc"
                },
                QueryType = QueryType.Full
            });

            log.LogInformation("Finished performing search for {searchText}. Total results: {totalResults} (page: {page})", searchText, resultsCollector.Count, page);

            // Build result
            var result = new FindTypeApiResult();

            result.TotalResults = resultsCollector.Count;
            result.PageIndex    = page;
            result.PageSize     = PageSize;
            result.TotalPages   = (long)Math.Ceiling((decimal)(resultsCollector.Count / PageSize) + 1);

            foreach (var searchResult in resultsCollector.Take(PageSize))
            {
                var nugetVersion = NuGetVersion.Parse(searchResult.PackageVersion);

                var resultItem = new FindTypeApiPackage
                {
                    Id          = searchResult.PackageId,
                    Version     = nugetVersion.ToNormalizedString(),
                    VersionId   = 1,
                    Title       = searchResult.Title,
                    Authors     = searchResult.Authors,
                    Description = searchResult.Summary,
                    Downloads   = searchResult.DownloadCount,
                    IconUrl     = !string.IsNullOrEmpty(searchResult.IconUrl) ? searchResult.IconUrl : Constants.NuGetPackageDefaultIconUrl,
                    LicenseUrl  = searchResult.LicenseUrl,
                    ProjectUrl  = searchResult.ProjectUrl,
                    Published   = searchResult.Published,
                    Tags        = (searchResult.Tags ?? "").Split(' ').ToList(),

                    IsPreRelease     = nugetVersion.IsPrerelease,
                    IsLastPreRelease = nugetVersion.IsPrerelease,
                    IsLastRelease    = !nugetVersion.IsPrerelease
                };

                foreach (var targetFramework in searchResult.TargetFrameworks)
                {
                    var framework = NuGetFramework.Parse(targetFramework, FrameworkNameProvider);
                    resultItem.Match.Platforms.Add(framework.DotNetFrameworkName);
                }

                foreach (var searchResultTypeName in searchResult.TypeNames)
                {
                    var resultNamespace = searchResultTypeName.SubstringUntilLast(".");
                    var resultType      = searchResultTypeName.SubstringAfterLast(".");

                    if (!string.IsNullOrEmpty(resultNamespace))
                    {
                        resultItem.Match.Assemblies.Add(resultNamespace);
                        if (!string.IsNullOrEmpty(typeName) && resultType.Equals(typeName, StringComparison.OrdinalIgnoreCase))
                        {
                            resultItem.Match.TypeNames.Add(new FindTypeApiMatchTypeName {
                                Kind = 0, Namespace = resultNamespace, Name = resultType
                            });
                        }
                        else if (!string.IsNullOrEmpty(typeNamespace) && resultNamespace.Equals(typeNamespace, StringComparison.OrdinalIgnoreCase))
                        {
                            resultItem.Match.TypeNames.Add(new FindTypeApiMatchTypeName {
                                Kind = 0, Namespace = resultNamespace
                            });
                        }
                    }
                }

                if (resultItem.Match.TypeNames.Count > 0)
                {
                    result.Packages.Add(resultItem);
                }
            }

            return(new OkObjectResult(result));
        }
Exemple #19
0
 public static NuGetVersion RemoveRevision(this NuGetVersion version)
 {
     return(new NuGetVersion(version.Major, version.Minor, version.Patch, 0, version.ReleaseLabels, version.Metadata));
 }
 public SimplePackageId(string packageId, SVersion v)
 {
     PackageIdentity = new PackageIdentity(packageId, NuGetVersion.Parse(v.ToString()));
     Version         = v;
 }
        public async Task <InternalNuGetCompatibilityResult> CheckCompatibilityAsync(string packageName, string version, string targetFramework, IEnumerable <SourceRepository> internalRepositories)
        {
            if (packageName == null || targetFramework == null || internalRepositories == null)
            {
                var invalidParamNames = new List <string>();
                if (packageName == null)
                {
                    invalidParamNames.Add(nameof(packageName));
                }
                if (targetFramework == null)
                {
                    invalidParamNames.Add(nameof(targetFramework));
                }
                if (internalRepositories == null)
                {
                    invalidParamNames.Add(nameof(internalRepositories));
                }

                throw new ArgumentException($"Invalid parameter(s) found. The following parameters " +
                                            $"cannot be null: {string.Join(", ", invalidParamNames)}");
            }

            string tmpPath   = Path.GetTempPath();
            var    framework = NuGetFramework.Parse(targetFramework);
            var    package   = new PackageIdentity(packageName, NuGetVersion.Parse(version));

            // Get package information from Nuget
            SourcePackageDependencyInfo packageSource = null;

            foreach (var sourceRepository in internalRepositories)
            {
                var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();

                packageSource = await dependencyInfoResource.ResolvePackage(
                    package, framework, _cacheContext, NullLogger.Instance, CancellationToken.None);

                if (packageSource != null)
                {
                    break;
                }
            }
            if (packageSource == null)
            {
                var errorMessage = $"Error: No package source found for {package}.";
                _logger.LogError(errorMessage);

                var innerException = new PackageSourceNotFoundException(errorMessage);
                throw new PortingAssistantClientException(ExceptionMessage.PackageSourceNotFound(package), innerException);
            }

            // Download package
            var downloadResource = await packageSource.Source.GetResourceAsync <DownloadResource>();

            var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
                packageSource,
                new PackageDownloadContext(_cacheContext),
                Path.Combine(tmpPath),
                NullLogger.Instance, CancellationToken.None);

            var packageReader = downloadResult.PackageReader;
            var nuspecReader  = packageReader.NuspecReader;

            var dependencies       = nuspecReader.GetDependencyGroups();
            var dependencyPackages = dependencies
                                     .SelectMany(d => d.Packages)
                                     .Select(p => p.Id)
                                     .ToList();

            // Gather dlls
            var frameworkReducer        = new FrameworkReducer();
            var libItems                = packageReader.GetLibItems();
            var nearestTargetFrameworks = libItems
                                          .Select(li =>
                                                  frameworkReducer.GetNearest(
                                                      framework,
                                                      new List <NuGetFramework> {
                li.TargetFramework
            }))
                                          .ToList();

            var isCompatible = libItems.Any() ? nearestTargetFrameworks.Any(nugetFramework => nugetFramework != null)
                : frameworkReducer.GetNearest(framework, packageReader.GetSupportedFrameworks()) != null;

            var compatibleDlls = libItems
                                 .Where(li => nearestTargetFrameworks.Contains(li.TargetFramework))
                                 .SelectMany(li => li.Items)
                                 .Where(s => s.EndsWith("dll", StringComparison.OrdinalIgnoreCase))
                                 .ToList();
            var incompatibleDlls = libItems
                                   .SelectMany(li => li.Items)
                                   .Where(s => !compatibleDlls.Contains(s) &&
                                          s.EndsWith("dll", StringComparison.OrdinalIgnoreCase))
                                   .ToList();

            return(new InternalNuGetCompatibilityResult
            {
                IncompatibleDlls = incompatibleDlls,
                CompatibleDlls = compatibleDlls,
                IsCompatible = isCompatible,
                DependencyPackages = dependencyPackages,
                Source = packageSource.Source.PackageSource.Name
            });
        }
        public void PackagesConfigWriter_Duplicate()
        {
            var stream = new MemoryStream();

            using (PackagesConfigWriter writer = new PackagesConfigWriter(stream))
            {
                writer.WritePackageEntry("packageA", NuGetVersion.Parse("1.0.1"), NuGetFramework.Parse("net45"));

                Assert.Throws <PackagingException>(() => writer.WritePackageEntry("packageA", NuGetVersion.Parse("2.0.1"), NuGetFramework.Parse("net4")));
            }
        }
Exemple #23
0
 private HijackIndexChange(NuGetVersion version, HijackIndexChangeType type)
 {
     Version = version ?? throw new ArgumentNullException(nameof(version));
     Type    = type;
 }
 public string GetRegistrationPageUrl(string id, NuGetVersion lower, NuGetVersion upper)
 {
     // BaGet does not support paging the registration resource.
     throw new NotImplementedException();
 }
Exemple #25
0
 public static HijackIndexChange Delete(NuGetVersion version)
 {
     return(new HijackIndexChange(version, HijackIndexChangeType.Delete));
 }
Exemple #26
0
        public static async Task <bool> RunAsync(LocalSettings settings, ISleetFileSystem source, string packageId, string version, string reason, bool force, ILogger log)
        {
            var success = true;

            var token = CancellationToken.None;
            var now   = DateTimeOffset.UtcNow;

            log.LogMinimal($"Reading feed {source.BaseURI.AbsoluteUri}");

            // Check if already initialized
            using (var feedLock = await SourceUtility.VerifyInitAndLock(settings, source, log, token))
            {
                // Validate source
                await UpgradeUtility.EnsureFeedVersionMatchesTool(source, log, token);

                // Get sleet.settings.json
                var sourceSettings = await FeedSettingsUtility.GetSettingsOrDefault(source, log, token);

                // Settings context used for all operations
                var context = new SleetContext()
                {
                    LocalSettings  = settings,
                    SourceSettings = sourceSettings,
                    Log            = log,
                    Source         = source,
                    Token          = token
                };

                var packageIndex = new PackageIndex(context);

                var packages = new List <PackageIdentity>();

                if (!string.IsNullOrEmpty(version))
                {
                    // Delete a single version of the package
                    var packageVersion = NuGetVersion.Parse(version);

                    packages.Add(new PackageIdentity(packageId, packageVersion));
                }
                else
                {
                    // Delete all versions of the package
                    packages.AddRange(await packageIndex.GetPackagesByIdAsync(packageId));
                }

                if (string.IsNullOrEmpty(reason))
                {
                    reason = string.Empty;
                }

                foreach (var package in packages)
                {
                    var exists = await packageIndex.Exists(package);

                    var symbolsExists = await packageIndex.SymbolsExists(package);

                    if (!exists && !symbolsExists)
                    {
                        log.LogInformation($"{package.ToString()} does not exist.");

                        if (force)
                        {
                            // ignore failures
                            continue;
                        }
                        else
                        {
                            throw new InvalidOperationException($"Package does not exists: {package.ToString()}");
                        }
                    }

                    var message = $"Removing {package.ToString()}";

                    if (exists && symbolsExists)
                    {
                        message = $"Removing {package.ToString()} and symbols package for {package.ToString()}";
                    }
                    else if (symbolsExists)
                    {
                        message = $"Removing symbols package {package.ToString()}";
                    }

                    await log.LogAsync(LogLevel.Information, message);

                    await SleetUtility.RemovePackage(context, package);
                }

                // Save all
                log.LogMinimal($"Committing changes to {source.BaseURI.AbsoluteUri}");

                success &= await source.Commit(log, token);
            }

            if (success)
            {
                log.LogMinimal($"Successfully deleted packages.");
            }
            else
            {
                log.LogError($"Failed to delete packages.");
            }

            return(success);
        }
Exemple #27
0
        public async Task GetPackageWithDependencies()
        {
            var packageService = server.Host.Services.GetRequiredService <IPackageService>();

            var result = await packageService.AddAsync(new Package()
            {
                Id               = "Dummy",
                Title            = "Dummy",
                Listed           = true,
                Version          = NuGetVersion.Parse("1.0.0"),
                Authors          = new [] { "Anton Setiawan" },
                LicenseUrl       = new Uri("https://github.com/antonmaju/dummy/blob/master/LICENSE"),
                MinClientVersion = null,
                Published        = DateTime.Parse("1900-01-01T00:00:00"),
                Dependencies     = new List <Core.Entities.PackageDependency>()
                {
                    new Core.Entities.PackageDependency()
                    {
                        Id = "Consul", VersionRange = "[0.7.2.6, )", TargetFramework = ".NETStandard2.0"
                    }
                }
            });

            Assert.Equal(PackageAddResult.Success, result);

            var found = await packageService.FindOrNullAsync(new NuGet.Packaging.Core.PackageIdentity("dummy", NuGetVersion.Parse("1.0.0")), false, true);

            Assert.NotNull(found.Dependencies);
            Assert.NotEmpty(found.Dependencies);
            var one = found.Dependencies.Single();

            Assert.Equal("Consul", one.Id);
            Assert.Equal("[0.7.2.6, )", one.VersionRange);
        }
 public static string ToNormalizedStringSafe(this NuGetVersion self)
 {
     return(self != null?self.ToNormalizedString() : String.Empty);
 }
Exemple #29
0
        /// <summary>
        /// Parse an entry into a V2FeedPackageInfo
        /// </summary>
        private V2FeedPackageInfo ParsePackage(string id, XElement element, MetadataReferenceCache metadataCache)
        {
            var properties   = element.Element(_xnameProperties);
            var idElement    = properties.Element(_xnameId);
            var titleElement = element.Element(_xnameTitle);

            // If 'Id' element exist, use its value as accurate package Id
            // Otherwise, use the value of 'title' if it exist
            // Use the given Id as final fallback if all elements above don't exist
            var identityId    = metadataCache.GetString(idElement?.Value ?? titleElement?.Value ?? id);
            var versionString = properties.Element(_xnameVersion).Value;
            var version       = metadataCache.GetVersion(metadataCache.GetString(versionString));
            var downloadUrl   = metadataCache.GetString(element.Element(_xnameContent).Attribute("src").Value);

            var title          = metadataCache.GetString(titleElement?.Value);
            var summary        = metadataCache.GetString(GetString(element, _xnameSummary));
            var description    = metadataCache.GetString(GetString(properties, _xnameDescription));
            var iconUrl        = metadataCache.GetString(GetString(properties, _xnameIconUrl));
            var licenseUrl     = metadataCache.GetString(GetString(properties, _xnameLicenseUrl));
            var projectUrl     = metadataCache.GetString(GetString(properties, _xnameProjectUrl));
            var reportAbuseUrl = metadataCache.GetString(GetString(properties, _xnameReportAbuseUrl));
            var tags           = metadataCache.GetString(GetString(properties, _xnameTags));
            var dependencies   = metadataCache.GetString(GetString(properties, _xnameDependencies));

            var downloadCount            = metadataCache.GetString(GetString(properties, _xnameDownloadCount));
            var requireLicenseAcceptance = StringComparer.OrdinalIgnoreCase.Equals(bool.TrueString, GetString(properties, _xnameRequireLicenseAcceptance));

            var packageHash          = metadataCache.GetString(GetString(properties, _xnamePackageHash));
            var packageHashAlgorithm = metadataCache.GetString(GetString(properties, _xnamePackageHashAlgorithm));

            NuGetVersion minClientVersion = null;

            var minClientVersionString = GetString(properties, _xnameMinClientVersion);

            if (!string.IsNullOrEmpty(minClientVersionString))
            {
                if (NuGetVersion.TryParse(minClientVersionString, out minClientVersion))
                {
                    minClientVersion = metadataCache.GetVersion(minClientVersionString);
                }
            }

            var created    = GetDate(properties, _xnameCreated);
            var lastEdited = GetDate(properties, _xnameLastEdited);
            var published  = GetDate(properties, _xnamePublished);

            IEnumerable <string> owners  = null;
            IEnumerable <string> authors = null;

            var authorNode = element.Element(_xnameAuthor);

            if (authorNode != null)
            {
                authors = authorNode.Elements(_xnameName).Select(e => metadataCache.GetString(e.Value));
            }

            return(new V2FeedPackageInfo(new PackageIdentity(identityId, version), title, summary, description, authors,
                                         owners, iconUrl, licenseUrl, projectUrl, reportAbuseUrl, tags, created, lastEdited, published,
                                         dependencies, requireLicenseAcceptance, downloadUrl, downloadCount, packageHash, packageHashAlgorithm,
                                         minClientVersion));
        }
 public static bool IsSemVer200(this NuGetVersion self)
 {
     return(self.ReleaseLabels.Count() > 1 || self.HasMetadata);
 }
Exemple #31
0
        public void ParseReadsSemverAndHybridSemverVersionNumbers(string versionString, string expectedString, string releaseString)
        {
            // Arrange
            var expected = new NuGetVersion(new Version(expectedString), releaseString);

            // Act
            var actual = NuGetVersion.Parse(versionString);

            // Assert
            Assert.Equal(expected.Version, actual.Version);
            Assert.Equal(expected.Release, actual.Release);
        }
 public NuGetArtifactTester(string file)
 {
     _reader        = new PackageArchiveReader(ZipFile.Open(file, ZipArchiveMode.Read));
     Identity       = _reader.NuspecReader.GetIdentity();
     PackageVersion = _reader.NuspecReader.GetVersion();
 }
Exemple #33
0
        public void ToStringConstructedFromVersionAndSpecialVersionConstructor(string versionString, string specialVersion, string expected)
        {
            // Arrange 
            var version = new Version(versionString);

            // Act
            var semVer = new NuGetVersion(version, specialVersion);

            // Assert
            Assert.Equal(expected, semVer.ToString());
        }
Exemple #34
0
 private string GetPackageFilePath(string id, NuGetVersion version)
 {
     return Path.Combine(Source, id + "." + version.ToNormalizedString() + Constants.PackageExtension);
 }
Exemple #35
0
 public static VersionRange ReplaceMaxVersion(this VersionRange range, NuGetVersion newMaxVersion)
 {
     return(new VersionRange(range.MinVersion, range.IsMinInclusive, newMaxVersion, range.IsMaxInclusive, range.Float, range.OriginalString));
 }
        public async Task PackageExpander_Recovers_WhenFileIsLocked()
        {
            // Arrange
            using (var package = TestPackages.GetNearestReferenceFilteringPackage())
            {
                var version  = new NuGetVersion(package.Version);
                var identity = new PackageIdentity(package.Id, version);

                var packagesDir  = TestDirectory.Create();
                var pathResolver = new VersionFolderPathResolver(packagesDir);

                var token  = CancellationToken.None;
                var logger = NullLogger.Instance;
                var versionFolderPathContext = new VersionFolderPathContext(
                    identity,
                    packagesDir,
                    logger,
                    packageSaveMode: PackageSaveMode.Defaultv3,
                    xmlDocFileSaveMode: XmlDocFileSaveMode.None);

                var packageDir = pathResolver.GetInstallPath(package.Id, identity.Version);
                Assert.False(Directory.Exists(packageDir), packageDir + " exist");

                string filePathToLock = Path.Combine(packageDir, "lib", "net40", "two.dll");

                // Act
                using (var stream = package.File.OpenRead())
                {
                    var cts = new CancellationTokenSource(DefaultTimeOut);

                    Func <CancellationToken, Task <bool> > action = (ct) => {
                        Assert.ThrowsAnyAsync <IOException>(async() =>
                                                            await PackageExtractor.InstallFromSourceAsync(
                                                                str => stream.CopyToAsync(stream, bufferSize: 8192, cancellationToken: token),
                                                                versionFolderPathContext,
                                                                token));

                        return(Task.FromResult(true));
                    };

                    await ConcurrencyUtilities.ExecuteWithFileLockedAsync(filePathToLock, action, cts.Token);
                }

                AssertDirectoryExists(packageDir, packageDir + " does not exist");

                Assert.NotEmpty(Directory.EnumerateFiles(packageDir));

                using (var stream = package.File.OpenRead())
                {
                    await PackageExtractor.InstallFromSourceAsync(async (d) => await stream.CopyToAsync(d),
                                                                  versionFolderPathContext,
                                                                  token);
                }

                // Assert
                var filePath = pathResolver.GetPackageFilePath(package.Id, identity.Version);
                Assert.True(File.Exists(filePath), filePath + " does not exist");

                var dllPath = Path.Combine(packageDir, "lib", "net40", "one.dll");
                Assert.True(File.Exists(dllPath), dllPath + " does not exist");

                Assert.True(File.Exists(filePathToLock));

                // Make sure the actual file from the zip was extracted
                Assert.Equal(new byte[] { 0 }, File.ReadAllBytes(filePathToLock));
            }
        }