public Task InitialAsync()
{
List <Lazy <INuGetResourceProvider> > _resourceProviders = new List <Lazy <INuGetResourceProvider> >();
_resourceProviders.AddRange(FactoryExtensionsV3.GetCoreV3(Repository.Provider));
SolutionDirectory = _solutionDiretoryManager.DiretoryPath;
Settings = _nuGetSettingsAccessor.Settings.Value;
PackagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(SolutionDirectory, Settings);
_packageSourceProvider = new PackageSourceProvider(Settings);
_sourceRepositoryProvider = new SourceRepositoryProvider(_packageSourceProvider, _resourceProviders);
_packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(Settings, _logger),
_logger);
_packageManager = CreatePackageManager();
return(Task.CompletedTask);
}
public RestoreRequest(
PackageSpec project,
RestoreCommandProviders dependencyProviders,
SourceCacheContext cacheContext,
ClientPolicyContext clientPolicyContext,
PackageSourceMapping packageSourceMapping,
ILogger log,
LockFileBuilderCache lockFileBuilderCache)
{
CacheContext = cacheContext ?? throw new ArgumentNullException(nameof(cacheContext));
LockFileBuilderCache = lockFileBuilderCache ?? throw new ArgumentNullException(nameof(lockFileBuilderCache));
Log = log ?? throw new ArgumentNullException(nameof(log));
Project = project ?? throw new ArgumentNullException(nameof(project));
DependencyProviders = dependencyProviders ?? throw new ArgumentNullException(nameof(dependencyProviders));
ClientPolicyContext = clientPolicyContext;
PackageSourceMapping = packageSourceMapping;
ExternalProjects = new List <ExternalProjectReference>();
CompatibilityProfiles = new HashSet <FrameworkRuntimePair>();
PackagesDirectory = dependencyProviders.GlobalPackages.RepositoryRoot;
IsLowercasePackagesDirectory = true;
// Default to the project folder
RestoreOutputPath = Path.GetDirectoryName(Project.FilePath);
}
protected NuGetPowerShellBaseCommand()
{
_sourceRepositoryProvider = ServiceLocator.GetInstance <ISourceRepositoryProvider>();
ConfigSettings = ServiceLocator.GetInstance <Configuration.ISettings>();
VsSolutionManager = ServiceLocator.GetInstance <IVsSolutionManager>();
DTE = ServiceLocator.GetInstance <DTE>();
SourceControlManagerProvider = ServiceLocator.GetInstance <ISourceControlManagerProvider>();
_commonOperations = ServiceLocator.GetInstance <ICommonOperations>();
PackageRestoreManager = ServiceLocator.GetInstance <IPackageRestoreManager>();
_deleteOnRestartManager = ServiceLocator.GetInstance <IDeleteOnRestartManager>();
var logger = new LoggerAdapter(this);
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(ConfigSettings, logger),
logger);
if (_commonOperations != null)
{
ExecutionContext = new IDEExecutionContext(_commonOperations);
}
ActivityCorrelationId.StartNew();
}
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 virtual Task <PackageRestoreResult> RestoreMissingPackagesAsync(string solutionDirectory,
IEnumerable <PackageRestoreData> packages,
INuGetProjectContext nuGetProjectContext,
PackageDownloadContext downloadContext,
ILogger logger,
CancellationToken token)
{
if (packages == null)
{
throw new ArgumentNullException(nameof(packages));
}
var nuGetPackageManager = GetNuGetPackageManager(solutionDirectory);
var packageRestoreContext = new PackageRestoreContext(
nuGetPackageManager,
packages,
token,
PackageRestoredEvent,
PackageRestoreFailedEvent,
sourceRepositories: null,
maxNumberOfParallelTasks: PackageManagementConstants.DefaultMaxDegreeOfParallelism,
logger: logger);
if (nuGetProjectContext.PackageExtractionContext == null)
{
nuGetProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(Settings, packageRestoreContext.Logger),
packageRestoreContext.Logger);
}
return(RestoreMissingPackagesAsync(packageRestoreContext, nuGetProjectContext, downloadContext));
}
private async Task RestoreMissingPackagesInSolutionAsync(
string solutionDirectory,
IEnumerable <PackageRestoreData> packages,
ILogger logger,
CancellationToken token)
{
await TaskScheduler.Default;
using (var cacheContext = new SourceCacheContext())
{
var downloadContext = new PackageDownloadContext(cacheContext)
{
ParentId = _nuGetProjectContext.OperationId,
ClientPolicyContext = ClientPolicyContext.GetClientPolicy(_settings, logger)
};
await _packageRestoreManager.RestoreMissingPackagesAsync(
solutionDirectory,
packages,
_nuGetProjectContext,
downloadContext,
logger,
token);
}
}
/// <summary>
/// Returns the UI for the project or given set of projects.
/// </summary>
public async ValueTask <INuGetUI> CreateAsync(params IProjectContextInfo[] projects)
{
var adapterLogger = new LoggerAdapter(ProjectContext);
ProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(Settings.Value, adapterLogger),
adapterLogger);
// only pick up at most three integrated package managers
const int MaxPackageManager = 3;
var packageManagerProviders = PackageManagerProviderUtility.Sort(
PackageManagerProviders, MaxPackageManager);
return(await NuGetUI.CreateAsync(
CommonOperations,
ProjectContext,
SourceRepositoryProvider.Value,
Settings.Value,
SolutionManager,
PackageRestoreManager.Value,
OptionsPageActivator.Value,
SolutionUserOptions,
DeleteOnRestartManager.Value,
packageManagerProviders,
SolutionUserOptions,
LockService.Value,
OutputConsoleLogger,
CancellationToken.None,
projects));
}
private async Task DownloadPackages(PackageIdentity identity, CancellationToken cancellationToken)
{
var resolutionContext = new ResolutionContext(DependencyBehavior.Lowest,
IncludePrerelease,
false,
VersionConstraints.None,
new GatherCache(),
new SourceCacheContext
{
NoCache = true,
DirectDownload = true
});
INuGetProjectContext projectContext = new ProjectContext(Logger);
projectContext.PackageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv2,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(Settings, Logger),
Logger);
var downloadContext = new PackageDownloadContext(resolutionContext.SourceCacheContext, _downloadDir,
resolutionContext.SourceCacheContext.DirectDownload);
await _packageManager.InstallPackageAsync(_project,
identity,
resolutionContext,
projectContext,
downloadContext,
SourceRepositories,
Array.Empty <SourceRepository>(),
cancellationToken);
}
/// <summary>
/// Add a nupkg to the global package folder.
/// </summary>
public static async Task AddPackageToGlobalFolderAsync(string packagePath, string globalFolder, bool requireSignVerify = false)
{
using (var reader = new PackageArchiveReader(packagePath))
{
var clientPolicyContext = requireSignVerify ?
ClientPolicyContext.GetClientPolicy(Configuration.NullSettings.Instance, Common.NullLogger.Instance) : null;
var pathContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
clientPolicyContext,
Common.NullLogger.Instance);
var versionFolderPathResolver = new VersionFolderPathResolver(globalFolder);
using (var stream = File.OpenRead(packagePath))
{
await PackageExtractor.InstallFromSourceAsync(
null,
reader.GetIdentity(),
async (d) => await stream.CopyToAsync(d),
versionFolderPathResolver,
pathContext,
CancellationToken.None);
}
}
}
private void ExtractNupkg(string nugetCache, string nupkg)
{
var pathResolver = new VersionFolderPathResolver(nugetCache);
PackageIdentity identity = null;
using (var reader = new PackageArchiveReader(File.OpenRead(nupkg)))
{
identity = reader.GetIdentity();
}
if (!File.Exists(pathResolver.GetHashPath(identity.Id, identity.Version)))
{
using (var fileStream = File.OpenRead(nupkg))
{
ClientPolicyContext clientPolicyContext = null;
PackageExtractor.InstallFromSourceAsync(
source: null,
packageIdentity: identity,
copyToAsync: stream => fileStream.CopyToAsync(stream, 4096, CancellationToken.None),
versionFolderPathResolver: pathResolver,
packageExtractionContext: new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
clientPolicyContext,
NullLogger.Instance),
token: CancellationToken.None).Wait();
}
}
}
public TestRestoreRequest(
PackageSpec project,
IEnumerable <SourceRepository> sources,
string packagesDirectory,
IEnumerable <string> fallbackPackageFolders,
SourceCacheContext cacheContext,
ClientPolicyContext clientPolicyContext,
ILogger log) : base(
project,
RestoreCommandProviders.Create(
packagesDirectory,
fallbackPackageFolderPaths: fallbackPackageFolders,
sources: sources,
cacheContext: cacheContext,
packageFileCache: new LocalPackageFileCache(),
log: log),
cacheContext,
clientPolicyContext,
log)
{
// We need the dependency graph spec to go through the proper no-op code paths
DependencyGraphSpec = new DependencyGraphSpec();
DependencyGraphSpec.AddProject(project);
DependencyGraphSpec.AddRestore(project.RestoreMetadata.ProjectUniqueName);
AllowNoOp = true;
}
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);
}
public VsPathContextProvider(
IAsyncServiceProvider asyncServiceProvider,
Lazy <ISettings> settings,
Lazy <IVsSolutionManager> solutionManager,
Lazy <ILogger> logger,
Lazy <IMachineWideSettings> machineWideSettings,
INuGetTelemetryProvider telemetryProvider)
{
_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;
if (machineWideSettings == null)
{
throw new ArgumentNullException(nameof(machineWideSettings));
}
_projectContext = new Lazy <INuGetProjectContext>(() => new VSAPIProjectContext
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings.Value, NullLogger.Instance),
NullLogger.Instance)
});
_userWideSettings = new Microsoft.VisualStudio.Threading.AsyncLazy <ISettings>(() => Task.FromResult(Settings.LoadDefaultSettings(null, null, machineWideSettings.Value)), NuGetUIThreadHelper.JoinableTaskFactory);
_telemetryProvider = telemetryProvider ?? throw new ArgumentNullException(nameof(telemetryProvider));
}
/// <summary>
/// Returns the UI for the project or given set of projects.
/// </summary>
public async ValueTask <INuGetUI> CreateAsync(
IServiceBroker serviceBroker,
params IProjectContextInfo[] projects)
{
if (serviceBroker is null)
{
throw new ArgumentNullException(nameof(serviceBroker));
}
var adapterLogger = new LoggerAdapter(ProjectContext);
ProjectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(Settings.Value, adapterLogger),
adapterLogger);
return(await NuGetUI.CreateAsync(
serviceBroker,
CommonOperations,
ProjectContext,
SourceRepositoryProvider.Value,
Settings.Value,
SolutionManager,
PackageRestoreManager.Value,
OptionsPageActivator.Value,
SolutionUserOptions,
DeleteOnRestartManager.Value,
SolutionUserOptions,
LockService.Value,
OutputConsoleLogger,
RestoreProgressReporter.Value,
CancellationToken.None,
projects));
}
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));
}
protected NuGetPowerShellBaseCommand()
{
var componentModel = NuGetUIThreadHelper.JoinableTaskFactory.Run(ServiceLocator.GetComponentModelAsync);
_sourceRepositoryProvider = componentModel.GetService <ISourceRepositoryProvider>();
ConfigSettings = componentModel.GetService <ISettings>();
VsSolutionManager = componentModel.GetService <IVsSolutionManager>();
SourceControlManagerProvider = componentModel.GetService <ISourceControlManagerProvider>();
_commonOperations = componentModel.GetService <ICommonOperations>();
PackageRestoreManager = componentModel.GetService <IPackageRestoreManager>();
_deleteOnRestartManager = componentModel.GetService <IDeleteOnRestartManager>();
_nuGetProgressReporter = componentModel.GetService <IRestoreProgressReporter>();
DTE = ServiceLocator.GetInstance <DTE>();
var logger = new LoggerAdapter(this);
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(ConfigSettings, logger),
logger);
if (_commonOperations != null)
{
ExecutionContext = new IDEExecutionContext(_commonOperations);
}
ActivityCorrelationId.StartNew();
}
private RestoreSummaryRequest Create(
string projectNameToRestore,
ExternalProjectReference project,
HashSet <ExternalProjectReference> projectReferenceClosure,
RestoreArgs restoreArgs,
DependencyGraphSpec projectDgSpec)
{
var projectPackageSpec = projectDgSpec.GetProjectSpec(projectNameToRestore);
//fallback paths, global packages path and sources need to all be passed in the dg spec
var fallbackPaths = projectPackageSpec.RestoreMetadata.FallbackFolders;
var globalPath = GetPackagesPath(restoreArgs, projectPackageSpec);
var settings = Settings.LoadSettingsGivenConfigPaths(projectPackageSpec.RestoreMetadata.ConfigFilePaths);
var sources = restoreArgs.GetEffectiveSources(settings, projectPackageSpec.RestoreMetadata.Sources);
var clientPolicyContext = ClientPolicyContext.GetClientPolicy(settings, restoreArgs.Log);
var sharedCache = _providerCache.GetOrCreate(
globalPath,
fallbackPaths.AsList(),
sources,
restoreArgs.CacheContext,
restoreArgs.Log);
var rootPath = Path.GetDirectoryName(project.PackageSpec.FilePath);
// Create request
var request = new RestoreRequest(
project.PackageSpec,
sharedCache,
restoreArgs.CacheContext,
clientPolicyContext,
restoreArgs.Log)
{
// Set properties from the restore metadata
ProjectStyle = project.PackageSpec.RestoreMetadata.ProjectStyle,
// Project.json is special cased to put assets file and generated .props and targets in the project folder
RestoreOutputPath = project.PackageSpec.RestoreMetadata.ProjectStyle == ProjectStyle.ProjectJson ? rootPath : project.PackageSpec.RestoreMetadata.OutputPath,
DependencyGraphSpec = projectDgSpec,
MSBuildProjectExtensionsPath = projectPackageSpec.RestoreMetadata.OutputPath
};
var restoreLegacyPackagesDirectory = project.PackageSpec?.RestoreMetadata?.LegacyPackagesDirectory
?? DefaultRestoreLegacyPackagesDirectory;
request.IsLowercasePackagesDirectory = !restoreLegacyPackagesDirectory;
// Standard properties
restoreArgs.ApplyStandardProperties(request);
// Add project references
request.ExternalProjects = projectReferenceClosure.ToList();
// The lock file is loaded later since this is an expensive operation
var summaryRequest = new RestoreSummaryRequest(
request,
project.MSBuildProjectPath,
settings.GetConfigFilePaths(),
sources);
return(summaryRequest);
}
/// <summary>
/// Restores missing packages for the entire solution
/// </summary>
/// <returns></returns>
public virtual async Task <PackageRestoreResult> RestoreMissingPackagesInSolutionAsync(
string solutionDirectory,
INuGetProjectContext nuGetProjectContext,
ILogger logger,
CancellationToken token)
{
var packageReferencesDictionary = await GetPackagesReferencesDictionaryAsync(token);
// When this method is called, the step to compute if a package is missing is implicit. Assume it is true
var packages = packageReferencesDictionary.Select(p =>
{
Debug.Assert(p.Value != null);
return(new PackageRestoreData(p.Key, p.Value, isMissing: true));
});
using (var cacheContext = new SourceCacheContext())
{
var adapterLogger = new LoggerAdapter(nuGetProjectContext);
var downloadContext = new PackageDownloadContext(cacheContext)
{
ParentId = nuGetProjectContext.OperationId,
ClientPolicyContext = ClientPolicyContext.GetClientPolicy(Settings, adapterLogger)
};
return(await RestoreMissingPackagesAsync(
solutionDirectory,
packages,
nuGetProjectContext,
downloadContext,
logger,
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 logger = new LoggerAdapter(projectContext);
projectContext.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, logger),
logger);
return(projectContext);
});
PumpingJTF = new PumpingJTF(NuGetUIThreadHelper.JoinableTaskFactory);
}
public async Task <PackageReaderBase> GetLocalPackageAsync(string packagePath, CancellationToken cancellationToken = default)
{
if (packagePath.StartsWith("~/", StringComparison.Ordinal))
{
packagePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), packagePath.Substring(2));
}
else
{
packagePath = Path.GetFullPath(packagePath);
}
var reader = new PackageArchiveReader(File.OpenRead(packagePath));
var identity = reader.GetIdentity();
var rootDirectory = Path.Combine(Path.GetTempPath(), "apidiffpackages", Path.GetRandomFileName());
m_tempDirectories.Add(rootDirectory);
var context = new PackageExtractionContext(
PackageSaveMode.Files | PackageSaveMode.Nuspec,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(m_settings, Logger),
Logger);
var resolver = new PackagePathResolver(rootDirectory);
await PackageExtractor.ExtractPackageAsync(null, reader, resolver, context, cancellationToken).ConfigureAwait(false);
var packageFolder = resolver.GetInstallPath(identity);
return(new PackageFolderReader(packageFolder));
}
public async Task DownloadPackages(SourceCacheContext context, IEnumerable <SourcePackageDependencyInfo> packagesToInstall, Action <string>?statusCallback = null)
{
foreach (var pkg in packagesToInstall)
{
if (!IsInstalled(pkg))
{
statusCallback?.Invoke($"downloading {pkg.Id}");
var downloadResource = await pkg.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
pkg,
new PackageDownloadContext(context),
SettingsUtility.GetGlobalPackagesFolder(NugetSettings),
Logger, CancellationToken.None);
await GlobalPackagesFolderUtility.AddPackageAsync(
source : null,
packageIdentity : pkg,
packageStream : downloadResult.PackageStream,
globalPackagesFolder : LocalPackagesFinder.Root,
clientPolicyContext : ClientPolicyContext.GetClientPolicy(NugetSettings, Logger),
logger : Logger,
parentId : Guid.Empty,
token : CancellationToken.None);
}
}
}
/// <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 logger = new LoggerAdapter(context);
context.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, logger),
logger);
WebSiteProjectSystem projectSystem = new WebSiteProjectSystem(_vsProjectAdapterProvider.CreateAdapterForFullyLoadedProject(project), context);
foreach (var packageName in packageNames)
{
string packagePath = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", packageName.Id, packageName.Version);
DirectoryInfo packageFolder = new DirectoryInfo(Path.Combine(repositoryPath, packagePath));
PackageFolderReader reader = new PackageFolderReader(packageFolder);
var frameworkGroups = reader.GetReferenceItems();
var groups = reader.GetReferenceItems();
var fwComparer = new NuGetFrameworkFullComparer();
FrameworkReducer reducer = new FrameworkReducer();
NuGetFramework targetGroupFramework = reducer.GetNearest(projectSystem.TargetFramework, groups.Select(e => e.TargetFramework));
if (targetGroupFramework != null)
{
var refGroup = groups.Where(e => fwComparer.Equals(targetGroupFramework, e.TargetFramework)).FirstOrDefault();
foreach (string refItem in refGroup.Items)
{
string sourcePath = Path.Combine(packageFolder.FullName, refItem.Replace('/', Path.DirectorySeparatorChar));
// create one refresh file for each assembly reference, as per required by Website projects
// projectSystem.CreateRefreshFile(assemblyPath);
RefreshFileUtility.CreateRefreshFile(projectSystem, sourcePath);
}
}
}
}
public RestoreRequest(
PackageSpec project,
RestoreCommandProviders dependencyProviders,
SourceCacheContext cacheContext,
ClientPolicyContext clientPolicyContext,
ILogger log) : this(project, dependencyProviders, cacheContext, clientPolicyContext, packageSourceMapping : null, log, new LockFileBuilderCache())
{
}
internal PackageExtractionContext GetPackageExtractionContext(ISettings settings)
{
return(new PackageExtractionContext(
PackageSaveMode,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(settings, Log),
Log));
}
public async Task UWPRestore_BlankUWPAppWithExcludes()
{
// Arrange
var sources = new List <PackageSource>();
sources.Add(new PackageSource("https://api.nuget.org/v3/index.json"));
using (var packagesDir = TestDirectory.Create())
using (var projectDir = TestDirectory.Create())
using (var cacheContext = new SourceCacheContext())
{
var configJson = JObject.Parse(@"{
""dependencies"": {
""Microsoft.NETCore.UniversalWindowsPlatform"": {
""version"": ""5.0.0"",
""exclude"": ""build,runtime,compile,native""
}
},
""frameworks"": {
""uap10.0"": {}
},
""runtimes"": {
""win10-arm"": {},
""win10-arm-aot"": {},
""win10-x86"": {},
""win10-x86-aot"": {},
""win10-x64"": {},
""win10-x64-aot"": {}
}
}");
var specPath = Path.Combine(projectDir, "TestProject", "project.json");
var spec = JsonPackageSpecReader.GetPackageSpec(configJson.ToString(), "TestProject", specPath);
var logger = new TestLogger();
var clientPolicyContext = ClientPolicyContext.GetClientPolicy(NullSettings.Instance, logger);
var request = new TestRestoreRequest(spec, sources, packagesDir, cacheContext, clientPolicyContext, logger)
{
LockFilePath = Path.Combine(projectDir, "project.lock.json")
};
var lockFileFormat = new LockFileFormat();
var command = new RestoreCommand(request);
// Act
var result = await command.ExecuteAsync();
await result.CommitAsync(logger, CancellationToken.None);
var lockFileJson = JObject.Parse(File.OpenText(request.LockFilePath).ReadToEnd());
// Assert
Assert.Equal(0, result.CompatibilityCheckResults.Sum(checkResult => checkResult.Issues.Count));
Assert.Equal(0, logger.Errors);
Assert.Equal(0, logger.Warnings);
Assert.Equal(118, result.GetAllInstalled().Count);
}
}
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)
{
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
ClientPolicyContext.GetClientPolicy(_settings, NullLogger.Instance),
NullLogger.Instance)
};
await InstallInternalAsync(
project,
toInstall,
repoProvider,
projectContext,
includePrerelease: false,
ignoreDependencies: ignoreDependencies,
token: CancellationToken.None);
});
}
public void UninstallPackage(Project project, string packageId, bool removeDependencies)
{
const string eventName = nameof(IVsPackageUninstaller) + "." + nameof(UninstallPackage);
using var _ = NuGetETW.ExtensibilityEventSource.StartStopEvent(eventName,
new
{
// Can't add project information, since it's a COM object that this method might be called on a background thread
PackageId = packageId,
RemoveDependencies = removeDependencies
});
if (project == null)
{
throw new ArgumentNullException(nameof(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,
_restoreProgressReporter);
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;
}
}
public void GetClientPolicy_ReadsAndParsesTrustedSigners()
{
// Arrange
var config = @"
<configuration>
<config>
<add key=""signatureValidationMode"" value=""require"" />
</config>
<trustedSigners>
<author name=""author1"">
<certificate fingerprint=""abc"" hashAlgorithm=""SHA256"" allowUntrustedRoot=""false"" />
</author>
<repository name=""repository1"" serviceIndex=""https://v3serviceIndex.test/api/json"">
<certificate fingerprint=""def"" hashAlgorithm=""SHA256"" allowUntrustedRoot=""true"" />
</repository>
</trustedSigners>
</configuration>";
var nugetConfigPath = "NuGet.Config";
using (var mockBaseDirectory = TestDirectory.Create())
{
SettingsTestUtils.CreateConfigurationFile(nugetConfigPath, mockBaseDirectory, config);
// Act and Assert
var settings = new Settings(mockBaseDirectory);
settings.Should().NotBeNull();
var expectedAllowList = new List <VerificationAllowListEntry>()
{
new TrustedSignerAllowListEntry(VerificationTarget.Author, SignaturePlacement.PrimarySignature, "abc", HashAlgorithmName.SHA256),
new TrustedSignerAllowListEntry(VerificationTarget.Repository, SignaturePlacement.Any, "def", HashAlgorithmName.SHA256, allowUntrustedRoot: true)
};
var clientPolicyContext = ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance);
clientPolicyContext.Policy.Should().Be(SignatureValidationMode.Require);
clientPolicyContext.AllowList.Count.Should().Be(2);
clientPolicyContext.AllowList.Should().BeEquivalentTo(expectedAllowList);
var verifierSettings = clientPolicyContext.VerifierSettings;
verifierSettings.AllowUnsigned.Should().BeFalse();
verifierSettings.AllowIllegal.Should().BeFalse();
verifierSettings.AllowUntrusted.Should().BeFalse();
verifierSettings.AllowIgnoreTimestamp.Should().BeTrue();
verifierSettings.AllowMultipleTimestamps.Should().BeTrue();
verifierSettings.AllowNoTimestamp.Should().BeTrue();
verifierSettings.AllowUnknownRevocation.Should().BeTrue();
verifierSettings.ReportUnknownRevocation.Should().BeTrue();
verifierSettings.VerificationTarget.Should().Be(VerificationTarget.All);
verifierSettings.SignaturePlacement.Should().Be(SignaturePlacement.Any);
verifierSettings.RepositoryCountersignatureVerificationBehavior.Should().Be(SignatureVerificationBehavior.IfExistsAndIsNecessary);
verifierSettings.RevocationMode.Should().Be(RevocationMode.Online);
}
}
public virtual async Task <NuGetInstallResult> InstallAsync(PackageIdentity packageIdentity, bool allowPrereleaseVersions = false)
{
using var cacheContext = new SourceCacheContext();
IEnumerable <SourcePackageDependencyInfo> dependencyPackages;
try
{
dependencyPackages = await QueryDependenciesAsync(packageIdentity, cacheContext);
}
catch (NuGetResolverInputException ex)
{
Logger.LogDebug(ex.ToString());
return(new NuGetInstallResult(NuGetInstallCode.PackageOrVersionNotFound));
}
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Nupkg,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(m_NugetSettings, Logger),
Logger);
foreach (var dependencyPackage in dependencyPackages)
{
if (await GetLatestPackageIdentityAsync(dependencyPackage.Id) != null)
{
continue;
}
var installedPath = m_PackagePathResolver.GetInstalledPath(dependencyPackage);
if (installedPath == null)
{
Logger.LogInformation($"Downloading: {dependencyPackage.Id} v{dependencyPackage.Version.OriginalVersion}");
var downloadResource = await dependencyPackage.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
dependencyPackage,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(m_NugetSettings),
Logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
m_PackagePathResolver,
packageExtractionContext,
CancellationToken.None);
}
await LoadAssembliesFromNuGetPackageAsync(GetNugetPackageFile(dependencyPackage));
}
await RemoveOutdatedPackagesAsync();
return(new NuGetInstallResult(packageIdentity));
}
public NuGetProjectContext(ISettings settings)
{
var nuGetLogger = new NuGetLogger();
PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Files,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, nuGetLogger),
nuGetLogger);
}
