private async Task PerformV2RestoreAsync(string packagesConfigFilePath, string installPath)
{
var sourceRepositoryProvider = GetSourceRepositoryProvider();
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, installPath, ExcludeVersion);
var installedPackageReferences = GetInstalledPackageReferences(
packagesConfigFilePath,
allowDuplicatePackageIds: true);
var packageRestoreData = installedPackageReferences.Select(reference =>
new PackageRestoreData(
reference,
new[] { packagesConfigFilePath },
isMissing: true));
var packageSources = GetPackageSources(Settings);
Console.PrintPackageSources(packageSources);
var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>();
var packageRestoreContext = new PackageRestoreContext(
nuGetPackageManager,
packageRestoreData,
CancellationToken.None,
packageRestoredEvent: null,
packageRestoreFailedEvent: (sender, args) => { failedEvents.Enqueue(args); },
sourceRepositories: packageSources.Select(sourceRepositoryProvider.CreateRepository),
maxNumberOfParallelTasks: DisableParallelProcessing ? 1 : PackageManagementConstants.DefaultMaxDegreeOfParallelism,
logger: Console);
var missingPackageReferences = installedPackageReferences.Where(reference =>
!nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity)).Any();
if (!missingPackageReferences)
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("InstallCommandNothingToInstall"),
packagesConfigFilePath);
Console.LogMinimal(message);
}
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = NoCache;
cacheContext.DirectDownload = DirectDownload;
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var signingSettings = SignedPackageVerifierSettings.GetClientPolicy(Settings, Console);
var projectContext = new ConsoleProjectContext(Console)
{
PackageExtractionContext = new PackageExtractionContext(
Packaging.PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
Console,
signedPackageVerifier,
signingSettings)
};
var downloadContext = new PackageDownloadContext(cacheContext, installPath, DirectDownload)
{
ExtractionContext = new PackageExtractionContext(
Packaging.PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
Console,
signedPackageVerifier,
signingSettings)
};
var result = await PackageRestoreManager.RestoreMissingPackagesAsync(
packageRestoreContext,
projectContext,
downloadContext);
if (downloadContext.DirectDownload)
{
GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext);
}
// Use failure count to determine errors. result.Restored will be false for noop restores.
if (failedEvents.Count > 0)
{
// Log errors if they exist
foreach (var message in failedEvents.Select(e => new RestoreLogMessage(LogLevel.Error, NuGetLogCode.Undefined, e.Exception.Message)))
{
await Console.LogAsync(message);
}
throw new ExitCodeException(1);
}
}
}
private async Task InstallPackageAsync(
string packageId,
NuGetVersion version,
string installPath)
{
if (version == null)
{
// Avoid searching for the highest version in the global packages folder,
// it needs to come from the feeds instead. Once found it may come from
// the global packages folder unless NoCache is true.
ExcludeCacheAsSource = true;
}
var framework = GetTargetFramework();
// Create the project and set the framework if available.
var project = new InstallCommandProject(
root: installPath,
packagePathResolver: new PackagePathResolver(installPath, !ExcludeVersion),
targetFramework: framework);
var sourceRepositoryProvider = GetSourceRepositoryProvider();
var packageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, installPath);
var packageSources = GetPackageSources(Settings);
var primaryRepositories = packageSources.Select(sourceRepositoryProvider.CreateRepository);
Console.PrintPackageSources(packageSources);
var allowPrerelease = Prerelease || (version != null && version.IsPrerelease);
var dependencyBehavior = GetDependencyBehavior();
using (var sourceCacheContext = new SourceCacheContext())
{
var resolutionContext = new ResolutionContext(
dependencyBehavior,
includePrelease: allowPrerelease,
includeUnlisted: true,
versionConstraints: VersionConstraints.None,
gatherCache: new GatherCache(),
sourceCacheContext: sourceCacheContext);
if (version == null)
{
// Write out a helpful message before the http messages are shown
Console.Log(LogLevel.Minimal, string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("InstallPackageMessage"), packageId, installPath));
// Find the latest version using NuGetPackageManager
var resolvePackage = await NuGetPackageManager.GetLatestVersionAsync(
packageId,
project,
resolutionContext,
primaryRepositories,
Console,
CancellationToken.None);
if (resolvePackage == null || resolvePackage.LatestVersion == null)
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("InstallCommandUnableToFindPackage"),
packageId);
throw new CommandLineException(message);
}
version = resolvePackage.LatestVersion;
}
// Get a list of packages already in the folder.
var installedPackages = await project.GetFolderPackagesAsync(CancellationToken.None);
// Find existing versions of the package
var alreadyInstalledVersions = new HashSet <NuGetVersion>(installedPackages
.Where(e => StringComparer.OrdinalIgnoreCase.Equals(packageId, e.PackageIdentity.Id))
.Select(e => e.PackageIdentity.Version));
var packageIdentity = new PackageIdentity(packageId, version);
// Check if the package already exists or a higher version exists already.
var skipInstall = project.PackageExists(packageIdentity);
// For SxS allow other versions to install. For non-SxS skip if a higher version exists.
skipInstall |= (ExcludeVersion && alreadyInstalledVersions.Any(e => e >= version));
if (skipInstall)
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("InstallCommandPackageAlreadyExists"),
packageIdentity);
Console.LogMinimal(message);
}
else
{
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var signingVerificationSettings = SignedPackageVerifierSettings.GetClientPolicy(Settings, Console);
var projectContext = new ConsoleProjectContext(Console)
{
PackageExtractionContext = new PackageExtractionContext(
Packaging.PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
Console,
signedPackageVerifier,
signingVerificationSettings)
};
resolutionContext.SourceCacheContext.NoCache = NoCache;
resolutionContext.SourceCacheContext.DirectDownload = DirectDownload;
var downloadContext = new PackageDownloadContext(resolutionContext.SourceCacheContext, installPath, DirectDownload)
{
ExtractionContext = new PackageExtractionContext(
Packaging.PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
Console,
signedPackageVerifier,
signingVerificationSettings)
};
if (EffectivePackageSaveMode != Packaging.PackageSaveMode.None)
{
downloadContext.ExtractionContext.PackageSaveMode = EffectivePackageSaveMode;
}
await packageManager.InstallPackageAsync(
project,
packageIdentity,
resolutionContext,
projectContext,
downloadContext,
primaryRepositories,
Enumerable.Empty <SourceRepository>(),
CancellationToken.None);
if (downloadContext.DirectDownload)
{
GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext);
}
}
}
}
/// <summary>
/// Installs one or more packages into the specified project.
/// </summary>
/// <param name="packageInstaller">The package installer service that performs the actual package installation.</param>
/// <param name="project">The target project for installation.</param>
/// <param name="configuration">
/// The packages to install, where to install them from, and additional options for
/// their installation.
/// </param>
/// <param name="repositorySettings">The repository settings for the packages being installed.</param>
/// <param name="preferPackageReferenceFormat">Install packages to the project as PackageReference if the project type supports it</param>
/// <param name="warningHandler">
/// An action that accepts a warning message and presents it to the user, allowing
/// execution to continue.
/// </param>
/// <param name="errorHandler">
/// An action that accepts an error message and presents it to the user, allowing
/// execution to continue.
/// </param>
internal async Task PerformPackageInstallAsync(
IVsPackageInstaller packageInstaller,
EnvDTE.Project project,
PreinstalledPackageConfiguration configuration,
bool preferPackageReferenceFormat,
Action <string> warningHandler,
Action <string> errorHandler)
{
ThreadHelper.ThrowIfNotOnUIThread();
var repositoryPath = configuration.RepositoryPath;
var repositorySource = new Configuration.PackageSource(repositoryPath);
var failedPackageErrors = new List <string>();
// find the project
var defaultProjectContext = new VSAPIProjectContext();
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var logger = new LoggerAdapter(defaultProjectContext);
defaultProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
logger,
signedPackageVerifier,
SignedPackageVerifierSettings.GetClientPolicy(_settings, logger));
var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, defaultProjectContext);
if (preferPackageReferenceFormat && await NuGetProjectUpgradeUtility.IsNuGetProjectUpgradeableAsync(nuGetProject, project, needsAPackagesConfig: false))
{
nuGetProject = await _solutionManager.UpgradeProjectToPackageReferenceAsync(nuGetProject);
}
// For BuildIntegratedNuGetProject, nuget will ignore preunzipped configuration.
var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject;
var repository = (buildIntegratedProject == null && configuration.IsPreunzipped) ?
_sourceProvider.CreateRepository(repositorySource, FeedType.FileSystemUnzipped) :
_sourceProvider.CreateRepository(repositorySource);
var repoProvider = new PreinstalledRepositoryProvider(errorHandler, _sourceProvider);
repoProvider.AddFromSource(repository);
var packageManager = _installer.CreatePackageManager(repoProvider);
var gatherCache = new GatherCache();
var sources = repoProvider.GetRepositories().ToList();
// store expanded node state
var expandedNodes = await VsHierarchyUtility.GetAllExpandedNodesAsync(_solutionManager);
try
{
foreach (var package in configuration.Packages)
{
var packageIdentity = new PackageIdentity(package.Id, package.Version);
// Does the project already have this package installed?
if (_packageServices.IsPackageInstalled(project, package.Id))
{
// If so, is it the right version?
if (!_packageServices.IsPackageInstalledEx(project, package.Id, package.Version.ToNormalizedString()))
{
// No? Raise a warning (likely written to the Output window) and ignore this package.
warningHandler(string.Format(VsResources.PreinstalledPackages_VersionConflict, package.Id, package.Version));
}
// Yes? Just silently ignore this package!
}
else
{
try
{
if (InfoHandler != null)
{
InfoHandler(string.Format(CultureInfo.CurrentCulture, VsResources.PreinstalledPackages_PackageInstallStatus, package.Id, package.Version));
}
// Skip assembly references and disable binding redirections should be done together
var disableBindingRedirects = package.SkipAssemblyReferences;
var projectContext = new VSAPIProjectContext(package.SkipAssemblyReferences, disableBindingRedirects);
var loggerAdapter = new LoggerAdapter(projectContext);
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
loggerAdapter,
signedPackageVerifier,
SignedPackageVerifierSettings.GetClientPolicy(_settings, loggerAdapter));
// This runs from the UI thread
await _installer.InstallInternalCoreAsync(
packageManager,
gatherCache,
nuGetProject,
packageIdentity,
sources,
projectContext,
includePrerelease : false,
ignoreDependencies : package.IgnoreDependencies,
token : CancellationToken.None);
}
catch (InvalidOperationException exception)
{
failedPackageErrors.Add(package.Id + "." + package.Version + " : " + exception.Message);
}
catch (AggregateException aggregateEx)
{
var ex = aggregateEx.Flatten().InnerExceptions.FirstOrDefault();
if (ex is InvalidOperationException)
{
failedPackageErrors.Add(package.Id + "." + package.Version + " : " + ex.Message);
}
else
{
throw;
}
}
}
}
if (failedPackageErrors.Any())
{
var errorString = new StringBuilder();
errorString.AppendFormat(VsResources.PreinstalledPackages_FailedToInstallPackage, repositoryPath);
errorString.AppendLine();
errorString.AppendLine();
errorString.Append(String.Join(Environment.NewLine, failedPackageErrors));
errorHandler(errorString.ToString());
}
// RepositorySettings = null in unit tests
if (EnvDTEProjectInfoUtility.IsWebSite(project))
{
CreateRefreshFilesInBin(
project,
repositoryPath,
configuration.Packages.Where(p => p.SkipAssemblyReferences));
CopyNativeBinariesToBin(project, repositoryPath, configuration.Packages);
}
}
finally
{
// collapse nodes
await VsHierarchyUtility.CollapseAllNodesAsync(_solutionManager, expandedNodes);
}
}
/// <summary>
/// Adds refresh files to the specified project for all assemblies references belonging to the packages
/// specified by packageNames.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="repositoryPath">The file system pointing to 'packages' folder under the solution.</param>
/// <param name="packageNames">The package names.</param>
private void AddRefreshFilesForReferences(EnvDTE.Project project, string repositoryPath, IEnumerable <PackageIdentity> packageNames)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (repositoryPath == null)
{
throw new ArgumentNullException("repositoryPath");
}
if (!packageNames.Any())
{
return;
}
VSAPIProjectContext context = new VSAPIProjectContext(skipAssemblyReferences: true, bindingRedirectsDisabled: true);
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var logger = new LoggerAdapter(context);
context.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
logger,
signedPackageVerifier,
SignedPackageVerifierSettings.GetClientPolicy(_settings, logger));
WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context);
foreach (var packageName in packageNames)
{
string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version);
DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath));
PackageFolderReader reader = new PackageFolderReader(packageFolder);
var frameworkGroups = reader.GetReferenceItems();
var groups = reader.GetReferenceItems();
var fwComparer = new NuGetFrameworkFullComparer();
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework));
if (targetGroupFramework != null)
{
var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault();
foreach (string refItem in refGroup.Items)
{
string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar));
// create one refresh file for each assembly reference, as per required by Website projects
// projectSystem.CreateRefreshFile(assemblyPath);
RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath);
}
}
}
}
/// <summary>
/// The static method which takes in all the possible parameters
/// </summary>
/// <returns>Returns true if at least one of the packages needed to be restored and got restored</returns>
/// <remarks>
/// Best use case is 'nuget.exe restore .sln' where there is no project loaded and there is no SolutionManager.
/// The references are obtained by parsing of solution file and by using PackagesConfigReader. In this case,
/// you don't construct an object of PackageRestoreManager,
/// but just the NuGetPackageManager using constructor that does not need the SolutionManager, and, optionally
/// register to events and/or specify the source repositories
/// </remarks>
public static async Task <PackageRestoreResult> RestoreMissingPackagesAsync(
PackageRestoreContext packageRestoreContext,
INuGetProjectContext nuGetProjectContext,
PackageDownloadContext downloadContext)
{
if (packageRestoreContext == null)
{
throw new ArgumentNullException(nameof(packageRestoreContext));
}
if (nuGetProjectContext == null)
{
throw new ArgumentNullException(nameof(nuGetProjectContext));
}
ActivityCorrelationId.StartNew();
var missingPackages = packageRestoreContext.Packages.Where(p => p.IsMissing).ToList();
if (!missingPackages.Any())
{
return(new PackageRestoreResult(true, Enumerable.Empty <PackageIdentity>()));
}
// It is possible that the dictionary passed in may not have used the PackageReferenceComparer.
// So, just to be sure, create a hashset with the keys from the dictionary using the PackageReferenceComparer
// Now, we are guaranteed to not restore the same package more than once
var hashSetOfMissingPackageReferences = new HashSet <PackageReference>(missingPackages.Select(p => p.PackageReference), new PackageReferenceComparer());
// Before starting to restore package, set the nuGetProjectContext such that satellite files are not copied yet
// Satellite files will be copied as a post operation. This helps restore packages in parallel
// and not have to determine if the package is a satellite package beforehand
if (nuGetProjectContext.PackageExtractionContext == null)
{
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
nuGetProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
new LoggerAdapter(nuGetProjectContext),
signedPackageVerifier,
SignedPackageVerifierSettings.GetDefault());
}
nuGetProjectContext.PackageExtractionContext.CopySatelliteFiles = false;
packageRestoreContext.Token.ThrowIfCancellationRequested();
var attemptedPackages = await ThrottledPackageRestoreAsync(
hashSetOfMissingPackageReferences,
packageRestoreContext,
nuGetProjectContext,
downloadContext);
packageRestoreContext.Token.ThrowIfCancellationRequested();
await ThrottledCopySatelliteFilesAsync(
hashSetOfMissingPackageReferences,
packageRestoreContext,
nuGetProjectContext);
return(new PackageRestoreResult(
attemptedPackages.All(p => p.Restored),
attemptedPackages.Select(p => p.Package.PackageIdentity).ToList()));
}
public IEnumerable <IVsPackageMetadata> GetInstalledPackages(Project project)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async delegate
{
var packages = new List <IVsPackageMetadata>();
if (_solutionManager != null &&
!string.IsNullOrEmpty(_solutionManager.SolutionDirectory))
{
InitializePackageManagerAndPackageFolderPath();
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var projectContext = new VSAPIProjectContext();
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
new LoggerAdapter(projectContext),
signedPackageVerifier,
SignedPackageVerifierSettings.GetDefault());
var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(
project,
projectContext);
if (nuGetProject != null)
{
FallbackPackagePathResolver pathResolver = null;
var buildIntegratedProject = nuGetProject as BuildIntegratedNuGetProject;
if (buildIntegratedProject != null)
{
pathResolver = await GetPackagesPathResolverAsync(buildIntegratedProject);
}
var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None);
foreach (var package in installedPackages)
{
if (!package.PackageIdentity.HasVersion)
{
// Currently we are not supporting floating versions
// because of that we will skip this package so that it doesn't throw ArgumentNullException
continue;
}
string installPath;
if (buildIntegratedProject != null)
{
installPath = pathResolver.GetPackageDirectory(package.PackageIdentity.Id, package.PackageIdentity.Version);
}
else
{
// Get the install path for package
installPath = _packageManager.PackagesFolderNuGetProject.GetInstalledPath(
package.PackageIdentity);
if (!string.IsNullOrEmpty(installPath))
{
// normalize the path and take the dir if the nupkg path was given
var dir = new DirectoryInfo(installPath);
installPath = dir.FullName;
}
}
var metadata = new VsPackageMetadata(package.PackageIdentity, installPath);
packages.Add(metadata);
}
}
}
return packages;
}));
}
internal async Task InstallInternalAsync(
Project project,
List <Packaging.Core.PackageDependency> packages,
ISourceRepositoryProvider repoProvider,
bool skipAssemblyReferences,
bool ignoreDependencies,
CancellationToken token)
{
foreach (var group in packages.GroupBy(e => e.Id, StringComparer.OrdinalIgnoreCase))
{
if (group.Count() > 1)
{
// throw if a package id appears more than once
throw new InvalidOperationException(VsResources.InvalidPackageList);
}
}
// find the latest package
var metadataResources = new List <MetadataResource>();
// create the resources for looking up the latest version
foreach (var repo in repoProvider.GetRepositories())
{
var resource = await repo.GetResourceAsync <MetadataResource>();
if (resource != null)
{
metadataResources.Add(resource);
}
}
// find the highest version within the ranges
var idToIdentity = new Dictionary <string, PackageIdentity>(StringComparer.OrdinalIgnoreCase);
using (var sourceCacheContext = new SourceCacheContext())
{
foreach (var dep in packages)
{
NuGetVersion highestVersion = null;
if (dep.VersionRange != null &&
VersionComparer.Default.Equals(dep.VersionRange.MinVersion, dep.VersionRange.MaxVersion) &&
dep.VersionRange.MinVersion != null)
{
// this is a single version, not a range
highestVersion = dep.VersionRange.MinVersion;
}
else
{
var tasks = new List <Task <IEnumerable <NuGetVersion> > >();
foreach (var resource in metadataResources)
{
tasks.Add(resource.GetVersions(dep.Id, sourceCacheContext, NullLogger.Instance, token));
}
var versions = await Task.WhenAll(tasks.ToArray());
highestVersion = versions.SelectMany(v => v).Where(v => dep.VersionRange.Satisfies(v)).Max();
}
if (highestVersion == null)
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, VsResources.UnknownPackage, dep.Id));
}
if (!idToIdentity.ContainsKey(dep.Id))
{
idToIdentity.Add(dep.Id, new PackageIdentity(dep.Id, highestVersion));
}
}
}
// Skip assembly references and disable binding redirections should be done together
var disableBindingRedirects = skipAssemblyReferences;
var projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects);
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
new LoggerAdapter(projectContext),
signedPackageVerifier,
SignedPackageVerifierSettings.GetDefault());
await InstallInternalAsync(
project,
idToIdentity.Values.ToList(),
repoProvider,
projectContext,
includePrerelease : false,
ignoreDependencies : ignoreDependencies,
token : token);
}
public override async Task ExecuteCommandAsync()
{
// update with self as parameter
if (Self)
{
var selfUpdater = new SelfUpdater(repositoryFactory: RepositoryFactory)
{
Console = Console
};
selfUpdater.UpdateSelf(Prerelease);
return;
}
string inputFile = GetInputFile();
if (string.IsNullOrEmpty(inputFile))
{
throw new CommandLineException(NuGetResources.InvalidFile);
}
_msbuildDirectory = MsBuildUtility.GetMsBuildDirectoryFromMsBuildPath(MSBuildPath, MSBuildVersion, Console).Value.Path;
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var signedPackageVerifierSettings = SignedPackageVerifierSettings.GetDefault();
var context = new UpdateConsoleProjectContext(Console, FileConflictAction);
context.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
new LoggerAdapter(context),
signedPackageVerifier,
signedPackageVerifierSettings);
string inputFileName = Path.GetFileName(inputFile);
// update with packages.config as parameter
if (CommandLineUtility.IsValidConfigFileName(inputFileName))
{
await UpdatePackagesAsync(inputFile, context);
return;
}
// update with project file as parameter
if (ProjectHelper.SupportedProjectExtensions.Contains(Path.GetExtension(inputFile) ?? string.Empty))
{
if (!File.Exists(inputFile))
{
throw new CommandLineException(NuGetResources.UnableToFindProject, inputFile);
}
var projectSystem = new MSBuildProjectSystem(
_msbuildDirectory,
inputFile,
context);
await UpdatePackagesAsync(projectSystem, GetRepositoryPath(projectSystem.ProjectFullPath));
return;
}
if (!File.Exists(inputFile))
{
throw new CommandLineException(NuGetResources.UnableToFindSolution, inputFile);
}
// update with solution as parameter
string solutionDir = Path.GetDirectoryName(inputFile);
await UpdateAllPackages(solutionDir, context);
}
/// <summary>
/// Asynchronously installs a package.
/// </summary>
/// <param name="packageIdentity">A package identity.</param>
/// <param name="downloadResourceResult">A download resource result.</param>
/// <param name="nuGetProjectContext">A NuGet project context.</param>
/// <param name="token">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns a <see cref="bool" />
/// indication successfulness of the operation.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="packageIdentity" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="downloadResourceResult" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="nuGetProjectContext" />
/// is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown if the package stream for
/// <paramref name="downloadResourceResult" /> is not seekable.</exception>
public override Task <bool> InstallPackageAsync(
PackageIdentity packageIdentity,
DownloadResourceResult downloadResourceResult,
INuGetProjectContext nuGetProjectContext,
CancellationToken token)
{
if (packageIdentity == null)
{
throw new ArgumentNullException(nameof(packageIdentity));
}
if (downloadResourceResult == null)
{
throw new ArgumentNullException(nameof(downloadResourceResult));
}
if (nuGetProjectContext == null)
{
throw new ArgumentNullException(nameof(nuGetProjectContext));
}
if (downloadResourceResult.Status == DownloadResourceResultStatus.Available &&
!downloadResourceResult.PackageStream.CanSeek)
{
throw new ArgumentException(Strings.PackageStreamShouldBeSeekable, nameof(downloadResourceResult));
}
var packageDirectory = PackagePathResolver.GetInstallPath(packageIdentity);
return(ConcurrencyUtilities.ExecuteWithFileLockedAsync(
packageDirectory,
action: async cancellationToken =>
{
// 1. Set a default package extraction context, if necessary.
var packageExtractionContext = nuGetProjectContext.PackageExtractionContext;
if (packageExtractionContext == null)
{
var signedPackageVerifier = !downloadResourceResult.SignatureVerified ? new PackageSignatureVerifier(
SignatureVerificationProviderFactory.GetSignatureVerificationProviders(),
SignedPackageVerifierSettings.Default) : null;
packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
new LoggerAdapter(nuGetProjectContext),
signedPackageVerifier);
}
// 2. Check if the Package already exists at root, if so, return false
if (PackageExists(packageIdentity, packageExtractionContext.PackageSaveMode))
{
nuGetProjectContext.Log(MessageLevel.Info, Strings.PackageAlreadyExistsInFolder, packageIdentity, Root);
return false;
}
nuGetProjectContext.Log(MessageLevel.Info, Strings.AddingPackageToFolder, packageIdentity, Path.GetFullPath(Root));
// 3. Call PackageExtractor to extract the package into the root directory of this FileSystemNuGetProject
if (downloadResourceResult.Status == DownloadResourceResultStatus.Available)
{
downloadResourceResult.PackageStream.Seek(0, SeekOrigin.Begin);
}
var addedPackageFilesList = new List <string>();
if (downloadResourceResult.PackageReader != null)
{
if (downloadResourceResult.Status == DownloadResourceResultStatus.AvailableWithoutStream)
{
addedPackageFilesList.AddRange(
await PackageExtractor.ExtractPackageAsync(
downloadResourceResult.PackageReader,
PackagePathResolver,
packageExtractionContext,
cancellationToken,
nuGetProjectContext.OperationId));
}
else
{
addedPackageFilesList.AddRange(
await PackageExtractor.ExtractPackageAsync(
downloadResourceResult.PackageReader,
downloadResourceResult.PackageStream,
PackagePathResolver,
packageExtractionContext,
cancellationToken,
nuGetProjectContext.OperationId));
}
}
else
{
addedPackageFilesList.AddRange(
await PackageExtractor.ExtractPackageAsync(
downloadResourceResult.PackageStream,
PackagePathResolver,
packageExtractionContext,
cancellationToken,
nuGetProjectContext.OperationId));
}
var packageSaveMode = GetPackageSaveMode(nuGetProjectContext);
if (packageSaveMode.HasFlag(PackageSaveMode.Nupkg))
{
var packageFilePath = GetInstalledPackageFilePath(packageIdentity);
if (File.Exists(packageFilePath))
{
addedPackageFilesList.Add(packageFilePath);
}
}
// Pend all the package files including the nupkg file
FileSystemUtility.PendAddFiles(addedPackageFilesList, Root, nuGetProjectContext);
nuGetProjectContext.Log(MessageLevel.Info, Strings.AddedPackageToFolder, packageIdentity, Path.GetFullPath(Root));
// Extra logging with source for verbosity detailed
// Used by external tool CoreXT to track package provenance
if (!string.IsNullOrEmpty(downloadResourceResult.PackageSource))
{
nuGetProjectContext.Log(MessageLevel.Debug, Strings.AddedPackageToFolderFromSource, packageIdentity, Path.GetFullPath(Root), downloadResourceResult.PackageSource);
}
return true;
},
token: token));
}
public static async Task AddPackageToSource(
OfflineFeedAddContext offlineFeedAddContext,
CancellationToken token)
{
if (offlineFeedAddContext == null)
{
throw new ArgumentNullException(nameof(offlineFeedAddContext));
}
token.ThrowIfCancellationRequested();
var packagePath = offlineFeedAddContext.PackagePath;
var source = offlineFeedAddContext.Source;
var logger = offlineFeedAddContext.Logger;
using (var packageStream = File.OpenRead(packagePath))
{
try
{
var packageReader = new PackageArchiveReader(packageStream, leaveStreamOpen: true);
var packageIdentity = packageReader.GetIdentity();
bool isValidPackage;
if (PackageExists(packageIdentity, source, out isValidPackage))
{
// Package already exists. Verify if it is valid
if (isValidPackage)
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.AddPackage_PackageAlreadyExists,
packageIdentity,
source);
if (offlineFeedAddContext.ThrowIfPackageExists)
{
throw new ArgumentException(message);
}
else
{
logger.LogMinimal(message);
}
}
else
{
var message = string.Format(CultureInfo.CurrentCulture,
Strings.AddPackage_ExistingPackageInvalid,
packageIdentity,
source);
if (offlineFeedAddContext.ThrowIfPackageExistsAndInvalid)
{
throw new ArgumentException(message);
}
else
{
logger.LogWarning(message);
}
}
}
else
{
var packageSaveMode = offlineFeedAddContext.Expand
? PackageSaveMode.Defaultv3
: PackageSaveMode.Nuspec | PackageSaveMode.Nupkg;
var signedPackageVerifier = new PackageSignatureVerifier(
SignatureVerificationProviderFactory.GetSignatureVerificationProviders(),
SignedPackageVerifierSettings.Default);
var packageExtractionContext = new PackageExtractionContext(
packageSaveMode,
PackageExtractionBehavior.XmlDocFileSaveMode,
logger,
signedPackageVerifier);
var versionFolderPathResolver = new VersionFolderPathResolver(source);
using (var packageDownloader = new LocalPackageArchiveDownloader(
packagePath,
packageIdentity,
logger))
{
await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDownloader,
versionFolderPathResolver,
packageExtractionContext,
token);
}
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.AddPackage_SuccessfullyAdded,
packagePath,
source);
logger.LogMinimal(message);
}
}
// Mono will throw ArchiveException when package is invalid.
// Reading Nuspec in invalid package on Mono will get PackagingException
catch (Exception ex) when(ex is InvalidDataException ||
(RuntimeEnvironmentHelper.IsMono &&
(ex.GetType().FullName.Equals("SharpCompress.Common.ArchiveException") ||
ex is PackagingException)))
{
var message = string.Format(
CultureInfo.CurrentCulture,
Strings.NupkgPath_Invalid,
packagePath);
if (offlineFeedAddContext.ThrowIfSourcePackageIsInvalid)
{
throw new ArgumentException(message);
}
else
{
logger.LogWarning(message);
}
}
}
}
private async Task <RestoreSummary> PerformNuGetV2RestoreAsync(PackageRestoreInputs packageRestoreInputs)
{
ReadSettings(packageRestoreInputs);
var packagesFolderPath = GetPackagesFolder(packageRestoreInputs);
var sourceRepositoryProvider = new CommandLineSourceRepositoryProvider(SourceProvider);
var nuGetPackageManager = new NuGetPackageManager(sourceRepositoryProvider, Settings, packagesFolderPath);
var installedPackageReferences = new HashSet <Packaging.PackageReference>(new PackageReferenceComparer());
if (packageRestoreInputs.RestoringWithSolutionFile)
{
installedPackageReferences.AddRange(packageRestoreInputs
.PackagesConfigFiles
.SelectMany(file => GetInstalledPackageReferences(file, allowDuplicatePackageIds: true)));
}
else if (packageRestoreInputs.PackagesConfigFiles.Count > 0)
{
// By default the PackageReferenceFile does not throw
// if the file does not exist at the specified path.
// So we'll need to verify that the file exists.
Debug.Assert(packageRestoreInputs.PackagesConfigFiles.Count == 1,
"Only one packages.config file is allowed to be specified " +
"at a time when not performing solution restore.");
var packageReferenceFile = packageRestoreInputs.PackagesConfigFiles[0];
if (!File.Exists(packageReferenceFile))
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("RestoreCommandFileNotFound"),
packageReferenceFile);
throw new InvalidOperationException(message);
}
installedPackageReferences.AddRange(
GetInstalledPackageReferences(packageReferenceFile, allowDuplicatePackageIds: true));
}
// EffectivePackageSaveMode is None when -PackageSaveMode is not provided by the user. None is treated as
// Defaultv3 for V3 restore and should be treated as Defaultv2 for V2 restore. This is the case in the
// actual V2 restore flow and should match in this preliminary missing packages check.
var packageSaveMode = EffectivePackageSaveMode == Packaging.PackageSaveMode.None ?
Packaging.PackageSaveMode.Defaultv2 :
EffectivePackageSaveMode;
var missingPackageReferences = installedPackageReferences.Where(reference =>
!nuGetPackageManager.PackageExistsInPackagesFolder(reference.PackageIdentity, packageSaveMode)).ToArray();
if (missingPackageReferences.Length == 0)
{
var message = string.Format(
CultureInfo.CurrentCulture,
LocalizedResourceManager.GetString("InstallCommandNothingToInstall"),
"packages.config");
Console.LogMinimal(message);
return(new RestoreSummary(true));
}
var packageRestoreData = missingPackageReferences.Select(reference =>
new PackageRestoreData(
reference,
new[] { packageRestoreInputs.RestoringWithSolutionFile
? packageRestoreInputs.DirectoryOfSolutionFile
: packageRestoreInputs.PackagesConfigFiles[0] },
isMissing: true));
var packageSources = GetPackageSources(Settings);
var repositories = packageSources
.Select(sourceRepositoryProvider.CreateRepository)
.ToArray();
var installCount = 0;
var failedEvents = new ConcurrentQueue <PackageRestoreFailedEventArgs>();
var collectorLogger = new RestoreCollectorLogger(Console);
var packageRestoreContext = new PackageRestoreContext(
nuGetPackageManager,
packageRestoreData,
CancellationToken.None,
packageRestoredEvent: (sender, args) => { Interlocked.Add(ref installCount, args.Restored ? 1 : 0); },
packageRestoreFailedEvent: (sender, args) => { failedEvents.Enqueue(args); },
sourceRepositories: repositories,
maxNumberOfParallelTasks: DisableParallelProcessing
? 1
: PackageManagementConstants.DefaultMaxDegreeOfParallelism,
logger: collectorLogger);
CheckRequireConsent();
var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var signingVerificationSettings = SignedPackageVerifierSettings.GetClientPolicy(Settings, collectorLogger);
var projectContext = new ConsoleProjectContext(collectorLogger)
{
PackageExtractionContext = new PackageExtractionContext(
Packaging.PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
collectorLogger,
signedPackageVerifier,
signingVerificationSettings)
};
if (EffectivePackageSaveMode != Packaging.PackageSaveMode.None)
{
projectContext.PackageExtractionContext.PackageSaveMode = EffectivePackageSaveMode;
}
using (var cacheContext = new SourceCacheContext())
{
cacheContext.NoCache = NoCache;
cacheContext.DirectDownload = DirectDownload;
var downloadContext = new PackageDownloadContext(cacheContext, packagesFolderPath, DirectDownload)
{
ExtractionContext = new PackageExtractionContext(
Packaging.PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
collectorLogger,
signedPackageVerifier,
signingVerificationSettings)
};
var result = await PackageRestoreManager.RestoreMissingPackagesAsync(
packageRestoreContext,
projectContext,
downloadContext);
if (downloadContext.DirectDownload)
{
GetDownloadResultUtility.CleanUpDirectDownloads(downloadContext);
}
return(new RestoreSummary(
result.Restored,
"packages.config projects",
SettingsUtility.GetConfigFilePaths(Settings),
packageSources.Select(x => x.Source),
installCount,
collectorLogger.Errors.Concat(ProcessFailedEventsIntoRestoreLogs(failedEvents))));
}
}
