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);
}
}
}
public string GetPackagePathInGlobalPackagesFolder(PackageIdentity identity)
{
using (var result = GlobalPackagesFolderUtility.GetPackage(identity, GlobalPackagesPath))
{
if (result == null)
{
return(null);
}
var resolver = new VersionFolderPathResolver(GlobalPackagesPath);
return(resolver.GetInstallPath(identity.Id, identity.Version));
}
}
public async Task AddToGlobalPackagesFolderAsync(PackageIdentity identity, string packagePath)
{
using (var fileStream = new FileStream(packagePath, FileMode.Open, FileAccess.Read))
{
using (await GlobalPackagesFolderUtility.AddPackageAsync(
identity,
fileStream,
GlobalPackagesPath,
Common.NullLogger.Instance,
CancellationToken.None))
{
}
}
}
public async Task AddToGlobalPackagesFolderAsync(PackageIdentity identity, string packagePath)
{
using (var fileStream = new FileStream(packagePath, FileMode.Open, FileAccess.Read))
{
using (await GlobalPackagesFolderUtility.AddPackageAsync(
source: null,
packageIdentity: identity,
packageStream: fileStream,
globalPackagesFolder: GlobalPackagesPath,
parentId: Guid.Empty,
logger: Common.NullLogger.Instance,
token: CancellationToken.None))
{
}
}
}
private static async Task VerifyDirectDownloadSkipsGlobalPackagesFolderAsync(
SourceRepositoryProvider sourceRepositoryProvider)
{
// Arrange
var sourceRepository = sourceRepositoryProvider.GetRepositories().First();
var packageIdentity = new PackageIdentity("jQuery", new NuGetVersion("1.8.2"));
using (var packagesDirectory = TestDirectory.Create())
using (var directDownloadDirectory = TestDirectory.Create())
using (var cacheContext = new SourceCacheContext())
{
var downloadContext = new PackageDownloadContext(
cacheContext,
directDownloadDirectory,
directDownload: true);
// Act
using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(
sourceRepository,
packageIdentity,
downloadContext,
packagesDirectory,
NullLogger.Instance,
CancellationToken.None))
{
var targetPackageStream = downloadResult.PackageStream;
using (var packageArchiveReader = new PackageArchiveReader(targetPackageStream))
{
var contentHash = packageArchiveReader.GetContentHash(CancellationToken.None);
// Assert
Assert.Equal(_jQuery182ContentHash, contentHash);
Assert.True(targetPackageStream.CanSeek);
}
}
// Verify that the direct download directory is empty. The package should be downloaded to a temporary
// file opened with DeleteOnClose.
Assert.Equal(0, Directory.EnumerateFileSystemEntries(directDownloadDirectory).Count());
// Verify that the package was not cached in the Global Packages Folder
var globalPackage = GlobalPackagesFolderUtility.GetPackage(packageIdentity, packagesDirectory);
Assert.Null(globalPackage);
}
}
public async Task AddToGlobalPackagesFolderAsync(PackageIdentity identity, string packagePath)
{
using (var fileStream = new FileStream(packagePath, FileMode.Open, FileAccess.Read))
{
using (await GlobalPackagesFolderUtility.AddPackageAsync(
source: null,
packageIdentity: identity,
packageStream: fileStream,
globalPackagesFolder: GlobalPackagesPath,
parentId: Guid.Empty,
extractionContext: new PackageExtractionContext(
PackageSaveMode.Defaultv3,
PackageExtractionBehavior.XmlDocFileSaveMode,
clientPolicyContext: null,
logger: NullLogger.Instance),
logger: NullLogger.Instance,
token: CancellationToken.None))
{
}
}
}
/// <summary>
/// Fetch, if not already downloaded, and install the package represented by
/// (<paramref name="packageId"/>, <paramref name="version"/>).
/// </summary>
/// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks>
/// <param name="packageId">Name of package to install.</param>
/// <param name="version">Version of package to install.</param>
public async Task <NugetLocalPackage> InstallPackage(string packageId, PackageVersion version, ProgressReport progress)
{
// Xenko 2.x still installs in GamePackages
var currentManager = IsPackageV2(packageId, version) ? managerV2 : manager;
using (GetLocalRepositoryLock())
{
currentProgressReport = progress;
try
{
var identity = new PackageIdentity(packageId, version.ToNuGetVersion());
var resolutionContext = new ResolutionContext(
DependencyBehavior.Lowest,
true,
true,
VersionConstraints.None);
var repositories = PackageSources.Select(sourceRepositoryProvider.CreateRepository).ToArray();
var projectContext = new EmptyNuGetProjectContext()
{
ActionType = NuGetActionType.Install,
PackageExtractionContext = new PackageExtractionContext(NativeLogger),
};
ActivityCorrelationId.StartNew();
{
// Equivalent to:
// await manager.InstallPackageAsync(manager.PackagesFolderNuGetProject,
// identity, resolutionContext, projectContext, repositories,
// Array.Empty<SourceRepository>(), // This is a list of secondary source respositories, probably empty
// CancellationToken.None);
using (var sourceCacheContext = new SourceCacheContext())
{
var nuGetProject = currentManager.PackagesFolderNuGetProject;
var packageIdentity = identity;
var nuGetProjectContext = projectContext;
var primarySources = repositories;
var secondarySources = Array.Empty <SourceRepository>();
var token = CancellationToken.None;
var downloadContext = new PackageDownloadContext(sourceCacheContext);
// Step-1 : Call PreviewInstallPackageAsync to get all the nuGetProjectActions
var nuGetProjectActions = await currentManager.PreviewInstallPackageAsync(nuGetProject, packageIdentity, resolutionContext,
nuGetProjectContext, primarySources, secondarySources, token);
// Notify that installations started.
foreach (var operation in nuGetProjectActions)
{
if (operation.NuGetProjectActionType == NuGetProjectActionType.Install)
{
var installPath = GetInstalledPath(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion());
OnPackageInstalling(this, new PackageOperationEventArgs(new PackageName(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion()), installPath));
}
}
NuGetPackageManager.SetDirectInstall(packageIdentity, nuGetProjectContext);
// Step-2 : Execute all the nuGetProjectActions
if (IsPackageV2(packageId, version))
{
await currentManager.ExecuteNuGetProjectActionsAsync(
nuGetProject,
nuGetProjectActions,
nuGetProjectContext,
downloadContext,
token);
}
else
{
// Download and install package in the global cache (can't use NuGetPackageManager anymore since it is designed for V2)
foreach (var operation in nuGetProjectActions)
{
if (operation.NuGetProjectActionType == NuGetProjectActionType.Install)
{
using (var downloadResult = await PackageDownloader.GetDownloadResourceResultAsync(primarySources, packageIdentity, downloadContext, InstallPath, NativeLogger, token))
{
if (downloadResult.Status != DownloadResourceResultStatus.Available)
{
throw new InvalidOperationException($"Could not download package {packageIdentity}");
}
using (var installResult = await GlobalPackagesFolderUtility.AddPackageAsync(packageIdentity, downloadResult.PackageStream, InstallPath, NativeLogger, token))
{
if (installResult.Status != DownloadResourceResultStatus.Available)
{
throw new InvalidOperationException($"Could not install package {packageIdentity}");
}
}
}
}
}
}
NuGetPackageManager.ClearDirectInstall(nuGetProjectContext);
// Notify that installations completed.
foreach (var operation in nuGetProjectActions)
{
if (operation.NuGetProjectActionType == NuGetProjectActionType.Install)
{
var installPath = GetInstalledPath(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion());
OnPackageInstalled(this, new PackageOperationEventArgs(new PackageName(operation.PackageIdentity.Id, operation.PackageIdentity.Version.ToPackageVersion()), installPath));
}
}
}
}
// Load the recently installed package
var installedPackages = GetPackagesInstalled(new[] { packageId });
return(installedPackages.FirstOrDefault(p => p.Version == version));
}
finally
{
currentProgressReport = null;
}
}
}
