public NuGetPackageManager(ILogger logger, string packagesDirectory, IEnumerable <string> repositories)
{
this.logger = logger;
this.packagesDirectory = packagesDirectory;
this.repositories = repositories;
providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
nugetSettings = Settings.LoadDefaultSettings(null);
frameworkReducer = new FrameworkReducer();
var frameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true)
.OfType <System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault();
currentFramework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
packagePathResolver = new PackagePathResolver(packagesDirectory);
packageResolver = new PackageResolver();
loadedPackageAssemblies = new Dictionary <string, List <CachedNuGetAssembly> >();
InstallAssemblyResolver();
}
public string GetShortFrameworkName(FrameworkName frameworkName)
{
if (frameworkName == null)
{
throw new ArgumentNullException(nameof(frameworkName));
}
var nuGetFramework = NuGetFramework.ParseFrameworkName(
frameworkName.ToString(),
DefaultFrameworkNameProvider.Instance);
try
{
return(nuGetFramework.GetShortFolderName());
}
catch (FrameworkException e)
{
// Wrap this exception for two reasons:
//
// 1) FrameworkException is not a .NET Framework type and therefore is not
// recognized by other components in Visual Studio.
//
// 2) Changing our NuGet code to throw ArgumentException is not appropriate in
// this case because the failure does not occur in a method that has arguments!
var message = string.Format(
CultureInfo.CurrentCulture,
VsResources.CouldNotGetShortFrameworkName,
frameworkName);
throw new ArgumentException(message, e);
}
}
/// <summary>
/// Gets the list of packages to install along with there dependencies
/// </summary>
/// <param name="repository">The package repository</param>
/// <param name="seederConfiguration">The seeder configuration</param>
/// <returns>The list of packages</returns>
private static async Task <IEnumerable <PackageIdentity> > GetPackagesToInstall(
IPackageRepository repository,
SeederConfiguration seederConfiguration)
{
// TODO: extract to helper method along with Configuration extensions
var supportedFramework = NuGetFramework.ParseFrameworkName(
PackageRepositoryExtensions.CurrentRuntime,
DefaultFrameworkNameProvider.Instance);
var packageTasks =
seederConfiguration.RequiredPackages.Select(
async packageName =>
{
var package = await repository.GetAsync(packageName);
if (package == null)
{
throw new PackageNotFoundException(packageName);
}
return(package);
});
var packagesToInstall = (await Task.WhenAll(packageTasks)).ToDictionary(p => p.Identity.Id);
var queue = new Queue <IPackageSearchMetadata>(packagesToInstall.Values);
while (queue.Count > 0)
{
var package = queue.Dequeue();
var dependencySet =
NuGetFrameworkUtility.GetNearest(package.DependencySets, supportedFramework);
if (dependencySet == null || !NuGetFrameworkUtility.IsCompatibleWithFallbackCheck(
supportedFramework,
dependencySet.TargetFramework))
{
continue;
}
foreach (var dependency in dependencySet.Packages)
{
IPackageSearchMetadata packageToInstall;
if (!packagesToInstall.TryGetValue(dependency.Id, out packageToInstall))
{
packageToInstall = await repository.GetAsync(dependency.Id);
if (packageToInstall == null)
{
throw new PackageNotFoundException(dependency.Id);
}
packagesToInstall.Add(dependency.Id, packageToInstall);
if (queue.All(p => p.Identity.Id != packageToInstall.Identity.Id))
{
queue.Enqueue(packageToInstall);
}
}
}
}
return(packagesToInstall.Values.Select(p => p.Identity));
}
public List <PackageIdentity> GetChildPackageIdentities(IPackageSearchMetadata rootPackage)
{
List <PackageIdentity> childPackageIdentities = new List <PackageIdentity>();
//
//load child package identity , if there is any dependency set
if (rootPackage.DependencySets != null && rootPackage.DependencySets.Count() > 0)
{
//check specific dependency set for this version only //note our _targetFramwork is .NETCoreApp,Version=v2.0
//while the deps may be for .NETStandard,Version=v2.0 or .NETCoreApp,Version = v2.0 as well.
var nugetFramwork = NuGetFramework.ParseFrameworkName(NugetHelper.Instance.GetTargetFramwork(), new DefaultFrameworkNameProvider());
var mostCompatibleFramework = NugetHelper.Instance.GetMostCompatibleFramework(nugetFramwork, rootPackage.DependencySets);
if (rootPackage.DependencySets.Any(x => x.TargetFramework == mostCompatibleFramework))
{
var depsForTargetFramwork = rootPackage.DependencySets.Where(x => x.TargetFramework == mostCompatibleFramework).FirstOrDefault();
if (depsForTargetFramwork.Packages.Count() > 0)
{
foreach (var package in depsForTargetFramwork.Packages)
{
PackageIdentity _identity = new PackageIdentity(package.Id, package.VersionRange.MinVersion);
if (_identity != null)
{
childPackageIdentities.Add(_identity);
}
}
}
}
}
//
return(childPackageIdentities);
}
public void with_two_assemblies_framework_assemblies_are_updated_in_correct_group()
{
var builder = new SpecificationBuilder();
builder.WithAssembly(@"regular\output\net40\EDO.Diagnostics.Core.dll".GetTestFileInfo());
builder.WithAssembly(@"regular\output\net45\EDO.Diagnostics.Core.dll".GetTestFileInfo());
var nuGetFrameworks = new List <NuGetFramework>()
{
NuGetFramework.ParseFrameworkName(".Net Framework 4",
DefaultFrameworkNameProvider.Instance)
,
NuGetFramework.ParseFrameworkName(".Net Framework 4.5.2",
DefaultFrameworkNameProvider.Instance)
};
var expectedAssemblies = new List <FrameworkAssemblyReference>()
{
new FrameworkAssemblyReference(
"mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
nuGetFrameworks)
,
new FrameworkAssemblyReference(
"System.Xml.Linq, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
nuGetFrameworks)
};
CollectionAssert.AreEqual(expectedAssemblies, builder.Specification.FrameworkAssemblies,
FrameworkAssemblyReferenceComparer.Default,
"unexpected version retrieved from assembly");
}
public PackagesConfigNuGetProject(string folderPath, Dictionary <string, object> metadata)
: base(metadata)
{
if (folderPath == null)
{
throw new ArgumentNullException(nameof(folderPath));
}
// In ProjectFactory.cs, an instance of _project is initialized as a dynamic through
// Activator.CreateInstance. It has a Dictionary<string, object> which is later
// provided to this constructor. Occasionally, the value is a string, occasionally, it
// is a NuGetFramework. Not knowing why that's happening, we can protect against it here.
// https://github.com/NuGet/Home/issues/4491
var oFramework = GetMetadata <object>(NuGetProjectMetadataKeys.TargetFramework);
TargetFramework = oFramework is string
?NuGetFramework.ParseFrameworkName((string)oFramework, DefaultFrameworkNameProvider.Instance)
: (NuGetFramework)oFramework;
PackagesConfigPath = Path.Combine(folderPath, "packages.config");
var projectName = GetMetadata <string>(NuGetProjectMetadataKeys.Name);
PackagesProjectNameConfigPath = Path.Combine(folderPath, "packages." + projectName + ".config");
}
public IEnumerable <FrameworkName> GetFrameworksSupportingNetStandard(FrameworkName frameworkName)
{
if (frameworkName == null)
{
throw new ArgumentNullException(nameof(frameworkName));
}
try
{
var nuGetFramework = NuGetFramework.ParseFrameworkName(frameworkName.ToString(), DefaultFrameworkNameProvider.Instance);
if (!StringComparer.OrdinalIgnoreCase.Equals(
nuGetFramework.Framework,
FrameworkConstants.FrameworkIdentifiers.NetStandard))
{
throw new ArgumentException(string.Format(
VsResources.InvalidNetStandardFramework,
frameworkName));
}
return(CompatibilityListProvider
.Default
.GetFrameworksSupporting(nuGetFramework)
.Select(framework => new FrameworkName(framework.DotNetFrameworkName))
.ToList());
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsFrameworkCompatibility).FullName);
throw;
}
}
/// <summary>
/// Extracts the lib files to execution directory
/// </summary>
/// <param name="package">
/// The package to extract
/// </param>
/// <param name="runtime">
/// The current runtime
/// </param>
/// <param name="frameworkName">
/// The current framework name
/// </param>
/// <param name="executionDir">
/// The execution directory to load packages
/// </param>
/// <param name="logAction">The log writing action</param>
/// <returns>
/// The list of extracted files
/// </returns>
private static IEnumerable <string> ExtractPackage(
DownloadResourceResult package,
string runtime,
NuGetFramework frameworkName,
string executionDir,
Action <string> logAction = null)
{
try
{
var id = package.PackageReader.GetIdentity();
var files = NuGetFrameworkUtility.GetNearest(package.PackageReader.GetLibItems(), frameworkName)?.Items.ToList()
?? NuGetFrameworkUtility.GetNearest(package.PackageReader.GetToolItems(), frameworkName)?.Items.ToList();
if (files == null || files.Count == 0)
{
var collection = new ContentItemCollection();
collection.Load(package.PackageReader.GetFiles());
var conventions = new ManagedCodeConventions(runtimeGraph);
var criteria = conventions.Criteria.ForFrameworkAndRuntime(
NuGetFramework.ParseFrameworkName(
PackageRepositoryExtensions.CurrentRuntime,
DefaultFrameworkNameProvider.Instance),
runtime);
files = collection.FindBestItemGroup(criteria, conventions.Patterns.NativeLibraries)?.Items
.Select(i => i.Path).ToList();
if (files == null || files.Count == 0)
{
files = collection.FindBestItemGroup(criteria, conventions.Patterns.RuntimeAssemblies)?.Items
.Select(i => i.Path).ToList();
}
if (files == null || files.Count == 0)
{
return(new string[0]);
}
else
{
logAction?.Invoke($"{id.Id}: {string.Join(", ", files)}");
}
}
foreach (var file in files)
{
using (var fileStream = File.Create(Path.Combine(executionDir, Path.GetFileName(file) ?? file)))
{
package.PackageReader.GetStream(file).CopyTo(fileStream);
}
}
return(files.Select(file => Path.GetFileName(file) ?? file));
}
finally
{
package.Dispose();
}
}
private FrameworkName GetNearestImpl(FrameworkName targetFramework, IEnumerable <FrameworkName> fallbackTargetFrameworks, IEnumerable <FrameworkName> 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));
}
IEnumerable <NuGetFramework> ParseAllFrameworks(IEnumerable <FrameworkName> frameworks)
{
foreach (FrameworkName frameworkName in frameworks)
{
if (frameworkName == null)
{
throw new ArgumentException(message: VsResourcesFormat.PropertyCannotBeNull(nameof(FrameworkName)), paramName: nameof(frameworks));
}
NuGetFramework nugetFramework = NuGetFramework.ParseFrameworkName(frameworkName.ToString(), DefaultFrameworkNameProvider.Instance);
yield return(nugetFramework);
}
}
var nuGetTargetFramework = NuGetFramework.ParseFrameworkName(targetFramework.ToString(), DefaultFrameworkNameProvider.Instance);
var nuGetFallbackTargetFrameworks = ParseAllFrameworks(fallbackTargetFrameworks).ToList();
var nuGetFrameworks = ParseAllFrameworks(frameworks).ToList();
try
{
if (nuGetFallbackTargetFrameworks.Any())
{
nuGetTargetFramework = new FallbackFramework(nuGetTargetFramework, nuGetFallbackTargetFrameworks);
}
var reducer = new FrameworkReducer();
var nearest = reducer.GetNearest(nuGetTargetFramework, nuGetFrameworks);
if (nearest == null)
{
return(null);
}
return(new FrameworkName(nearest.DotNetFrameworkName));
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsFrameworkCompatibility).FullName);
throw;
}
}
public NuGetFramework GetTargetNugetFramework()
{
var frameworkName = GetTargetFramework();
var currentFramework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
return(currentFramework);
}
static PackageLoader()
{
m_localRepositories = new List <NuGetv3LocalRepository>();
m_loadedPackages = new Dictionary <string, Package>();
var frameworkName = Assembly.GetExecutingAssembly().
GetCustomAttribute <TargetFrameworkAttribute>().FrameworkName;
m_framework = NuGetFramework.ParseFrameworkName(frameworkName,
DefaultFrameworkNameProvider.Instance);
}
private async Task PopulateDependencies(Dependency dependency)
{
var dependencies = new List <Dependency>();
NuGetVersion.TryParse(dependency.Version, out var version);
var package = new PackageIdentity(dependency.Name, version);
var framework = String.IsNullOrEmpty(dependency.Framework)
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(dependency.Framework, new DefaultFrameworkNameProvider());
var dependencyInfo = await _dependencyResolver.ResolvePackage(package, framework, _cacheContext, _logger, _cancellationToken);
if (dependencyInfo == null)
{
_logger.LogWarning($"Package not available in source(s): {dependency.Name} {dependency.Version}. Required by {dependency.Project}");
return;
}
dependency.FoundInSources = true;
if (dependencyInfo?.Dependencies == null)
{
return;
}
foreach (var info in dependencyInfo.Dependencies)
{
var searchResults = await _metadataProvider.GetMetadataAsync(info.Id, includePrerelease : INCLUDE_PRERELEASE, includeUnlisted : false, sourceCacheContext : _cacheContext, _logger, _cancellationToken);
var metadata = searchResults.OrderBy(s => s.Identity.Version).LastOrDefault(r => info.VersionRange.Satisfies(r.Identity.Version));
if (metadata == null)
{
_logger.LogWarning($"Package not available in source(s): {info.Id} {info.VersionRange}. Required by {dependency.Name} from {dependency.Project}");
continue;
}
var subpackage = await _dependencyResolver.ResolvePackage(metadata.Identity, framework, _cacheContext, _logger, _cancellationToken);
var childDependency = new Dependency
{
Framework = dependency.Framework,
Name = subpackage.Id,
Version = subpackage.Version?.Version?.ToString(),
Project = dependency.Project,
VersionLimited = info.VersionRange.MaxVersion == null ? null : $"{info.VersionRange.MaxVersion.Version.ToString()} by {dependency.Name} ({dependency.Version})"
};
dependencies.Add(childDependency);
await PopulateDependencies(childDependency);
}
dependency.Dependencies = dependencies;
}
public static NuGetFramework TryParseFrameworkName(string frameworkString, IFrameworkNameProvider frameworkNameProvider)
{
try
{
return(NuGetFramework.ParseFrameworkName(frameworkString, frameworkNameProvider));
}
catch (ArgumentException)
{
return(NuGetFramework.UnsupportedFramework);
}
}
/// <summary>
/// Creates a <see cref="PackageDependencyGroup"/> from string definition
/// </summary>
/// <param name="framework">The framework name</param>
/// <param name="definition">The dependencies definition</param>
/// <returns>The dependency set</returns>
internal static PackageDependencyGroup CreatePackageDependencySet(string framework, params string[] definition)
{
return(new PackageDependencyGroup(
NuGetFramework.ParseFrameworkName(framework, DefaultFrameworkNameProvider.Instance),
definition.Select(
d =>
{
var parts = d.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
return new PackageDependency(parts[0], CreateVersionRange(parts[1]));
})));
}
private NuGetFramework GetCurrentFramework()
{
string frameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true)
.OfType <System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault();
return(frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider()));
}
public static NuGetFramework GetTargetFramework(Assembly assembly = null)
{
var frameworkName = (assembly ?? Assembly.GetCallingAssembly()).GetCustomAttributes(true)
.OfType <TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault();
var currentFramework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
return(currentFramework);
}
/// <summary>
/// Creates test package from assembly
/// </summary>
/// <param name="assembly">The source assembly</param>
/// <param name="allAssemblies">The list of all defined assemblies</param>
/// <returns>The test package</returns>
private static TestPackage CreateTestPackage(Assembly assembly, Assembly[] allAssemblies)
{
var dependencies = assembly.GetReferencedAssemblies().Select(
d =>
{
var dependentAssembly = allAssemblies.FirstOrDefault(a => a.GetName().Name == d.Name);
return(dependentAssembly != null && !dependentAssembly.IsDynamic
#if APPDOMAIN
&& !dependentAssembly.GlobalAssemblyCache
#endif
? dependentAssembly
: null);
}).Where(d => d != null).Select(
d => new PackageDependency(
d.GetName().Name,
new VersionRange(NuGetVersion.Parse(d.GetName().Version.ToString())))).ToList();
var standardDependencies = new PackageDependencyGroup(
NuGetFramework.ParseFrameworkName(
ConfigurationCheckTestsBase.NetCore,
DefaultFrameworkNameProvider.Instance),
dependencies);
var net46Dependencies = new PackageDependencyGroup(
NuGetFramework.ParseFrameworkName(
ConfigurationCheckTestsBase.Net46,
DefaultFrameworkNameProvider.Instance),
dependencies);
Func <string, string, string, IEnumerable <string> > extaction = (framework, destination, temp) =>
{
if (string.IsNullOrWhiteSpace(assembly.Location))
{
throw new InvalidOperationException("Assembly has no location");
}
var fileName = Path.GetFileName(assembly.Location);
File.Copy(assembly.Location, Path.Combine(destination, fileName));
return(new[] { fileName });
};
return(new TestPackage(assembly.GetName().Name, assembly.GetName().Version.ToString())
{
DependencySets =
new[]
{
standardDependencies,
net46Dependencies
},
Extract =
extaction
});
}
public string GetShortFrameworkName(FrameworkName frameworkName)
{
#pragma warning disable CS0618 // Type or member is obsolete
const string eventName = nameof(IVsFrameworkParser) + "." + nameof(GetShortFrameworkName);
#pragma warning restore CS0618 // Type or member is obsolete
using var _ = NuGetETW.ExtensibilityEventSource.StartStopEvent(eventName,
new
{
Framework = frameworkName?.FullName
});
if (frameworkName == null)
{
throw new ArgumentNullException(nameof(frameworkName));
}
try
{
var nuGetFramework = NuGetFramework.ParseFrameworkName(
frameworkName.ToString(),
DefaultFrameworkNameProvider.Instance);
try
{
return(nuGetFramework.GetShortFolderName());
}
catch (FrameworkException e)
{
// Wrap this exception for two reasons:
//
// 1) FrameworkException is not a .NET Framework type and therefore is not
// recognized by other components in Visual Studio.
//
// 2) Changing our NuGet code to throw ArgumentException is not appropriate in
// this case because the failure does not occur in a method that has arguments!
var message = string.Format(
CultureInfo.CurrentCulture,
VsResources.CouldNotGetShortFrameworkName,
frameworkName);
throw new ArgumentException(message, e);
}
}
catch (ArgumentException)
{
throw;
}
catch (Exception exception)
{
_telemetryProvider.PostFault(exception, typeof(VsFrameworkParser).FullName);
throw;
}
}
public NuGetPackageManager(string packagesDirectory)
{
m_AssemblyLoader = Assembly.Load;
Logger = new NullLogger();
PackagesDirectory = packagesDirectory;
m_Providers = new List <Lazy <INuGetResourceProvider> >();
m_Providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
const string nugetFile = "NuGet.Config";
if (!Directory.Exists(packagesDirectory))
{
Directory.CreateDirectory(packagesDirectory);
}
var nugetConfig = Path.Combine(packagesDirectory, nugetFile);
if (!File.Exists(nugetConfig))
{
var nl = Environment.NewLine;
File.WriteAllText(nugetConfig,
$"<?xml version=\"1.0\" encoding=\"utf-8\"?>{nl}"
+ $"<configuration>{nl}"
+ $" <packageSources>{nl}"
+ $" <add key=\"nuget.org\" value=\"https://api.nuget.org/v3/index.json\" protocolVersion=\"3\" />{nl}"
+ $" </packageSources>{nl}"
+ "</configuration>");
}
m_NugetSettings = Settings.LoadDefaultSettings(packagesDirectory, nugetFile, null);
m_FrameworkReducer = new FrameworkReducer();
var frameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true)
.OfType <System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault();
m_CurrentFramework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
m_PackagePathResolver = new PackagePathResolver(packagesDirectory);
m_PackageResolver = new PackageResolver();
m_LoadedPackageAssemblies = new Dictionary <string, List <NuGetAssembly> >();
m_ResolveCache = new Dictionary <string, Assembly>();
m_IgnoredDependendencies = new HashSet <string>();
InstallAssemblyResolver();
}
private static NuGetFramework?ToNuGetFramework(object value)
{
// See https://github.com/NuGet/Home/issues/4491
if (value is string stringValue)
{
return(NuGetFramework.ParseFrameworkName(stringValue, DefaultFrameworkNameProvider.Instance));
}
if (value is NuGetFramework frameworkValue)
{
return(frameworkValue);
}
return(null);
}
private void button2_Click(object sender, EventArgs e)
{
try
{
if (textBox2.Text.Trim()
.Length
> 0)
{
var nugetFramwork = NuGetFramework.ParseFrameworkName(NugetHelper.Instance.GetTargetFramwork(), new DefaultFrameworkNameProvider());
var nupkgPath = textBox2.Text.Trim();
var package = new ZipPackage(nupkgPath);
//var content = package.GetContentFiles();
var files = package.GetLibFiles()
.ToList();
var targetDlls = files.FindAll(x => x.EffectivePath.ToLower()
.Contains(".dll") &&
x.TargetFramework.Identifier.ToLower() == nugetFramwork.Framework.ToLower())
.Take(1);
foreach (var item in targetDlls)
{
if (item.EffectivePath.ToLower()
.Contains(".dll"))
{
var rawAssembly = item.GetStream()
.ReadAllBytes();
var ad = AppDomain.CreateDomain("newDomian");
// Loader lives in another AppDomain
var loader = (Loader)ad.CreateInstanceAndUnwrap(typeof(Loader).Assembly.FullName, typeof(Loader).FullName);
loader.LoadAssembly(rawAssembly);
var dd = loader.ExecuteStaticMethod("RestSharp.Validation.Ensure", "NotEmpty", "admin", "admin");
var dd1 = loader.ExecuteStaticMethod("RestSharp.SimpleJson", "EscapeToJavascriptString", "admin\\teset\\asdf\\sdaf");
richTextBox1.Text = $"RestSharp.SimpleJson.EscapeToJavascriptString(\"admin\\\\teset\\\\asdf\\\\sdaf\") -- {dd1}";
ad.DomainUnload += OnAppDomainUnload;
AppDomain.Unload(ad);
}
}
}
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
}
public static IEnumerable <string> GetCompatibleAssemblyReferences(this IPackageContentReaderWithRef package, FrameworkName target)
{
var framework = NuGetFramework.ParseFrameworkName(target.FullName, DefaultFrameworkNameProvider.Instance);
var result = NuGetFrameworkUtility.GetNearest(package.GetRefItems(), framework);
if (result != null)
{
var items = result.Items.ToArray();
if (items.Length != 0)
{
return(items);
}
}
result = NuGetFrameworkUtility.GetNearest(package.GetLibItems(), framework);
return(result == null?Enumerable.Empty <string>() : result.Items);
}
public static NuGetFramework GetTargetFrameworkMoniker(this ITaskItem taskItem)
{
NuGetFramework result = null;
var metadataValue = taskItem.GetMetadata(Metadata.TargetFrameworkMoniker);
if (!string.IsNullOrEmpty(metadataValue))
{
result = NuGetFramework.ParseFrameworkName(metadataValue, DefaultFrameworkNameProvider.Instance);
}
else
{
result = NuGetFramework.AnyFramework;
}
return(result);
}
/// <inheritdoc />
public Task <Dictionary <PackageIdentity, IEnumerable <string> > > ExtractPackage(
IEnumerable <PackageIdentity> packages,
string runtime,
string frameworkName,
string executionDir,
string tmpDir,
Action <string> logAction = null)
{
var framework = NuGetFramework.ParseFrameworkName(frameworkName, DefaultFrameworkNameProvider.Instance);
Console.WriteLine(framework.ToString());
return(packages.Install(
runtime,
framework,
this.url,
executionDir,
logAction));
}
private NuGetFramework ProcessAssembly(Assembly assembly)
{
IList <CustomAttributeData> attributesData = assembly.GetCustomAttributesData();
Specification.Id = assembly.FullName;
NuGetFramework targetFramework = null;
foreach (CustomAttributeData attributeData in attributesData)
{
if (attributeData.Constructor.DeclaringType == typeof(AssemblyCopyrightAttribute))
{
Specification.Copyright = attributeData.ConstructorArguments.First().ToString().Trim(new[] { '"' });
}
else if (attributeData.Constructor.DeclaringType == typeof(AssemblyInformationalVersionAttribute))
{
string[] version = attributeData.ConstructorArguments.First().ToString().Trim(new [] { '"' }).Split(new [] { '-' }, StringSplitOptions.RemoveEmptyEntries);
if (version.Length == 1)
{
Specification.Version = NuGetVersion.Parse(version[0]);
}
else
{
Specification.Version = new NuGetVersion(System.Version.Parse(version[0]), version[1]);
}
}
else if (attributeData.Constructor.DeclaringType ==
typeof(TargetFrameworkAttribute))
{
targetFramework = NuGetFramework.ParseFrameworkName(
attributeData.NamedArguments.First().TypedValue.Value.ToString().Trim(new[] { '"' }),
DefaultFrameworkNameProvider.Instance);
}
}
if (targetFramework == null)
{
throw new ArgumentException("no target framework identified in assembly " + assembly);
}
foreach (AssemblyName referencedAssembly in assembly.GetReferencedAssemblies())
{
Specification.FrameworkAssemblies.Add(referencedAssembly.FullName, targetFramework);
}
return(targetFramework);
}
public NuGetPackageManager(ILogger logger, string packagesDirectory)
{
this.logger = logger;
this.packagesDirectory = packagesDirectory;
providers = new List<Lazy<INuGetResourceProvider>>();
providers.AddRange(Repository.Provider.GetCoreV3()); // Add v3 API support
const string nugetFile = "NuGet.Config";
var nugetConfig = Path.Combine(packagesDirectory, nugetFile);
if (!File.Exists(nugetConfig))
{
var nl = Environment.NewLine;
File.WriteAllText(nugetConfig,
$"<?xml version=\"1.0\" encoding=\"utf-8\"?>{nl}"
+ $"<configuration>{nl}"
+ $" <packageSources>{nl}"
+ $" <add key=\"rocketmod-hangar\" value=\"http://hangar.rocketmod.net/index.json\" protocolVersion=\"3\" />{nl}"
+ $" <add key=\"nuget.org\" value=\"https://api.nuget.org/v3/index.json\" protocolVersion=\"3\" />{nl}"
+ $" </packageSources>{nl}"
+ $"</configuration>");
}
nugetSettings = Settings.LoadDefaultSettings(packagesDirectory, nugetFile, null);
frameworkReducer = new FrameworkReducer();
var frameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true)
.OfType<System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault();
currentFramework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
packagePathResolver = new PackagePathResolver(packagesDirectory);
packageResolver = new PackageResolver();
loadedPackageAssemblies = new Dictionary<string, List<CachedNuGetAssembly>>();
InstallAssemblyResolver();
}
public FrameworkName GetNearest(FrameworkName targetFramework, IEnumerable <FrameworkName> fallbackTargetFrameworks, IEnumerable <FrameworkName> 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 nuGetTargetFramework = NuGetFramework.ParseFrameworkName(targetFramework.ToString(), DefaultFrameworkNameProvider.Instance);
var nuGetFallbackTargetFrameworks = fallbackTargetFrameworks
.Select(framework => NuGetFramework.ParseFrameworkName(framework.ToString(), DefaultFrameworkNameProvider.Instance))
.ToList();
if (nuGetFallbackTargetFrameworks.Any())
{
nuGetTargetFramework = new FallbackFramework(nuGetTargetFramework, nuGetFallbackTargetFrameworks);
}
var nuGetFrameworks = frameworks
.Select(framework => NuGetFramework.ParseFrameworkName(framework.ToString(), DefaultFrameworkNameProvider.Instance));
var reducer = new FrameworkReducer();
var nearest = reducer.GetNearest(nuGetTargetFramework, nuGetFrameworks);
if (nearest == null)
{
return(null);
}
return(new FrameworkName(nearest.DotNetFrameworkName));
}
private static NuGetFramework TargetFrameworkName_ParserCore(string name)
{
var result = NuGetFramework.ParseFolder(name);
if (!result.IsUnsupported)
{
return(result);
}
// Everything should be in the folder format, but fallback to
// full parsing for legacy support.
result = NuGetFramework.ParseFrameworkName(name, DefaultFrameworkNameProvider.Instance);
if (!result.IsUnsupported)
{
return(result);
}
// For unknown frameworks return the name as is.
return(new NuGetFramework(name, FrameworkConstants.EmptyVersion));
}
internal static NuGetFramework ToNuGetFramework(this TargetFramework targetFramework)
{
string frameworkName = targetFramework switch
{
TargetFramework.NetStandard2_1 => ".NETStandard,Version=v2.1",
TargetFramework.NetStandard2_0 => ".NETStandard,Version=v2.0",
TargetFramework.NetCoreApp3_1 => ".NETCoreApp,Version=v3.1",
TargetFramework.NetCoreApp3_0 => ".NETCoreApp,Version=v3.0",
TargetFramework.NetCoreApp2_2 => ".NETCoreApp,Version=v2.2",
TargetFramework.NetCoreApp2_1 => ".NETCoreApp,Version=v2.1",
TargetFramework.NetCoreApp2_0 => ".NETCoreApp,Version=v2.0",
TargetFramework.Net48 => ".NETFramework,Version=v4.8",
TargetFramework.Net472 => ".NETFramework,Version=v4.7.2",
TargetFramework.Net471 => ".NETFramework,Version=v4.7.1",
TargetFramework.Net47 => ".NETFramework,Version=v4.7",
_ => throw new ArgumentException(nameof(targetFramework))
};
return(NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider()));
}
}
internal PackageInstaller(IFileSystem fileSystem, AssemblyLoader assemblyLoader)
{
_fileSystem = fileSystem;
// Get the current framework
string frameworkName = Assembly.GetExecutingAssembly().GetCustomAttributes(true)
.OfType <System.Runtime.Versioning.TargetFrameworkAttribute>()
.Select(x => x.FrameworkName)
.FirstOrDefault();
CurrentFramework = frameworkName == null
? NuGetFramework.AnyFramework
: NuGetFramework.ParseFrameworkName(frameworkName, new DefaultFrameworkNameProvider());
Settings = global::NuGet.Configuration.Settings.LoadDefaultSettings(_fileSystem.RootPath.FullPath, null, new MachineWideSettings());
IPackageSourceProvider packageSourceProvider = new PackageSourceProvider(Settings);
SourceRepositoryProvider = new WyamSourceRepositoryProvider(packageSourceProvider);
_nuGetProject = new WyamFolderNuGetProject(fileSystem, assemblyLoader, CurrentFramework, GetAbsolutePackagesPath().FullPath);
PackageManager = new NuGetPackageManager(SourceRepositoryProvider, Settings, GetAbsolutePackagesPath().FullPath)
{
PackagesFolderNuGetProject = _nuGetProject
};
}
