public void VersionRange_Exact() { // Act var versionInfo = new VersionRange(new NuGetVersion(4, 3, 0), true, new NuGetVersion(4, 3, 0), true, false); // Assert Assert.True(versionInfo.Satisfies(NuGetVersion.Parse("4.3.0"))); }
public void ParseVersionRangeNoPrerelease() { // Act var versionInfo = new VersionRange(minVersion: new NuGetVersion("1.2-Alpha"), includePrerelease: false); // Assert Assert.False(versionInfo.IncludePrerelease); }
/// <summary> /// Construct a P4ChangelistSpanQuery from the changelist numbers specified as parameters; the numbers are not required to be in order /// </summary> /// <param name="InQueryChangelistStart">The start or end changelist number for the query</param> /// <param name="InQueryChangelistEnd">The start or end changelist number for the query, whichever wasn't specified by the first parameter</param> /// <param name="InDepotFilter">Path to filter the depot by</param> /// <param name="InUserFilter">User to filter the depot by, can be empty string</param> public P4ChangelistSpanQuery(int InQueryChangelistStart, int InQueryChangelistEnd, String InDepotFilter, String InUserFilter="") : base(InDepotFilter, InUserFilter) { // Reorder the changelists increasing ReOrder(ref InQueryChangelistStart, ref InQueryChangelistEnd); ChangelistIdVersion StartVersionId = new ChangelistIdVersion(InQueryChangelistStart); ChangelistIdVersion EndVersionId = new ChangelistIdVersion(InQueryChangelistEnd); VersionRange Versions = new VersionRange(StartVersionId, EndVersionId); mFileFilter = new FileSpec(new DepotPath(InDepotFilter), null, null, Versions); }
/// <summary> /// Construct a P4ChangelistSpanQuery from the dates specified as parameters; the dates are not required to be in order /// </summary> /// <param name="InQueryDateTimeStart">The start or end date for the query</param> /// <param name="InQueryDateTimeEnd">The start or end date for the query, whichever wasn't specified by the first parameter</param> /// <param name="InDepotFilter">Path to filter the depot by</param> /// <param name="InUserFilter">User to filter the depot by, can be empty string</param> public P4ChangelistSpanQuery(DateTime InQueryDateTimeStart, DateTime InQueryDateTimeEnd, String InDepotFilter, String InUserFilter = "") : base(InDepotFilter, InUserFilter) { // Reorder the changelists increasing ReOrder(ref InQueryDateTimeStart, ref InQueryDateTimeEnd); DateTimeVersion StartDateTime = new DateTimeVersion(InQueryDateTimeStart); DateTimeVersion EndDateTime = new DateTimeVersion(InQueryDateTimeEnd); VersionRange Versions = new VersionRange(StartDateTime, EndDateTime); mFileFilter = new FileSpec(new DepotPath(InDepotFilter), null, null, Versions); }
public static Mock <TestPackageReader> CreateNuGetPackage( string id = "theId", string version = "01.0.42.0", string title = "theTitle", string summary = "theSummary", string authors = "theFirstAuthor, theSecondAuthor", string owners = "Package owners", string description = "theDescription", string tags = "theTags", string language = null, string copyright = "theCopyright", string releaseNotes = "theReleaseNotes", string minClientVersion = null, Uri licenseUrl = null, Uri projectUrl = null, Uri iconUrl = null, bool requireLicenseAcceptance = true, IEnumerable <PackageDependencyGroup> packageDependencyGroups = null, IEnumerable <NuGet.Packaging.Core.PackageType> packageTypes = null) { licenseUrl = licenseUrl ?? new Uri("http://thelicenseurl/"); projectUrl = projectUrl ?? new Uri("http://theprojecturl/"); iconUrl = iconUrl ?? new Uri("http://theiconurl/"); if (packageDependencyGroups == null) { packageDependencyGroups = new[] { new PackageDependencyGroup( new NuGetFramework("net40"), new[] { new NuGet.Packaging.Core.PackageDependency( "theFirstDependency", VersionRange.Parse("[1.0.0, 2.0.0)")), new NuGet.Packaging.Core.PackageDependency( "theSecondDependency", VersionRange.Parse("[1.0]")), new NuGet.Packaging.Core.PackageDependency( "theThirdDependency") }), new PackageDependencyGroup( new NuGetFramework("net35"), new[] { new NuGet.Packaging.Core.PackageDependency( "theFourthDependency", VersionRange.Parse("[1.0]")) }) }; } if (packageTypes == null) { packageTypes = new[] { new NuGet.Packaging.Core.PackageType("dependency", new Version("1.0.0")), new NuGet.Packaging.Core.PackageType("DotNetCliTool", new Version("2.1.1")) }; } var testPackage = TestPackage.CreateTestPackageStream( id, version, title, summary, authors, owners, description, tags, language, copyright, releaseNotes, minClientVersion, licenseUrl, projectUrl, iconUrl, requireLicenseAcceptance, packageDependencyGroups, packageTypes); var mock = new Mock <TestPackageReader>(testPackage); mock.CallBase = true; return(mock); }
public async Task InstallPackageFromAnotherProcessVerifyCacheIsCleared() { // Arrange var logger = new TestLogger(); using (var cacheContext = new SourceCacheContext()) using (var pathContext = new SimpleTestPathContext()) { var tfi = new List <TargetFrameworkInformation> { new TargetFrameworkInformation() { FrameworkName = NuGetFramework.Parse("net462") } }; var spec = NETCoreRestoreTestUtility.GetProject(projectName: "projectA", framework: "net46"); spec.Dependencies.Add(new LibraryDependency() { LibraryRange = new LibraryRange("a", VersionRange.Parse("1.0.0"), LibraryDependencyTarget.Package) }); var project = NETCoreRestoreTestUtility.CreateProjectsFromSpecs(pathContext, spec).Single(); var packageA = new SimpleTestPackageContext("a"); SimpleTestPackageUtility.CreatePackages(pathContext.PackageSource, packageA); // Create dg file var dgFile = new DependencyGraphSpec(); dgFile.AddProject(spec); dgFile.AddRestore(spec.RestoreMetadata.ProjectUniqueName); dgFile.Save(Path.Combine(pathContext.WorkingDirectory, "out.dg")); var providerCache = new RestoreCommandProvidersCache(); var sources = new List <string>() { pathContext.PackageSource }; var restoreContext = new RestoreArgs() { CacheContext = cacheContext, DisableParallel = true, GlobalPackagesFolder = pathContext.UserPackagesFolder, Sources = sources, Log = logger, CachingSourceProvider = new CachingSourceProvider(new TestPackageSourceProvider(new List <PackageSource>() { new PackageSource(pathContext.PackageSource) })), PreLoadedRequestProviders = new List <IPreLoadedRestoreRequestProvider>() { new DependencyGraphSpecRequestProvider(providerCache, dgFile) } }; var request = (await RestoreRunner.GetRequests(restoreContext)).Single(); var providers = providerCache.GetOrCreate(pathContext.UserPackagesFolder, sources, new List <SourceRepository>(), cacheContext, logger); var command = new RestoreCommand(request.Request); // Add to cache before install on all providers var globalPackages = providers.GlobalPackages; var packages = globalPackages.FindPackagesById("a"); packages.Should().BeEmpty("has not been installed yet"); foreach (var local in providers.LocalProviders) { await local.GetDependenciesAsync(new LibraryIdentity("a", NuGetVersion.Parse("1.0.0"), LibraryType.Package), NuGetFramework.Parse("net46"), cacheContext, logger, CancellationToken.None); } // Install the package without updating the cache await SimpleTestPackageUtility.CreateFolderFeedV3(pathContext.UserPackagesFolder, PackageSaveMode.Defaultv3, packageA); // Run restore using an incorrect cache var result = await command.ExecuteAsync(); // Verify a is in the output assets file result.Success.Should().BeTrue(); result.LockFile.GetLibrary("a", new NuGetVersion(1, 0, 0)).Should().NotBeNull(); } }
/// <summary> /// Creates a new packages config entry /// </summary> /// <param name="identity">Package id and version</param> /// <param name="targetFramework">Package target framework installed to the project</param> /// <param name="userInstalled">True if the user installed this package directly</param> /// <param name="developmentDependency">True if the package is a development dependency</param> /// <param name="requireReinstallation">True if this package needs to be reinstalled</param> /// <param name="allowedVersions">Restrict package versions to the allowedVersions range</param> public PackageReference(PackageIdentity identity, NuGetFramework targetFramework, bool userInstalled, bool developmentDependency, bool requireReinstallation, VersionRange allowedVersions) { _identity = identity; _allowedVersions = allowedVersions; _targetFramework = targetFramework; _developmentDependency = developmentDependency; _userInstalled = userInstalled; _requireReinstallation = requireReinstallation; }
public async Task ContentFilesMSBuild_VerifyConditionForFallbackContentItemGroupAsync(string files, string expected) { // Arrange var logger = new TestLogger(); using (var cacheContext = new SourceCacheContext()) using (var pathContext = new SimpleTestPathContext()) { var tfi = new List <TargetFrameworkInformation> { new TargetFrameworkInformation() { FrameworkName = NuGetFramework.Parse("net462") } }; var spec = NETCoreRestoreTestUtility.GetProject(projectName: "projectA", framework: "net46"); spec.Dependencies.Add(new LibraryDependency() { LibraryRange = new LibraryRange("a", VersionRange.Parse("1.0.0"), LibraryDependencyTarget.Package) }); var project = NETCoreRestoreTestUtility.CreateProjectsFromSpecs(pathContext, spec).Single(); var packageA = new SimpleTestPackageContext("a"); packageA.AddFile("contentFiles/any/any/anyMarker.txt"); foreach (var file in files.Split('|')) { packageA.AddFile(file); } await SimpleTestPackageUtility.CreatePackagesAsync(pathContext.PackageSource, packageA); // Create dg file var dgFile = new DependencyGraphSpec(); dgFile.AddProject(spec); dgFile.AddRestore(spec.RestoreMetadata.ProjectUniqueName); dgFile.Save(Path.Combine(pathContext.WorkingDirectory, "out.dg")); // Act var result = (await NETCoreRestoreTestUtility.RunRestore( pathContext, logger, new List <PackageSource>() { new PackageSource(pathContext.PackageSource) }, dgFile, cacheContext)).Single(); var props = XDocument.Load(project.PropsOutput); var itemGroups = props.Root.Elements(XName.Get("ItemGroup", "http://schemas.microsoft.com/developer/msbuild/2003")).ToArray(); var group = itemGroups.Single(e => e.ToString().Contains("anyMarker.txt")); // Assert Assert.True(result.Success, logger.ShowErrors()); Assert.Equal(expected.Trim(), group.Attribute(XName.Get("Condition")).Value.Trim()); } }
public async Task DotnetCliTool_ToolRestoreNoOpsRegardlessOfProject() { // Arrange using (var pathContext = new SimpleTestPathContext()) { var logger1 = new TestLogger(); var logger2 = new TestLogger(); var spec1 = ToolRestoreUtility.GetSpec( Path.Combine(pathContext.SolutionRoot, "fake1.csproj"), "a", VersionRange.Parse("1.0.0"), NuGetFramework.Parse("netcoreapp1.0"), pathContext.UserPackagesFolder, new List <string>() { pathContext.FallbackFolder }, new List <PackageSource>() { new PackageSource(pathContext.PackageSource) }, new WarningProperties()); var spec2 = ToolRestoreUtility.GetSpec( Path.Combine(pathContext.SolutionRoot, "fake2.csproj"), "a", VersionRange.Parse("1.0.0"), NuGetFramework.Parse("netcoreapp1.0"), pathContext.UserPackagesFolder, new List <string>() { pathContext.FallbackFolder }, new List <PackageSource>() { new PackageSource(pathContext.PackageSource) }, new WarningProperties()); var dgFile1 = new DependencyGraphSpec(); dgFile1.AddProject(spec1); dgFile1.AddRestore(spec1.Name); var dgFile2 = new DependencyGraphSpec(); dgFile2.AddProject(spec2); dgFile2.AddRestore(spec2.Name); var pathResolver = new ToolPathResolver(pathContext.UserPackagesFolder); var path = pathResolver.GetLockFilePath( "a", NuGetVersion.Parse("1.0.0"), NuGetFramework.Parse("netcoreapp1.0")); await SimpleTestPackageUtility.CreateFolderFeedV3(pathContext.PackageSource, new PackageIdentity("a", NuGetVersion.Parse("1.0.0"))); // Act var results1 = await CommandsTestUtility.RunRestore(dgFile1, pathContext, logger1); // Assert Assert.Equal(1, results1.Count); var result1 = results1.Single(); Assert.True(result1.Success, "Failed: " + string.Join(Environment.NewLine, logger1.Messages)); Assert.False(result1.NoOpRestore, "Should not no-op: " + string.Join(Environment.NewLine, logger1.Messages)); Assert.True(File.Exists(path)); // Act var results2 = await CommandsTestUtility.RunRestore(dgFile2, pathContext, logger2); // Assert Assert.Equal(1, results2.Count); var result2 = results2.Single(); Assert.True(result2.Success, "Failed: " + string.Join(Environment.NewLine, logger2.Messages)); Assert.True(result2.NoOpRestore, "Should no-op: " + string.Join(Environment.NewLine, logger2.Messages)); Assert.True(File.Exists(path)); } }
public async Task DotnetCliTool_BasicToolRestore_DifferentVersionRanges() { // Arrange using (var pathContext = new SimpleTestPathContext()) { // Debugger.Launch(); var logger = new TestLogger(); var dgFile = new DependencyGraphSpec(); var versions = new List <VersionRange>(); var limit = 100; for (int i = 0; i < limit; i++) { var version = VersionRange.Parse($"{i + 1}.0.0"); versions.Add(version); var spec = ToolRestoreUtility.GetSpec( Path.Combine(pathContext.SolutionRoot, $"fake{i}.csproj"), "a", version, NuGetFramework.Parse("netcoreapp1.0"), pathContext.UserPackagesFolder, new List <string>() { pathContext.FallbackFolder }, new List <PackageSource>() { new PackageSource(pathContext.PackageSource) }, new WarningProperties()); dgFile.AddProject(spec); dgFile.AddRestore(spec.Name); } var pathResolver = new ToolPathResolver(pathContext.UserPackagesFolder); foreach (var version in versions) { await SimpleTestPackageUtility.CreateFolderFeedV3(pathContext.PackageSource, new PackageIdentity("a", version.MinVersion)); } // Act var results = await CommandsTestUtility.RunRestore(dgFile, pathContext, logger); // Assert Assert.Equal(limit, results.Count); foreach (var result in results) { Assert.True(result.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages)); } foreach (var version in versions) { var path = pathResolver.GetLockFilePath( "a", version.MinVersion, NuGetFramework.Parse("netcoreapp1.0")); Assert.True(File.Exists(path), $"{path} does not exist!"); } } }
protected override Task CreateVersionsAsync(CancellationToken cancellationToken) { // The value will be null if the server does not return any versions. if (_allPackageVersions == null || _allPackageVersions.Count == 0) { return(Task.CompletedTask); } Versions.Clear(); var installedDependency = InstalledPackageDependencies.Where(p => StringComparer.OrdinalIgnoreCase.Equals(p.Id, Id) && p.VersionRange != null && p.VersionRange.HasLowerBound) .OrderByDescending(p => p.VersionRange.MinVersion) .FirstOrDefault(); // installVersion is null if the package is not installed var installedVersion = installedDependency?.VersionRange; List <(NuGetVersion version, bool isDeprecated)> allVersions = _allPackageVersions?.OrderByDescending(v => v.version).ToList(); // null, if no version constraint defined in package.config VersionRange allowedVersions = _projectVersionConstraints.Select(e => e.VersionRange).FirstOrDefault(); // null, if all versions are allowed to be install or update var blockedVersions = new List <NuGetVersion>(allVersions.Count); List <(NuGetVersion version, bool isDeprecated)> allVersionsAllowed; if (allowedVersions == null) { allowedVersions = VersionRange.All; allVersionsAllowed = allVersions; } else { allVersionsAllowed = allVersions.Where(v => allowedVersions.Satisfies(v.version)).ToList(); foreach ((NuGetVersion version, bool isDeprecated) in allVersions) { if (!allVersionsAllowed.Any(a => a.version.Version.Equals(version.Version))) { blockedVersions.Add(version); } } } var latestPrerelease = allVersionsAllowed.FirstOrDefault(v => v.version.IsPrerelease); var latestStableVersion = allVersionsAllowed.FirstOrDefault(v => !v.version.IsPrerelease); // Add installed version if the project is PackageReference if (_nugetProjects.Any() && installedDependency != null && installedDependency.VersionRange != null && _nugetProjects.First().ProjectStyle.Equals(ProjectModel.ProjectStyle.PackageReference)) { VersionRange installedVersionRange = VersionRange.Parse(installedDependency.VersionRange.OriginalString, true); NuGetVersion bestVersion = installedVersionRange.FindBestMatch(allVersionsAllowed.Select(v => v.version)); var deprecationInfo = allVersionsAllowed.FirstOrDefault(v => v.version == bestVersion).isDeprecated; DisplayVersion displayVersion = new DisplayVersion(installedVersionRange, bestVersion, additionalInfo: string.Empty, isDeprecated: deprecationInfo); _versions.Add(displayVersion); } var isInstalledFloatingOrRange = installedVersion != null && installedVersion.IsFloating || (installedVersion?.OriginalString != null && (installedVersion.OriginalString.StartsWith("(", StringComparison.OrdinalIgnoreCase) || installedVersion.OriginalString.StartsWith("[", StringComparison.OrdinalIgnoreCase))); // Add latest prerelease if neeeded if (latestPrerelease.version != null && (latestStableVersion.version == null || latestPrerelease.version > latestStableVersion.version) && (isInstalledFloatingOrRange || !latestPrerelease.version.Equals(installedVersion?.MinVersion))) { VersionRange latestPrereleaseVersionRange = VersionRange.Parse(latestPrerelease.version.ToString(), allowFloating: false); _versions.Add(new DisplayVersion(latestPrereleaseVersionRange, latestPrerelease.version, Resources.Version_LatestPrerelease, isDeprecated: latestPrerelease.isDeprecated)); } // Add latest stable if needed if (latestStableVersion.version != null && (isInstalledFloatingOrRange || !latestStableVersion.version.Equals(InstalledVersion))) { VersionRange latestStableVersionRange = VersionRange.Parse(latestStableVersion.version.ToString(), allowFloating: false); _versions.Add(new DisplayVersion(latestStableVersionRange, latestStableVersion.version, Resources.Version_LatestStable, isDeprecated: latestStableVersion.isDeprecated)); } // add a separator if (_versions.Count > 0) { _versions.Add(null); } // first add all the available versions to be updated foreach (var version in allVersionsAllowed) { var installed = version.version.Equals(InstalledVersion); var autoReferenced = false; if (installed && _projectVersionConstraints.Any(e => e.IsAutoReferenced && e.VersionRange?.Satisfies(version.version) == true)) { // do not allow auto referenced packages autoReferenced = true; } VersionRange versionRange = VersionRange.Parse(version.version.ToString(), allowFloating: false); _versions.Add(new DisplayVersion(versionRange, version.version, additionalInfo: null, isCurrentInstalled: installed, autoReferenced: autoReferenced, isDeprecated: version.isDeprecated)); } // Disable controls if this is an auto referenced package. SetAutoReferencedCheck(InstalledVersion); // Add disabled versions AddBlockedVersions(blockedVersions); var latestVersion = latestPrerelease.version > latestStableVersion.version ? latestPrerelease.version : latestStableVersion.version; SelectVersion(latestVersion); return(Task.CompletedTask); }
public override Task <bool> InstallPackageAsync(string packageId, VersionRange range, INuGetProjectContext nuGetProjectContext, BuildIntegratedInstallationContext installationContext, CancellationToken token) { throw new NotImplementedException(); }
/// <summary> /// Construct a P4ChangelistSpanQuery from the labels specified as parameters; the labels are not required to be in order /// </summary> /// <param name="InQueryLabelStart">The start or end date for the query</param> /// <param name="InQueryLabelEnd">The start or end date for the query, whichever wasn't specified by the first parameter</param> /// <param name="InDepotFilter">Path to filter the depot by</param> /// <param name="InUserFilter">User to filter the depot by, can be empty string</param> public P4ChangelistSpanQuery(Label InQueryLabelStart, Label InQueryLabelEnd, String InDepotFilter, String InUserFilter = "") : base(InDepotFilter, InUserFilter) { // Reorder the changelists increasing ReOrder(ref InQueryLabelStart, ref InQueryLabelEnd); LabelNameVersion StartLabel = new LabelNameVersion(InQueryLabelStart.Id); LabelNameVersion EndLabel = new LabelNameVersion(InQueryLabelEnd.Id); VersionRange Versions = new VersionRange(StartLabel, EndLabel); mFileFilter = new FileSpec(new DepotPath(InDepotFilter), null, null, Versions); }
// Verifies if minimum version specification for nearVersion is greater than the // minimum version specification for farVersion public static bool IsGreaterThanOrEqualTo(VersionRange nearVersion, VersionRange farVersion) { if (!nearVersion.HasLowerBound) { return(true); } else if (!farVersion.HasLowerBound) { return(false); } else if (nearVersion.IsFloating || farVersion.IsFloating) { NuGetVersion nearMinVersion; NuGetVersion farMinVersion; string nearRelease; string farRelease; if (nearVersion.IsFloating) { if (nearVersion.Float.FloatBehavior == NuGetVersionFloatBehavior.Major) { // nearVersion: "*" return(true); } nearMinVersion = GetReleaseLabelFreeVersion(nearVersion); nearRelease = nearVersion.Float.MinVersion.Release; } else { nearMinVersion = nearVersion.MinVersion; nearRelease = nearVersion.MinVersion.Release; } if (farVersion.IsFloating) { if (farVersion.Float.FloatBehavior == NuGetVersionFloatBehavior.Major) { // farVersion: "*" return(false); } farMinVersion = GetReleaseLabelFreeVersion(farVersion); farRelease = farVersion.Float.MinVersion.Release; } else { farMinVersion = farVersion.MinVersion; farRelease = farVersion.MinVersion.Release; } var result = nearMinVersion.CompareTo(farMinVersion, VersionComparison.Version); if (result != 0) { return(result > 0); } nearRelease = nearRelease?.Trim('-'); farRelease = farRelease?.Trim('-'); if (string.IsNullOrEmpty(nearRelease)) { // near is 1.0.0-* return(true); } else if (string.IsNullOrEmpty(farRelease)) { // near is 1.0.0-alpha-* and far is 1.0.0-* return(false); } else { var lengthToCompare = Math.Min(nearRelease.Length, farRelease.Length); return(StringComparer.OrdinalIgnoreCase.Compare( nearRelease.Substring(0, lengthToCompare), farRelease.Substring(0, lengthToCompare)) >= 0); } } return(nearVersion.MinVersion >= farVersion.MinVersion); }
public void HashCode_WithDownloadDependencies(string left, string right, bool expected) { var leftSide = new TargetFrameworkInformation(); leftSide.DownloadDependencies.AddRange(left.Split(';').Select(e => new DownloadDependency(e, VersionRange.Parse("1.0.0")))); var rightSide = new TargetFrameworkInformation(); rightSide.DownloadDependencies.AddRange(right.Split(';').Select(e => new DownloadDependency(e, VersionRange.Parse("1.0.0")))); AssertHashCode(expected, leftSide, rightSide); }
private static IEnumerable <PackageDependency> GetDependencies(Nuget2BazelConfig json) { return(json.externals.Select(x => x.Key.Split("/")) .Select(y => new PackageDependency(y[0], VersionRange.Parse(y[1]))) .Union(json.dependencies.Select(z => new PackageDependency(z.Key, VersionRange.Parse(z.Value))))); }
/// <summary> /// Creates a new bootstrap process. /// </summary> /// <param name="handler">A callback object used when the the user needs to be asked questions or informed about download and IO tasks.</param> /// <param name="gui"><c>true</c> if the application was launched in GUI mode; <c>false</c> if it was launched in command-line mode.</param> public BootstrapProcess([NotNull] ITaskHandler handler, bool gui) : base(handler) { _gui = gui; _options = new OptionSet { { "?|h|help", () => "Show the built-in help text.", _ => { Handler.Output("Help", HelpText); throw new OperationCanceledException(); // Don't handle any of the other arguments } }, { "batch", () => "Automatically answer questions with defaults when possible. Avoid unnecessary console output (e.g. progress bars).", _ => { if (Handler.Verbosity >= Verbosity.Verbose) throw new OptionException("Cannot combine --batch and --verbose", "verbose"); Handler.Verbosity = Verbosity.Batch; } }, { "v|verbose", () => "More verbose output. Use twice for even more verbose output.", _ => { if (Handler.Verbosity == Verbosity.Batch) throw new OptionException("Cannot combine --batch and --verbose", "batch"); Handler.Verbosity++; } }, { "no-existing", () => "Do not detect and use existing Zero Install instances. Always use downloaded and cached instance.", _ => _noExisting = true }, { "version=", () => "Select a specific {VERSION} of Zero Install. Implies --no-existing.", (VersionRange range) => { _version = range; _noExisting = true; } }, { "feed=", () => "Specify an alternative {FEED} for Zero Install. Must be an absolute URI. Implies --no-existing.", feed => { Config.SelfUpdateUri = new FeedUri(feed); _noExisting = true; } }, { "content-dir=", () => "Specifies a {DIRECTORY} to search for feeds and archives to import. The default is a directory called 'content'.", path => { if (!Directory.Exists(path)) throw new DirectoryNotFoundException($"Directory '{path}' not found."); _contentDir = path; } }, { "o|offline", () => "Run in off-line mode, not downloading anything.", _ => Config.NetworkUse = NetworkLevel.Offline }, // Disable interspersed arguments (needed for passing arguments through to target) { "<>", value => { _targetArgs.Add(value); // Stop using options parser, treat everything from here on as unknown _options.Clear(); } } }; if (EmbeddedConfig.Instance.AppMode == BootstrapMode.None) { _options.Add("silent", () => "Deploy Zero Install in unattended mode. Equivalent to \"maintenance deploy --batch\".", _ => { _targetArgs.Clear(); _targetArgs.AddRange(new[] {"maintenance", "deploy", "--batch"}); if (!IsPerUser) _targetArgs.Add("--machine"); }); _options.Add("verysilent", () => "Deploy Zero Install in unattended mode with no UI. Equivalent to \"maintenance deploy --batch --background\".", _ => { _targetArgs.Clear(); _targetArgs.AddRange(new[] {"maintenance", "deploy", "--batch", "--background"}); if (!IsPerUser) _targetArgs.Add("--machine"); }); } }
public static async Task <IPackageSearchMetadata> GetLatestPackageMetadataAsync( this SourceRepository sourceRepository, string packageId, bool includePrerelease, CancellationToken cancellationToken, VersionRange allowedVersions) { cancellationToken.ThrowIfCancellationRequested(); var metadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>(cancellationToken); using (var sourceCacheContext = new SourceCacheContext()) { // Update http source cache context MaxAge so that it can always go online to fetch // latest version of packages. sourceCacheContext.MaxAge = DateTimeOffset.UtcNow; var packages = await metadataResource?.GetMetadataAsync( packageId, includePrerelease, false, sourceCacheContext, Common.NullLogger.Instance, cancellationToken); // filter packages based on allowed versions var updatedPackages = packages.Where(p => allowedVersions.Satisfies(p.Identity.Version)); var highest = updatedPackages .OrderByDescending(e => e.Identity.Version, VersionComparer.VersionRelease) .FirstOrDefault(); return(highest?.WithVersions(ToVersionInfo(packages, includePrerelease))); } }
public List <string> InstallHelper(string repositoryUrl, List <string> pkgsLeftToInstall, CancellationToken cancellationToken) { PackageSource source = new PackageSource(repositoryUrl); if (_credential != null) { string password = new NetworkCredential(string.Empty, _credential.Password).Password; source.Credentials = PackageSourceCredential.FromUserInput(repositoryUrl, _credential.UserName, password, true, null); } var provider = FactoryExtensionsV3.GetCoreV3(NuGet.Protocol.Core.Types.Repository.Provider); SourceRepository repository = new SourceRepository(source, provider); SearchFilter filter = new SearchFilter(_prerelease); ////////////////////// packages from source /// PackageSource source2 = new PackageSource(repositoryUrl); if (_credential != null) { string password = new NetworkCredential(string.Empty, _credential.Password).Password; source2.Credentials = PackageSourceCredential.FromUserInput(repositoryUrl, _credential.UserName, password, true, null); } var provider2 = FactoryExtensionsV3.GetCoreV3(NuGet.Protocol.Core.Types.Repository.Provider); SourceRepository repository2 = new SourceRepository(source2, provider2); // TODO: proper error handling here PackageMetadataResource resourceMetadata2 = null; try { resourceMetadata2 = repository.GetResourceAsync <PackageMetadataResource>().GetAwaiter().GetResult(); } catch { } SearchFilter filter2 = new SearchFilter(_prerelease); SourceCacheContext context2 = new SourceCacheContext(); foreach (var n in _name) { IPackageSearchMetadata filteredFoundPkgs = null; // Check version first to narrow down the number of pkgs before potential searching through tags VersionRange versionRange = null; if (_version == null) { // ensure that the latst version is returned first (the ordering of versions differ // TODO: proper error handling try { filteredFoundPkgs = (resourceMetadata2.GetMetadataAsync(n, _prerelease, false, context2, NullLogger.Instance, cancellationToken).GetAwaiter().GetResult() .OrderByDescending(p => p.Identity.Version, VersionComparer.VersionRelease) .FirstOrDefault()); } catch { } } else { // check if exact version NuGetVersion nugetVersion; //VersionRange versionRange = VersionRange.Parse(version); NuGetVersion.TryParse(_version, out nugetVersion); // throw if (nugetVersion != null) { // exact version versionRange = new VersionRange(nugetVersion, true, nugetVersion, true, null, null); } else { // check if version range versionRange = VersionRange.Parse(_version); } // Search for packages within a version range // ensure that the latst version is returned first (the ordering of versions differ filteredFoundPkgs = (resourceMetadata2.GetMetadataAsync(n, _prerelease, false, context2, NullLogger.Instance, cancellationToken).GetAwaiter().GetResult() .Where(p => versionRange.Satisfies(p.Identity.Version)) .OrderByDescending(p => p.Identity.Version, VersionComparer.VersionRelease) .FirstOrDefault()); } List <IPackageSearchMetadata> foundDependencies = new List <IPackageSearchMetadata>(); // found a package to install and looking for dependencies // Search for dependencies if (filteredFoundPkgs != null) { // need to parse the depenency and version and such // need to improve this later // this function recursively finds all dependencies // might need to do add instead of AddRange foundDependencies.AddRange(FindDependenciesFromSource(filteredFoundPkgs, resourceMetadata2, context2)); } /// end dep conditional // check which pkgs you actually need to install List <IPackageSearchMetadata> pkgsToInstall = new List <IPackageSearchMetadata>(); // install pkg, then install any dependencies to a temp directory pkgsToInstall.Add(filteredFoundPkgs); pkgsToInstall.AddRange(foundDependencies); if (_asNupkg) { // CreateFolderFeedV3Async(_path, PackageSaveMode.Nupkg | PackageSaveMode.Nuspec, packages). var tempInstallPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString()); var dir = Directory.CreateDirectory(tempInstallPath); // should check it gets created properly //dir.SetAccessControl(new DirectorySecurity(dir.FullName, AccessControlSections.Owner)); // To delete file attributes from the existing ones get the current file attributes first and use AND (&) operator // with a mask (bitwise complement of desired attributes combination). dir.Attributes = dir.Attributes & ~FileAttributes.ReadOnly; //remove any null pkgs pkgsToInstall.Remove(null); // install everything to a temp path foreach (var p in pkgsToInstall) { var pkgIdentity = new PackageIdentity(p.Identity.Id, p.Identity.Version); var resource = new DownloadResourceV2FeedProvider(); var resource2 = resource.TryCreate(repository, cancellationToken); var cacheContext = new SourceCacheContext(); var downloadResource = repository.GetResourceAsync <DownloadResource>().GetAwaiter().GetResult(); var result = downloadResource.GetDownloadResourceResultAsync( pkgIdentity, new PackageDownloadContext(cacheContext), tempInstallPath, logger: NullLogger.Instance, CancellationToken.None).GetAwaiter().GetResult(); // need to close the .nupkg result.Dispose(); // 4) copy to proper path // TODO: test installing a script when it already exists // or move to script path // check for failures // var newPath = Directory.CreateDirectory(Path.Combine(psModulesPath, p.Identity.Id, p.Identity.Version.ToNormalizedString())); var installPath = _path; // when we move the directory over, we'll change the casing of the module directory name from lower case to proper casing. // if script, just move the files over, if module, move the version directory overp var tempPkgIdPath = System.IO.Path.Combine(tempInstallPath, p.Identity.Id, p.Identity.Version.ToString()); var tempPkgVersionPath = System.IO.Path.Combine(tempPkgIdPath, p.Identity.Id.ToLower() + "." + p.Identity.Version + ".nupkg"); var newPath = System.IO.Path.Combine(_path, p.Identity.Id + "." + p.Identity.Version + ".nupkg"); File.Move(tempPkgVersionPath, newPath); // 2) TODO: Verify that all the proper modules installed correctly // remove temp directory recursively Directory.Delete(tempInstallPath, true); pkgsLeftToInstall.Remove(n); } } else { var tempInstallPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString()); var dir = Directory.CreateDirectory(tempInstallPath); // should check it gets created properly //dir.SetAccessControl(new DirectorySecurity(dir.FullName, AccessControlSections.Owner)); // To delete file attributes from the existing ones get the current file attributes first and use AND (&) operator // with a mask (bitwise complement of desired attributes combination). dir.Attributes = dir.Attributes & ~FileAttributes.ReadOnly; //remove any null pkgs pkgsToInstall.Remove(null); // install everything to a temp path foreach (var p in pkgsToInstall) { var pkgIdentity = new PackageIdentity(p.Identity.Id, p.Identity.Version); var resource = new DownloadResourceV2FeedProvider(); var resource2 = resource.TryCreate(repository, cancellationToken); var cacheContext = new SourceCacheContext(); var downloadResource = repository.GetResourceAsync <DownloadResource>().GetAwaiter().GetResult(); var result = downloadResource.GetDownloadResourceResultAsync( pkgIdentity, new PackageDownloadContext(cacheContext), tempInstallPath, logger: NullLogger.Instance, CancellationToken.None).GetAwaiter().GetResult(); // need to close the .nupkg result.Dispose(); // create a download count to see if everything was installed properly // 1) remove the *.nupkg file // may need to modify due to capitalization var dirNameVersion = System.IO.Path.Combine(tempInstallPath, p.Identity.Id, p.Identity.Version.ToNormalizedString()); var nupkgMetadataToDelete = System.IO.Path.Combine(dirNameVersion, ".nupkg.metadata"); var nupkgToDelete = System.IO.Path.Combine(dirNameVersion, (p.Identity.ToString() + ".nupkg").ToLower()); var nupkgSHAToDelete = System.IO.Path.Combine(dirNameVersion, (p.Identity.ToString() + ".nupkg.sha512").ToLower()); var nuspecToDelete = System.IO.Path.Combine(dirNameVersion, (p.Identity.Id + ".nuspec").ToLower()); File.Delete(nupkgMetadataToDelete); File.Delete(nupkgSHAToDelete); File.Delete(nuspecToDelete); File.Delete(nupkgToDelete); // if it's not a script, do the following: var scriptPath = System.IO.Path.Combine(dirNameVersion, (p.Identity.Id.ToString() + ".ps1").ToLower()); var isScript = File.Exists(scriptPath) ? true : false; // 3) create xml //Create PSGetModuleInfo.xml //Set attribute as hidden [System.IO.File]::SetAttributes($psgetItemInfopath, [System.IO.FileAttributes]::Hidden) var fullinstallPath = isScript ? System.IO.Path.Combine(dirNameVersion, (p.Identity.Id + "_InstalledScriptInfo.xml")) : System.IO.Path.Combine(dirNameVersion, "PSGetModuleInfo.xml"); // Create XMLs using (StreamWriter sw = new StreamWriter(fullinstallPath)) { var psModule = "PSModule"; var tags = p.Tags.Split(' '); var module = tags.Contains("PSModule") ? "Module" : null; var script = tags.Contains("PSScript") ? "Script" : null; List <string> includesDscResource = new List <string>(); List <string> includesCommand = new List <string>(); List <string> includesFunction = new List <string>(); List <string> includesRoleCapability = new List <string>(); List <string> filteredTags = new List <string>(); var psDscResource = "PSDscResource_"; var psCommand = "PSCommand_"; var psFunction = "PSFunction_"; var psRoleCapability = "PSRoleCapability_"; foreach (var tag in tags) { if (tag.StartsWith(psDscResource)) { includesDscResource.Add(tag.Remove(0, psDscResource.Length)); } else if (tag.StartsWith(psCommand)) { includesCommand.Add(tag.Remove(0, psCommand.Length)); } else if (tag.StartsWith(psFunction)) { includesFunction.Add(tag.Remove(0, psFunction.Length)); } else if (tag.StartsWith(psRoleCapability)) { includesRoleCapability.Add(tag.Remove(0, psRoleCapability.Length)); } else if (!tag.StartsWith("PSWorkflow_") && !tag.StartsWith("PSCmdlet_") && !tag.StartsWith("PSIncludes_") && !tag.Equals("PSModule") && !tag.Equals("PSScript")) { filteredTags.Add(tag); } } Dictionary <string, List <string> > includes = new Dictionary <string, List <string> >() { { "DscResource", includesDscResource }, { "Command", includesCommand }, { "Function", includesFunction }, { "RoleCapability", includesRoleCapability } }; Dictionary <string, VersionRange> dependencies = new Dictionary <string, VersionRange>(); foreach (var depGroup in p.DependencySets) { PackageDependency depPkg = depGroup.Packages.FirstOrDefault(); dependencies.Add(depPkg.Id, depPkg.VersionRange); } var psGetModuleInfoObj = new PSObject(); // TODO: Add release notes psGetModuleInfoObj.Members.Add(new PSNoteProperty("Name", p.Identity.Id)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("Version", p.Identity.Version)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("Type", module != null ? module : (script != null ? script : null))); psGetModuleInfoObj.Members.Add(new PSNoteProperty("Description", p.Description)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("Author", p.Authors)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("CompanyName", p.Owners)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("PublishedDate", p.Published)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("InstalledDate", System.DateTime.Now)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("LicenseUri", p.LicenseUrl)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("ProjectUri", p.ProjectUrl)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("IconUri", p.IconUrl)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("Includes", includes.ToList())); // TODO: check if getting deserialized properly psGetModuleInfoObj.Members.Add(new PSNoteProperty("PowerShellGetFormatVersion", "3")); psGetModuleInfoObj.Members.Add(new PSNoteProperty("Dependencies", dependencies.ToList())); psGetModuleInfoObj.Members.Add(new PSNoteProperty("RepositorySourceLocation", repositoryUrl)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("Repository", repositoryUrl)); psGetModuleInfoObj.Members.Add(new PSNoteProperty("InstalledLocation", null)); // TODO: add installation location psGetModuleInfoObj.TypeNames.Add("Microsoft.PowerShell.Commands.PSRepositoryItemInfo"); var serializedObj = PSSerializer.Serialize(psGetModuleInfoObj); sw.Write(serializedObj); // set the xml attribute to hidden //System.IO.File.SetAttributes("c:\\code\\temp\\installtestpath\\PSGetModuleInfo.xml", FileAttributes.Hidden); } // 4) copy to proper path // TODO: test installing a script when it already exists // or move to script path // check for failures // var newPath = Directory.CreateDirectory(Path.Combine(psModulesPath, p.Identity.Id, p.Identity.Version.ToNormalizedString())); var installPath = _path; var newPath = isScript ? installPath : System.IO.Path.Combine(installPath, p.Identity.Id.ToString()); // when we move the directory over, we'll change the casing of the module directory name from lower case to proper casing. // if script, just move the files over, if module, move the version directory overp var tempModuleVersionDir = isScript ? System.IO.Path.Combine(tempInstallPath, p.Identity.Id.ToLower(), p.Identity.Version.ToNormalizedString()) : System.IO.Path.Combine(tempInstallPath, p.Identity.Id.ToLower()); if (isScript) { var scriptXML = p.Identity.Id + "_InstalledScriptInfo.xml"; File.Move(System.IO.Path.Combine(tempModuleVersionDir, scriptXML), System.IO.Path.Combine(_path, "InstalledScriptInfos", scriptXML)); File.Move(System.IO.Path.Combine(tempModuleVersionDir, p.Identity.Id.ToLower() + ".ps1"), System.IO.Path.Combine(newPath, p.Identity.Id + ".ps1")); } else { if (!Directory.Exists(newPath)) { Directory.Move(tempModuleVersionDir, newPath); } else { // If the module directory path already exists, Directory.Move throws an exception, so we'll just move the version directory over instead tempModuleVersionDir = System.IO.Path.Combine(tempModuleVersionDir, p.Identity.Version.ToNormalizedString()); Directory.Move(tempModuleVersionDir, System.IO.Path.Combine(newPath, p.Identity.Version.ToNormalizedString())); } } // 2) TODO: Verify that all the proper modules installed correctly // remove temp directory recursively Directory.Delete(tempInstallPath, true); pkgsLeftToInstall.Remove(n); } } } return(pkgsLeftToInstall); }
public void VersionRangeSet_SpecialCaseRangeCombine_AllStablePlusStable() { // Arrange var stable = new VersionRange(new NuGetVersion("1.0.0"), true, new NuGetVersion("2.0.0"), true); var ranges = new List<VersionRange>() { VersionRange.AllStable, stable }; // Act var combined = VersionRange.Combine(ranges); // Assert Assert.Equal(VersionRange.AllStable.ToNormalizedString(), combined.ToNormalizedString()); Assert.False(combined.IncludePrerelease); }
public void ReadFromReadsAllMetadataValues() { var references = new List <PackageReferenceSet> { new PackageReferenceSet( (NuGetFramework)null, new [] { "Test.dll" } ), new PackageReferenceSet( NuGetFramework.Parse("hello"), new [] { "world.winmd" } ) }; // Arrange var manifestStream = CreateManifest( id: "Test-Pack2", version: "1.0.0-alpha", title: "blah", authors: "Outercurve", licenseUrl: "http://nuget.org/license", projectUrl: "http://nuget.org/project", iconUrl: "https://nuget.org/icon", requiresLicenseAcceptance: true, developmentDependency: true, description: "This is not a description", summary: "This is a summary", releaseNotes: "Release notes", copyright: "Copyright 2012", language: "fr-FR", tags: "Test Unit", dependencies: new[] { new PackageDependency("Test", VersionRange.Parse("1.2.0")) }, assemblyReference: new[] { new FrameworkAssemblyReference("System.Data", new[] { NuGetFramework.Parse("4.0") }) }, references: references, serviceable: true, packageTypes: new[] { new PackageType("foo", new Version(2, 0, 0)), new PackageType("bar", new Version(0, 0)) }, minClientVersion: "2.0.1.0" ); var manifestMetadata = new ManifestMetadata { Id = "Test-Pack2", Version = NuGetVersion.Parse("1.0.0-alpha"), Description = "This is not a description", Authors = new[] { "Outercurve" }, RequireLicenseAcceptance = true, DevelopmentDependency = true, Summary = "This is a summary", ReleaseNotes = "Release notes", Copyright = "Copyright 2012", Language = "fr-FR", Tags = "Test Unit", Serviceable = true, DependencyGroups = new[] { new PackageDependencyGroup( NuGetFramework.AnyFramework, new [] { new PackageDependency("Test", VersionRange.Parse("1.2.0")) } ) }, FrameworkReferences = new[] { new FrameworkAssemblyReference("System.Data", new [] { NuGetFramework.Parse("4.0") } ) }, PackageAssemblyReferences = new[] { new PackageReferenceSet( (NuGetFramework)null, new [] { "Test.dll" } ), new PackageReferenceSet( NuGetFramework.Parse("hello"), new [] { "world.winmd" } ) }, PackageTypes = new[] { new PackageType("foo", new Version(2, 0, 0)), new PackageType("bar", new Version(0, 0)) }, MinClientVersionString = "2.0.1.0", }; manifestMetadata.SetLicenseUrl("http://nuget.org/license"); manifestMetadata.SetProjectUrl("http://nuget.org/project"); manifestMetadata.SetIconUrl("https://nuget.org/icon"); var expectedManifest = new Manifest(manifestMetadata); // Act var manifest = Manifest.ReadFrom(manifestStream, validateSchema: true); // Assert AssertManifest(expectedManifest, manifest); }
public void FloatingRange_ToStringMinor() { var range = VersionRange.Parse("1.*"); Assert.Equal("[1.*, )", range.ToNormalizedString()); }
private static void AddDependencyGroups(IEnumerable <LibraryDependency> dependencies, NuGetFramework framework, PackageBuilder builder) { List <PackageDependency> packageDependencies = new List <PackageDependency>(); foreach (var dependency in dependencies) { LibraryIncludeFlags effectiveInclude = dependency.IncludeType & ~dependency.SuppressParent; if (dependency.IncludeType == LibraryIncludeFlags.None || dependency.SuppressParent == LibraryIncludeFlags.All) { continue; } if (dependency.LibraryRange.TypeConstraint == LibraryDependencyTarget.Reference) { var reference = builder.FrameworkReferences.FirstOrDefault(r => r.AssemblyName == dependency.Name); if (reference == null) { builder.FrameworkReferences.Add(new FrameworkAssemblyReference(dependency.Name, new NuGetFramework [] { framework })); } else { if (!reference.SupportedFrameworks.Contains(framework)) { // Add another framework reference by replacing the existing reference var newReference = new FrameworkAssemblyReference(reference.AssemblyName, reference.SupportedFrameworks.Concat(new NuGetFramework[] { framework })); int index = builder.FrameworkReferences.IndexOf(reference); builder.FrameworkReferences.Remove(reference); builder.FrameworkReferences.Insert(index, newReference); } } } else { List <string> includes = new List <string>(); List <string> excludes = new List <string>(); if (effectiveInclude == LibraryIncludeFlags.All) { includes.Add(LibraryIncludeFlags.All.ToString()); } else if ((effectiveInclude & LibraryIncludeFlags.ContentFiles) == LibraryIncludeFlags.ContentFiles) { includes.AddRange(effectiveInclude.ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)); } else { if ((LibraryIncludeFlagUtils.NoContent & ~effectiveInclude) != LibraryIncludeFlags.None) { excludes.AddRange((LibraryIncludeFlagUtils.NoContent & ~effectiveInclude).ToString().Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)); } } VersionRange version = dependency.LibraryRange.VersionRange; if (!version.HasLowerBound && !version.HasUpperBound) { version = new VersionRange(builder.Version); } packageDependencies.Add(new PackageDependency(dependency.Name, version, includes, excludes)); } } builder.DependencyGroups.Add(new PackageDependencyGroup(framework, packageDependencies)); }
public IToolPackage InstallPackage(PackageId packageId, VersionRange versionRange = null, string targetFramework = null, FilePath?nugetConfig = null, DirectoryPath?rootConfigDirectory = null, string[] additionalFeeds = null, string verbosity = null) { var packageRootDirectory = _store.GetRootPackageDirectory(packageId); string rollbackDirectory = null; return(TransactionalAction.Run <IToolPackage>( action: () => { try { var stageDirectory = _store.GetRandomStagingDirectory(); Directory.CreateDirectory(stageDirectory.Value); rollbackDirectory = stageDirectory.Value; var tempProject = CreateTempProject( packageId: packageId, versionRange: versionRange, targetFramework: targetFramework ?? BundledTargetFramework.GetTargetFrameworkMoniker(), restoreDirectory: stageDirectory, assetJsonOutputDirectory: stageDirectory, rootConfigDirectory: rootConfigDirectory, additionalFeeds: additionalFeeds); try { _projectRestorer.Restore( tempProject, nugetConfig, verbosity: verbosity); } finally { File.Delete(tempProject.Value); } var version = _store.GetStagedPackageVersion(stageDirectory, packageId); var packageDirectory = _store.GetPackageDirectory(packageId, version); if (Directory.Exists(packageDirectory.Value)) { throw new ToolPackageException( string.Format( CommonLocalizableStrings.ToolPackageConflictPackageId, packageId, version.ToNormalizedString())); } Directory.CreateDirectory(packageRootDirectory.Value); FileAccessRetrier.RetryOnMoveAccessFailure(() => Directory.Move(stageDirectory.Value, packageDirectory.Value)); rollbackDirectory = packageDirectory.Value; return new ToolPackageInstance(_store, packageId, version, packageDirectory); } catch (Exception ex) when(ex is UnauthorizedAccessException || ex is IOException) { throw new ToolPackageException( string.Format( CommonLocalizableStrings.FailedToInstallToolPackage, packageId, ex.Message), ex); } }, rollback: () => { if (!string.IsNullOrEmpty(rollbackDirectory) && Directory.Exists(rollbackDirectory)) { Directory.Delete(rollbackDirectory, true); } // Delete the root if it is empty if (Directory.Exists(packageRootDirectory.Value) && !Directory.EnumerateFileSystemEntries(packageRootDirectory.Value).Any()) { Directory.Delete(packageRootDirectory.Value, false); } })); }
public override int Execute() { if (!string.IsNullOrEmpty(_configFilePath) && !File.Exists(_configFilePath)) { throw new GracefulException( string.Format( LocalizableStrings.NuGetConfigurationFileDoesNotExist, Path.GetFullPath(_configFilePath))); } VersionRange versionRange = _parseResult.GetVersionRange(); DirectoryPath?toolPath = null; if (!string.IsNullOrEmpty(_toolPath)) { toolPath = new DirectoryPath(_toolPath); } (IToolPackageStore toolPackageStore, IToolPackageStoreQuery toolPackageStoreQuery, IToolPackageInstaller toolPackageInstaller) = _createToolPackageStoresAndInstaller(toolPath, _forwardRestoreArguments); // Prevent installation if any version of the package is installed if (toolPackageStoreQuery.EnumeratePackageVersions(_packageId).FirstOrDefault() != null) { _errorReporter.WriteLine(string.Format(LocalizableStrings.ToolAlreadyInstalled, _packageId).Red()); return(1); } FilePath?configFile = null; if (!string.IsNullOrEmpty(_configFilePath)) { configFile = new FilePath(_configFilePath); } try { IToolPackage package = null; using (var scope = new TransactionScope( TransactionScopeOption.Required, TimeSpan.Zero)) { package = toolPackageInstaller.InstallPackage( new PackageLocation(nugetConfig: configFile, additionalFeeds: _source), packageId: _packageId, versionRange: versionRange, targetFramework: _framework, verbosity: _verbosity); NuGetFramework framework; if (string.IsNullOrEmpty(_framework) && package.Frameworks.Count() > 0) { framework = package.Frameworks .Where(f => f.Version < (new NuGetVersion(Product.Version)).Version) .MaxBy(f => f.Version); } else { framework = string.IsNullOrEmpty(_framework) ? null : NuGetFramework.Parse(_framework); } string appHostSourceDirectory = _shellShimTemplateFinder.ResolveAppHostSourceDirectoryAsync(_architectureOption, framework, RuntimeInformation.ProcessArchitecture).Result; IShellShimRepository shellShimRepository = _createShellShimRepository(appHostSourceDirectory, toolPath); foreach (var command in package.Commands) { shellShimRepository.CreateShim(command.Executable, command.Name, package.PackagedShims); } scope.Complete(); } foreach (string w in package.Warnings) { _reporter.WriteLine(w.Yellow()); } if (_global) { _environmentPathInstruction.PrintAddPathInstructionIfPathDoesNotExist(); } _reporter.WriteLine( string.Format( LocalizableStrings.InstallationSucceeded, string.Join(", ", package.Commands.Select(c => c.Name)), package.Id, package.Version.ToNormalizedString()).Green()); return(0); } catch (Exception ex) when(InstallToolCommandLowLevelErrorConverter.ShouldConvertToUserFacingError(ex)) { throw new GracefulException( messages: InstallToolCommandLowLevelErrorConverter.GetUserFacingMessages(ex, _packageId), verboseMessages: new[] { ex.ToString() }, isUserError: false); } }
private Range(VersionRange real) => UnderlyingRange = real;
internal static TargetFrameworkInformation CreateTargetFrameworkInformation(string tfm = "net461") { var framework = NuGetFramework.Parse(tfm); var dependency = new LibraryDependency( libraryRange: new LibraryRange("Dependency", LibraryDependencyTarget.Package), type: LibraryDependencyType.Default, includeType: LibraryIncludeFlags.None, suppressParent: LibraryIncludeFlags.ContentFiles, noWarn: new List <NuGetLogCode>() { NuGetLogCode.NU1000, NuGetLogCode.NU1001 }, autoReferenced: false, generatePathProperty: false); var imports = NuGetFramework.Parse("net45"); // This makes no sense in the context of fallback, just for testing :) var originalTargetFrameworkInformation = new TargetFrameworkInformation(); originalTargetFrameworkInformation.FrameworkName = framework; originalTargetFrameworkInformation.Dependencies = new List <LibraryDependency>() { dependency }; originalTargetFrameworkInformation.AssetTargetFallback = false; originalTargetFrameworkInformation.Imports = new List <NuGetFramework>() { imports }; originalTargetFrameworkInformation.DownloadDependencies.Add(new DownloadDependency("X", VersionRange.Parse("1.0.0"))); originalTargetFrameworkInformation.FrameworkReferences.Add("frameworkRef"); originalTargetFrameworkInformation.FrameworkReferences.Add("FrameworkReference"); return(originalTargetFrameworkInformation); }
public async Task DotnetCliTool_VerifyProjectsAreNotAllowed() { // Arrange using (var pathContext = new SimpleTestPathContext()) { var logger = new TestLogger(); var dgFile = new DependencyGraphSpec(); var spec = ToolRestoreUtility.GetSpec( Path.Combine(pathContext.SolutionRoot, "tool", "fake.csproj"), "a", VersionRange.Parse("1.0.0"), NuGetFramework.Parse("netcoreapp1.0"), pathContext.UserPackagesFolder, new List <string>() { pathContext.FallbackFolder }, new List <PackageSource>() { new PackageSource(pathContext.PackageSource) }, new WarningProperties()); dgFile.AddProject(spec); dgFile.AddRestore(spec.Name); var pathResolver = new ToolPathResolver(pathContext.UserPackagesFolder); var path = pathResolver.GetLockFilePath( "a", NuGetVersion.Parse("1.0.0"), NuGetFramework.Parse("netcoreapp1.0")); var packageA = new SimpleTestPackageContext() { Id = "a", Version = "1.0.0" }; var packageB = new SimpleTestPackageContext() { Id = "b", Version = "1.0.0" }; packageA.Dependencies.Add(packageB); await SimpleTestPackageUtility.CreateFolderFeedV3( pathContext.PackageSource, PackageSaveMode.Defaultv3, packageA, packageB); var projectYRoot = Path.Combine(pathContext.SolutionRoot, "b"); Directory.CreateDirectory(projectYRoot); var projectYJson = Path.Combine(projectYRoot, "project.json"); var projectJsonContent = JObject.Parse(@"{ 'dependencies': { }, 'frameworks': { 'netstandard1.0': { } } }"); File.WriteAllText(projectYJson, projectJsonContent.ToString()); // Act var result = await CommandsTestUtility.RunSingleRestore(dgFile, pathContext, logger); // Assert Assert.True(result.Success, "Failed: " + string.Join(Environment.NewLine, logger.Messages)); Assert.True(File.Exists(path)); var lockFormat = new LockFileFormat(); var lockFile = lockFormat.Read(path); // Verify only packages Assert.Empty(lockFile.Libraries.Where(e => e.Type != "package")); } }
private async Task ReportDependency(IConsole console, Project.Dependency dependency, VersionRange versionRange, List <Uri> sources, int indentLevel, Project.TargetFramework targetFramework, string projectFilePath) { console.WriteIndent(indentLevel); console.Write($"{dependency.Name}"); if (dependency.AutoReferenced) { console.Write(" [A]"); } var referencedVersion = dependency.ResolvedVersion; if (referencedVersion == null) { console.Write(" "); console.Write("Cannot resolve referenced version", ConsoleColor.White, ConsoleColor.DarkRed); console.WriteLine(); } else { console.Write("..."); var latestVersion = await _nugetService.ResolvePackageVersions(dependency.Name, referencedVersion, sources, versionRange, VersionLock, Prerelease, targetFramework.Name, projectFilePath); console.Write("\b\b\b "); if (latestVersion != null) { console.Write(referencedVersion, latestVersion > referencedVersion ? ConsoleColor.Red : ConsoleColor.Green); } else { console.Write($"{referencedVersion} ", ConsoleColor.Yellow); console.Write("Cannot resolve latest version", ConsoleColor.White, ConsoleColor.DarkCyan); } if (latestVersion > referencedVersion) { console.Write(" ("); console.Write(latestVersion, ConsoleColor.Blue); console.Write(")"); } console.WriteLine(); } foreach (var childDependency in dependency.Dependencies) { await ReportDependency(console, childDependency, childDependency.VersionRange, sources, indentLevel + 1, targetFramework, projectFilePath); } }
public void SerializeThenDeserialize_WithValidArguments_RoundTrips(VersionRange expectedResult) { VersionRange actualResult = SerializeThenDeserialize(VersionRangeFormatter.Instance, expectedResult); Assert.Equal(expectedResult, actualResult); }
public void PackageGraphAnalysisUtilities_GetPackagesWithDependants_Succeeds() { // Set up var packageIdentityA100 = new PackageIdentity("a", NuGetVersion.Parse("1.0.0")); var packageIdentityB100 = new PackageIdentity("b", NuGetVersion.Parse("1.0.0")); var packageIdentityC100 = new PackageIdentity("c", NuGetVersion.Parse("1.0.0")); var packageIdentityC110 = new PackageIdentity("c", NuGetVersion.Parse("1.1.0")); var packageIdentityD100 = new PackageIdentity("d", NuGetVersion.Parse("1.0.0")); var packageDependencyInfos = new List <PackageDependencyInfo>(); var packageDependencyInfoA = new PackageDependencyInfo(packageIdentityA100, new PackageDependency[] { new PackageDependency(packageIdentityB100.Id, VersionRange.Parse(packageIdentityB100.Version.OriginalVersion)), new PackageDependency(packageIdentityC100.Id, VersionRange.Parse(packageIdentityC100.Version.OriginalVersion)), }); var packageDependencyInfoB = new PackageDependencyInfo(packageIdentityB100, new PackageDependency[] { new PackageDependency(packageIdentityD100.Id, VersionRange.Parse(packageIdentityD100.Version.OriginalVersion)), }); var packageDependencyInfoC = new PackageDependencyInfo(packageIdentityC110, Enumerable.Empty <PackageDependency>()); var packageDependencyInfoD = new PackageDependencyInfo(packageIdentityD100, Enumerable.Empty <PackageDependency>()); packageDependencyInfos.Add(packageDependencyInfoA); packageDependencyInfos.Add(packageDependencyInfoB); packageDependencyInfos.Add(packageDependencyInfoC); packageDependencyInfos.Add(packageDependencyInfoD); // Act var packageWithDependants = PackageGraphAnalysisUtilities.GetPackagesWithDependants(packageDependencyInfos); // Assert foreach (var package in packageWithDependants) { switch (package.Identity.Id) { case "a": { Assert.Equal(0, package.DependantPackages.Count); Assert.True(package.IsTopLevelPackage); break; } case "b": { Assert.Equal(1, package.DependantPackages.Count); Assert.Equal(packageIdentityA100.Id, package.DependantPackages.Single().Id); Assert.False(package.IsTopLevelPackage); break; } case "c": { Assert.Equal(0, package.DependantPackages.Count); Assert.True(package.IsTopLevelPackage); break; } case "d": { Assert.Equal(1, package.DependantPackages.Count); Assert.Equal(packageIdentityB100.Id, package.DependantPackages.Single().Id); Assert.False(package.IsTopLevelPackage); break; } default: { Assert.True(false, $"Unexpected package {package.Identity}"); break; } } } }
public void ParseVersionRangeToStringReParse(string minString, string maxString, bool minInc, bool maxInc) { // Arrange var min = NuGetVersion.Parse(minString); var max = NuGetVersion.Parse(maxString); // Act var original = new VersionRange(min, minInc, max, maxInc); var versionInfo = VersionRange.Parse(original.ToString()); // Assert Assert.Equal(min, versionInfo.MinVersion, VersionComparer.Default); Assert.Equal(max, versionInfo.MaxVersion, VersionComparer.Default); Assert.Equal(minInc, versionInfo.IsMinInclusive); Assert.Equal(maxInc, versionInfo.IsMaxInclusive); }
/// <summary> /// </summary> protected override void ProcessRecord() { var dirsToSearch = new List <string>(); if (_path != null) { dirsToSearch.AddRange(Directory.GetDirectories(_path).ToList()); } else { var isWindows = OsPlatform.ToLower().Contains("windows"); // should just check the psmodules path???? // PSModules path var psModulePath = Environment.GetEnvironmentVariable("PSModulePath"); var modulePaths = psModulePath.Split(';'); // if not core var isWindowsPS = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory().ToLower().Contains("windows") ? true : false; if (isWindowsPS) { programFilesPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), "WindowsPowerShell"); /// TODO: Come back to this var userENVpath = System.IO.Path.Combine(Environment.GetEnvironmentVariable("USERPROFILE"), "Documents"); myDocumentsPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), "WindowsPowerShell"); } else { programFilesPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), "PowerShell"); myDocumentsPath = System.IO.Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), "PowerShell"); } /*** Will search first in PSModulePath, then will search in default paths ***/ // 1) Create a list of either // Of all names try { foreach (var path in modulePaths) { dirsToSearch.AddRange(Directory.GetDirectories(path).ToList()); } } catch { } var pfModulesPath = System.IO.Path.Combine(programFilesPath, "Modules"); if (Directory.Exists(pfModulesPath)) { dirsToSearch.AddRange(Directory.GetDirectories(pfModulesPath).ToList()); } var pfScriptsPath = System.IO.Path.Combine(programFilesPath, "Scripts"); if (Directory.Exists(pfScriptsPath)) { dirsToSearch.AddRange(Directory.GetDirectories(pfScriptsPath).ToList()); } var mdModulesPath = System.IO.Path.Combine(myDocumentsPath, "Modules"); // change programfiles to mydocuments if (Directory.Exists(mdModulesPath)) { dirsToSearch.AddRange(Directory.GetDirectories(mdModulesPath).ToList()); } var mdScriptsPath = System.IO.Path.Combine(myDocumentsPath, "Scripts"); // change programFiles to myDocuments if (Directory.Exists(mdScriptsPath)) { dirsToSearch.AddRange(Directory.GetDirectories(mdScriptsPath).ToList()); } // uniqueify dirsToSearch = dirsToSearch.Distinct().ToList(); } // Or a list of the passed in names if (_name != null && !_name[0].Equals("*")) { var nameLowerCased = new List <string>(); Array.ForEach(_name, n => nameLowerCased.Add(n.ToLower())); dirsToSearch = dirsToSearch.FindAll(p => nameLowerCased.Contains(new DirectoryInfo(p).Name.ToLower())); } // try to parse into a specific NuGet version VersionRange versionRange = null; if (_version != null) { NuGetVersion specificVersion; NuGetVersion.TryParse(_version, out specificVersion); if (specificVersion != null) { // exact version versionRange = new VersionRange(specificVersion, true, specificVersion, true, null, null); } else { // check if version range versionRange = VersionRange.Parse(_version); } } List <string> installedPkgsToReturn = new List <string>(); IEnumerable <string> returnPkgs = null; var versionDirs = new List <string>(); //2) use above list to check // if the version specificed is a version range if (versionRange != null) { foreach (var pkgPath in dirsToSearch) { var versionsDirs = Directory.GetDirectories(pkgPath); foreach (var versionPath in versionsDirs) { NuGetVersion dirAsNugetVersion; var dirInfo = new DirectoryInfo(versionPath); NuGetVersion.TryParse(dirInfo.Name, out dirAsNugetVersion); if (versionRange.Satisfies(dirAsNugetVersion)) { // just search scripts paths if (pkgPath.ToLower().Contains("scripts")) { // TODO check if scripts are installed var scriptXmls = Directory.GetFiles(pkgPath); if (_name == null || _name[0].Equals("*")) { // Add all the script xmls installedPkgsToReturn.AddRange(scriptXmls); } else { // Just add the xmls of the names specified foreach (var name in _name) { var scriptXMLPath = System.IO.Path.Combine(pkgPath, name, "_InstalledScriptInfo"); if (File.Exists(scriptXMLPath)) { installedPkgsToReturn.Add(scriptXMLPath); } } } } else { // modules paths versionsDirs = Directory.GetDirectories(pkgPath); // Check if the pkg path actually has version sub directories. if (versionsDirs.Length != 0) { Array.Sort(versionsDirs, StringComparer.OrdinalIgnoreCase); Array.Reverse(versionsDirs); var pkgXmlFilePath = System.IO.Path.Combine(versionsDirs.First(), "PSGetModuleInfo.xml"); // TODO: check if this xml file exists, if it doesn't check if it exists in a previous version installedPkgsToReturn.Add(pkgXmlFilePath); } } installedPkgsToReturn.Add(versionPath); } } } } else { // THIS SHOULD BE DONE // if no version is specified, just get the latest version foreach (var pkgPath in dirsToSearch) { // just search scripts paths if (pkgPath.ToLower().Contains("scripts")) { // TODO check if scripts are installed var scriptXmls = Directory.GetFiles(pkgPath); if (_name == null || _name[0].Equals("*")) { // Add all the script xmls installedPkgsToReturn.AddRange(scriptXmls); } else { // Just add the xmls of the names specified foreach (var name in _name) { var scriptXMLPath = System.IO.Path.Combine(pkgPath, name, "_InstalledScriptInfo"); if (File.Exists(scriptXMLPath)) { installedPkgsToReturn.Add(scriptXMLPath); } } } } else { // modules paths string[] versionsDirs = new string[0]; versionsDirs = Directory.GetDirectories(pkgPath); // Check if the pkg path actually has version sub directories. if (versionsDirs.Length != 0) { Array.Sort(versionsDirs, StringComparer.OrdinalIgnoreCase); Array.Reverse(versionsDirs); var pkgXmlFilePath = System.IO.Path.Combine(versionsDirs.First(), "PSGetModuleInfo.xml"); // TODO: check if this xml file exists, if it doesn't check if it exists in a previous version installedPkgsToReturn.Add(pkgXmlFilePath); } } } } // Flatten returned pkgs before displaying output returnedPkgsFound.Flatten().ToList()[0] var flattenedPkgs = installedPkgsToReturn.Flatten(); foreach (string xmlFilePath in flattenedPkgs) { // Open xml and read metadata from it if (File.Exists(xmlFilePath)) { ReadOnlyPSMemberInfoCollection <PSPropertyInfo> nameInfo; ReadOnlyPSMemberInfoCollection <PSPropertyInfo> versionInfo; ReadOnlyPSMemberInfoCollection <PSPropertyInfo> additionalMetadataInfo; ReadOnlyPSMemberInfoCollection <PSPropertyInfo> psDataInfo; ReadOnlyPSMemberInfoCollection <PSPropertyInfo> repositoryInfo; ReadOnlyPSMemberInfoCollection <PSPropertyInfo> descriptionversionInfo; var isPrelease = false; using (StreamReader sr = new StreamReader(xmlFilePath)) { string text = sr.ReadToEnd(); var deserializedObj = (PSObject)PSSerializer.Deserialize(text); nameInfo = deserializedObj.Properties.Match("Name"); /* // testing adding prerelease parameter * additionalMetadataInfo = deserializedObj.Properties.Match("AdditionalMetadata"); * if (additionalMetadataInfo.Any()) * { * isPrelease = additionalMetadataInfo.FirstOrDefault().Value.ToString().Contains("IsPrerelease=true"); * if ((isPrelease == true) && _prerelease) // find a stable version of the pkg {} * } */ versionInfo = deserializedObj.Properties.Match("Version"); repositoryInfo = deserializedObj.Properties.Match("Repository"); descriptionversionInfo = deserializedObj.Properties.Match("Description"); }; // if -Prerelease is not passed in as a parameter, don't allow prerelease pkgs to be returned, // we still want all pkgs to be returned if -Prerelease is passed in as a param //if ((_prerelease == false && isPrelease == false) || _prerelease == true) //{ PSObject pkgAsPSObject = new PSObject(); try { pkgAsPSObject.Members.Add(new PSNoteProperty("Name", nameInfo.FirstOrDefault().Value)); // need to fix output pkgAsPSObject.Members.Add(new PSNoteProperty("Version", versionInfo.FirstOrDefault().Value)); pkgAsPSObject.Members.Add(new PSNoteProperty("Repository", repositoryInfo.FirstOrDefault().Value)); pkgAsPSObject.Members.Add(new PSNoteProperty("Description", descriptionversionInfo.FirstOrDefault().Value)); WriteObject(pkgAsPSObject); } catch { } //} } } }
public void NonParsedVersionRangeHasNullOriginalString(string range) { // Act var versionInfo = new VersionRange(NuGetVersion.Parse("1.0.0")); // Assert Assert.Null(versionInfo.OriginalString); }
/// <summary> /// Installs the latest version of package <paramref name="packageId" /> that matches /// <paramref name="versionRange" />. Package data, and <paramref name="metadata" /> will be /// saved to the package json configuration file. If plugin already exists try to update its /// version. /// </summary> /// <param name="packageId">The package name</param> /// <param name="metadata">Optional metadata to associate</param> /// <param name="versionRange">The version constraint</param> /// <param name="allowPrereleaseVersions"> /// Whether to include pre-release version in the search /// results /// </param> /// <param name="framework">Which .NET framework should the package be compatible with</param> /// <param name="cancellationToken"></param> /// <returns>Success of operation</returns> /// <exception cref="ArgumentException"><paramref name="packageId" /> contains only white spaces</exception> public async Task <bool> InstallAsync( string packageId, TMeta metadata = default, VersionRange versionRange = null, bool allowPrereleaseVersions = false, NuGetFramework framework = null, CancellationToken cancellationToken = default) { if (packageId == null) { throw new ArgumentNullException(nameof(packageId)); } if (string.IsNullOrWhiteSpace(packageId)) { throw new ArgumentException($"{nameof(packageId)} contains only white spaces"); } try { var version = (await SearchMatchingVersion(packageId, versionRange, framework, cancellationToken).ConfigureAwait(false)).Max(); if (version == null) { return(false); } LogTo.Trace($"Install requested for plugin {packageId} {version.ToNormalizedString()}"); // Check if this package was already installed in a previous run PackageIdentity packageIdentity = new PackageIdentity(packageId, version); // If plugin exact version already exists, abort if (PluginRepo.IsPluginInstalled(packageIdentity, Solution)) { LogTo.Information($"Plugin {packageId} is already installed with version {version.ToNormalizedString()}"); return(true); } // If plugin already exists in a different version, try to update it if (PluginRepo.FindPluginById(packageId) != null) { LogTo.Information("Plugin already exist with a different version. Redirecting to UpdateAsync."); return(await UpdateAsync()); } // If plugin doesn't exist, go ahead and install it return(await Solution.InstallPluginAsync( packageIdentity, metadata, allowPrereleaseVersions, cancellationToken)); } catch (InvalidOperationException ex1) when(ex1.InnerException is OperationCanceledException) { throw; } catch (Exception ex) { LogTo.Error( $"Unexpected exception while installing packages: {(ex is AggregateException aggEx ? string.Join("; ", aggEx.InnerExceptions.Select(x => x.Message)) : ex.Message)}"); throw; } }
public void ParseVersionParsesTokensVersionsCorrectly(string versionString, string min, bool incMin, string max, bool incMax) { // Arrange var versionRange = new VersionRange(min == null ? null : NuGetVersion.Parse(min), incMin, max == null ? null : NuGetVersion.Parse(max), incMax); // Act var actual = VersionRange.Parse(versionString); // Assert Assert.Equal(versionRange.IsMinInclusive, actual.IsMinInclusive); Assert.Equal(versionRange.IsMaxInclusive, actual.IsMaxInclusive); Assert.Equal(versionRange.MinVersion, actual.MinVersion); Assert.Equal(versionRange.MaxVersion, actual.MaxVersion); }
/// <summary> /// True if the range allows pre-release versions. /// </summary> internal static bool IsPrereleaseAllowed(VersionRange range) { return(range?.MaxVersion?.IsPrerelease == true || range?.MinVersion?.IsPrerelease == true); }
/// <summary> /// Found 2839 version(s) in nuget-build [ Nearest version: 1.0.0-beta ] /// </summary> internal static string FormatSourceInfo(KeyValuePair <PackageSource, SortedSet <NuGetVersion> > sourceInfo, VersionRange range) { var bestMatch = GetBestMatch(sourceInfo.Value, range); if (bestMatch != null) { return(string.Format(CultureInfo.CurrentCulture, Strings.FoundVersionsInSource, sourceInfo.Value.Count, sourceInfo.Key.Name, bestMatch.ToNormalizedString())); } return(string.Format(CultureInfo.CurrentCulture, Strings.FoundVersionsInSourceWithoutMatch, sourceInfo.Value.Count, sourceInfo.Key.Name)); }
public IHttpActionResult GetUpdates( ODataQueryOptions <V2FeedPackage> options, [FromODataUri] string packageIds, [FromODataUri] string versions, [FromODataUri] bool includePrerelease, [FromODataUri] bool includeAllVersions, [FromODataUri] string targetFrameworks = "", [FromODataUri] string versionConstraints = "") { if (string.IsNullOrEmpty(packageIds) || string.IsNullOrEmpty(versions)) { return(Ok(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(Ok(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 = _packagesRepository.GetAll() .Include(p => p.PackageRegistration) .Include(p => p.SupportedFrameworks) .Where(p => p.Listed && (includePrerelease || !p.IsPrerelease) && !p.Deleted && idValues.Contains(p.PackageRegistration.Id.ToLower())) .OrderBy(p => p.PackageRegistration.Id); var queryable = GetUpdates(packages, versionLookup, targetFrameworkValues, includeAllVersions) .AsQueryable() .ToV2FeedPackageQuery(GetSiteRoot(), _configurationService.Features.FriendlyLicenses); return(QueryResult(options, queryable, MaxPageSize)); }
public void FindPackage([CanBeNull] string name, [CanBeNull] ImplementationVersion requiredVersion, [CanBeNull] ImplementationVersion minimumVersion, [CanBeNull] ImplementationVersion maximumVersion) { FeedManager.Refresh = Refresh; VersionRange versionRange; if (requiredVersion != null) versionRange = new VersionRange(requiredVersion); else if (minimumVersion != null || maximumVersion != null) versionRange = new VersionRange(minimumVersion, maximumVersion); else versionRange = null; if (SearchMirror) MirrorSearch(name, versionRange); else CatalogSearch(name, versionRange); }
public void FloatingRange_ToStringPrePrefix() { var range = VersionRange.Parse("1.0.0-alpha.*"); Assert.Equal("[1.0.0-alpha.*, )", range.ToNormalizedString()); }
/// <inheritdoc/> public Selection([NotNull] ICommandHandler handler) : base(handler) { Requirements = new Requirements(); Options.Add("customize", () => Resources.OptionCustomize, _ => CustomizeSelections = true); Options.Add("o|offline", () => Resources.OptionOffline, _ => Config.NetworkUse = NetworkLevel.Offline); Options.Add("r|refresh", () => Resources.OptionRefresh, _ => FeedManager.Refresh = true); Options.Add("with-store=", () => Resources.OptionWithStore, delegate(string path) { if (string.IsNullOrEmpty(path)) throw new OptionException(string.Format(Resources.MissingOptionValue, "--with-store"), "with-store"); Store = new CompositeStore(new[] {new DirectoryStore(path), Store}); }); Options.Add("command=", () => Resources.OptionCommand, command => Requirements.Command = command); Options.Add("before=", () => Resources.OptionBefore, (ImplementationVersion version) => _before = version); Options.Add("not-before=", () => Resources.OptionNotBefore, (ImplementationVersion version) => _notBefore = version); Options.Add("version=", () => Resources.OptionVersionRange, (VersionRange range) => _version = range); Options.Add("version-for==", () => Resources.OptionVersionRangeFor, (FeedUri interfaceUri, VersionRange range) => Requirements.ExtraRestrictions[interfaceUri] = range); Options.Add("s|source", () => Resources.OptionSource, _ => Requirements.Source = true); Options.Add("os=", () => Resources.OptionOS + "\n" + SupportedValues(Architecture.KnownOS), (OS os) => Requirements.Architecture = new Architecture(os, Requirements.Architecture.Cpu)); Options.Add("cpu=", () => Resources.OptionCpu + "\n" + SupportedValues(Architecture.KnownCpu), (Cpu cpu) => Requirements.Architecture = new Architecture(Requirements.Architecture.OS, cpu)); Options.Add("language=", () => Resources.OptionLanguage, (CultureInfo lang) => Requirements.Languages.Add(lang)); Options.Add("xml", () => Resources.OptionXml, _ => ShowXml = true); }
public void FindPackage(string name, string requiredVersion, string minimumVersion, string maximumVersion) { FeedManager.Refresh = Refresh; VersionRange versionRange; if (requiredVersion != null) versionRange = new VersionRange(requiredVersion); else if (minimumVersion != null || maximumVersion != null) { versionRange = new VersionRange( (minimumVersion == null) ? null : new ImplementationVersion(minimumVersion), (maximumVersion == null) ? null : new ImplementationVersion(maximumVersion)); } else versionRange = null; if (GlobalSearch) MirrorSearch(name, versionRange); else CatalogSearch(name, versionRange); }