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 static bool TryGetCompatibleItems <T>(FrameworkName projectFramework, IEnumerable <T> items, out IEnumerable <T> compatibleItems) where T : IFrameworkTargetable
{
if (!items.Any())
{
compatibleItems = Enumerable.Empty <T>();
return(true);
}
// Not all projects have a framework, we need to consider those projects.
var internalProjectFramework = projectFramework ?? EmptyFramework;
// Turn something that looks like this:
// item -> [Framework1, Framework2, Framework3] into
// [{item, Framework1}, {item, Framework2}, {item, Framework3}]
var normalizedItems = from item in items
let frameworks = (item.SupportedFrameworks != null && item.SupportedFrameworks.Any()) ? item.SupportedFrameworks : new FrameworkName[] { null }
from framework in frameworks
select new
{
Item = item,
TargetFramework = framework
};
// Group references by target framework (if there is no target framework we assume it is the default)
var frameworkGroups = normalizedItems
.GroupBy(g => g.TargetFramework, g => g.Item)
.ToList();
// Try to find the best match using NuGet's Get Nearest algorithm
var nuGetFrameworkToFrameworkGroup = frameworkGroups
.Where(g => g.Key != null)
.ToDictionary(g => GetNuGetFramework(
NetPortableProfileTable.Instance,
ReferenceAssemblyFrameworkNameProvider.Instance,
g.Key),
NuGetFramework.Comparer);
var reducer = new FrameworkReducer(
ReferenceAssemblyFrameworkNameProvider.Instance,
ReferenceAssemblyCompatibilityProvider.Instance);
var nearest = reducer.GetNearest(
GetNuGetFramework(
NetPortableProfileTable.Instance,
ReferenceAssemblyFrameworkNameProvider.Instance,
internalProjectFramework),
nuGetFrameworkToFrameworkGroup.Keys);
if (nearest != null)
{
compatibleItems = nuGetFrameworkToFrameworkGroup[nearest];
}
else
{
compatibleItems = null;
}
bool hasItems = compatibleItems != null && compatibleItems.Any();
if (!hasItems)
{
// if there's no matching profile, fall back to the items without target framework
// because those are considered to be compatible with any target framework
compatibleItems = frameworkGroups.Where(g => g.Key == null).SelectMany(g => g);
hasItems = compatibleItems != null && compatibleItems.Any();
}
if (!hasItems)
{
compatibleItems = null;
}
return(hasItems);
}
public static async Task LoadPackage(string packageId, string packageVersion, HashSet <string> buildReferences, HashSet <string> runtimeReferences)
{
Console.WriteLine($"Loading package '{packageId} ({packageVersion})'...");
var version = NuGetVersion.Parse(packageVersion);
var nuGetFramework = NuGetFramework.ParseFrameworkName(AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName, DefaultFrameworkNameProvider.Instance);
var settings = Settings.LoadDefaultSettings(null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var packagesPath = SettingsUtility.GetGlobalPackagesFolder(settings);
var runtimeFramework = NuGetFramework.ParseFolder(BuildInfo.RuntimeIdentifier);
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, version),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().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)));
var packagePathResolver = new PackagePathResolver(packagesPath, true);
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
Console.WriteLine($"Installing package '{packageToInstall.Id} ({packageToInstall.Version})'...");
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
packagesPath,
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
}
installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
var packageReader = new PackageFolderReader(installedPath);
if (buildReferences != null)
{
var items = await packageReader.GetReferenceItemsAsync(CancellationToken.None);
var paths = GetAssemblyPaths(items, frameworkReducer, nuGetFramework, installedPath);
buildReferences.AddRange(paths);
}
if (runtimeReferences != null)
{
var items = await packageReader.GetItemsAsync("runtimes", CancellationToken.None);
var nearest = items.Select(x => x.TargetFramework)
.Where(x => x.Framework == runtimeFramework.Framework && (!x.HasProfile || x.Profile == runtimeFramework.Profile))
.OrderBy(x => x.HasProfile ? 1 : -1)
.FirstOrDefault();
var runtimeDir = items.FirstOrDefault(x => x.TargetFramework.Equals(nearest))?.Items.FirstOrDefault()?.Split('/').ElementAtOrDefault(1);
if (runtimeDir != null)
{
installedPath = Path.Combine(installedPath, "runtimes", runtimeDir);
packageReader = new PackageFolderReader(installedPath);
}
items = await packageReader.GetLibItemsAsync(CancellationToken.None);
var paths = GetAssemblyPaths(items, frameworkReducer, nuGetFramework, installedPath);
runtimeReferences.AddRange(paths);
}
}
}
}
public async Task UninstallPackage(PackageIdentity identity)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger);
bool failed = true;
try
{
await PackageExtractor.ExtractPackageAsync(installedPath,
packageReader,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
failed = false;
}
catch (Exception)
{
}
if (failed)
{
try
{
await Download(identity);
installedPath = packagePathResolver.GetInstalledPath(identity);
packageReader = new PackageFolderReader(installedPath);
failed = false;
}
catch (Exception)
{
throw;
}
}
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
RemoveFile(installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
RemoveFile(installedPath, f);
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(Destinationfolder, filename);
if (System.IO.File.Exists(target))
{
try
{
System.IO.File.Delete(target);
}
catch (Exception)
{
}
}
}
}
}
}
public async Task <bool> IsPackageInstalled(LocalPackageInfo package)
{
await Download(package.Identity);
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(package.Identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
if (libItems.Count() == 0)
{
Console.WriteLine("Booom!");
}
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
string source = "";
string f2 = "";
string filename = "";
string dir = "";
string target = "";
try
{
source = System.IO.Path.Combine(installedPath, f);
f2 = f.Substring(f.IndexOf("/", 4) + 1);
filename = System.IO.Path.GetFileName(f2);
dir = System.IO.Path.GetDirectoryName(f2);
target = System.IO.Path.Combine(Destinationfolder, dir, filename);
if (!System.IO.Directory.Exists(System.IO.Path.Combine(Destinationfolder, dir)))
{
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(Destinationfolder, dir));
}
if (!System.IO.File.Exists(source))
{
return(false);
}
if (!System.IO.File.Exists(target))
{
return(false);
}
var infoOld = new System.IO.FileInfo(source);
var infoNew = new System.IO.FileInfo(target);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
return(true);
}
private IEnumerable <LibraryDependency> GetDependencies(LocalPackageInfo package, NuGetFramework targetFramework)
{
NuspecReader nuspecReader = null;
using (var stream = File.OpenRead(package.ManifestPath))
{
nuspecReader = new NuspecReader(stream);
}
var reducer = new FrameworkReducer();
var deps = nuspecReader.GetDependencyGroups()
.ToDictionary(g => new NuGetFramework(g.TargetFramework),
g => g.Packages);
var nearest = reducer.GetNearest(targetFramework, deps.Keys);
if (nearest != null)
{
foreach (var d in deps[nearest])
{
yield return(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = d.Id,
VersionRange = d.VersionRange == null ? null : new NuGetVersionRange(d.VersionRange)
}
});
}
}
// TODO: Remove this when we do #596
// ASP.NET Core isn't compatible with generic PCL profiles
//if (string.Equals(targetFramework.Identifier, VersionUtility.AspNetCoreFrameworkIdentifier, StringComparison.OrdinalIgnoreCase))
//{
// yield break;
//}
var frameworks = nuspecReader.GetFrameworkReferenceGroups()
.ToDictionary(f => f.TargetFramework,
f => f.Items);
nearest = reducer.GetNearest(targetFramework, frameworks.Keys) ?? frameworks.Keys.FirstOrDefault(f => f.AnyPlatform);
if (nearest != null)
{
if (nearest.AnyPlatform && !targetFramework.IsDesktop())
{
// REVIEW: This isn't 100% correct since none *can* mean
// any in theory, but in practice it means .NET full reference assembly
// If there's no supported target frameworks and we're not targeting
// the desktop framework then skip it.
// To do this properly we'll need all reference assemblies supported
// by each supported target framework which isn't always available.
yield break;
}
foreach (var name in frameworks[nearest])
{
yield return(new LibraryDependency
{
LibraryRange = new LibraryRange
{
Name = name,
IsGacOrFrameworkReference = true
}
});
}
}
}
public bool InstallPackage(PackageIdentity identity)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
using (var packageReader = new PackageFolderReader(installedPath))
{
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
try
{
var dependencies = packageReader.GetPackageDependencies();
nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework));
foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest)))
{
foreach (var p in dep.Packages)
{
var local = GetLocal(p.Id);
InstallPackage(local.Identity);
}
}
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
}
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(Destinationfolder, filename);
CopyIfNewer(f, target);
}
}
}
return(true);
}
public async Task InstallPackageAsync(
Project project,
string packageId,
string version,
string framework)
{
var packageIdentity = new PackageIdentity(packageId, NuGetVersion.Parse(version));
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepoProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
var nuGetFramework = NuGetFramework.ParseFolder(framework);
var logger = NullLogger.Instance;
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepoProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
// This will cache the dependencies.
await GetPackageDependencies(
packageIdentity,
nuGetFramework,
cacheContext,
logger,
repositories,
availablePackages)
.ConfigureAwait(false);
var resolverContext = new PackageResolverContext(
dependencyBehavior: DependencyBehavior.Lowest,
targetIds: new[] { packageId },
requiredPackageIds: Enumerable.Empty <string>(),
packagesConfig: Enumerable.Empty <PackageReference>(),
preferredVersions: Enumerable.Empty <PackageIdentity>(),
availablePackages: availablePackages,
packageSources: sourceRepoProvider
.GetRepositories()
.Select(s => s.PackageSource),
log: logger);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(
resolverContext,
CancellationToken.None)
.Select(
p => availablePackages.Single(
x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new PackagePathResolver(Path.GetFullPath("packages"));
var packageExtractContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, logger),
//new PackageSignatureVerifier(
//new[] { new SignatureTrustAndValidityVerificationProvider() as ISignatureVerificationProvider }),
//SignatureVerificationProviderFactory.GetSignatureVerificationProviders()),
logger);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstallPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source
.GetResourceAsync <DownloadResource>(CancellationToken.None)
.ConfigureAwait(false);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
logger,
CancellationToken.None)
.ConfigureAwait(false);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractContext,
CancellationToken.None)
.ConfigureAwait(false);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
var libtItems = packageReader.GetLibItems();
var nearest = frameworkReducer.GetNearest(
nuGetFramework,
libtItems.Select(x => x.TargetFramework));
var frameworkItems = packageReader.GetFrameworkItems();
nearest = frameworkReducer.GetNearest(
nuGetFramework,
frameworkItems.Select(x => x.TargetFramework));
}
}
// Update csproj file to include the project reference.
var projectElement = new ProjectElement(project);
projectElement.AddPackageReference(
packageId,
version)
.Save();
}
/// <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 signedPackageVerifier = new PackageSignatureVerifier(SignatureVerificationProviderFactory.GetSignatureVerificationProviders());
var logger = new LoggerAdapter(context);
context.PackageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv2,
PackageExtractionBehavior.XmlDocFileSaveMode,
logger,
signedPackageVerifier,
SignedPackageVerifierSettings.GetClientPolicy(_settings, 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 async Task <InternalNuGetCompatibilityResult> CheckCompatibilityAsync(string packageName, string version, string targetFramework, IEnumerable <SourceRepository> internalRepositories)
{
if (packageName == null || targetFramework == null || internalRepositories == null)
{
var invalidParamNames = new List <string>();
if (packageName == null)
{
invalidParamNames.Add(nameof(packageName));
}
if (targetFramework == null)
{
invalidParamNames.Add(nameof(targetFramework));
}
if (internalRepositories == null)
{
invalidParamNames.Add(nameof(internalRepositories));
}
throw new ArgumentException($"Invalid parameter(s) found. The following parameters " +
$"cannot be null: {string.Join(", ", invalidParamNames)}");
}
string tmpPath = Path.GetTempPath();
var framework = NuGetFramework.Parse(targetFramework);
var package = new PackageIdentity(packageName, NuGetVersion.Parse(version));
// Get package information from Nuget
SourcePackageDependencyInfo packageSource = null;
foreach (var sourceRepository in internalRepositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
packageSource = await dependencyInfoResource.ResolvePackage(
package, framework, _cacheContext, NullLogger.Instance, CancellationToken.None);
if (packageSource != null)
{
break;
}
}
if (packageSource == null)
{
var errorMessage = $"Error: No package source found for {package}.";
_logger.LogError(errorMessage);
var innerException = new PackageSourceNotFoundException(errorMessage);
throw new PortingAssistantClientException(ExceptionMessage.PackageSourceNotFound(package), innerException);
}
// Download package
var downloadResource = await packageSource.Source.GetResourceAsync <DownloadResource>();
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageSource,
new PackageDownloadContext(_cacheContext),
Path.Combine(tmpPath),
NullLogger.Instance, CancellationToken.None);
var packageReader = downloadResult.PackageReader;
var nuspecReader = packageReader.NuspecReader;
var dependencies = nuspecReader.GetDependencyGroups();
var dependencyPackages = dependencies
.SelectMany(d => d.Packages)
.Select(p => p.Id)
.ToList();
// Gather dlls
var frameworkReducer = new FrameworkReducer();
var libItems = packageReader.GetLibItems();
var nearestTargetFrameworks = libItems
.Select(li =>
frameworkReducer.GetNearest(
framework,
new List <NuGetFramework> {
li.TargetFramework
}))
.ToList();
var isCompatible = libItems.Any() ? nearestTargetFrameworks.Any(nugetFramework => nugetFramework != null)
: frameworkReducer.GetNearest(framework, packageReader.GetSupportedFrameworks()) != null;
var compatibleDlls = libItems
.Where(li => nearestTargetFrameworks.Contains(li.TargetFramework))
.SelectMany(li => li.Items)
.Where(s => s.EndsWith("dll", StringComparison.OrdinalIgnoreCase))
.ToList();
var incompatibleDlls = libItems
.SelectMany(li => li.Items)
.Where(s => !compatibleDlls.Contains(s) &&
s.EndsWith("dll", StringComparison.OrdinalIgnoreCase))
.ToList();
return(new InternalNuGetCompatibilityResult
{
IncompatibleDlls = incompatibleDlls,
CompatibleDlls = compatibleDlls,
IsCompatible = isCompatible,
DependencyPackages = dependencyPackages,
Source = packageSource.Source.PackageSource.Name
});
}
public IEnumerable <AssemblyInfo> GetAssemblies(PackageIdentity pkg)
{
// Ignore all SDK packages:
if (pkg == null || IsSystemPackage(pkg))
{
return(Enumerable.Empty <AssemblyInfo>());
}
var pkgInfo = LocalPackagesFinder.GetPackage(pkg, Logger, CancellationToken.None);
if (pkgInfo == null)
{
Logger.LogWarning($"Could not find Package {pkg}");
return(Enumerable.Empty <AssemblyInfo>());
}
var packageReader = pkgInfo.GetReader();
var libs = packageReader?.GetLibItems();
// If package contains no dlls:
if (libs == null)
{
Logger.LogWarning($"Could not find any dll for {pkg}");
return(Enumerable.Empty <AssemblyInfo>());
}
var root = Path.GetDirectoryName(pkgInfo.Path);
string[] CheckOnFramework(NuGetFramework framework)
{
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(framework, libs.Select(x => x.TargetFramework));
if (nearest == null)
{
return(new string[0]);
}
var files = libs
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)
.Where(n => n.EndsWith(".dll"))
.Select(p => Path.Combine(root, p));
return(files.ToArray());
}
var names = CheckOnFramework(NETCOREAPP3_1);
Assembly?LoadAssembly(string path)
{
try
{
return(Assembly.LoadFile(path));
}
catch (Exception e)
{
Logger.LogWarning($"Unable to load assembly '{path}' ({e.Message})");
return(null);
}
}
return(names
.Select(LoadAssembly)
.Select(AssemblyInfo.Create)
.Where(a => a != null));
}
public static async Task InstallPackages(PackagePathResolver packagePathResolver, SourcePackageDependencyInfo packageToInstall, SourceCacheContext cacheContext,
PackageExtractionContext packageExtractionContext, FrameworkReducer frameworkReducer, NuGetFramework nuGetFramework, ISettings settings, ILogger logger)
{
PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource =
await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
var libItems = packageReader.GetLibItems();
var nearest = frameworkReducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
var frameworkItems = packageReader.GetFrameworkItems();
nearest = frameworkReducer.GetNearest(nuGetFramework,
frameworkItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", frameworkItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
}
public override void DoExecute(IInstallPluginContext input)
{
var pluginInstallFolder = Path.Combine(input.InstallDirectory, input.PackageId);
if (Directory.Exists(pluginInstallFolder))
{
return;
}
Directory.CreateDirectory(pluginInstallFolder);
var nuGetVersion = NuGetVersion.Parse(input.PackageVersion);
var packageIdentity = new PackageIdentity(input.PackageId, nuGetVersion);
var nuGetFramework = NuGetFramework.ParseFolder(input.PackageFramework);
var packagesToInstall = _nugetService
.GetPackagesToInstall(packageIdentity, nuGetFramework, input.OmitDependencies)
.Result;
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
var(package, installPath) = _nugetService.DownloadPackage(packageToInstall).Result;
var libItems = package.GetLibItems().ToList();
var possibleFrameworks = libItems.Select(group => group.TargetFramework);
var nearestFramework = frameworkReducer.GetNearest(nuGetFramework, possibleFrameworks);
var assemblies = libItems
.Where(group => group.TargetFramework == nearestFramework)
.SelectMany(group => group.Items)
.ToList();
foreach (var assembly in assemblies)
{
var destFileName = Path.Combine(pluginInstallFolder, Path.GetFileName(assembly));
if (File.Exists(destFileName))
{
continue;
}
var sourceFileName = Path.Combine(installPath, assembly);
File.Copy(sourceFileName, destFileName);
}
var contentItems = package.GetContentItems().ToList();
var nearestContentFramework =
frameworkReducer.GetNearest(nuGetFramework, contentItems.Select(x => x.TargetFramework));
var ci = contentItems
.Where(group => group.TargetFramework == nearestContentFramework)
.SelectMany(group => group.Items)
.ToList();
foreach (var contentItem in ci)
{
var destFileName = Path.Combine(pluginInstallFolder, contentItem);
var folder = Path.GetDirectoryName(destFileName);
if (folder != null && !Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
if (File.Exists(destFileName))
{
continue;
}
var sourceFileName = Path.Combine(installPath, contentItem);
File.Copy(sourceFileName, destFileName);
}
}
}
public void UninstallPackage(string TargetFolder, PackageIdentity identity)
{
var packagePathResolver = new PackagePathResolver(PackagesInstallFolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
UninstallFile(TargetFolder, installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
UninstallFile(TargetFolder, installedPath, f);
}
try
{
var dependencies = packageReader.GetPackageDependencies();
nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework));
foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest)))
{
foreach (var p in dep.Packages)
{
var local = getLocal(p.Id);
UninstallPackage(TargetFolder, local.Identity);
}
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(TargetFolder, filename);
if (System.IO.File.Exists(target))
{
try
{
System.IO.File.Delete(target);
}
catch (Exception)
{
PendingDeletion.Add(target);
}
}
}
}
}
}
public async Task UninstallAsync(PackageIdentity package, IExtensibleProject project, IEnumerable <PackageReference> installedPackageReferences,
CancellationToken cancellationToken = default)
{
List <string> failedEntries = null;
ICollection <PackageIdentity> uninstalledPackages;
var targetFramework = FrameworkParser.TryParseFrameworkName(project.Framework, _frameworkNameProvider);
#if NET5_0_OR_GREATER
var reducer = new FrameworkReducer();
var mostSpecific = reducer.ReduceUpwards(project.SupportedPlatforms).FirstOrDefault();
targetFramework = mostSpecific;
#endif
var projectConfig = _nuGetProjectConfigurationProvider.GetProjectConfig(project);
var uninstallationContext = new UninstallationContext(false, false);
_nugetLogger.LogInformation($"Uninstall package {package}, Target framework: {targetFramework}");
if (projectConfig is null)
{
_nugetLogger.LogWarning($"Project {project.Name} doesn't implement any configuration for own packages");
}
using (var cacheContext = new SourceCacheContext()
{
NoCache = false,
DirectDownload = false,
})
{
var dependencyInfoResource = await project.AsSourceRepository(_sourceRepositoryProvider)
.GetResourceAsync <DependencyInfoResource>(cancellationToken);
var dependencyInfoResourceCollection = new DependencyInfoResourceCollection(dependencyInfoResource);
var resolverContext = await ResolveDependenciesAsync(package, targetFramework, PackageIdentity.Comparer, dependencyInfoResourceCollection, cacheContext, project, true, cancellationToken);
var packageReferences = installedPackageReferences.ToList();
if (uninstallationContext.RemoveDependencies)
{
uninstalledPackages = await GetPackagesCanBeUninstalledAsync(resolverContext.AvailablePackages, packageReferences.Select(x => x.PackageIdentity));
}
else
{
uninstalledPackages = new List <PackageIdentity>()
{
package
};
}
}
try
{
foreach (var removedPackage in uninstalledPackages)
{
if (removedPackage.Version is null)
{
_nugetLogger.LogWarning($"Skip package {removedPackage.Id} uninstall. Check your package.config for references of this packages");
continue;
}
var folderProject = new FolderNuGetProject(project.ContentPath);
if (folderProject.PackageExists(removedPackage))
{
_directoryService.ForceDeleteDirectory(_fileService, folderProject.GetInstalledPath(removedPackage), out failedEntries);
}
if (projectConfig is null)
{
continue;
}
var result = await projectConfig.UninstallPackageAsync(removedPackage, _nuGetProjectContextProvider.GetProjectContext(FileConflictAction.PromptUser), cancellationToken);
if (!result)
{
_nugetLogger.LogError($"Saving package configuration failed in project {project} when installing package {package}");
}
}
}
catch (IOException ex)
{
Log.Error(ex);
_nugetLogger.LogError("Package files cannot be complete deleted by unexpected error (may be directory in use by another process?");
}
finally
{
LogHelper.LogUnclearedPaths(failedEntries, Log);
}
}
public static async Task InstallPackage(string packageId, string version, Dictionary <string, string> projectDependenciesDict, string installDefaultSource = "")
{
var packageSources = new ApplicationSettings().GetOrCreateApplicationSettings().ClientSettings.PackageSourceDT;
var packageVersion = NuGetVersion.Parse(version);
var nuGetFramework = NuGetFramework.ParseFolder("net48");
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var repositories = new List <SourceRepository>();
if (!string.IsNullOrEmpty(installDefaultSource))
{
var sourceRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(installDefaultSource, "Default Packages Source", true));
repositories.Add(sourceRepo);
}
else
{
foreach (DataRow row in packageSources.Rows)
{
if (row[0].ToString() == "True")
{
var sourceRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(row[2].ToString(), row[1].ToString(), true));
repositories.Add(sourceRepo);
}
}
}
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
//TODO: Installation failure happens here if package isn't found. Failure is being caught but not reported because it's asynchronous
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new PackagePathResolver(Folders.GetFolder(FolderType.LocalAppDataPackagesFolder));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
PackageReaderBase packageReader;
PackageDownloadContext downloadContext = new PackageDownloadContext(cacheContext);
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
downloadContext,
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
if (packageToInstall.Id == packageId)
{
if (projectDependenciesDict.ContainsKey(packageToInstall.Id))
{
projectDependenciesDict[packageToInstall.Id] = packageToInstall.Version.ToString();
}
else
{
projectDependenciesDict.Add(packageToInstall.Id, packageToInstall.Version.ToString());
}
}
}
}
}
public static void Generate(string outDir, Nuspec spec)
{
if (Directory.Exists(outDir))
{
Directory.Delete(outDir, true);
}
Directory.CreateDirectory(outDir);
/*
* This approach creates a lib/<framework> as necessary, depending on the target framework of each assembly.
* An issue will arise when referencing such nuget package via SlnX, because as per today there only one
* targetFramework can be selected on each <package ... /> element.
* Another potential issue is caused by NuGet.exe (see https://docs.microsoft.com/en-us/nuget/reference/nuspec#dependencies-element).
* For each lib/<framework> there should be a
* <group targetFramework="<framework>"> in the <dependencies> element.
* This code creates such a structure, but due to the nature of the Slnx nuget packages handling
* it cannot know weather a file (DLL) in a specific framwork does reference one of the listed packages.
* It fact, it is well possible that this code would generate invalid dependencies.
* e.g.
* <group targetFramework="net45"> ---> Caused by a project present in the SlnX (no reference to NUinit here)
* <dependency id = "NUnit" version="3.13.1" /> ---> Caused by another project in the SlnX
* <group>
* For this reason, the code will now check for the "highest" compatible framwork, and create the package for that one only
*
* var dependencies = new StringBuilder();
* foreach (var frameworkItems in spec.Files)
* {
* var frameworkDir = Path.Combine(outDir, "lib", frameworkItems.Key);
* Directory.CreateDirectory(frameworkDir);
* foreach(var f in frameworkItems.Value)
* {
* File.Copy(f, Path.Combine(frameworkDir, Path.GetFileName(f)), true);
* }
*
* if (string.IsNullOrEmpty(frameworkItems.Key))
* {
* dependencies.Append(_dependencyGroupOpening);
* }
* else
* {
* dependencies.AppendFormat(_dependencyGroupFrameworkTemplate, frameworkItems.Key);
* }
* dependencies.AppendLine();
* foreach (var d in spec.Dependecies)
* {
* dependencies.AppendFormat(string.Format(_dependencyTemplate, d.Id, d.Version));
* dependencies.AppendLine();
* }
* dependencies.Append(_dependencyGroupClosing);
* dependencies.AppendLine();
* }
*/
var frameworkReducer = new FrameworkReducer();
var highestFramework = frameworkReducer.ReduceUpwards(spec.Elements.Select(x => NuGetFramework.Parse(x.Key))).ToList();
if (highestFramework.Count != 1)
{
var required = string.Join(Environment.NewLine, highestFramework);
throw new Exception($"For the required package {spec.Id} multiple .NET frameworks would be necessary. This is probably caused by a mixture of '.NET Framework' and '.NET Core' based projects.\nThis is not supported.\nRequired frameworks: {required}");
}
var highestFrameworkName = highestFramework.Single().GetShortFolderName();
var packageVersion = spec.Version;
if (packageVersion == null)
{
if (!spec.Elements.ContainsKey(highestFrameworkName))
{
throw new Exception($"The .NET version of the required package {spec.Id} has been resolved to {highestFrameworkName}. No file has been found under that framework.");
}
var assemblies = spec.Elements[highestFrameworkName].Where(x => File.Exists(x) && (x.ToLower().EndsWith(".dll") || x.ToLower().EndsWith(".exe")));
if (assemblies.Count() == 0)
{
throw new Exception("Error while loading the nuget information. No DLL found from which automatically retrieve the version information.");
}
var assemblyPath = assemblies.First();
if (File.Exists(assemblyPath))
{
var assemblyName = AssemblyName.GetAssemblyName(assemblyPath);
packageVersion = assemblyName.Version.ToString(3);
}
else
{
throw new Exception(string.Format("Unable to automatically retrieve the package version. Assembly {0} not found", assemblyPath));
}
}
foreach (var frameworkItems in spec.Elements)
{
var frameworkDir = Path.Combine(outDir, "lib", highestFrameworkName);
Directory.CreateDirectory(frameworkDir);
foreach (var f in frameworkItems.Value)
{
FileAttributes attr = File.GetAttributes(f);
if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
{
CopyDirectory(f, Path.Combine(frameworkDir, Path.GetFileName(f)));
}
else
{
File.Copy(f, Path.Combine(frameworkDir, Path.GetFileName(f)), true);
}
}
}
var dependencies = new StringBuilder();
if (string.IsNullOrEmpty(highestFrameworkName))
{
dependencies.Append(_dependencyGroupOpening);
}
else
{
dependencies.AppendFormat(_dependencyGroupFrameworkTemplate, highestFrameworkName);
}
dependencies.AppendLine();
foreach (var d in spec.Dependecies)
{
dependencies.AppendFormat(string.Format(_dependencyTemplate, d.Id, d.VersionRange.OriginalString));
dependencies.AppendLine();
}
dependencies.Append(_dependencyGroupClosing);
dependencies.AppendLine();
string customElements = null;
if (spec.AdditionalElements != null)
{
var lines = spec.AdditionalElements.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
customElements = string.Join($"{Environment.NewLine} ", lines);
}
var content = string.Format(_nuspecTemplate, spec.Id, packageVersion, customElements, dependencies);
Utilities.WriteAllText(Path.Combine(outDir, spec.FileName), content);
}
public static List <string> LoadPackageAssemblies(string configPath, bool throwException = false)
{
string packagesPath = Folders.GetFolder(FolderType.LocalAppDataPackagesFolder);
List <string> assemblyPaths = new List <string>();
var dependencies = JsonConvert.DeserializeObject <Project>(File.ReadAllText(configPath)).Dependencies;
var packagePathResolver = new PackagePathResolver(packagesPath);
var nuGetFramework = NuGetFramework.ParseFolder("net48");
var settings = Settings.LoadDefaultSettings(root: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var localRepo = sourceRepositoryProvider.CreateRepository(new PackageSource(packagesPath, "Local OpenBots Repo", true));
var resolver = new PackageResolver();
var frameworkReducer = new FrameworkReducer();
var repositories = new List <SourceRepository>
{
localRepo
};
Parallel.ForEach(dependencies, async dependency =>
{
try
{
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(dependency.Key, NuGetVersion.Parse(dependency.Value)),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { dependency.Key },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
foreach (var packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader = new PackageFolderReader(packagePathResolver.GetInstalledPath(packageToInstall));
var nearest = frameworkReducer.GetNearest(nuGetFramework, packageReader.GetLibItems().Select(x => x.TargetFramework));
var packageListAssemblyPaths = packageReader.GetLibItems()
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items.Where(i => i.EndsWith(".dll"))).ToList();
if (packageListAssemblyPaths != null)
{
foreach (string path in packageListAssemblyPaths)
{
if (!assemblyPaths.Contains(Path.Combine(packagesPath, $"{packageToInstall.Id}.{packageToInstall.Version}", path)))
{
assemblyPaths.Add(Path.Combine(packagesPath, $"{packageToInstall.Id}.{packageToInstall.Version}", path));
}
}
}
}
}
}
catch (Exception ex)
{
//Only true for scheduled and attended executions
if (throwException)
{
MessageBox.Show($"Unable to load {packagesPath}\\{dependency.Key}.{dependency.Value}. " +
"Please install this package using the OpenBots Studio Package Manager.", "Error");
Application.Exit();
}
else
{
Console.WriteLine(ex);
}
}
});
try
{
return(FilterAssemblies(assemblyPaths));
}
catch (Exception)
{
//try again
return(LoadPackageAssemblies(configPath, throwException));
}
}
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(PackageIdentity identity)
{
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = SourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().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)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, OpenRPAPackageManagerLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, OpenRPAPackageManagerLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
// PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
// packageReader = downloadResult.PackageReader;
}
//else
//{
// packageReader = new PackageFolderReader(installedPath);
//}
InstallPackage(packageToInstall);
}
}
return(result);
}
public bool InstallPackage(PackageIdentity identity)
{
bool ret = true;
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
var libItems = packageReader.GetLibItems();
var frameworkReducer = new FrameworkReducer();
var nearest = frameworkReducer.GetNearest(NuGetFramework, libItems.Select(x => x.TargetFramework));
var files = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
var cont = packageReader.GetContentItems();
nearest = frameworkReducer.GetNearest(NuGetFramework, cont.Select(x => x.TargetFramework));
files = cont
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items).ToList();
foreach (var f in files)
{
InstallFile(installedPath, f);
}
try
{
var dependencies = packageReader.GetPackageDependencies();
nearest = frameworkReducer.GetNearest(NuGetFramework, dependencies.Select(x => x.TargetFramework));
foreach (var dep in dependencies.Where(x => x.TargetFramework.Equals(nearest)))
{
foreach (var p in dep.Packages)
{
var local = getLocal(p.Id);
InstallPackage(local.Identity);
}
}
}
catch (Exception ex)
{
ret = false;
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "安装nupkg包出错", ex);
}
if (System.IO.Directory.Exists(installedPath + @"\build"))
{
if (System.IO.Directory.Exists(installedPath + @"\build\x64"))
{
foreach (var f in System.IO.Directory.GetFiles(installedPath + @"\build\x64"))
{
var filename = System.IO.Path.GetFileName(f);
var target = System.IO.Path.Combine(TargetFolder, filename);
CopyIfNewer(f, target);
}
}
}
return(ret);
}
public DependencyGraph Analyze(string packageId, string version, string framework)
{
var package = new PackageIdentity(packageId, NuGetVersion.Parse(version));
var settings = Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null);
var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
var nuGetFramework = NuGetFramework.ParseFolder(framework);
var nugetLogger = _logger.AsNuGetLogger();
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
var resolvedPackages = new ConcurrentDictionary <PackageIdentity, SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
ResolvePackage(package, nuGetFramework, cacheContext, nugetLogger, repositories, resolvedPackages).Wait();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(resolvedPackages.Values);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
nugetLogger);
var resolver = new PackageResolver();
var prunedPackages = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(x => resolvedPackages[x]);
var rootNode = new PackageReferenceNode(package.Id, package.Version.ToString());
var packageNodes = new Dictionary <string, PackageReferenceNode>(StringComparer.OrdinalIgnoreCase);
var builder = new DependencyGraph.Builder(rootNode);
foreach (var target in prunedPackages)
{
var downloadResource = target.Source.GetResource <DownloadResource>();
var downloadResult = downloadResource.GetDownloadResourceResultAsync(new PackageIdentity(target.Id, target.Version),
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
nugetLogger, CancellationToken.None).Result;
var libItems = downloadResult.PackageReader.GetLibItems();
var reducer = new FrameworkReducer();
var nearest = reducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework));
var assemblyReferences = libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)
.Where(x => Path.GetExtension(x).Equals(".dll", StringComparison.OrdinalIgnoreCase))
.Select(x => new AssemblyReferenceNode(Path.GetFileName(x)));
var frameworkItems = downloadResult.PackageReader.GetFrameworkItems();
nearest = reducer.GetNearest(nuGetFramework, frameworkItems.Select(x => x.TargetFramework));
assemblyReferences = assemblyReferences.Concat(frameworkItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)
.Select(x => new AssemblyReferenceNode(x)));
var packageReferenceNode = new PackageReferenceNode(target.Id, target.Version.ToString());
builder.WithNode(packageReferenceNode);
builder.WithNodes(assemblyReferences);
builder.WithEdges(assemblyReferences.Select(x => new Edge(packageReferenceNode, x)));
packageNodes.Add(target.Id, packageReferenceNode);
}
foreach (var target in prunedPackages)
{
var packageReferenceNode = packageNodes[target.Id];
builder.WithEdges(target.Dependencies.Select(x =>
new Edge(packageReferenceNode, packageNodes[x.Id], x.VersionRange.ToString())));
}
return(builder.Build());
}
}
public async Task <IReadOnlyList <NuGetVersion> > GetAllVersions(string package, IEnumerable <Uri> sources, bool includePrerelease, NuGetFramework targetFramework,
string projectFilePath, bool isDevelopmentDependency, int olderThanDays, bool ignoreFailedSources = false)
{
var allVersions = new List <NuGetVersion>();
foreach (var source in sources)
{
try
{
var metadata = await FindMetadataResourceForSource(source, projectFilePath);
if (metadata != null)
{
var compatibleMetadataList = (await metadata.GetMetadataAsync(package, includePrerelease, false, _context, NullLogger.Instance, CancellationToken.None)).ToList();
if (olderThanDays > 0)
{
compatibleMetadataList = compatibleMetadataList.Where(c => !c.Published.HasValue ||
c.Published <= DateTimeOffset.UtcNow.AddDays(-olderThanDays)).ToList();
}
// We need to ensure that we only get package versions which are compatible with the requested target framework.
// For development dependencies, we do not perform this check
if (!isDevelopmentDependency)
{
var reducer = new FrameworkReducer();
compatibleMetadataList = compatibleMetadataList
.Where(meta => meta.DependencySets == null || !meta.DependencySets.Any() ||
reducer.GetNearest(targetFramework, meta.DependencySets.Select(ds => ds.TargetFramework)) != null)
.ToList();
}
foreach (var m in compatibleMetadataList)
{
if (m is PackageSearchMetadata packageSearchMetadata)
{
allVersions.Add(packageSearchMetadata.Version);
}
else if (m is PackageSearchMetadataV2Feed packageSearchMetadataV2Feed)
{
allVersions.Add(packageSearchMetadataV2Feed.Version);
}
else if (m is LocalPackageSearchMetadata localPackageSearchMetadata)
{
allVersions.Add(localPackageSearchMetadata.Identity.Version);
}
else
{
allVersions.Add(m.Identity.Version);
}
}
;
}
}
catch (HttpRequestException)
{
// Suppress HTTP errors when connecting to NuGet sources
}
catch (Exception ex)
{
if (!ignoreFailedSources)
{
continue;
}
// if the inner exception is NOT HttpRequestException, throw it
if (ex.InnerException != null && !(ex.InnerException is HttpRequestException))
{
throw ex;
}
}
}
return(allVersions);
}
public async Task Download(PackageIdentity identity)
{
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var installedPath = packagePathResolver.GetInstalledPath(identity);
if (identity.HasVersion && !string.IsNullOrEmpty(installedPath))
{
var idstring = identity.Id + "." + identity.Version;
if (installedPath.Contains(idstring))
{
return;
}
}
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = SourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageWithoutDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
Logger);
var packageToInstall = availablePackages.Where(p => p.Id == identity.Id).FirstOrDefault();
// var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger);
var frameworkReducer = new FrameworkReducer();
// PackageReaderBase packageReader;
installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
//if (installedPath == null)
//{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
Logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
// packageReader = downloadResult.PackageReader;
// }
//else
//{
// packageReader = new PackageFolderReader(installedPath);
//}
}
return;
}
public IVsNuGetFramework GetNearest(IVsNuGetFramework targetFramework, IEnumerable <IVsNuGetFramework> fallbackTargetFrameworks, IEnumerable <IVsNuGetFramework> frameworks)
{
if (targetFramework == null)
{
throw new ArgumentNullException(nameof(targetFramework));
}
if (fallbackTargetFrameworks == null)
{
throw new ArgumentNullException(nameof(fallbackTargetFrameworks));
}
if (frameworks == null)
{
throw new ArgumentNullException(nameof(frameworks));
}
var inputFrameworks = new Dictionary <NuGetFramework, IVsNuGetFramework>();
NuGetFramework ToNuGetFramework(IVsNuGetFramework framework, string paramName)
{
NuGetFramework nugetFramework = MSBuildProjectFrameworkUtility.GetProjectFramework(
projectFilePath: null,
targetFrameworkMoniker: framework.TargetFrameworkMoniker,
targetPlatformMoniker: framework.TargetPlatformMoniker,
targetPlatformMinVersion: framework.TargetPlatformMinVersion);
if (!nugetFramework.IsSpecificFramework)
{
throw new ArgumentException($"Framework '{framework}' could not be parsed", paramName);
}
inputFrameworks[nugetFramework] = framework;
return(nugetFramework);
}
List <NuGetFramework> ToNuGetFrameworks(IEnumerable <IVsNuGetFramework> enumerable, string paramName)
{
var list = new List <NuGetFramework>();
foreach (var framework in enumerable)
{
if (framework == null)
{
throw new ArgumentException("Enumeration contains a null value", paramName);
}
NuGetFramework nugetFramework = ToNuGetFramework(framework, paramName);
list.Add(nugetFramework);
}
return(list);
}
NuGetFramework targetNuGetFramework = ToNuGetFramework(targetFramework, nameof(targetFramework));
List <NuGetFramework> nugetFallbackTargetFrameworks = ToNuGetFrameworks(fallbackTargetFrameworks, nameof(fallbackTargetFrameworks));
List <NuGetFramework> nugetFrameworks = ToNuGetFrameworks(frameworks, nameof(frameworks));
try
{
if (nugetFallbackTargetFrameworks.Count > 0)
{
targetNuGetFramework = new FallbackFramework(targetNuGetFramework, nugetFallbackTargetFrameworks);
}
var reducer = new FrameworkReducer();
var nearest = reducer.GetNearest(targetNuGetFramework, nugetFrameworks);
if (nearest == null)
{
return(null);
}
var originalFrameworkString = inputFrameworks[nearest];
return(originalFrameworkString);
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsFrameworkCompatibility).FullName);
throw;
}
}
public static async Task Main()
{
var packageId = "cake.nuget";
var packageVersion = NuGetVersion.Parse("0.30.0");
var nuGetFramework = NuGetFramework.ParseFolder("net46");
var settings = Settings.LoadDefaultSettings(root: null);
var packageSourceProvider = new PackageSourceProvider(
settings, new PackageSource[] { new PackageSource("https://api.nuget.org/v3/index.json") });
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, NullLogger.Instance, repositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().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)));
var packagePathResolver = new PackagePathResolver(Path.GetFullPath("packages"));
var packageExtractionContext =
new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, NullLogger.Instance),
NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
SettingsUtility.GetGlobalPackagesFolder(settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageSource,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
packageReader = downloadResult.PackageReader;
}
else
{
packageReader = new PackageFolderReader(installedPath);
}
var libItems = packageReader.GetLibItems();
var nearest = frameworkReducer.GetNearest(nuGetFramework, libItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", libItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
var frameworkItems = packageReader.GetFrameworkItems();
nearest = frameworkReducer.GetNearest(nuGetFramework, frameworkItems.Select(x => x.TargetFramework));
Console.WriteLine(string.Join("\n", frameworkItems
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)));
}
}
async Task GetPackageDependencies(PackageIdentity package,
NuGetFramework framework,
SourceCacheContext cacheContext,
ILogger logger,
IEnumerable <SourceRepository> repositories,
ISet <SourcePackageDependencyInfo> availablePackages)
{
if (availablePackages.Contains(package))
{
return;
}
foreach (var sourceRepository in repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackage(
package, framework, cacheContext, logger, CancellationToken.None);
if (dependencyInfo == null)
{
continue;
}
availablePackages.Add(dependencyInfo);
foreach (var dependency in dependencyInfo.Dependencies)
{
await GetPackageDependencies(
new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion),
framework, cacheContext, logger, repositories, availablePackages);
}
}
}
}
public FrameworkLogic()
{
_reducer = new FrameworkReducer();
_compatibilityProvider = DefaultCompatibilityProvider.Instance;
}
public async Task PreProcess(string directive, ScriptExecutionContext context, Action <string> logger)
{
var actionLogger = new NugetLogger(logger);
var nugetDirective = NugetPreProcessorDirective.Parse(directive);
string frameworkName = Assembly.GetEntryAssembly() !.GetCustomAttributes(true)
.OfType <System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault() !;
NuGetFramework framework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
using var cache = new SourceCacheContext();
var packagesPath = Path.Combine(Path.GetTempPath(), "packages");
await CreateEmptyNugetConfig(packagesPath, nugetDirective.FeedUrl);
var settings = Settings.LoadImmutableSettingsGivenConfigPaths(new[] { Path.Combine(packagesPath, "empty.config") }, new SettingsLoadingContext());
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
#pragma warning disable CS0618 // Type or member is obsolete
var repositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
#pragma warning restore CS0618 // Type or member is obsolete
var repository = repositoryProvider.GetRepositories().FirstOrDefault();
var packageMetadataResource = await repository.GetResourceAsync <PackageMetadataResource>(CancellationToken.None);
var searchMetadata = await packageMetadataResource.GetMetadataAsync(
nugetDirective.PackageId,
includePrerelease : false,
includeUnlisted : false,
cache,
actionLogger,
CancellationToken.None);
if (!searchMetadata.Any())
{
throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}");
}
var latest = searchMetadata.OrderByDescending(a => a.Identity.Version).FirstOrDefault();
if (latest is null)
{
throw new NuGetResolverException($"Unable to resolve nuget package with id {nugetDirective.PackageId}");
}
var packageId = latest.Identity;
var dependencyResource = await repository.GetResourceAsync <DependencyInfoResource>();
await GetPackageDependencies(
packageId,
framework,
cache,
repository,
dependencyResource,
availablePackages, actionLogger);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { nugetDirective.PackageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
new[] { repository.PackageSource },
actionLogger);
var resolver = new PackageResolver();
var toInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(a => availablePackages.Single(b => PackageIdentityComparer.Default.Equals(b, a)));
var pathResolver = new PackagePathResolver(packagesPath);
var extractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, actionLogger),
actionLogger);
var libraries = new List <string>();
var frameworkReducer = new FrameworkReducer();
var downloadResource = await repository.GetResourceAsync <DownloadResource>(CancellationToken.None);
foreach (var package in toInstall)
{
libraries.AddRange(await Install(downloadResource, package, pathResolver, extractionContext, frameworkReducer, framework, packagesPath, actionLogger));
}
foreach (var path in libraries)
{
var assembly = Assembly.LoadFrom(path);
if (context.TryAddReferenceAssembly(assembly))
{
foreach (var ns in assembly.GetTypes().Where(a => a.Namespace != null).Select(a => a.Namespace).Distinct())
{
context.AddImport(ns);
}
}
}
}
static IEnumerable <string> GetAssemblyPaths(IEnumerable <FrameworkSpecificGroup> items, FrameworkReducer frameworkReducer, NuGetFramework nuGetFramework, string installedPath)
{
var nearest = frameworkReducer.GetNearest(nuGetFramework, items.Select(x => x.TargetFramework));
return(items
.Where(x => x.TargetFramework.Equals(nearest))
.SelectMany(x => x.Items)
.Where(x => x.EndsWith(".dll"))
.Select(x => Path.Combine(installedPath, x)));
}
