/// <summary>
/// Installs the specified resource at the given location.
/// </summary>
/// <param name="package">The package reference.</param>
/// <param name="type">The package type.</param>
/// <param name="path">The location where to install the package.</param>
/// <returns>The installed files.</returns>
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
// Create the addin directory if it doesn't exist.
path = GetPackagePath(path.MakeAbsolute(_environment), package);
var root = _fileSystem.GetDirectory(path);
if (!root.Exists)
{
_log.Debug("Creating directory {0}", path);
root.Create();
}
// Package already exist?
var packagePath = GetPackagePath(root, package.Package);
if (packagePath != null)
{
// Fetch available content from disc.
var content = _contentResolver.GetFiles(packagePath, package, type);
if (content.Any())
{
_log.Debug("Package {0} has already been installed.", package.Package);
return(content);
}
}
// Install the package.
InstallPackage(package, path);
// Try locating the install folder again.
packagePath = GetPackagePath(root, package.Package);
// Get the files.
var result = _contentResolver.GetFiles(packagePath, package, type);
if (result.Count == 0)
{
if (type == PackageType.Addin)
{
var framework = _environment.Runtime.TargetFramework;
_log.Warning("Could not find any assemblies compatible with {0}.", framework.FullName);
}
else if (type == PackageType.Tool)
{
const string format = "Could not find any relevant files for tool '{0}'. Perhaps you need an include parameter?";
_log.Warning(format, package.Package);
}
}
return(result);
}
public IReadOnlyCollection <IFile> GetFiles(DirectoryPath directoryPath, PackageReference packageReference, PackageType type)
{
bool loadDependencies;
if (packageReference.Parameters.ContainsKey("LoadDependencies"))
{
bool.TryParse(packageReference.Parameters["LoadDependencies"].FirstOrDefault() ?? bool.TrueString, out loadDependencies);
}
else
{
bool.TryParse(_config.GetValue(Constants.NuGet.LoadDependencies) ?? bool.FalseString, out loadDependencies);
}
var files = new List <IFile>();
var package = _installedPackages.First(p => p.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase));
var installPath = new DirectoryPath(_pathResolver.GetInstallPath(package));
if (!_fileSystem.Exist(installPath))
{
_log.Warning("Package {0} is not installed.", packageReference.Package);
return(Array.Empty <IFile>());
}
files.AddRange(_contentResolver.GetFiles(installPath, packageReference, type));
if (loadDependencies)
{
foreach (var dependency in _installedPackages
.Where(p => !p.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase)))
{
if (_blackListedPackages.Contains(dependency.Id))
{
_log.Warning("Package {0} depends on package {1}. Will not load this dependency...",
packageReference.Package, dependency.ToString());
continue;
}
var dependencyInstallPath = new DirectoryPath(_pathResolver.GetInstallPath(dependency));
if (!_fileSystem.Exist(dependencyInstallPath))
{
_log.Warning("Package {0} is not installed.", dependency.Id);
continue;
}
files.AddRange(_contentResolver.GetFiles(dependencyInstallPath, packageReference, type));
}
}
return(files);
}
public IReadOnlyCollection <IFile> GetFiles(DirectoryPath directoryPath, PackageReference packageReference, PackageType type)
{
var files = new List <IFile>();
foreach (var installedPackage in _installedPackages)
{
if (_blackListedPackages.Contains(installedPackage.Id))
{
const string format = "Package {0} depends on package {1}. This dependency won't be loaded.";
_log.Debug(format, packageReference.Package, installedPackage.ToString());
continue;
}
var installPath = new DirectoryPath(_pathResolver.GetInstallPath(installedPackage));
if (!_fileSystem.Exist(installPath))
{
_log.Warning("Package {0} is not installed.", installedPackage.Id);
continue;
}
// If the installed package is not the target package, create a new PackageReference
// which is passed to the content resolver. This makes logging make more sense.
var installedPackageReference = installedPackage.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase) ?
packageReference :
new PackageReference($"nuget:?package={installedPackage.Id}");
files.AddRange(_contentResolver.GetFiles(installPath, installedPackageReference, type));
}
return(files);
}
public IReadOnlyCollection <IFile> GetFiles(DirectoryPath directoryPath, PackageReference packageReference, PackageType type)
{
var loadDependencies = packageReference.ShouldLoadDependencies(_config);
var files = new List <IFile>();
var package = _installedPackages.First(p => p.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase));
var installPath = new DirectoryPath(_pathResolver.GetInstallPath(package));
if (!_fileSystem.Exist(installPath))
{
_log.Warning("Package {0} is not installed.", packageReference.Package);
return(Array.Empty <IFile>());
}
files.AddRange(_contentResolver.GetFiles(installPath, packageReference, type));
if (loadDependencies)
{
foreach (var dependency in _installedPackages
.Where(p => !p.Id.Equals(packageReference.Package, StringComparison.OrdinalIgnoreCase)))
{
if (_blackListedPackages.Contains(dependency.Id))
{
_log.Warning("Package {0} depends on package {1}. Will not load this dependency...",
packageReference.Package, dependency.ToString());
continue;
}
var dependencyInstallPath = new DirectoryPath(_pathResolver.GetInstallPath(dependency));
if (!_fileSystem.Exist(dependencyInstallPath))
{
_log.Warning("Package {0} is not installed.", dependency.Id);
continue;
}
files.AddRange(_contentResolver.GetFiles(dependencyInstallPath, packageReference, type));
}
}
return(files);
}
/// <summary>
/// Installs the specified resource at the given location.
/// </summary>
/// <param name="package">The package reference.</param>
/// <param name="type">The package type.</param>
/// <param name="path">The location where to install the package.</param>
/// <returns>The installed files.</returns>
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
path = path.MakeAbsolute(_environment);
var root = _fileSystem.GetDirectory(path);
var packagePath = path.Combine(package.Package);
// Create the addin directory if it doesn't exist.
if (!root.Exists)
{
_log.Debug("Creating directory {0}", path);
root.Create();
}
// Fetch available content from disc.
var content = _contentResolver.GetFiles(packagePath, package, type);
if (content.Any())
{
_log.Debug("Package {0} has already been installed.", package.Package);
return(content);
}
// Install the package.
_log.Debug("Installing NuGet package {0}...", package.Package);
var nugetPath = GetNuGetPath();
var process = _processRunner.Start(nugetPath, new ProcessSettings
{
Arguments = GetArguments(package, path, _config),
RedirectStandardOutput = true,
Silent = _log.Verbosity < Verbosity.Diagnostic
});
process.WaitForExit();
var exitCode = process.GetExitCode();
if (exitCode != 0)
{
_log.Warning("NuGet exited with {0}", exitCode);
var output = string.Join(Environment.NewLine, process.GetStandardOutput());
_log.Verbose(Verbosity.Diagnostic, "Output:\r\n{0}", output);
}
// Get the files.
var result = _contentResolver.GetFiles(packagePath, package, type);
if (result.Count == 0)
{
if (type == PackageType.Addin)
{
var framework = _environment.Runtime.TargetFramework;
_log.Warning("Could not find any assemblies compatible with {0}.", framework.FullName);
}
else if (type == PackageType.Tool)
{
const string format = "Could not find any relevant files for tool '{0}'. Perhaps you need an include parameter?";
_log.Warning(format, package.Package);
}
}
return(result);
}
public IReadOnlyCollection <IFile> Install(PackageReference package, PackageType type, DirectoryPath path)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
var packageRoot = path.MakeAbsolute(_environment).FullPath;
var targetFramework = type == PackageType.Addin ? _currentFramework : NuGetFramework.AnyFramework;
var sourceRepositoryProvider = new NuGetSourceRepositoryProvider(_nugetSettings, _config, package, packageRoot);
var localAndPrimaryRepositories = new HashSet <SourceRepository>(new NuGetSourceRepositoryComparer());
localAndPrimaryRepositories.AddRange(sourceRepositoryProvider.LocalRepositories);
localAndPrimaryRepositories.AddRange(sourceRepositoryProvider.PrimaryRepositories);
var allRepositories = new HashSet <SourceRepository>(new NuGetSourceRepositoryComparer());
allRepositories.AddRange(localAndPrimaryRepositories);
allRepositories.AddRange(sourceRepositoryProvider.Repositories);
var packageIdentity = GetPackageId(package, localAndPrimaryRepositories, targetFramework, _sourceCacheContext, _nugetLogger);
if (packageIdentity == null)
{
_log.Debug("No package identity returned.");
return(Array.Empty <IFile>());
}
if (packageIdentity.Version.IsPrerelease && !package.IsPrerelease())
{
// If a prerelease version is explicitly specified, we should install that with or without prerelease flag.
_log.Debug("Prerelease version string explicitly specified. Installing prerelease package version.");
}
var pathResolver = new PackagePathResolver(packageRoot);
var dependencyBehavior = GetDependencyBehavior(type, package);
var downloadContext = new PackageDownloadContext(_sourceCacheContext);
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
GetPackageDependencies(packageIdentity,
targetFramework,
_sourceCacheContext,
_nugetLogger,
allRepositories,
availablePackages,
dependencyBehavior,
localAndPrimaryRepositories);
var resolverContext = new PackageResolverContext(
dependencyBehavior,
new[] { packageIdentity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <global::NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
allRepositories.Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))).ToArray();
if (packagesToInstall.Length == 0)
{
_log.Debug("No packages to install after running package resolver.");
}
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Nuspec | PackageSaveMode.Files | PackageSaveMode.Nupkg,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(_nugetSettings, _nugetLogger),
_nugetLogger);
var installedFiles = new List <IFile>();
foreach (var packageToInstall in packagesToInstall)
{
var isTargetPackage = packageToInstall.Id.Equals(package.Package, StringComparison.OrdinalIgnoreCase);
var installPath = new DirectoryPath(pathResolver.GetInstallPath(packageToInstall));
if (!_fileSystem.Exist(installPath))
{
var downloadResource = packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None).GetAwaiter().GetResult();
var downloadResult = downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
downloadContext,
SettingsUtility.GetGlobalPackagesFolder(_nugetSettings),
_nugetLogger, CancellationToken.None).GetAwaiter().GetResult();
PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
pathResolver,
packageExtractionContext,
CancellationToken.None).GetAwaiter().GetResult();
// If this is the target package, to avoid problems with casing, get the actual install path from the nuspec
if (isTargetPackage)
{
installPath = new DirectoryPath(pathResolver.GetInstallPath(downloadResult.PackageReader.GetIdentity()));
}
}
if (_denyListPackages.Contains(packageToInstall.Id))
{
const string format = "Package {0} depends on package {1}. This dependency won't be loaded.";
_log.Debug(format, package.Package, packageToInstall.ToString());
continue;
}
// If the installed package is not the target package, create a new PackageReference
// which is passed to the content resolver. This makes logging make more sense.
var installedPackageReference = isTargetPackage ? package : new PackageReference($"nuget:?package={packageToInstall.Id}");
var assemblies = _contentResolver.GetFiles(installPath, installedPackageReference, type);
if (assemblies.Count == 0)
{
_log.Debug("No assemblies found after running content resolver.");
}
installedFiles.AddRange(assemblies);
}
return(installedFiles);
}
