private void SetDotNetLibInformation(string targetFramework, NugetPackageType t)
{
PackageType = t;
TargetFramework = "";
var assemblyFolderDict = new Dictionary <NugetPackageType, string>()
{
{ NugetPackageType.DotNetCompileTimeAssembly, DotNetCompileTimeAssemblyPath },
{ NugetPackageType.DotNetImplementationAssembly, DotNetImplementationAssemblyPath }
};
if (!string.IsNullOrEmpty(targetFramework))
{
TargetFramework = System.Environment.ExpandEnvironmentVariables(targetFramework);
}
var basePath = Path.Combine(RootPath, string.Format("{0}.{1}", Id, MinVersion));
if (t == NugetPackageType.DotNetImplementationAssembly || t == NugetPackageType.DotNetCompileTimeAssembly)
{
if (string.IsNullOrEmpty(TargetFramework))
{
throw new Exception($"The NuGet package {ToString()} is marked as .NET lib, but the TargetFramework is not specified.");
}
FullPath = Path.Combine(basePath, assemblyFolderDict[t], TargetFramework);
}
else
{
FullPath = basePath;
if (!string.IsNullOrEmpty(TargetFramework))
{
FullPath = Path.Combine(FullPath, TargetFramework);
}
}
}
public NugetPackage(string id, string version, string targetFramework, string source, string[] dependenciesSources, string var, NugetPackageType packageType, string packagesRoot, bool dependeciesForceMinVersion = true)
{
Dependencies = new List <NugetDependency>();
Libraries = new List <string>();
Id = id;
VersionRange = NuGet.Versioning.VersionRange.Parse(System.Environment.ExpandEnvironmentVariables(version));
MinVersion = VersionRange.ToNonSnapshotRange().MinVersion.ToString();
DependenciesForceMinVersion = dependeciesForceMinVersion;
if (string.IsNullOrEmpty(source))
{
throw new Exception(string.Format("Invalid source for the package id {0};{1}. The source parameter is mandatory.", Id, MinVersion));
}
Source = TryGetUri(source);
DependencySources = new List <Uri>();
if (dependenciesSources != null)
{
foreach (var src in dependenciesSources)
{
DependencySources.Add(TryGetUri(src));
}
}
RootPath = packagesRoot;
SetDotNetLibInformation(targetFramework, packageType);
EnvironmentVariableKeys = new List <string>();
EnvironmentVariableKeys.Add(EscapeStringAsEnvironmentVariableAsKey(Id));
EnvironmentVariableKeys.Add(GetVersionEnvironmentVariableKey(Id));
EnvironmentVariableKeys.Add(GetFrameworkEnvironmentVariableKey(Id));
//Alaways set the "default" key value
Environment.SetEnvironmentVariable(EscapeStringAsEnvironmentVariableAsKey(Id), FullPath);
Environment.SetEnvironmentVariable(GetVersionEnvironmentVariableKey(Id), MinVersion);
Environment.SetEnvironmentVariable(GetFrameworkEnvironmentVariableKey(Id), TargetFramework);
if (!string.IsNullOrEmpty(var)) //If requested, set also the user specified value
{
EnvironmentVariableAdditionalKey = var;
if (Environment.GetEnvironmentVariable(EnvironmentVariableAdditionalKey) == null)
{
Environment.SetEnvironmentVariable(EnvironmentVariableAdditionalKey, FullPath);
}
}
}
private static bool CheckFrameworkMatch(PackageReaderBase packageReader, NuGetFramework targetFramework, ref NugetPackageType type)
{
var frameworkReducer = new FrameworkReducer();
Dictionary <NugetPackageType, Func <IEnumerable <FrameworkSpecificGroup> > > getter = new Dictionary <NugetPackageType, Func <IEnumerable <FrameworkSpecificGroup> > >
{
{ NugetPackageType.DotNetImplementationAssembly, () => packageReader.GetItems(NugetPackage.DotNetImplementationAssemblyPath) },
{ NugetPackageType.DotNetCompileTimeAssembly, () => packageReader.GetItems(NugetPackage.DotNetCompileTimeAssemblyPath) },
};
foreach (var get in getter)
{
var items = get.Value();
var targetFrameworkString = targetFramework.GetFrameworkString();
var match = items.Where(x => targetFrameworkString == x.TargetFramework.GetFrameworkString());
if (match.Count() > 0)
{
type = get.Key;
return(true);
}
}
return(false);
}
public NugetPackage(string id, string version, string targetFramework, string source, string var, NugetPackageType packageType, string packagesRoot, bool dependeciesForceMinVersion = true)
: this(id, version, targetFramework, source, null, var, packageType, packagesRoot, dependeciesForceMinVersion)
{
}
/// <summary>
/// This method looks for the requestedPackage and installes (unpacks) it.
/// </summary>
/// <param name="requestedPackage"></param>
/// <param name="installedPackages"></param>
/// <returns></returns>
private static async Task InstallPackageActionAsync(NugetPackage requestedPackage,
SourcePackageDependencyInfo packageToInstall,
ISettings settings,
SourceCacheContext cacheContext,
List <NugetPackage> installedPackages)
{
var packetRoot = Path.GetFullPath(requestedPackage.RootPath);
//var packagePathResolver = new PackagePathResolver(Path.Combine(packetRoot, packageToInstall.Id, packageToInstall.Version.ToFullString()), true);
var packagePathResolver = new PackagePathResolver(packetRoot);
var nuGetFramework = NuGetFramework.ParseFolder(requestedPackage.TargetFramework);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, ClientPolicyContext.GetClientPolicy(settings, _logger), _logger);
//Check if the package was previousely installed in this session
var knownPackage = installedPackages.Where((x) => x.Id == packageToInstall.Id).FirstOrDefault();
var packageToInstallVersionRange = VersionRange.Parse(packageToInstall.Version.OriginalVersion);
if (knownPackage == null || !packageToInstallVersionRange.Satisfies(knownPackage.VersionRange.MinVersion))
{
PackageReaderBase packageReader;
//Check if the package is already installed in the file system
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var download = downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
_logger, CancellationToken.None);
download.Wait();
var downloadResult = download.Result;
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
NugetPackage newlyInstalled = null;
if (requestedPackage.Id != packageToInstall.Id) //Was not the first requested id, must be a dependency.
{
var nearest = GetNearestFramework(packageReader, nuGetFramework);
if (nearest == null)
{
throw new Exceptions.TargetFrameworkNotFoundException($"The current package {packageToInstall.Id} V{packageToInstall.Version} was installed as dependecy of {requestedPackage}. The parent package framework {nuGetFramework} is unknown/incompatible with the dependency's available frameworks.");
}
else
{
var version = packageToInstall.Version;
try
{ //If available, get the NuSpec version
version = packageReader.NuspecReader.GetVersion();
}
catch (NuGet.Packaging.Core.PackagingException) { }
newlyInstalled = new NugetPackage(packageToInstall.Id, version.OriginalVersion,
nearest.Item2.GetShortFolderName(),
packageToInstall.Source.PackageSource.Source,
null, nearest.Item1, requestedPackage.RootPath, requestedPackage.DependenciesForceMinVersion);
}
}
else
{
NugetPackageType packageType = requestedPackage.PackageType;
if (packageType != NugetPackageType.Other)
{
if (!CheckFrameworkMatch(packageReader, nuGetFramework, ref packageType))
{
throw new Exceptions.TargetFrameworkNotFoundException($"The current package {packageToInstall.Id} V{packageToInstall.Version} requested framework {nuGetFramework} is unknown/incompatible with the available frameworks.");
}
}
if (requestedPackage.Source.AbsoluteUri != packageToInstall.Source.PackageSource.Source)
{
//Possible Dependency Confusion attack
throw new Exceptions.DependencyConfusionException($"The requested package has been found in {packageToInstall.Source.PackageSource.Source} instead of the required URI {requestedPackage.Source.AbsoluteUri}. Update the pakcage source if this is intended");
}
newlyInstalled = new NugetPackage(requestedPackage.Id, requestedPackage.VersionRange.OriginalString,
requestedPackage.TargetFramework,
requestedPackage.Source.AbsoluteUri,
null, packageType, requestedPackage.RootPath, requestedPackage.DependenciesForceMinVersion);
}
newlyInstalled.AddDependencies(packageToInstall.Dependencies);
newlyInstalled.LoadLibraries();
installedPackages.Add(newlyInstalled);
}
}
