private IEnumerable <string> GetPackageAssemblyNames(string path)
{
var compatibilityProvider = new DefaultCompatibilityProvider();
var folderReader = new PackageFolderReader(Path.Combine(path, _fileSystem.PackagesFolder));
var nupkgFiles = folderReader.GetFiles().Where(x => Path.GetExtension(x).ToLowerInvariant() == ".nupkg");
var packagesConfig = XDocument.Parse(File.ReadAllText(Path.Combine(path, _fileSystem.PackagesFile)));
var reader = new PackagesConfigReader(packagesConfig);
var contents = reader.GetPackages();
var result = new List <string>();
foreach (var nupkg in nupkgFiles)
{
var stream = folderReader.GetStream(nupkg);
var packageReader = new PackageReader(stream);
var identity = packageReader.GetIdentity();
var packagesConfigReference = contents.FirstOrDefault(x => x.PackageIdentity.Id == identity.Id && x.PackageIdentity.Version == identity.Version);
if (packagesConfigReference == null)
{
break;
}
var packageContents = packageReader.GetLibItems().Where(x => compatibilityProvider.IsCompatible(x.TargetFramework, packagesConfigReference.TargetFramework)).
SelectMany(x => x.Items.Where(i => Path.GetExtension(i).ToLowerInvariant() == ".dll"));
result.AddRange(packageContents);
}
return(result);
}
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path)
{
var lockFileLib = new LockFileLibrary();
lockFileLib.Name = package.Id;
lockFileLib.Version = package.Version;
lockFileLib.Type = LibraryType.Package;
lockFileLib.Sha512 = sha512;
// This is the relative path, appended to the global packages folder path. All
// of the paths in the in the Files property should be appended to this path along
// with the global packages folder path to get the absolute path to each file in the
// package.
lockFileLib.Path = path;
using (var packageReader = new PackageFolderReader(package.ExpandedPath))
{
// Get package files, excluding directory entries and OPC files
// This is sorted before it is written out
lockFileLib.Files = packageReader
.GetFiles()
.Where(file => IsAllowedLibraryFile(file))
.ToList();
}
return(lockFileLib);
}
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path, string correctedPackageName)
{
var lockFileLib = new LockFileLibrary();
// package.Id is read from nuspec and it might be in wrong casing.
// correctedPackageName should be the package name used by dependency graph and
// it has the correct casing that runtime needs during dependency resolution.
lockFileLib.Name = correctedPackageName ?? package.Id;
lockFileLib.Version = package.Version;
lockFileLib.Type = LibraryType.Package;
lockFileLib.Sha512 = sha512;
// This is the relative path, appended to the global packages folder path. All
// of the paths in the in the Files property should be appended to this path along
// with the global packages folder path to get the absolute path to each file in the
// package.
lockFileLib.Path = path;
using (var packageReader = new PackageFolderReader(package.ExpandedPath))
{
// Get package files, excluding directory entries and OPC files
// This is sorted before it is written out
lockFileLib.Files = packageReader
.GetFiles()
.Where(file => IsAllowedLibraryFile(file))
.ToList();
}
return(lockFileLib);
}
private static CommandSpec ConfigureCommandFromPackage(string commandName, string args, string packageDir)
{
var commandPackage = new PackageFolderReader(packageDir);
var files = commandPackage.GetFiles();
return(ConfigureCommandFromPackage(commandName, args, files, packageDir));
}
/// <summary>
/// Read files from a package folder.
/// </summary>
private IReadOnlyList <string> GetFiles()
{
using (var packageReader = new PackageFolderReader(ExpandedPath))
{
// Get package files, excluding directory entries and OPC files
// This is sorted before it is written out
return(packageReader.GetFiles()
.Where(file => IsAllowedLibraryFile(file))
.ToList());
}
}
private static IList <string> GetPackageFiles(LockFileLibrary library, LocalPackageInfo package)
{
IList <string> files;
// If the previous LockFileLibrary was given, use that to find the file list. Otherwise read the nupkg.
if (library == null)
{
using (var packageReader = new PackageFolderReader(package.ExpandedPath))
{
if (Path.DirectorySeparatorChar != LockFile.DirectorySeparatorChar)
{
files = packageReader
.GetFiles()
.Select(p => p.Replace(Path.DirectorySeparatorChar, LockFile.DirectorySeparatorChar))
.ToList();
}
else
{
files = packageReader
.GetFiles()
.ToList();
}
}
}
else
{
if (Path.DirectorySeparatorChar != LockFile.DirectorySeparatorChar)
{
files = library.Files.Select(p => p.Replace(Path.DirectorySeparatorChar, LockFile.DirectorySeparatorChar)).ToList();
}
else
{
files = library.Files;
}
}
return(files);
}
public AppDomainContext LoadPackageAssemblies(
string appDomainId,
NuGetFramework framework,
PackageIdentity packageIdentity)
{
var pathResolver = new VersionFolderPathResolver(_settings.GlobalPackagesFolder);
var hashPath = pathResolver.GetHashPath(packageIdentity.Id, packageIdentity.Version);
if (!File.Exists(hashPath))
{
throw new InvalidOperationException($"The package '{packageIdentity}' could not found.");
}
var installPath = pathResolver.GetInstallPath(packageIdentity.Id, packageIdentity.Version);
using (var packageReader = new PackageFolderReader(installPath))
{
var conventions = new ManagedCodeConventions(null);
var criteria = conventions.Criteria.ForFramework(framework);
var files = packageReader
.GetFiles()
.Select(p => p.Replace(Path.DirectorySeparatorChar, AssetDirectorySeparator))
.ToList();
var contentItems = new ContentItemCollection();
contentItems.Load(files);
var runtimeGroup = contentItems.FindBestItemGroup(
criteria,
conventions.Patterns.RuntimeAssemblies);
var appDomainContext = _loader.GetAppDomainContext(appDomainId);
foreach (var asset in runtimeGroup.Items)
{
var absolutePath = Path.Combine(installPath, asset.Path.Replace(AssetDirectorySeparator, Path.DirectorySeparatorChar));
_loader.LoadAssembly(appDomainContext, absolutePath);
}
return(appDomainContext);
}
}
/// <summary>
/// Возвращает список
/// </summary>
/// <param name="reader"></param>
public static IEnumerable <FrameworkSpecificGroup> GetPluginItems(this PackageFolderReader reader)
{
var plugins = reader.GetFiles(NuGetPackageRepositoryManager.PluginFolderName);
var dictionary = new Dictionary <NuGetFramework, List <string> >();
foreach (var p in plugins)
{
var nugetFramework = GetNugetFrameworkFromPath(p);
if (dictionary.ContainsKey(nugetFramework))
{
dictionary[nugetFramework].Add(p);
}
else
{
dictionary.Add(nugetFramework, new List <string> {
p
});
}
}
return(dictionary.Select(s => new FrameworkSpecificGroup(s.Key, s.Value)));
}
public static LockFileTargetLibrary CreateLockFileTargetLibrary(
LockFileLibrary library,
LocalPackageInfo package,
RestoreTargetGraph targetGraph,
LibraryIncludeFlags dependencyType,
NuGetFramework targetFrameworkOverride,
IEnumerable <LibraryDependency> dependencies)
{
var lockFileLib = new LockFileTargetLibrary();
var framework = targetFrameworkOverride ?? targetGraph.Framework;
var runtimeIdentifier = targetGraph.RuntimeIdentifier;
lockFileLib.Name = package.Id;
lockFileLib.Version = package.Version;
lockFileLib.Type = LibraryType.Package;
IList <string> files;
var contentItems = new ContentItemCollection();
HashSet <string> referenceFilter = null;
// If the previous LockFileLibrary was given, use that to find the file list. Otherwise read the nupkg.
if (library == null)
{
using (var packageReader = new PackageFolderReader(package.ExpandedPath))
{
if (Path.DirectorySeparatorChar != LockFile.DirectorySeparatorChar)
{
files = packageReader
.GetFiles()
.Select(p => p.Replace(Path.DirectorySeparatorChar, LockFile.DirectorySeparatorChar))
.ToList();
}
else
{
files = packageReader
.GetFiles()
.ToList();
}
}
}
else
{
if (Path.DirectorySeparatorChar != LockFile.DirectorySeparatorChar)
{
files = library.Files.Select(p => p.Replace(Path.DirectorySeparatorChar, LockFile.DirectorySeparatorChar)).ToList();
}
else
{
files = library.Files;
}
}
contentItems.Load(files);
// This will throw an appropriate error if the nuspec is missing
var nuspec = package.Nuspec;
if (dependencies == null)
{
var dependencySet = nuspec
.GetDependencyGroups()
.GetNearest(framework);
if (dependencySet != null)
{
var set = dependencySet.Packages;
if (set != null)
{
lockFileLib.Dependencies = set.ToList();
}
}
}
else
{
// Filter the dependency set down to packages and projects.
// Framework references will not be displayed
lockFileLib.Dependencies = dependencies
.Where(ld => ld.LibraryRange.TypeConstraintAllowsAnyOf(LibraryDependencyTarget.PackageProjectExternal))
.Select(ld => new PackageDependency(ld.Name, ld.LibraryRange.VersionRange))
.ToList();
}
var referenceSet = nuspec.GetReferenceGroups().GetNearest(framework);
if (referenceSet != null)
{
referenceFilter = new HashSet <string>(referenceSet.Items, StringComparer.OrdinalIgnoreCase);
}
// Exclude framework references for package based frameworks.
if (!framework.IsPackageBased)
{
var frameworkAssemblies = nuspec.GetFrameworkReferenceGroups().GetNearest(framework);
if (frameworkAssemblies != null)
{
foreach (var assemblyReference in frameworkAssemblies.Items)
{
lockFileLib.FrameworkAssemblies.Add(assemblyReference);
}
}
}
// Create an ordered list of selection criteria. Each will be applied, if the result is empty
// fallback frameworks from "imports" will be tried.
// These are only used for framework/RID combinations where content model handles everything.
var orderedCriteria = CreateCriteria(targetGraph, framework);
// Compile
var compileGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.CompileAssemblies,
targetGraph.Conventions.Patterns.RuntimeAssemblies);
lockFileLib.CompileTimeAssemblies.AddRange(compileGroup);
// Runtime
var runtimeGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.RuntimeAssemblies);
lockFileLib.RuntimeAssemblies.AddRange(runtimeGroup);
// Resources
var resourceGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.ResourceAssemblies);
lockFileLib.ResourceAssemblies.AddRange(resourceGroup);
// Native
var nativeGroup = GetLockFileItems(
orderedCriteria,
contentItems,
targetGraph.Conventions.Patterns.NativeLibraries);
lockFileLib.NativeLibraries.AddRange(nativeGroup);
// content v2 items
var contentFileGroups = contentItems.FindItemGroups(targetGraph.Conventions.Patterns.ContentFiles);
// Multiple groups can match the same framework, find all of them
var contentFileGroupsForFramework = ContentFileUtils.GetContentGroupsForFramework(
lockFileLib,
framework,
contentFileGroups);
lockFileLib.ContentFiles = ContentFileUtils.GetContentFileGroup(
framework,
nuspec,
contentFileGroupsForFramework);
// Runtime targets
// These are applied only to non-RID target graphs.
// They are not used for compatibility checks.
if (string.IsNullOrEmpty(runtimeIdentifier))
{
// Runtime targets contain all the runtime specific assets
// that could be contained in the runtime specific target graphs.
// These items are contained in a flat list and have additional properties
// for the RID and lock file section the assembly would belong to.
var runtimeTargetItems = new List <LockFileRuntimeTarget>();
// Runtime
runtimeTargetItems.AddRange(GetRuntimeTargetLockFileItems(
contentItems,
framework,
dependencyType,
LibraryIncludeFlags.Runtime,
targetGraph.Conventions.Patterns.RuntimeAssemblies,
"runtime"));
// Resource
runtimeTargetItems.AddRange(GetRuntimeTargetLockFileItems(
contentItems,
framework,
dependencyType,
LibraryIncludeFlags.Runtime,
targetGraph.Conventions.Patterns.ResourceAssemblies,
"resource"));
// Native
runtimeTargetItems.AddRange(GetRuntimeTargetLockFileItems(
contentItems,
framework,
dependencyType,
LibraryIncludeFlags.Native,
targetGraph.Conventions.Patterns.NativeLibraries,
"native"));
lockFileLib.RuntimeTargets = runtimeTargetItems;
}
// COMPAT: Support lib/contract so older packages can be consumed
var contractPath = "lib/contract/" + package.Id + ".dll";
var hasContract = files.Any(path => path == contractPath);
var hasLib = lockFileLib.RuntimeAssemblies.Any();
if (hasContract &&
hasLib &&
!framework.IsDesktop())
{
lockFileLib.CompileTimeAssemblies.Clear();
lockFileLib.CompileTimeAssemblies.Add(new LockFileItem(contractPath));
}
// Apply filters from the <references> node in the nuspec
if (referenceFilter != null)
{
// Remove anything that starts with "lib/" and is NOT specified in the reference filter.
// runtimes/* is unaffected (it doesn't start with lib/)
lockFileLib.RuntimeAssemblies = lockFileLib.RuntimeAssemblies.Where(p => !p.Path.StartsWith("lib/") || referenceFilter.Contains(Path.GetFileName(p.Path))).ToList();
lockFileLib.CompileTimeAssemblies = lockFileLib.CompileTimeAssemblies.Where(p => !p.Path.StartsWith("lib/") || referenceFilter.Contains(Path.GetFileName(p.Path))).ToList();
}
// Exclude items
if ((dependencyType & LibraryIncludeFlags.Runtime) == LibraryIncludeFlags.None)
{
ClearIfExists(lockFileLib.RuntimeAssemblies);
lockFileLib.FrameworkAssemblies.Clear();
lockFileLib.ResourceAssemblies.Clear();
}
if ((dependencyType & LibraryIncludeFlags.Compile) == LibraryIncludeFlags.None)
{
ClearIfExists(lockFileLib.CompileTimeAssemblies);
}
if ((dependencyType & LibraryIncludeFlags.Native) == LibraryIncludeFlags.None)
{
ClearIfExists(lockFileLib.NativeLibraries);
}
if ((dependencyType & LibraryIncludeFlags.ContentFiles) == LibraryIncludeFlags.None &&
GroupHasNonEmptyItems(lockFileLib.ContentFiles))
{
// Empty lock file items still need lock file properties for language, action, and output.
lockFileLib.ContentFiles.Clear();
lockFileLib.ContentFiles.Add(ContentFileUtils.CreateEmptyItem());
}
return(lockFileLib);
}
private CompatibilityData GetCompatibilityData(RestoreTargetGraph graph, LibraryIdentity libraryId)
{
LockFileTargetLibrary targetLibrary = null;
var target = _lockFile.Targets.FirstOrDefault(t => Equals(t.TargetFramework, graph.Framework) && string.Equals(t.RuntimeIdentifier, graph.RuntimeIdentifier, StringComparison.Ordinal));
if (target != null)
{
targetLibrary = target.Libraries.FirstOrDefault(t => t.Name.Equals(libraryId.Name) && t.Version.Equals(libraryId.Version));
}
IEnumerable <string> files = null;
var lockFileLibrary = _lockFile.Libraries.FirstOrDefault(l => l.Name.Equals(libraryId.Name) && l.Version.Equals(libraryId.Version));
if (lockFileLibrary != null)
{
files = lockFileLibrary.Files;
}
if (files != null && targetLibrary != null)
{
// Everything we need is in the lock file!
return(new CompatibilityData(lockFileLibrary.Files, targetLibrary));
}
else
{
// We need to generate some of the data. We'll need the local packge info to do that
var packageInfo = NuGetv3LocalRepositoryUtility.GetPackage(
_localRepositories,
libraryId.Name,
libraryId.Version);
if (packageInfo == null)
{
return(null);
}
// Collect the file list if necessary
if (files == null)
{
using (var packageReader = new PackageFolderReader(packageInfo.Package.ExpandedPath))
{
if (Path.DirectorySeparatorChar != '/')
{
files = packageReader
.GetFiles()
.Select(p => p.Replace(Path.DirectorySeparatorChar, '/'))
.ToList();
}
else
{
files = packageReader.GetFiles().ToList();
}
}
}
// Generate the target library if necessary
if (targetLibrary == null)
{
targetLibrary = LockFileUtils.CreateLockFileTargetLibrary(
library: null,
package: packageInfo.Package,
targetGraph: graph,
dependencyType: LibraryIncludeFlags.All);
}
return(new CompatibilityData(files, targetLibrary));
}
}