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