public void UninstallPackage(Project project, string packageId, bool removeDependencies) { if (project == null) { throw new ArgumentNullException("project"); } if (String.IsNullOrEmpty(packageId)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId")); } PumpingJTF.Run(async delegate { NuGetPackageManager packageManager = new NuGetPackageManager( _sourceRepositoryProvider, _settings, _solutionManager, _deleteOnRestartManager); UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false); VSAPIProjectContext projectContext = new VSAPIProjectContext(); // find the project NuGetProject nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext); // uninstall the package await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None); }); }
private Task InstallPackageAsync(string source, Project project, string packageId, NuGetVersion version, bool includePrerelease, bool ignoreDependencies) { IEnumerable <string> sources = null; if (!string.IsNullOrEmpty(source) && !StringComparer.OrdinalIgnoreCase.Equals("All", source)) // "All" was supported in V2 { sources = new[] { source }; } var toInstall = new List <PackageIdentity> { new PackageIdentity(packageId, version) }; var projectContext = new VSAPIProjectContext { PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance), NullLogger.Instance) }; return(InstallInternalAsync(project, toInstall, GetSources(sources), projectContext, includePrerelease, ignoreDependencies, CancellationToken.None)); }
private Task InstallPackageAsync(string source, Project project, string packageId, NuGetVersion version, bool includePrerelease, bool ignoreDependencies) { IEnumerable <string> sources = null; if (!String.IsNullOrEmpty(source) && !StringComparer.OrdinalIgnoreCase.Equals("All", source)) // "All" was supported in V2 { sources = new[] { source }; } VersionRange versionRange = VersionRange.All; if (version != null) { versionRange = new VersionRange(version, true, version, true); } List <PackageIdentity> toInstall = new List <PackageIdentity>(); toInstall.Add(new PackageIdentity(packageId, version)); VSAPIProjectContext projectContext = new VSAPIProjectContext(); return(InstallInternalAsync(project, toInstall, GetSources(sources), projectContext, includePrerelease, ignoreDependencies, CancellationToken.None)); }
private Task InstallPackageAsync(string source, Project project, string packageId, NuGetVersion version, bool includePrerelease, bool ignoreDependencies) { IEnumerable <string> sources = null; if (!string.IsNullOrEmpty(source) && !StringComparer.OrdinalIgnoreCase.Equals("All", source)) // "All" was supported in V2 { sources = new[] { source }; } var versionRange = VersionRange.All; if (version != null) { versionRange = new VersionRange(version, true, version, true); } var toInstall = new List <PackageIdentity> { new PackageIdentity(packageId, version) }; var projectContext = new VSAPIProjectContext(); var logger = new LoggerAdapter(projectContext); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); projectContext.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, logger, signedPackageVerifier, SignedPackageVerifierSettings.GetClientPolicy(_settings, logger)); return(InstallInternalAsync(project, toInstall, GetSources(sources), projectContext, includePrerelease, ignoreDependencies, CancellationToken.None)); }
private async Task <IEnumerable <PackageReference> > GetInstalledPackageReferencesAsync( Project project) { if (project == null) { throw new ArgumentNullException("project"); } var packages = new List <PackageReference>(); if (_solutionManager != null && !string.IsNullOrEmpty(_solutionManager.SolutionDirectory)) { var projectContext = new VSAPIProjectContext { PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance), NullLogger.Instance) }; var nuGetProject = await _solutionManager.GetOrCreateProjectAsync( project, projectContext); var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None); packages.AddRange(installedPackages); } return(packages); }
/// <summary> /// Core install method. All installs from the VS API and template wizard end up here. /// This does not check for already installed packages /// </summary> internal async Task InstallInternalCoreAsync( NuGetPackageManager packageManager, GatherCache gatherCache, NuGetProject nuGetProject, PackageIdentity package, IEnumerable <SourceRepository> sources, VSAPIProjectContext projectContext, bool includePrerelease, bool ignoreDependencies, CancellationToken token) { await TaskScheduler.Default; DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest; ResolutionContext resolution = new ResolutionContext( depBehavior, includePrerelease, includeUnlisted: false, versionConstraints: VersionConstraints.None, gatherCache: gatherCache); // install the package if (package.Version == null) { await packageManager.InstallPackageAsync(nuGetProject, package.Id, resolution, projectContext, sources, Enumerable.Empty <SourceRepository>(), token); } else { await packageManager.InstallPackageAsync(nuGetProject, package, resolution, projectContext, sources, Enumerable.Empty <SourceRepository>(), token); } }
public VsPackageInstaller( ISourceRepositoryProvider sourceRepositoryProvider, Configuration.ISettings settings, IVsSolutionManager solutionManager, IVsPackageInstallerServices packageServices, IDeleteOnRestartManager deleteOnRestartManager) { _sourceRepositoryProvider = sourceRepositoryProvider; _settings = settings; _solutionManager = solutionManager; _packageServices = packageServices; _deleteOnRestartManager = deleteOnRestartManager; _isCPSJTFLoaded = false; _projectContext = new Lazy <INuGetProjectContext>(() => { var projectContext = new VSAPIProjectContext(); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); var logger = new LoggerAdapter(projectContext); projectContext.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, logger, signedPackageVerifier, SignedPackageVerifierSettings.GetClientPolicy(_settings, logger)); return(projectContext); }); PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory); }
/// <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()); context.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, new LoggerAdapter(context), signedPackageVerifier, SignedPackageVerifierSettings.GetDefault()); 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); } } } }
public VsPathContextProvider( IAsyncServiceProvider asyncServiceProvider, Lazy <ISettings> settings, Lazy <IVsSolutionManager> solutionManager, Lazy <NuGet.Common.ILogger> logger) { _asyncServiceprovider = asyncServiceProvider ?? throw new ArgumentNullException(nameof(asyncServiceProvider)); _settings = settings ?? throw new ArgumentNullException(nameof(settings)); _solutionManager = solutionManager ?? throw new ArgumentNullException(nameof(solutionManager)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _getLockFileOrNullAsync = BuildIntegratedProjectUtility.GetLockFileOrNull; _projectContext = new Lazy <INuGetProjectContext>(() => { var projectContext = new VSAPIProjectContext(); var adapterLogger = new LoggerAdapter(projectContext); projectContext.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings.Value, adapterLogger), adapterLogger); return(projectContext); }); }
public void InstallPackagesFromVSExtensionRepository(string extensionId, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions) { if (String.IsNullOrEmpty(extensionId)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "extensionId"); } if (project == null) { throw new ArgumentNullException("project"); } if (!packageVersions.Any()) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageVersions"); } PreinstalledRepositoryProvider repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider); repoProvider.AddFromExtension(_sourceRepositoryProvider, extensionId); List <PackageIdentity> toInstall = GetIdentitiesFromDict(packageVersions); // Skip assembly references and disable binding redirections should be done together bool disableBindingRedirects = skipAssemblyReferences; VSAPIProjectContext projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects); PackageManagementHelpers.RunSync(async() => await InstallInternal(project, toInstall, repoProvider, projectContext, ignoreDependencies, CancellationToken.None)); }
public void InstallPackagesFromRegistryRepository(string keyName, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions) { if (string.IsNullOrEmpty(keyName)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(keyName)); } if (project == null) { throw new ArgumentNullException(nameof(project)); } if (packageVersions == null || !packageVersions.Any()) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageVersions)); } RunJTFWithCorrectContext(project, async() => { // HACK !!! : This is a hack for PCL projects which send isPreUnzipped = true, but their package source // (located at C:\Program Files (x86)\Microsoft SDKs\NuGetPackages) follows the V3 // folder version format. if (isPreUnzipped) { var isProjectJsonProject = await EnvDTEProjectUtility.HasBuildIntegratedConfig(project); isPreUnzipped = isProjectJsonProject ? false : isPreUnzipped; } // create a repository provider with only the registry repository var repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider); repoProvider.AddFromRegistry(keyName, isPreUnzipped); var toInstall = GetIdentitiesFromDict(packageVersions); // 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()); var logger = new LoggerAdapter(projectContext); projectContext.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, logger, signedPackageVerifier, SignedPackageVerifierSettings.GetClientPolicy(_settings, logger)); await InstallInternalAsync( project, toInstall, repoProvider, projectContext, includePrerelease: false, ignoreDependencies: ignoreDependencies, token: CancellationToken.None); }); }
public void InstallPackagesFromVSExtensionRepository(string extensionId, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions) { if (string.IsNullOrEmpty(extensionId)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(extensionId)); } if (project == null) { throw new ArgumentNullException(nameof(project)); } if (!packageVersions.Any()) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageVersions)); } try { RunJTFWithCorrectContext(project, () => { var repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider); repoProvider.AddFromExtension(_sourceRepositoryProvider, extensionId); var toInstall = GetIdentitiesFromDict(packageVersions); // Skip assembly references and disable binding redirections should be done together var disableBindingRedirects = skipAssemblyReferences; var projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects) { PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance), NullLogger.Instance) }; return(InstallInternalAsync( project, toInstall, repoProvider, projectContext, includePrerelease: false, ignoreDependencies: ignoreDependencies, token: CancellationToken.None)); }); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsPackageInstaller).FullName); throw; } }
/// <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="packagesFileSystem">The file system pointing to 'packages' folder under the solution.</param> /// <param name="packageNames">The package names.</param> private void AddRefreshFilesForReferences(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(); WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(project, context); var root = EnvDTEProjectUtility.GetFullPath(project); 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, context); } } } }
/// <summary> /// By convention, we copy all files under the NativeBinaries folder under package root to the bin folder of /// the Website. /// </summary> /// <param name="project">The target Website project.</param> /// <param name="repositoryPath">The local repository path.</param> /// <param name="packageInfos">The packages that were installed.</param> private void CopyNativeBinariesToBin(EnvDTE.Project project, string repositoryPath, IEnumerable <PreinstalledPackageInfo> packageInfos) { var context = new VSAPIProjectContext(); var projectSystem = new VsMSBuildProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context); foreach (var packageInfo in packageInfos) { var packagePath = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageInfo.Id, packageInfo.Version); CopyNativeBinaries(projectSystem, repositoryPath, Path.Combine(repositoryPath, packagePath)); } }
/// <summary> /// By convention, we copy all files under the NativeBinaries folder under package root to the bin folder of /// the Website. /// </summary> /// <param name="project">The target Website project.</param> /// <param name="repositoryPath">The local repository path.</param> /// <param name="packageInfos">The packages that were installed.</param> private void CopyNativeBinariesToBin(Project project, string repositoryPath, IEnumerable <PreinstalledPackageInfo> packageInfos) { VSAPIProjectContext context = new VSAPIProjectContext(); VSMSBuildNuGetProjectSystem projectSystem = new VSMSBuildNuGetProjectSystem(project, context); foreach (var packageInfo in packageInfos) { string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageInfo.Id, packageInfo.Version); CopyNativeBinaries(projectSystem, repositoryPath, Path.Combine(repositoryPath, packagePath)); } }
public void InstallPackagesFromRegistryRepository(string keyName, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions) { if (String.IsNullOrEmpty(keyName)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(keyName)); } if (project == null) { throw new ArgumentNullException(nameof(project)); } if (packageVersions == null || !packageVersions.Any()) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageVersions)); } PumpingJTF.Run(async() => { // HACK !!! : This is a hack for PCL projects which send isPreUnzipped = true, but their package source // (located at C:\Program Files (x86)\Microsoft SDKs\NuGetPackages) follows the V3 // folder version format. if (isPreUnzipped) { var isProjectJsonProject = await EnvDTEProjectUtility.HasBuildIntegratedConfig(project); isPreUnzipped = isProjectJsonProject ? false : isPreUnzipped; } // create a repository provider with only the registry repository PreinstalledRepositoryProvider repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider); repoProvider.AddFromRegistry(keyName, isPreUnzipped); List <PackageIdentity> toInstall = GetIdentitiesFromDict(packageVersions); // Skip assembly references and disable binding redirections should be done together bool disableBindingRedirects = skipAssemblyReferences; VSAPIProjectContext projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects); await InstallInternalAsync( project, toInstall, repoProvider, projectContext, includePrerelease: false, ignoreDependencies: ignoreDependencies, token: CancellationToken.None); }); }
public void InstallPackagesFromVSExtensionRepository(string extensionId, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions) { if (string.IsNullOrEmpty(extensionId)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(extensionId)); } if (project == null) { throw new ArgumentNullException(nameof(project)); } if (!packageVersions.Any()) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageVersions)); } RunJTFWithCorrectContext(project, () => { var repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider); repoProvider.AddFromExtension(_sourceRepositoryProvider, extensionId); var toInstall = GetIdentitiesFromDict(packageVersions); // 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()); return(InstallInternalAsync( project, toInstall, repoProvider, projectContext, includePrerelease: false, ignoreDependencies: ignoreDependencies, token: CancellationToken.None)); }); }
public void UninstallPackage(Project project, string packageId, bool removeDependencies) { if (project == null) { throw new ArgumentNullException("project"); } if (string.IsNullOrEmpty(packageId)) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageId))); } try { PumpingJTF.Run(async delegate { NuGetPackageManager packageManager = new NuGetPackageManager( _sourceRepositoryProvider, _settings, _solutionManager, _deleteOnRestartManager); var uninstallContext = new UninstallationContext(removeDependencies, forceRemove: false); var projectContext = new VSAPIProjectContext { PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance), NullLogger.Instance) }; // find the project NuGetProject nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext); // uninstall the package await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None); }); } catch (Exception exception) { _telemetryProvider.PostFault(exception, typeof(VsPackageUninstaller).FullName); throw; } }
/// <summary> /// By convention, we copy all files under the NativeBinaries folder under package root to the bin folder of /// the Website. /// </summary> /// <param name="project">The target Website project.</param> /// <param name="repositoryPath">The local repository path.</param> /// <param name="packageInfos">The packages that were installed.</param> private void CopyNativeBinariesToBin(EnvDTE.Project project, string repositoryPath, IEnumerable <PreinstalledPackageInfo> packageInfos) { var context = new VSAPIProjectContext { PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance), NullLogger.Instance) }; var projectSystem = new VsMSBuildProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context); foreach (var packageInfo in packageInfos) { var packagePath = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageInfo.Id, packageInfo.Version); CopyNativeBinaries(projectSystem, repositoryPath, Path.Combine(repositoryPath, packagePath)); } }
/// <summary> /// This constructor is just used for testing. /// </summary> public VsPathContextProvider( ISettings settings, IVsSolutionManager solutionManager, NuGet.Common.ILogger logger, Func <BuildIntegratedNuGetProject, Task <LockFile> > getLockFileOrNullAsync) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (solutionManager == null) { throw new ArgumentNullException(nameof(solutionManager)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _settings = new Lazy <ISettings>(() => settings); _solutionManager = new Lazy <IVsSolutionManager>(() => solutionManager); _logger = new Lazy <NuGet.Common.ILogger>(() => logger); _getLockFileOrNullAsync = getLockFileOrNullAsync ?? BuildIntegratedProjectUtility.GetLockFileOrNull; _projectContext = new Lazy <INuGetProjectContext>(() => { var projectContext = new VSAPIProjectContext(); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); var adapterLogger = new LoggerAdapter(projectContext); projectContext.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, adapterLogger, signedPackageVerifier, SignedPackageVerifierSettings.GetClientPolicy(settings, adapterLogger)); return(projectContext); }); }
public void InstallPackagesFromRegistryRepository(string keyName, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions) { if (String.IsNullOrEmpty(keyName)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(keyName)); } if (project == null) { throw new ArgumentNullException(nameof(project)); } if (packageVersions == null || !packageVersions.Any()) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, nameof(packageVersions)); } PumpingJTF.Run(() => { // create a repository provider with only the registry repository PreinstalledRepositoryProvider repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider); repoProvider.AddFromRegistry(keyName, isPreUnzipped); List <PackageIdentity> toInstall = GetIdentitiesFromDict(packageVersions); // Skip assembly references and disable binding redirections should be done together bool disableBindingRedirects = skipAssemblyReferences; VSAPIProjectContext projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects); return(InstallInternalAsync( project, toInstall, repoProvider, projectContext, includePrerelease: false, ignoreDependencies: ignoreDependencies, token: CancellationToken.None)); }); }
/// <summary> /// Finds the NuGetProject from a DTE project /// </summary> public static NuGetProject GetProject(ISolutionManager solutionManager, Project project, VSAPIProjectContext projectContext=null) { if (solutionManager == null) { throw new ArgumentNullException("solution"); } var projectSafeName = EnvDTEProjectUtility.GetCustomUniqueName(project); NuGetProject nuGetProject = solutionManager.GetNuGetProject(projectSafeName); var settings = ServiceLocator.GetInstance<ISettings>(); // if the project does not exist in the solution (this is true for new templates) create it manually if (nuGetProject == null) { VSNuGetProjectFactory factory = new VSNuGetProjectFactory(() => PackagesFolderPathUtility.GetPackagesFolderPath(solutionManager, settings)); nuGetProject = factory.CreateNuGetProject(project, projectContext); } return nuGetProject; }
public Task InstallPackageAsync(IEnumerable<string> sources, Project project, string packageId, string version, bool ignoreDependencies, CancellationToken token) { return Task.Run(async () => { var sourceProvider = GetSources(sources); NuGetVersion semVer = null; if (!String.IsNullOrEmpty(version)) { NuGetVersion.TryParse(version, out semVer); } List<PackageIdentity> toInstall = new List<PackageIdentity>() { new PackageIdentity(packageId, semVer) }; // Normalize the install folder for new installs (this only happens for IVsPackageInstaller2. IVsPackageInstaller keeps legacy behavior) VSAPIProjectContext projectContext = new VSAPIProjectContext(false, false, false); await InstallInternal(project, toInstall, sourceProvider, projectContext, ignoreDependencies, token); }); }
/// <summary> /// By convention, we copy all files under the NativeBinaries folder under package root to the bin folder of /// the Website. /// </summary> /// <param name="project">The target Website project.</param> /// <param name="repositoryPath">The local repository path.</param> /// <param name="packageInfos">The packages that were installed.</param> private void CopyNativeBinariesToBin(EnvDTE.Project project, string repositoryPath, IEnumerable <PreinstalledPackageInfo> packageInfos) { var context = new VSAPIProjectContext(); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); context.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, new LoggerAdapter(context), signedPackageVerifier, SignedPackageVerifierSettings.GetDefault()); var projectSystem = new VsMSBuildProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context); foreach (var packageInfo in packageInfos) { var packagePath = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageInfo.Id, packageInfo.Version); CopyNativeBinaries(projectSystem, repositoryPath, Path.Combine(repositoryPath, packagePath)); } }
public void UninstallPackage(Project project, string packageId, bool removeDependencies) { if (project == null) { throw new ArgumentNullException("project"); } if (String.IsNullOrEmpty(packageId)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId")); } PumpingJTF.Run(async delegate { NuGetPackageManager packageManager = new NuGetPackageManager( _sourceRepositoryProvider, _settings, _solutionManager, _deleteOnRestartManager); UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false); VSAPIProjectContext projectContext = new VSAPIProjectContext(); var signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders()); var logger = new LoggerAdapter(projectContext); projectContext.PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, logger, signedPackageVerifier, SignedPackageVerifierSettings.GetClientPolicy(_settings, logger)); // find the project NuGetProject nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext); // uninstall the package await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None); }); }
public void UninstallPackage(Project project, string packageId, bool removeDependencies) { if (project == null) { throw new ArgumentNullException("project"); } if (String.IsNullOrEmpty(packageId)) { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId")); } NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, _solutionManager); UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false); VSAPIProjectContext projectContext = new VSAPIProjectContext(); // find the project NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext); // uninstall the package PackageManagementHelpers.RunSync(async () => await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None)); }
private async Task <IEnumerable <Packaging.PackageReference> > GetInstalledPackageReferencesAsync( Project project) { if (project == null) { throw new ArgumentNullException("project"); } var packages = new List <Packaging.PackageReference>(); 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); var installedPackages = await nuGetProject.GetInstalledPackagesAsync(CancellationToken.None); packages.AddRange(installedPackages); } return(packages); }
private void InstallPackage(string source, Project project, string packageId, NuGetVersion version, bool ignoreDependencies) { IEnumerable <string> sources = null; if (!String.IsNullOrEmpty(source)) { sources = new string[] { source }; } VersionRange versionRange = VersionRange.All; if (version != null) { versionRange = new VersionRange(version, true, version, true); } List <PackageIdentity> toInstall = new List <PackageIdentity>(); toInstall.Add(new PackageIdentity(packageId, version)); VSAPIProjectContext projectContext = new VSAPIProjectContext(); PackageManagementHelpers.RunSync(async() => await InstallInternal(project, toInstall, GetSources(sources), projectContext, ignoreDependencies, CancellationToken.None)); }
public Task InstallPackageAsync(IEnumerable <string> sources, Project project, string packageId, string version, bool ignoreDependencies, CancellationToken token) { return(Task.Run(async() => { var sourceProvider = GetSources(sources); NuGetVersion semVer = null; if (!String.IsNullOrEmpty(version)) { NuGetVersion.TryParse(version, out semVer); } List <PackageIdentity> toInstall = new List <PackageIdentity>() { new PackageIdentity(packageId, semVer) }; // Normalize the install folder for new installs (this only happens for IVsPackageInstaller2. IVsPackageInstaller keeps legacy behavior) VSAPIProjectContext projectContext = new VSAPIProjectContext(false, false, false); await InstallInternal(project, toInstall, sourceProvider, projectContext, ignoreDependencies, token); })); }
/// <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="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, Action <string> warningHandler, Action <string> errorHandler) { ThreadHelper.ThrowIfNotOnUIThread(); string repositoryPath = configuration.RepositoryPath; var repositorySource = new Configuration.PackageSource(repositoryPath); var failedPackageErrors = new List <string>(); // find the project var defaultProjectContext = new VSAPIProjectContext(); var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, defaultProjectContext); // 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 bool disableBindingRedirects = package.SkipAssemblyReferences; var projectContext = new VSAPIProjectContext(package.SkipAssemblyReferences, disableBindingRedirects); // Old templates have hardcoded non-normalized paths projectContext.PackageExtractionContext.UseLegacyPackageInstallPath = true; // 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> /// Internal install method. All installs from the VS API and template wizard end up here. /// </summary> internal async Task InstallInternalAsync( Project project, List <PackageIdentity> packages, ISourceRepositoryProvider repoProvider, VSAPIProjectContext projectContext, bool includePrerelease, bool ignoreDependencies, CancellationToken token) { // Go off the UI thread. This may be called from the UI thread. Only switch to the UI thread where necessary // This method installs multiple packages and can likely take more than a few secs // So, go off the UI thread explicitly to improve responsiveness await TaskScheduler.Default; var gatherCache = new GatherCache(); var sources = repoProvider.GetRepositories().ToList(); // store expanded node state IDictionary <string, ISet <VsHierarchyItem> > expandedNodes = await VsHierarchyUtility.GetAllExpandedNodesAsync(_solutionManager); try { DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest; ResolutionContext resolution = new ResolutionContext( depBehavior, includePrerelease, includeUnlisted: false, versionConstraints: VersionConstraints.None); var packageManager = CreatePackageManager(repoProvider); // find the project var nuGetProject = await _solutionManager.GetOrCreateProjectAsync(project, projectContext); // install the package foreach (PackageIdentity package in packages) { // Check if the package is already installed if (package.Version == null) { if (_packageServices.IsPackageInstalled(project, package.Id)) { continue; } } else { if (_packageServices.IsPackageInstalledEx(project, package.Id, package.Version.ToString())) { continue; } } // Perform the install await InstallInternalCoreAsync( packageManager, gatherCache, nuGetProject, package, sources, projectContext, includePrerelease, ignoreDependencies, token); } } finally { // collapse nodes await VsHierarchyUtility.CollapseAllNodesAsync(_solutionManager, expandedNodes); } }
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 List <MetadataResource> metadataResources = new List <MetadataResource>(); // create the resources for looking up the latest version foreach (var repo in repoProvider.GetRepositories()) { MetadataResource 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); 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, 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 bool disableBindingRedirects = skipAssemblyReferences; VSAPIProjectContext projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects); await InstallInternalAsync( project, idToIdentity.Values.ToList(), repoProvider, projectContext, includePrerelease : false, ignoreDependencies : ignoreDependencies, token : token); }
private void InstallPackage(string source, Project project, string packageId, NuGetVersion version, bool ignoreDependencies) { IEnumerable<string> sources = null; if (!String.IsNullOrEmpty(source)) { sources = new string[] { source }; } VersionRange versionRange = VersionRange.All; if (version != null) { versionRange = new VersionRange(version, true, version, true); } List<PackageIdentity> toInstall = new List<PackageIdentity>(); toInstall.Add(new PackageIdentity(packageId, version)); VSAPIProjectContext projectContext = new VSAPIProjectContext(); PackageManagementHelpers.RunSync(async () => await InstallInternal(project, toInstall, GetSources(sources), projectContext, ignoreDependencies, CancellationToken.None)); }
public void InstallPackagesFromVSExtensionRepository(string extensionId, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary<string, string> packageVersions) { if (String.IsNullOrEmpty(extensionId)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "extensionId"); } if (project == null) { throw new ArgumentNullException("project"); } if (!packageVersions.Any()) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageVersions"); } PreinstalledRepositoryProvider repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider); repoProvider.AddFromExtension(_sourceRepositoryProvider, extensionId); List<PackageIdentity> toInstall = GetIdentitiesFromDict(packageVersions); // Skip assembly references and disable binding redirections should be done together bool disableBindingRedirects = skipAssemblyReferences; VSAPIProjectContext projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects); PackageManagementHelpers.RunSync(async () => await InstallInternal(project, toInstall, repoProvider, projectContext, ignoreDependencies, CancellationToken.None)); }
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)) { //switch to background thread await TaskScheduler.Default; NuGetPackageManager nuGetPackageManager = CreateNuGetPackageManager(); var projectContext = new VSAPIProjectContext { PackageExtractionContext = new PackageExtractionContext( PackageSaveMode.Defaultv2, PackageExtractionBehavior.XmlDocFileSaveMode, ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance), NullLogger.Instance) }; 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 = nuGetPackageManager.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 InstallInternal(Project project, List<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 List<MetadataResource> metadataResources = new List<MetadataResource>(); // create the resources for looking up the latest version foreach (var repo in repoProvider.GetRepositories()) { MetadataResource 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); 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, 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 bool disableBindingRedirects = skipAssemblyReferences; VSAPIProjectContext projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects); await InstallInternal(project, idToIdentity.Values.ToList(), repoProvider, projectContext, ignoreDependencies, token); }
/// <summary> /// By convention, we copy all files under the NativeBinaries folder under package root to the bin folder of the Website. /// </summary> /// <param name="project">The target Website project.</param> /// <param name="repositoryPath">The local repository path.</param> /// <param name="packageInfos">The packages that were installed.</param> private void CopyNativeBinariesToBin(Project project, string repositoryPath, IEnumerable<PreinstalledPackageInfo> packageInfos) { VSAPIProjectContext context = new VSAPIProjectContext(); VSMSBuildNuGetProjectSystem projectSystem = new VSMSBuildNuGetProjectSystem(project, context); foreach (var packageInfo in packageInfos) { string packagePath = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageInfo.Id, packageInfo.Version); CopyNativeBinaries(projectSystem, repositoryPath, Path.Combine(repositoryPath, packagePath)); } }
/// <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="packagesFileSystem">The file system pointing to 'packages' folder under the solution.</param> /// <param name="packageNames">The package names.</param> private void AddRefreshFilesForReferences(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(); WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(project, context); var root = EnvDTEProjectUtility.GetFullPath(project); 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, context); } } } }
/// <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="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 void PerformPackageInstall( IVsPackageInstaller packageInstaller, Project project, PreinstalledPackageConfiguration configuration, Action<string> warningHandler, Action<string> errorHandler) { string repositoryPath = configuration.RepositoryPath; var failedPackageErrors = new List<string>(); LegacyNuGet.IPackageRepository repository = configuration.IsPreunzipped ? (LegacyNuGet.IPackageRepository)new LegacyNuGet.UnzippedPackageRepository(repositoryPath) : (LegacyNuGet.IPackageRepository)new LegacyNuGet.LocalPackageRepository(repositoryPath); PreinstalledRepositoryProvider repos = new PreinstalledRepositoryProvider(errorHandler, _sourceProvider); repos.AddFromRepository(repository); // store expanded node state IDictionary<string, ISet<VsHierarchyItem>> expandedNodes = VsHierarchyHelper.GetAllExpandedNodes(_solutionManager); foreach (var package in configuration.Packages) { // 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)); } List<PackageIdentity> toInstall = new List<PackageIdentity>(); toInstall.Add(new PackageIdentity(package.Id, package.Version)); // Skip assembly references and disable binding redirections should be done together bool disableBindingRedirects = package.SkipAssemblyReferences; VSAPIProjectContext projectContext = new VSAPIProjectContext(package.SkipAssemblyReferences, disableBindingRedirects); // Old templates have hardcoded non-normalized paths projectContext.PackageExtractionContext.UseLegacyPackageInstallPath = true; // This runs from the UI thread PackageManagementHelpers.RunSync(async () => await _installer.InstallInternal(project, toInstall, repos, projectContext, package.IgnoreDependencies, 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 (EnvDTEProjectUtility.IsWebSite(project)) { CreateRefreshFilesInBin( project, repositoryPath, configuration.Packages.Where(p => p.SkipAssemblyReferences)); CopyNativeBinariesToBin(project, repositoryPath, configuration.Packages); } // collapse nodes VsHierarchyHelper.CollapseAllNodes(_solutionManager, expandedNodes); }
/// <summary> /// Core install method. All installs from the VS API and template wizard end up here. /// </summary> internal async Task InstallInternal(Project project, List<PackageIdentity> packages, ISourceRepositoryProvider repoProvider, VSAPIProjectContext projectContext, bool ignoreDependencies, CancellationToken token) { // store expanded node state IDictionary<string, ISet<VsHierarchyItem>> expandedNodes = VsHierarchyHelper.GetAllExpandedNodes(_solutionManager); try { DependencyBehavior depBehavior = ignoreDependencies ? DependencyBehavior.Ignore : DependencyBehavior.Lowest; bool includePrerelease = false; ResolutionContext resolution = new ResolutionContext(depBehavior, includePrerelease, false); NuGetPackageManager packageManager = new NuGetPackageManager(repoProvider, _settings, _solutionManager); // find the project NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext); // install the package foreach (PackageIdentity package in packages) { if (package.Version == null) { if (!_packageServices.IsPackageInstalled(project, package.Id)) { await packageManager.InstallPackageAsync(nuGetProject, package.Id, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty<SourceRepository>(), token); } } else { if (!_packageServices.IsPackageInstalledEx(project, package.Id, package.Version.ToString())) { await packageManager.InstallPackageAsync(nuGetProject, package, resolution, projectContext, repoProvider.GetRepositories(), Enumerable.Empty<SourceRepository>(), token); } } } } finally { // collapse nodes VsHierarchyHelper.CollapseAllNodes(_solutionManager, expandedNodes); } }