public override int Execute()
{
ValidateArguments();
DirectoryPath?toolPath = null;
if (_toolPath != null)
{
toolPath = new DirectoryPath(_toolPath);
}
VersionRange versionRange = null;
if (!string.IsNullOrEmpty(_packageVersion) && !VersionRange.TryParse(_packageVersion, out versionRange))
{
throw new GracefulException(
string.Format(
LocalizableStrings.InvalidNuGetVersionRange,
_packageVersion));
}
(IToolPackageStore toolPackageStore,
IToolPackageStoreQuery toolPackageStoreQuery,
IToolPackageInstaller toolPackageInstaller,
IToolPackageUninstaller toolPackageUninstaller) = _createToolPackageStoreInstallerUninstaller(toolPath, _forwardRestoreArguments);
IShellShimRepository shellShimRepository = _createShellShimRepository(toolPath);
IToolPackage oldPackageNullable = GetOldPackage(toolPackageStoreQuery);
using (var scope = new TransactionScope(
TransactionScopeOption.Required,
TimeSpan.Zero))
{
if (oldPackageNullable != null)
{
RunWithHandlingUninstallError(() =>
{
foreach (RestoredCommand command in oldPackageNullable.Commands)
{
shellShimRepository.RemoveShim(command.Name);
}
toolPackageUninstaller.Uninstall(oldPackageNullable.PackageDirectory);
});
}
RunWithHandlingInstallError(() =>
{
IToolPackage newInstalledPackage = toolPackageInstaller.InstallPackage(
new PackageLocation(nugetConfig: GetConfigFile(), additionalFeeds: _additionalFeeds),
packageId: _packageId,
targetFramework: _framework,
versionRange: versionRange,
verbosity: _verbosity);
EnsureVersionIsHigher(oldPackageNullable, newInstalledPackage);
foreach (RestoredCommand command in newInstalledPackage.Commands)
{
shellShimRepository.CreateShim(command.Executable, command.Name);
}
PrintSuccessMessage(oldPackageNullable, newInstalledPackage);
});
scope.Complete();
}
return(0);
}
/// <summary>
/// </summary>
protected override void ProcessRecord()
{
source = new CancellationTokenSource();
cancellationToken = source.Token;
NuGetVersion.TryParse(_version, out nugetVersion);
if (nugetVersion == null)
{
VersionRange.TryParse(_version, out versionRange);
}
var consoleIsElevated = false;
var isWindowsPS = true;
#if NET472
// WindowsPS
var id = System.Security.Principal.WindowsIdentity.GetCurrent();
consoleIsElevated = (id.Owner != id.User);
isWindowsPS = true;
myDocumentsPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), "WindowsPowerShell");
programFilesPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), "WindowsPowerShell");
#else
// If Windows OS (PS6+)
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
var id = System.Security.Principal.WindowsIdentity.GetCurrent();
consoleIsElevated = (id.Owner != id.User);
myDocumentsPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), "PowerShell");
programFilesPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), "PowerShell");
}
else
{
// Paths are the same for both Linux and MacOS
myDocumentsPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.LocalApplicationData), "Powershell");
programFilesPath = Path.Combine("usr", "local", "share", "Powershell");
using (System.Management.Automation.PowerShell pwsh = System.Management.Automation.PowerShell.Create())
{
var results = pwsh.AddCommand("id").AddParameter("u").Invoke();
}
}
#endif
foreach (var pkgName in _name)
{
var successfullyUninstalledPkg = UninstallPkgHelper(pkgName, cancellationToken);
if (successfullyUninstalledPkg)
{
Console.WriteLine("Successfully uninstalled {0}", pkgName);
}
else
{
Console.WriteLine("Did not successfully uninstall {0}", pkgName);
}
}
}
public static InstalledPackage GetGlobalInstalledPackage(string packageId, string version = null, string packagesDirectory = null)
{
VersionRange.TryParse(version != null && version.Contains("*") ? $"{version}" : $"[{version}]", out var versionRange);
return(GetGlobalInstalledPackage(packageId, versionRange, packagesDirectory));
}
private static void UpdateDependencies(Dictionary <string, PackageInfo> packages, VersionTranslation translation, bool exactVersions, Func <string, string, string, bool> allowPreReleaseDependencyOpt)
{
var errors = new List <Exception>();
foreach (var package in packages.Values)
{
var dependencies = package.SpecificationXml.
Element(XName.Get("package", package.NuspecXmlns))?.
Element(XName.Get("metadata", package.NuspecXmlns))?.
Element(XName.Get("dependencies", package.NuspecXmlns))?.
Descendants(XName.Get("dependency", package.NuspecXmlns)) ?? Array.Empty <XElement>();
foreach (var dependency in dependencies)
{
string id = dependency.Attribute("id")?.Value;
if (id == null)
{
throw new InvalidDataException($"'{package.Id}' has invalid format: element 'dependency' is missing 'id' attribute");
}
var versionRangeAttribute = dependency.Attribute("version");
if (versionRangeAttribute == null)
{
throw new InvalidDataException($"'{package.Id}' has invalid format: element 'dependency' is missing 'version' attribute");
}
if (!VersionRange.TryParse(versionRangeAttribute.Value, out var versionRange))
{
throw new InvalidDataException($"'{id}' has invalid version range: '{versionRangeAttribute.Value}'");
}
if (packages.TryGetValue(id, out var dependentPackage))
{
if (versionRange.IsFloating ||
versionRange.HasLowerAndUpperBounds && versionRange.MinVersion != versionRange.MaxVersion)
{
throw new InvalidDataException($"Unexpected dependency version range: '{id}, {versionRangeAttribute.Value}'");
}
var newVersion = ToNuGetVersion(dependentPackage.NewVersion);
var newRange = exactVersions ?
new VersionRange(newVersion, includeMinVersion: true, newVersion, includeMaxVersion: true) :
new VersionRange(
versionRange.HasLowerBound ? newVersion : null,
versionRange.IsMinInclusive,
versionRange.HasUpperBound ? newVersion : null,
versionRange.IsMaxInclusive);
// Note: metadata is not included in the range
versionRangeAttribute.SetValue(newRange.ToNormalizedString());
}
else if (translation == VersionTranslation.Release && (versionRange.MinVersion?.IsPrerelease == true || versionRange.MaxVersion?.IsPrerelease == true))
{
if (allowPreReleaseDependencyOpt?.Invoke(package.Id, id, versionRangeAttribute.Value) != true)
{
errors.Add(new InvalidOperationException($"Package '{package.Id}' depends on a pre-release package '{id}, {versionRangeAttribute.Value}'"));
}
}
}
}
ThrowExceptions(errors);
}
private async Task <int> OnExecuteAsync()
{
var reporter = new ConsoleReporter(PhysicalConsole.Singleton)
{
IsVerbose = Verbose
};
var installDir = string.IsNullOrEmpty(OutputDirectory)
? Path.Combine(Directory.GetCurrentDirectory(), "packages")
: Path.GetFullPath(OutputDirectory);
var tempFilePath = Path.Combine(AppContext.BaseDirectory, "projectThatNeverExists.csproj");
ISettings settings = Settings.LoadDefaultSettings(tempFilePath);
VersionRange versionRange;
if (!string.IsNullOrEmpty(Version))
{
if (!VersionRange.TryParse(Version, out versionRange))
{
reporter.Error($"Invalid nuget version '{Version}'");
return(1);
}
}
else
{
versionRange = Prerelease
? VersionRange.AllFloating
: VersionRange.AllStableFloating;
}
var logger = new ConsoleNuGetLogger(reporter);
var results = await RestoreRunnerEx.RunWithoutCommit(tempFilePath,
installDir,
PackageId,
versionRange,
settings,
Sources,
logger);
var success = false;
foreach (var result in results)
{
if (result.Result.Success)
{
var installedVersion = result.Result.LockFile.Libraries.FirstOrDefault(l => string.Equals(PackageId, l.Name, StringComparison.OrdinalIgnoreCase));
if (installedVersion != null)
{
var path = installedVersion.Path;
reporter.Output($"Installed {installedVersion.Name} {installedVersion.Version}");
foreach (var file in installedVersion.Files)
{
reporter.Verbose("Package file: " + file);
}
success = true;
break;
}
}
else
{
foreach (var unresolved in result.Result.GetAllUnresolved())
{
reporter.Warn($"Could not find a package {unresolved.Name} in the version range {unresolved.VersionRange}");
}
}
}
if (success)
{
reporter.Output("Installation succeeded");
return(0);
}
reporter.Error("Installation failed");
return(success ? 1 : 0);
}
private static VersionRange TryParseVersionRange(string versionString)
{
VersionRange value;
return(VersionRange.TryParse(versionString, out value) ? value : null);
}
public static InstalledPackage GetGlobalInstalledPackage(string packageId, [CanBeNull] string version, [CanBeNull] string packagesConfigFile)
{
VersionRange.TryParse(version != null && version.Contains("*") ? $"{version}" : $"[{version}]", out var versionRange);
return(GetGlobalInstalledPackage(packageId, versionRange, packagesConfigFile));
}
/// <summary>
/// Defines a validator that will fail if the value cannot be parsed as <see cref="VersionRange"/>.
/// </summary>
public static IRuleBuilderOptions <T, string?> IsVersionRange <T>(this IRuleBuilder <T, string?> ruleBuilder)
{
return(ruleBuilder
.Must(x => VersionRange.TryParse(x, out _))
.WithMessage("Value '{PropertyValue}' of '{PropertyName}' is not a valid version range."));
}
/// <summary>
/// Reads all package node entries in the config
/// </summary>
/// <returns></returns>
public IEnumerable <PackageReference> GetPackages()
{
var packages = new List <PackageReference>();
foreach (var package in _doc.Root.Elements(XName.Get("package")))
{
string id = null;
if (!TryGetAttribute(package, "id", out id) ||
String.IsNullOrEmpty(id))
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorNullOrEmptyPackageId));
}
string version = null;
if (!TryGetAttribute(package, "version", out version) ||
String.IsNullOrEmpty(version))
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorInvalidPackageVersion,
id,
version));
}
NuGetVersion semver = null;
if (!NuGetVersion.TryParse(version, out semver))
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorInvalidPackageVersion,
id,
version));
}
string attributeValue = null;
VersionRange allowedVersions = null;
if (TryGetAttribute(package, "allowedVersions", out attributeValue))
{
if (!VersionRange.TryParse(attributeValue, out allowedVersions))
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorInvalidAllowedVersions,
id,
attributeValue));
}
}
var targetFramework = NuGetFramework.UnsupportedFramework;
if (TryGetAttribute(package, "targetFramework", out attributeValue))
{
targetFramework = NuGetFramework.Parse(attributeValue, _frameworkMappings);
}
var developmentDependency = BoolAttribute(package, "developmentDependency");
var requireReinstallation = BoolAttribute(package, "requireReinstallation");
var userInstalled = BoolAttribute(package, "userInstalled", true);
var entry = new PackageReference(new PackageIdentity(id, semver), targetFramework, userInstalled, developmentDependency, requireReinstallation, allowedVersions);
packages.Add(entry);
}
// check if there are duplicate entries
var packageIds = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var duplicates = new List <string>();
foreach (var package in packages)
{
if (packageIds.Contains(package.PackageIdentity.Id))
{
duplicates.Add(package.PackageIdentity.Id);
}
else
{
packageIds.Add(package.PackageIdentity.Id);
}
}
if (duplicates.Count > 0)
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorDuplicatePackages,
string.Join(", ", duplicates)));
}
return(packages);
}
public override int Execute()
{
if (_configFilePath != null && !File.Exists(_configFilePath))
{
throw new GracefulException(
string.Format(
LocalizableStrings.NuGetConfigurationFileDoesNotExist,
Path.GetFullPath(_configFilePath)));
}
VersionRange versionRange = null;
if (!string.IsNullOrEmpty(_packageVersion) && !VersionRange.TryParse(_packageVersion, out versionRange))
{
throw new GracefulException(
string.Format(
LocalizableStrings.InvalidNuGetVersionRange,
_packageVersion));
}
FilePath?configFile = null;
if (_configFilePath != null)
{
configFile = new FilePath(_configFilePath);
}
string targetFramework = BundledTargetFramework.GetTargetFrameworkMoniker();
try
{
FilePath manifestFile = GetManifestFilePath();
IToolPackage toolDownloadedPackage =
_toolPackageInstaller.InstallPackageToExternalManagedLocation(
new PackageLocation(
nugetConfig: configFile,
additionalFeeds: _sources,
rootConfigDirectory: manifestFile.GetDirectoryPath()),
_packageId,
versionRange,
targetFramework,
verbosity: _verbosity);
_toolManifestEditor.Add(
manifestFile,
toolDownloadedPackage.Id,
toolDownloadedPackage.Version,
toolDownloadedPackage.Commands.Select(c => c.Name).ToArray());
foreach (var restoredCommand in toolDownloadedPackage.Commands)
{
_localToolsResolverCache.Save(
new Dictionary <RestoredCommandIdentifier, RestoredCommand>
{
[new RestoredCommandIdentifier(
toolDownloadedPackage.Id,
toolDownloadedPackage.Version,
NuGetFramework.Parse(targetFramework),
Constants.AnyRid,
restoredCommand.Name)] =
restoredCommand
});
}
_reporter.WriteLine(
string.Format(
LocalizableStrings.LocalToolInstallationSucceeded,
string.Join(", ", toolDownloadedPackage.Commands.Select(c => c.Name)),
toolDownloadedPackage.Id,
toolDownloadedPackage.Version.ToNormalizedString(),
manifestFile.Value).Green());
return(0);
}
catch (Exception ex) when(InstallToolCommandLowLevelErrorConverter.ShouldConvertToUserFacingError(ex))
{
throw new GracefulException(
messages: InstallToolCommandLowLevelErrorConverter.GetUserFacingMessages(ex, _packageId),
verboseMessages: new[] { ex.ToString() },
isUserError: false);
}
}
public IPackageReferenceContextInfo?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
options.Security.DepthStep(ref reader);
try
{
PackageIdentity?identity = null;
NuGetFramework? framework = null;
bool isUserInstalled = false;
bool isAutoReferenced = false;
bool isDevelopmentDependency = false;
string? allowedVersions = null;
int propertyCount = reader.ReadMapHeader();
for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
{
switch (reader.ReadString())
{
case IdentityPropertyName:
identity = PackageIdentityFormatter.Instance.Deserialize(ref reader, options);
break;
case FrameworkPropertyName:
framework = NuGetFrameworkFormatter.Instance.Deserialize(ref reader, options);
break;
case IsUserInstalledPropertyName:
isUserInstalled = reader.ReadBoolean();
break;
case IsAutoReferencedPropertyName:
isAutoReferenced = reader.ReadBoolean();
break;
case IsDevelopmentDependencyPropertyName:
isDevelopmentDependency = reader.ReadBoolean();
break;
case AllowedVersionsPropertyName:
if (!reader.TryReadNil()) // Advances beyond the current value if the current value is nil and returns true; otherwise leaves the reader's position unchanged and returns false.
{
allowedVersions = reader.ReadString();
}
break;
default:
reader.Skip();
break;
}
}
Assumes.NotNull(identity);
Assumes.NotNull(framework);
var packageReferenceContextInfo = new PackageReferenceContextInfo(identity, framework)
{
IsUserInstalled = isUserInstalled,
IsAutoReferenced = isAutoReferenced,
IsDevelopmentDependency = isDevelopmentDependency
};
if (!string.IsNullOrWhiteSpace(allowedVersions) && VersionRange.TryParse(allowedVersions, out VersionRange versionRange))
{
packageReferenceContextInfo.AllowedVersions = versionRange;
}
return(packageReferenceContextInfo);
}
finally
{
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
reader.Depth--;
}
}
/// <summary>
/// </summary>
protected override void ProcessRecord()
{
source = new CancellationTokenSource();
cancellationToken = source.Token;
NuGetVersion.TryParse(_version, out nugetVersion);
if (nugetVersion == null)
{
VersionRange.TryParse(_version, out versionRange);
}
var windowsIdentity = WindowsIdentity.GetCurrent();
// identity name and authentication type.
string authenticationType = windowsIdentity.AuthenticationType;
string userName = windowsIdentity.Name;
GenericIdentity authenticatedGenericIdentity =
new GenericIdentity(userName, authenticationType);
var id = WindowsIdentity.GetCurrent();
var consoleIsElevated = (id.Owner != id.User);
// Paths
//if (!Platform.IsCoreCLR)
var isWindowsPS = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory().ToLower().Contains("windows") ? true : false;
if (isWindowsPS)
{
programFilesPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), "WindowsPowerShell");
// TODO: Come back to this
//var userENVpath = Path.Join(Environment.GetEnvironmentVariable("USERPROFILE"), "Documents");
myDocumentsPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), "WindowsPowerShell");
}
else
{
programFilesPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.ProgramFiles), "PowerShell");
myDocumentsPath = Path.Combine(Environment.GetFolderPath(SpecialFolder.MyDocuments), "PowerShell");
}
// TODO: uninstall scope???
foreach (var pkgName in _name)
{
var successfullyUninstalledPkg = UninstallPkgHelper(pkgName, cancellationToken);
if (successfullyUninstalledPkg)
{
Console.WriteLine("Successfully uninstalled {0}", pkgName);
}
else
{
Console.WriteLine("Did not successfully uninstall {0}", pkgName);
}
}
}
private void VerifyPackageReferences(string filePath, IReadOnlyDictionary <string, PackageVersionVariable> versionVariables)
{
ProjectRootElement doc;
try
{
doc = ProjectRootElement.Open(filePath);
}
catch (InvalidProjectFileException ex)
{
Log.LogError(null, null, null, filePath, 0, 0, 0, 0, message: "Invalid project file: " + ex.Message);
return;
}
var packageReferences = doc.Items.Where(i => i.ItemType == "PackageReference");
foreach (var pkgRef in packageReferences)
{
var id = pkgRef.Include;
if (string.IsNullOrEmpty(id))
{
// this node is an Update or Remove node
continue;
}
var versionMetadata = pkgRef.Metadata.LastOrDefault(m => m.Name == "Version");
var versionRaw = versionMetadata?.Value;
if (versionMetadata == null || string.IsNullOrEmpty(versionRaw))
{
Log.LogKoreBuildError(pkgRef.Location.File, pkgRef.Location.Line, KoreBuildErrors.PackageReferenceDoesNotHaveVersion, $"PackageReference to {id} does not define a Version");
continue;
}
var versionIsVariable =
versionRaw != null &&
versionRaw.Length > 3 &&
versionRaw[0] == '$' &&
versionRaw[1] == '(' &&
versionRaw[versionRaw.Length - 1] == ')' &&
versionRaw.IndexOf(')') == versionRaw.Length - 1;
if (!versionIsVariable)
{
Log.LogKoreBuildError(pkgRef.Location.File, pkgRef.Location.Line, KoreBuildErrors.PackageRefHasLiteralVersion, "PackageReference must use an MSBuild variable to set the version.");
continue;
}
var versionVarName = versionRaw.Substring(2, versionRaw.Length - 3);
if (!versionVariables.TryGetValue(versionVarName, out var variable))
{
Log.LogKoreBuildError(pkgRef.Location.File, pkgRef.Location.Line, KoreBuildErrors.VariableNotFoundInDependenciesPropsFile, $"The variable {versionRaw} could not be found in {DependenciesFile}");
continue;
}
var versionValue = variable.Version;
if (!VersionRange.TryParse(versionValue, out var nugetVersion))
{
Log.LogKoreBuildError(pkgRef.Location.File, pkgRef.Location.Line, KoreBuildErrors.InvalidPackageVersion, $"PackageReference to {id} has an invalid version identifier: '{versionValue}'");
continue;
}
if (nugetVersion.IsFloating)
{
Log.LogKoreBuildError(pkgRef.Location.File, pkgRef.Location.Line, KoreBuildErrors.PackageRefHasFloatingVersion, $"PackageReference to {id} uses a floating version: '{versionValue}'");
}
}
}
/// <summary>
/// Read package dependencies for all frameworks
/// </summary>
public IEnumerable <PackageDependencyGroup> GetDependencyGroups()
{
var ns = MetadataNode.GetDefaultNamespace().NamespaceName;
var groupFound = false;
foreach (var depGroup in MetadataNode.Elements(XName.Get(Dependencies, ns)).Elements(XName.Get(Group, ns)))
{
groupFound = true;
var groupFramework = GetAttributeValue(depGroup, TargetFramework);
var packages = new List <PackageDependency>();
foreach (var depNode in depGroup.Elements(XName.Get(Dependency, ns)))
{
VersionRange range = null;
var rangeNode = GetAttributeValue(depNode, Version);
if (!String.IsNullOrEmpty(rangeNode))
{
VersionRange.TryParse(rangeNode, out range);
Debug.Assert(range != null, "Unable to parse range: " + rangeNode);
}
var includeFlags = GetFlags(GetAttributeValue(depNode, IncludeFlags));
var excludeFlags = GetFlags(GetAttributeValue(depNode, ExcludeFlags));
var dependency = new PackageDependency(
GetAttributeValue(depNode, Id),
range,
includeFlags,
excludeFlags);
packages.Add(dependency);
}
var framework = String.IsNullOrEmpty(groupFramework)
? NuGetFramework.AnyFramework
: NuGetFramework.Parse(groupFramework, _frameworkProvider);
yield return(new PackageDependencyGroup(framework, packages));
}
// legacy behavior
if (!groupFound)
{
var depNodes = MetadataNode.Elements(XName.Get(Dependencies, ns))
.Elements(XName.Get(Dependency, ns));
var packages = new List <PackageDependency>();
foreach (var depNode in depNodes)
{
VersionRange range = null;
var rangeNode = GetAttributeValue(depNode, Version);
if (!String.IsNullOrEmpty(rangeNode))
{
VersionRange.TryParse(rangeNode, out range);
Debug.Assert(range != null, "Unable to parse range: " + rangeNode);
}
packages.Add(new PackageDependency(GetAttributeValue(depNode, Id), range));
}
if (packages.Any())
{
yield return(new PackageDependencyGroup(NuGetFramework.AnyFramework, packages));
}
}
yield break;
}
public void VersionRangeFloatParsing_Valid(string rangeString)
{
VersionRange range = null;
Assert.True(VersionRange.TryParse(rangeString, out range));
}
public override int Execute()
{
if (string.IsNullOrWhiteSpace(_toolPath) && !_global)
{
throw new GracefulException(LocalizableStrings.InstallToolCommandNeedGlobalOrToolPath);
}
if (!string.IsNullOrWhiteSpace(_toolPath) && _global)
{
throw new GracefulException(LocalizableStrings.InstallToolCommandInvalidGlobalAndToolPath);
}
if (_configFilePath != null && !File.Exists(_configFilePath))
{
throw new GracefulException(
string.Format(
LocalizableStrings.NuGetConfigurationFileDoesNotExist,
Path.GetFullPath(_configFilePath)));
}
VersionRange versionRange = null;
if (!string.IsNullOrEmpty(_packageVersion) && !VersionRange.TryParse(_packageVersion, out versionRange))
{
throw new GracefulException(
string.Format(
LocalizableStrings.InvalidNuGetVersionRange,
_packageVersion));
}
DirectoryPath?toolPath = null;
if (_toolPath != null)
{
toolPath = new DirectoryPath(_toolPath);
}
(IToolPackageStore toolPackageStore, IToolPackageInstaller toolPackageInstaller) =
_createToolPackageStoreAndInstaller(toolPath);
IShellShimRepository shellShimRepository = _createShellShimRepository(toolPath);
// Prevent installation if any version of the package is installed
if (toolPackageStore.EnumeratePackageVersions(_packageId).FirstOrDefault() != null)
{
_errorReporter.WriteLine(string.Format(LocalizableStrings.ToolAlreadyInstalled, _packageId).Red());
return(1);
}
FilePath?configFile = null;
if (_configFilePath != null)
{
configFile = new FilePath(_configFilePath);
}
try
{
IToolPackage package = null;
using (var scope = new TransactionScope(
TransactionScopeOption.Required,
TimeSpan.Zero))
{
package = toolPackageInstaller.InstallPackage(
packageId: _packageId,
versionRange: versionRange,
targetFramework: _framework,
nugetConfig: configFile,
source: _source,
verbosity: _verbosity);
foreach (var command in package.Commands)
{
shellShimRepository.CreateShim(command.Executable, command.Name);
}
scope.Complete();
}
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 (ToolPackageException ex)
{
if (Reporter.IsVerbose)
{
Reporter.Verbose.WriteLine(ex.ToString().Red());
}
_errorReporter.WriteLine(ex.Message.Red());
_errorReporter.WriteLine(string.Format(LocalizableStrings.ToolInstallationFailed, _packageId).Red());
return(1);
}
catch (ToolConfigurationException ex)
{
if (Reporter.IsVerbose)
{
Reporter.Verbose.WriteLine(ex.ToString().Red());
}
_errorReporter.WriteLine(
string.Format(
LocalizableStrings.InvalidToolConfiguration,
ex.Message).Red());
_errorReporter.WriteLine(string.Format(LocalizableStrings.ToolInstallationFailedContactAuthor, _packageId).Red());
return(1);
}
catch (ShellShimException ex)
{
if (Reporter.IsVerbose)
{
Reporter.Verbose.WriteLine(ex.ToString().Red());
}
_errorReporter.WriteLine(
string.Format(
LocalizableStrings.FailedToCreateToolShim,
_packageId,
ex.Message).Red());
_errorReporter.WriteLine(string.Format(LocalizableStrings.ToolInstallationFailed, _packageId).Red());
return(1);
}
}
protected override ITransitivePackageReferenceContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
PackageIdentity?identity = null;
NuGetFramework? framework = null;
bool isUserInstalled = false;
bool isAutoReferenced = false;
bool isDevelopmentDependency = false;
string? allowedVersions = null;
var transitiveOrigins = new List <IPackageReferenceContextInfo>();
int propertyCount = reader.ReadMapHeader();
for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
{
switch (reader.ReadString())
{
case IdentityPropertyName:
identity = PackageIdentityFormatter.Instance.Deserialize(ref reader, options);
break;
case FrameworkPropertyName:
framework = NuGetFrameworkFormatter.Instance.Deserialize(ref reader, options);
break;
case IsUserInstalledPropertyName:
isUserInstalled = reader.ReadBoolean();
break;
case IsAutoReferencedPropertyName:
isAutoReferenced = reader.ReadBoolean();
break;
case IsDevelopmentDependencyPropertyName:
isDevelopmentDependency = reader.ReadBoolean();
break;
case AllowedVersionsPropertyName:
if (!reader.TryReadNil()) // Advances beyond the current value if the current value is nil and returns true; otherwise leaves the reader's position unchanged and returns false.
{
allowedVersions = reader.ReadString();
}
break;
case TransitiveOriginsPropertyName:
var elems = reader.ReadArrayHeader();
for (int i = 0; i < elems; i++)
{
var result = IPackageReferenceContextInfoFormatter.Instance.Deserialize(ref reader, options);
if (result != null)
{
transitiveOrigins.Add(result);
}
}
break;
default:
reader.Skip();
break;
}
}
Assumes.NotNull(identity);
var packageReferenceContextInfo = new TransitivePackageReferenceContextInfo(identity, framework)
{
IsUserInstalled = isUserInstalled,
IsAutoReferenced = isAutoReferenced,
IsDevelopmentDependency = isDevelopmentDependency
};
if (!string.IsNullOrWhiteSpace(allowedVersions) && VersionRange.TryParse(allowedVersions, out VersionRange versionRange))
{
packageReferenceContextInfo.AllowedVersions = versionRange;
}
packageReferenceContextInfo.TransitiveOrigins = transitiveOrigins;
return(packageReferenceContextInfo);
}
private bool TryResolveNugetPackageVersion(
Dictionary <string, INugetPackage> packagesOnConfig,
INugetPackage requestorPackage,
string id,
string version,
bool doNotEnforceDependencyVersions,
out INugetPackage nugetPackage,
out string errorMessage)
{
Contract.Assert(id != null);
// First, the requestedId must exist in the list specified in the config file
if (!packagesOnConfig.ContainsKey(id))
{
nugetPackage = null;
if (requestorPackage.DependentPackageIdsToIgnore.Contains(id) || requestorPackage.DependentPackageIdsToIgnore.Contains("*"))
{
errorMessage = null;
return(true);
}
errorMessage = string.Format(
CultureInfo.InvariantCulture,
"The requested dependency with id '{0}' and version '{1}' is not explicitly listed in the configuration file.", id, version);
return(false);
}
// Now we deal with the version. The candidate package is what we found above, but we have to validate the version is valid wrt the request
var candidatePackage = packagesOnConfig[id];
// If the version is not specified, we use the one listed in the config
if (version == null)
{
nugetPackage = candidatePackage;
errorMessage = null;
// This is just informative. We succeeded already.
Logger.Log.NugetDependencyVersionWasNotSpecifiedButConfigOneWasChosen(
m_context.LoggingContext,
nugetPackage.Id,
nugetPackage.Version);
return(true);
}
// Now we parse the requested version to validate it is compatible with the one specified in the config
if (!NuGetVersion.TryParse(candidatePackage.Version, out var packageOnConfigVersion))
{
nugetPackage = null;
errorMessage = string.Format(
CultureInfo.InvariantCulture,
"Version '{1}' on package '{0}' is malformed.", candidatePackage.Id, packagesOnConfig[id].Version);
return(false);
}
if (VersionRange.TryParse(version, out var versionRange))
{
if (versionRange.Satisfies(packageOnConfigVersion))
{
nugetPackage = candidatePackage;
errorMessage = null;
// This is just informative. We succeeded already.
Logger.Log.NugetDependencyVersionWasPickedWithinRange(
m_context.LoggingContext,
nugetPackage.Id,
nugetPackage.Version,
version);
return(true);
}
if (doNotEnforceDependencyVersions)
{
nugetPackage = candidatePackage;
errorMessage = null;
// This is a warning, but we suceeded since versions are configured to not be enforced
Logger.Log.NugetDependencyVersionDoesNotMatch(
m_context.LoggingContext,
requestorPackage.Id,
requestorPackage.Version,
nugetPackage.Id,
nugetPackage.Version,
version);
return(true);
}
nugetPackage = null;
errorMessage = string.Format(
CultureInfo.InvariantCulture,
"Package '{0}' is specified with version '{1}', but that is not contained in the interval '{2}'.",
id, candidatePackage.Version, version);
return(false);
}
nugetPackage = null;
errorMessage = string.Format(CultureInfo.InvariantCulture, "Could not parse version '{0}'.", version);
return(false);
}
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()));
}
if (!ODataQueryVerifier.AreODataOptionsAllowed(options, ODataQueryVerifier.V2GetUpdates,
_configurationService.Current.IsODataFilterEnabled, nameof(GetUpdates)))
{
return(BadRequest(ODataQueryVerifier.GetValidationFailedMessage(options)));
}
// 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 accepted 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));
}
/// <summary>
/// Reads all package node entries in the config.
/// </summary>
/// <param name="allowDuplicatePackageIds">If True validation will be performed to ensure that
/// only one entry exists for each unique package id.</param>
public IEnumerable <PackageReference> GetPackages(bool allowDuplicatePackageIds)
{
var packages = new List <PackageReference>();
foreach (var package in _doc.Root.Elements(XName.Get(PackagesConfig.PackageNodeName)))
{
string id = null;
if (!PackagesConfig.TryGetAttribute(package, "id", out id) ||
String.IsNullOrEmpty(id))
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorNullOrEmptyPackageId));
}
string version = null;
if (!PackagesConfig.TryGetAttribute(package, PackagesConfig.VersionAttributeName, out version) ||
String.IsNullOrEmpty(version))
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorInvalidPackageVersion,
id,
version));
}
NuGetVersion semver = null;
if (!NuGetVersion.TryParse(version, out semver))
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorInvalidPackageVersion,
id,
version));
}
string attributeValue = null;
VersionRange allowedVersions = null;
if (PackagesConfig.TryGetAttribute(package, PackagesConfig.allowedVersionsAttributeName, out attributeValue))
{
if (!VersionRange.TryParse(attributeValue, out allowedVersions))
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorInvalidAllowedVersions,
id,
attributeValue));
}
}
var targetFramework = NuGetFramework.UnsupportedFramework;
if (PackagesConfig.TryGetAttribute(package, PackagesConfig.TargetFrameworkAttributeName, out attributeValue))
{
targetFramework = NuGetFramework.Parse(attributeValue, _frameworkMappings);
}
var developmentDependency = PackagesConfig.BoolAttribute(package, PackagesConfig.developmentDependencyAttributeName);
var requireReinstallation = PackagesConfig.BoolAttribute(package, PackagesConfig.RequireInstallAttributeName);
var userInstalled = PackagesConfig.BoolAttribute(package, PackagesConfig.UserInstalledAttributeName, true);
var entry = new PackageReference(new PackageIdentity(id, semver), targetFramework, userInstalled, developmentDependency, requireReinstallation, allowedVersions);
packages.Add(entry);
}
// check if there are duplicate entries
var duplicates = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
PackageIdentity lastIdentity = null;
var comparer = PackageIdentity.Comparer;
// Sort the list of packages and check for duplicates
foreach (var package in packages.OrderBy(p => p.PackageIdentity, comparer))
{
if (lastIdentity != null)
{
if (allowDuplicatePackageIds)
{
// Full compare
if (comparer.Equals(package.PackageIdentity, lastIdentity))
{
duplicates.Add(lastIdentity.ToString());
}
}
else if (string.Equals(
package.PackageIdentity.Id,
lastIdentity.Id,
StringComparison.OrdinalIgnoreCase))
{
// Id only compare
duplicates.Add(lastIdentity.Id);
}
}
lastIdentity = package.PackageIdentity;
}
if (duplicates.Count > 0)
{
throw new PackagesConfigReaderException(string.Format(
CultureInfo.CurrentCulture,
Strings.ErrorDuplicatePackages,
string.Join(", ", duplicates)));
}
return(packages);
}
public IEnumerable <PackageDependencyGroup> GetDependencyGroups()
{
string ns = MetadataNode.GetDefaultNamespace().NamespaceName;
bool groupFound = false;
foreach (var depGroup in MetadataNode.Elements(XName.Get(Dependencies, ns)).Elements(XName.Get(Group, ns)))
{
groupFound = true;
string groupFramework = GetAttributeValue(depGroup, TargetFramework);
List <PackageDependency> packages = new List <PackageDependency>();
foreach (var depNode in depGroup.Elements(XName.Get(Dependency, ns)))
{
VersionRange range = null;
var rangeNode = GetAttributeValue(depNode, Version);
if (!String.IsNullOrEmpty(rangeNode))
{
if (!VersionRange.TryParse(rangeNode, out range))
{
// TODO: error handling
}
}
packages.Add(new PackageDependency(GetAttributeValue(depNode, Id), range));
}
yield return(new PackageDependencyGroup(groupFramework, packages));
}
// legacy behavior
if (!groupFound)
{
var depNodes = MetadataNode.Elements(XName.Get(Dependencies, ns))
.Elements(XName.Get(Dependency, ns));
var packages = new List <PackageDependency>();
foreach (var depNode in depNodes)
{
VersionRange range = null;
var rangeNode = GetAttributeValue(depNode, Version);
if (!String.IsNullOrEmpty(rangeNode))
{
if (!VersionRange.TryParse(rangeNode, out range))
{
// TODO: error handling
}
}
packages.Add(new PackageDependency(GetAttributeValue(depNode, Id), range));
}
if (packages.Any())
{
yield return(new PackageDependencyGroup(NuGetFramework.AnyFramework, packages));
}
}
yield break;
}
/// <summary>
/// Replaces the single dependency with the updated version, if it matches any of the
/// dependencies that need to be updated. Stops on the first updated value found.
/// </summary>
/// <returns>The BuildInfo used to change the value, or null if there was no change.</returns>
private DependencyChange ReplaceDependencyVersion(
string projectJsonFile,
JProperty dependencyProperty,
IEnumerable <BuildDependencyInfo> parsedBuildInfos)
{
string id = dependencyProperty.Name;
foreach (BuildDependencyInfo info in parsedBuildInfos)
{
foreach (PackageIdentity packageInfo in info.Packages)
{
if (id != packageInfo.Id)
{
continue;
}
string oldVersion;
if (dependencyProperty.Value is JObject)
{
oldVersion = (string)dependencyProperty.Value["version"];
}
else
{
oldVersion = (string)dependencyProperty.Value;
}
VersionRange parsedOldVersionRange;
if (!VersionRange.TryParse(oldVersion, out parsedOldVersionRange))
{
Trace.TraceWarning($"Couldn't parse '{oldVersion}' for package '{id}' in '{projectJsonFile}'. Skipping.");
continue;
}
NuGetVersion oldNuGetVersion = parsedOldVersionRange.MinVersion;
if (oldNuGetVersion == packageInfo.Version)
{
// Versions match, no update to make.
continue;
}
if (oldNuGetVersion.IsPrerelease || info.UpgradeStableVersions)
{
string newVersion = packageInfo.Version.ToNormalizedString();
if (dependencyProperty.Value is JObject)
{
dependencyProperty.Value["version"] = newVersion;
}
else
{
dependencyProperty.Value = newVersion;
}
return(new DependencyChange
{
Info = info,
PackageId = id,
Before = oldNuGetVersion,
After = packageInfo.Version
});
}
}
}
return(null);
}
public override int Execute()
{
if (_configFilePath != null && !File.Exists(_configFilePath))
{
throw new GracefulException(
string.Format(
LocalizableStrings.NuGetConfigurationFileDoesNotExist,
Path.GetFullPath(_configFilePath)));
}
VersionRange versionRange = null;
if (!string.IsNullOrEmpty(_packageVersion) && !VersionRange.TryParse(_packageVersion, out versionRange))
{
throw new GracefulException(
string.Format(
LocalizableStrings.InvalidNuGetVersionRange,
_packageVersion));
}
DirectoryPath?toolPath = null;
if (_toolPath != null)
{
toolPath = new DirectoryPath(_toolPath);
}
(IToolPackageStore toolPackageStore, IToolPackageStoreQuery toolPackageStoreQuery, IToolPackageInstaller toolPackageInstaller) =
_createToolPackageStoresAndInstaller(toolPath, _forwardRestoreArguments);
IShellShimRepository shellShimRepository = _createShellShimRepository(toolPath);
// 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 (_configFilePath != null)
{
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);
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 static Dependency[] GetDependencies(ArrayList dependencyInfos)
{
List <Dependency> dependenciesFound = new List <Dependency>();
if (dependencyInfos == null)
{
return(dependenciesFound.ToArray());
}
foreach (PSObject dependencyObj in dependencyInfos)
{
// The dependency object can be a string or a hashtable
// eg:
// RequiredModules = @('PSGetTestDependency1')
// RequiredModules = @(@{ModuleName='PackageManagement';ModuleVersion='1.0.0.1'})
if (dependencyObj.BaseObject is Hashtable dependencyInfo)
{
if (!dependencyInfo.ContainsKey("Name"))
{
Dbg.Assert(false, "Derived dependencies Hashtable must contain a Name key");
continue;
}
string dependencyName = (string)dependencyInfo["Name"];
if (String.IsNullOrEmpty(dependencyName))
{
Dbg.Assert(false, "Dependency Name must not be null or empty");
continue;
}
if (dependencyInfo.ContainsKey("RequiredVersion"))
{
if (!Utils.TryParseVersionOrVersionRange((string)dependencyInfo["RequiredVersion"], out VersionRange dependencyVersion))
{
dependencyVersion = VersionRange.All;
}
dependenciesFound.Add(new Dependency(dependencyName, dependencyVersion));
continue;
}
if (dependencyInfo.ContainsKey("MinimumVersion") || dependencyInfo.ContainsKey("MaximumVersion"))
{
NuGetVersion minimumVersion = null;
NuGetVersion maximumVersion = null;
bool includeMin = false;
bool includeMax = false;
if (dependencyInfo.ContainsKey("MinimumVersion") &&
!NuGetVersion.TryParse((string)dependencyInfo["MinimumVersion"], out minimumVersion))
{
VersionRange dependencyAll = VersionRange.All;
dependenciesFound.Add(new Dependency(dependencyName, dependencyAll));
continue;
}
if (dependencyInfo.ContainsKey("MaximumVersion") &&
!NuGetVersion.TryParse((string)dependencyInfo["MaximumVersion"], out maximumVersion))
{
VersionRange dependencyAll = VersionRange.All;
dependenciesFound.Add(new Dependency(dependencyName, dependencyAll));
continue;
}
if (minimumVersion != null)
{
includeMin = true;
}
if (maximumVersion != null)
{
includeMax = true;
}
VersionRange dependencyVersionRange = new VersionRange(
minVersion: minimumVersion,
includeMinVersion: includeMin,
maxVersion: maximumVersion,
includeMaxVersion: includeMax);
dependenciesFound.Add(new Dependency(dependencyName, dependencyVersionRange));
continue;
}
// neither Required, Minimum or Maximum Version provided
VersionRange dependencyVersionRangeAll = VersionRange.All;
dependenciesFound.Add(new Dependency(dependencyName, dependencyVersionRangeAll));
}
else if (dependencyObj.Properties["Name"] != null)
{
string name = dependencyObj.Properties["Name"].Value.ToString();
string version = string.Empty;
VersionRange versionRange = VersionRange.All;
if (dependencyObj.Properties["VersionRange"] != null)
{
version = dependencyObj.Properties["VersionRange"].Value.ToString();
VersionRange.TryParse(version, out versionRange);
}
dependenciesFound.Add(new Dependency(name, versionRange));
}
}
return(dependenciesFound.ToArray());
}
