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