private async Task <DownloadResourceResult> DownloadPackageResourceAsync(
SourcePackageDependencyInfo package, SourceCacheContext cacheContext, CancellationToken cancellationToken, string globalFolder = "")
{
if (string.Equals(globalFolder, ""))
{
globalFolder = DefaultNuGetFolders.GetGlobalPackagesFolder();
}
using (var progressToken = await _downloadingProgressTrackerService?.TrackDownloadOperationAsync(this, package))
{
var downloadResource = await package.Source.GetResourceAsync <DownloadResource>(cancellationToken);
var packageDownloadContext = new PackageDownloadContext(cacheContext);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync
(
package,
new PackageDownloadContext(cacheContext),
globalFolder,
_nugetLogger,
cancellationToken
);
return(downloadResult);
}
}
public PackageInstallationService(IServiceLocator serviceLocator, ITypeFactory typeFactory, IFrameworkNameProvider frameworkNameProvider, ISourceRepositoryProvider sourceRepositoryProvider, INuGetProjectConfigurationProvider nuGetProjectConfigurationProvider,
INuGetProjectContextProvider nuGetProjectContextProvider, IDirectoryService directoryService, IFileService fileService, IApiPackageRegistry apiPackageRegistry, IFileSystemService fileSystemService, ILogger logger)
{
Argument.IsNotNull(() => frameworkNameProvider);
Argument.IsNotNull(() => sourceRepositoryProvider);
Argument.IsNotNull(() => nuGetProjectConfigurationProvider);
Argument.IsNotNull(() => nuGetProjectContextProvider);
Argument.IsNotNull(() => directoryService);
Argument.IsNotNull(() => fileService);
Argument.IsNotNull(() => apiPackageRegistry);
Argument.IsNotNull(() => fileSystemService);
Argument.IsNotNull(() => logger);
_serviceLocator = serviceLocator;
_typeFactory = typeFactory;
_frameworkNameProvider = frameworkNameProvider;
_sourceRepositoryProvider = sourceRepositoryProvider;
_nuGetProjectConfigurationProvider = nuGetProjectConfigurationProvider;
_nuGetProjectContextProvider = nuGetProjectContextProvider;
_directoryService = directoryService;
_fileService = fileService;
_apiPackageRegistry = apiPackageRegistry;
_fileSystemService = fileSystemService;
_nugetLogger = logger;
_nuGetCacheManager = new NuGetCacheManager(_directoryService, _fileService);
if (serviceLocator.IsTypeRegistered <IDownloadingProgressTrackerService>())
{
_downloadingProgressTrackerService = serviceLocator.ResolveType <IDownloadingProgressTrackerService>();
}
_installerPathResolver = new VersionFolderPathResolver(DefaultNuGetFolders.GetGlobalPackagesFolder());
}
public IList <string> GetConfigFilePaths()
{
var localFolderConfig = Path.Combine(DefaultNuGetFolders.GetApplicationLocalFolder(), ConfigurationFileName);
var roamingFolderConfig = Path.Combine(DefaultNuGetFolders.GetApplicationRoamingFolder(), ConfigurationFileName);
return(new string[] { localFolderConfig, roamingFolderConfig });
}
public bool ClearAll()
{
bool noErrors = true;
noErrors &= ClearHttpCache();
noErrors &= ClearNuGetFolder(DefaultNuGetFolders.GetGlobalPackagesFolder(), "Global-packages");
noErrors &= ClearNuGetFolder(NuGetEnvironment.GetFolderPath(NuGetFolderPath.Temp), "Temp");
Log.Info("Cache clearing operation finished");
return(noErrors);
}
private async Task <IDictionary <SourcePackageDependencyInfo, DownloadResourceResult> > DownloadPackagesResourcesAsync(
IEnumerable <SourcePackageDependencyInfo> packageIdentities, SourceCacheContext cacheContext, CancellationToken cancellationToken)
{
var downloaded = new Dictionary <SourcePackageDependencyInfo, DownloadResourceResult>();
string globalFolderPath = DefaultNuGetFolders.GetGlobalPackagesFolder();
foreach (var package in packageIdentities)
{
var downloadResult = await DownloadPackageResourceAsync(package, cacheContext, cancellationToken, globalFolderPath);
downloaded.Add(package, downloadResult);
}
return(downloaded);
}
public async Task <InstallerResult> InstallAsync(
PackageIdentity package,
IExtensibleProject project,
IReadOnlyList <SourceRepository> repositories,
bool ignoreMissingPackages = false,
CancellationToken cancellationToken = default)
{
try
{
// Step 1. Decide what framework version used on package resolving
// Enforce platform-specific framework for .NET 5.0
var targetFramework = FrameworkParser.TryParseFrameworkName(project.Framework, _frameworkNameProvider);
var reducer = new FrameworkReducer();
#if NET5_0_OR_GREATER
var mostSpecific = reducer.ReduceUpwards(project.SupportedPlatforms).FirstOrDefault();
targetFramework = mostSpecific;
#endif
_nugetLogger.LogInformation($"Installing package {package}, Target framework: {targetFramework}");
// Prepare to step 2. Add globals if cache enabled as available repository with highest priority.
// Note: This part falls under responsibility of RepositoryContextService but the same logic used to determine what packages are found by IPackageLoaderService
// To not break behavior for now add here
if (!project.NoCache)
{
var repositoryList = repositories.ToList();
repositoryList.Insert(0, new SourceRepository(new PackageSource(DefaultNuGetFolders.GetGlobalPackagesFolder(), ".nuget"), Repository.Provider.GetCoreV3()));
repositories = repositoryList;
}
// Step 2. Build list of dependencies and determine DependencyBehavior if some packages are misssed in current feed
Resolver.PackageResolverContext resolverContext = null;
using (var cacheContext = new SourceCacheContext())
{
#pragma warning disable IDISP013 // Await in using.
var getDependencyResourcesTasks = repositories.Select(repo => repo.GetResourceAsync <DependencyInfoResource>());
#pragma warning restore IDISP013 // Await in using.
var dependencyResources = (await getDependencyResourcesTasks.WhenAllOrExceptionAsync()).Where(x => x.IsSuccess && x.Result is not null)
.Select(x => x.Result).ToArray();
var dependencyInfoResources = new DependencyInfoResourceCollection(dependencyResources);
resolverContext = await ResolveDependenciesAsync(package, targetFramework, PackageIdentityComparer.Default, dependencyInfoResources, cacheContext, project, ignoreMissingPackages, cancellationToken);
if (resolverContext is null ||
!(resolverContext?.AvailablePackages?.Any() ?? false))
{
var errorMessage = $"Package {package} cannot be resolved with current settings (TFM: {targetFramework}) for chosen destination";
_nugetLogger.LogWarning(errorMessage);
return(new InstallerResult(errorMessage));
}
// Step 3. Try to check is main package can be downloaded from resource
var mainPackageInfo = resolverContext.AvailablePackages.FirstOrDefault(p => p.Id == package.Id);
_nugetLogger.LogInformation($"Downloading {package}...");
var mainDownloadedFiles = await DownloadPackageResourceAsync(mainPackageInfo, cacheContext, cancellationToken);
_nugetLogger.LogInformation($"{package} download completed");
if (!mainDownloadedFiles.IsAvailable())
{
// Downlod failed by some reasons (probably connection issue or package goes deleted before feed updated)
var errorMessage = $"Current source lists package {package} but attempts to download it have failed. The source in invalid or required packages were removed while the current operation was in progress";
_nugetLogger.LogError(errorMessage);
return(new InstallerResult(errorMessage));
}
// Step 4. Check is main package compatible with target Framework
var canBeInstalled = await CheckCanBeInstalledAsync(project, mainDownloadedFiles.PackageReader, targetFramework, cancellationToken);
if (!canBeInstalled)
{
throw new IncompatiblePackageException($"Package {package} incompatible with project target platform {targetFramework}");
}
// Step 5. Build install list using NuGet Resolver and select available resources.
// Track packages which already installed and make sure only one version of package exists
var resolver = new Resolver.PackageResolver();
var availablePackagesToInstall = await resolver.ResolveWithVersionOverrideAsync(resolverContext, project, DependencyBehavior.Highest,
(project, conflict) => _fileSystemService.CreateDeleteme(conflict.PackageIdentity.Id, project.GetInstallPath(conflict.PackageIdentity)),
cancellationToken);
// Step 6. Download everything except main package and extract all
availablePackagesToInstall.Remove(mainPackageInfo);
_nugetLogger.LogInformation($"Downloading package dependencies...");
var downloadResults = await DownloadPackagesResourcesAsync(availablePackagesToInstall, cacheContext, cancellationToken);
downloadResults[mainPackageInfo] = mainDownloadedFiles;
_nugetLogger.LogInformation($"{downloadResults.Count - 1} dependencies downloaded");
var extractionContext = GetExtractionContext();
await ExtractPackagesResourcesAsync(downloadResults, project, extractionContext, cancellationToken);
await CheckLibAndFrameworkItemsAsync(downloadResults, targetFramework, cancellationToken);
return(new InstallerResult(downloadResults));
}
}
catch (NuGetResolverInputException ex)
{
throw new IncompatiblePackageException($"Package {package} or some of it dependencies are missed for current target framework", ex);
}
catch (Exception ex)
{
Log.Error(ex);
throw;
}
}
public IList <string> GetConfigRoots()
{
return(new string[] { DefaultNuGetFolders.GetApplicationLocalFolder(), DefaultNuGetFolders.GetApplicationRoamingFolder() });
}
