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);
}
