private static IList <ISourceReference> JoinSourceReferences(
LibraryExport internalExports,
IReadOnlyList <LibraryExport> additionalExports)
{
return(internalExports
.SourceReferences
.AsEnumerable()
.Concat(
additionalExports.SelectMany(x => x.SourceReferences)).ToList());
}
private static IEnumerable <string> GenerateLines(LibraryExport export, IEnumerable <LibraryAsset> items, string type)
{
return(items.Select(item =>
EscapeCsv(export.Library.Identity.Type.Value) + "," +
EscapeCsv(export.Library.Identity.Name) + "," +
EscapeCsv(export.Library.Identity.Version.ToNormalizedString()) + "," +
EscapeCsv(export.Library.Hash) + "," +
EscapeCsv(type) + "," +
EscapeCsv(item.Name) + "," +
EscapeCsv(item.RelativePath) + ","));
}
private static IEnumerable <string> GenerateLines(LibraryExport export, IEnumerable <LibraryAsset> items, string type)
{
return(items.Select(i => DepsFormatter.EscapeRow(new[]
{
export.Library.Identity.Type.Value,
export.Library.Identity.Name,
export.Library.Identity.Version.ToNormalizedString(),
export.Library.Hash,
type,
i.Name,
i.RelativePath
})));
}
private static ILibraryExporter GetLibraryExporter()
{
var fileReference = new Mock <IMetadataFileReference>();
fileReference.SetupGet(f => f.Path)
.Returns(typeof(string).Assembly.Location);
var libraryExport = new LibraryExport(fileReference.Object);
var libraryExporter = new Mock <ILibraryExporter>();
libraryExporter.Setup(l => l.GetAllExports(It.IsAny <string>()))
.Returns(libraryExport);
return(libraryExporter.Object);
}
private void ResolveFileReferences(LibraryExport export)
{
if (export.Library.Identity.Type == LibraryType.Project)
{
// If this is a project, only add its compilation assembly if it is simply wrapping another assembly.
var projectDescription = export.Library as ProjectDescription;
if (!string.IsNullOrEmpty(projectDescription.TargetFrameworkInfo?.AssemblyPath))
{
_fileReferences.AddRange(export.CompilationAssemblies.Select(asset => asset.ResolvedPath));
}
}
else
{
_fileReferences.AddRange(export.CompilationAssemblies.Select(asset => asset.ResolvedPath));
}
}
public void LibraryExportExtensions_GetMetadataReferences_throwException()
{
var libraryExporter = GetInvalidLibraryExporter();
_export = libraryExporter.GetExport("ModelTypesLocatorTestClassLibrary");
var ex = Assert.ThrowsAny <Exception>(() => LibraryExportExtensions.GetMetadataReferences(_export));
Assert.True(ex is FileNotFoundException ||
ex is DirectoryNotFoundException ||
ex is NotSupportedException ||
ex is ArgumentException ||
ex is ArgumentOutOfRangeException ||
ex is BadImageFormatException ||
ex is IOException ||
ex is ArgumentNullException);
}
private ICompilationService GetCompilationService()
{
var appEnvironment = PlatformServices.Default.Application;
var loaderAccessor = PlatformServices.Default.AssemblyLoadContextAccessor;
var libExporter = CompilationServices.Default.LibraryExporter;
var emptyLibExport = new LibraryExport(metadataReferences: null);
var mockLibExporter = new Mock <ILibraryExporter>();
var input = "Microsoft.Extensions.CodeGeneration.Templating.Test";
mockLibExporter
.Setup(lm => lm.GetAllExports(input))
.Returns(libExporter.GetAllExports(input));
return(new RoslynCompilationService(appEnvironment, loaderAccessor, mockLibExporter.Object));
}
private static Library GetLibrary(LibraryExport export,
NuGetFramework target,
string configuration,
IEnumerable <LibraryAsset> libraryAssets,
IDictionary <string, Dependency> dependencyLookup)
{
var type = export.Library.Identity.Type.Value.ToLowerInvariant();
var serviceable = (export.Library as PackageDescription)?.Library.IsServiceable ?? false;
var libraryDependencies = new List <Dependency>();
foreach (var libraryDependency in export.Library.Dependencies)
{
Dependency dependency;
if (dependencyLookup.TryGetValue(libraryDependency.Name, out dependency))
{
libraryDependencies.Add(dependency);
}
}
string[] assemblies;
if (type == "project")
{
var isExe = ((ProjectDescription)export.Library)
.Project
.GetCompilerOptions(target, configuration)
.EmitEntryPoint
.GetValueOrDefault(false);
assemblies = new[] { export.Library.Identity.Name + (isExe ? ".exe": ".dll") };
}
else
{
assemblies = libraryAssets.Select(libraryAsset => libraryAsset.RelativePath).ToArray();
}
return(new Library(
type,
export.Library.Identity.Name,
export.Library.Identity.Version.ToString(),
export.Library.Hash,
assemblies,
libraryDependencies.ToArray(),
serviceable
));
}
private static Library GetLibrary(LibraryExport export, IEnumerable <LibraryAsset> libraryAssets, IEnumerable <LibraryExport> dependencies)
{
var serviceable = (export.Library as PackageDescription)?.Library.IsServiceable ?? false;
var version = dependencies.Where(dependency => dependency.Library.Identity == export.Library.Identity);
var libraryDependencies = export.Library.Dependencies.Select(libraryRange => GetDependency(libraryRange, dependencies)).ToArray();
return(new Library(
export.Library.Identity.Type.ToString().ToLowerInvariant(),
export.Library.Identity.Name,
export.Library.Identity.Version.ToString(),
export.Library.Hash,
libraryAssets.Select(libraryAsset => libraryAsset.RelativePath).ToArray(),
libraryDependencies,
serviceable
));
}
private ICompilationService GetCompilationService()
{
var originalProvider = CallContextServiceLocator.Locator.ServiceProvider;
var appEnvironment = (IApplicationEnvironment)originalProvider.GetService(typeof(IApplicationEnvironment));
var loaderAccessor = (IAssemblyLoadContextAccessor)originalProvider.GetService(typeof(IAssemblyLoadContextAccessor));
var libManager = (ILibraryManager)originalProvider.GetService(typeof(ILibraryManager));
var emptyLibExport = new LibraryExport();
var mockLibManager = new Mock<ILibraryManager>();
mockLibManager
.Setup(lm => lm.GetAllExports("Microsoft.Framework.CodeGeneration"))
.Returns(emptyLibExport);
var input = "Microsoft.Framework.CodeGeneration.Templating.Test";
mockLibManager
.Setup(lm => lm.GetAllExports(input))
.Returns(libManager.GetAllExports(input));
return new RoslynCompilationService(appEnvironment, loaderAccessor, mockLibManager.Object);
}
private static void PublishRefs(LibraryExport export, string outputPath)
{
var refsPath = Path.Combine(outputPath, "refs");
if (!Directory.Exists(refsPath))
{
Directory.CreateDirectory(refsPath);
}
// Do not copy compilation assembly if it's in runtime assemblies
var runtimeAssemblies = new HashSet <LibraryAsset>(export.RuntimeAssemblyGroups.GetDefaultAssets());
foreach (var compilationAssembly in export.CompilationAssemblies)
{
if (!runtimeAssemblies.Contains(compilationAssembly))
{
var destFileName = Path.Combine(refsPath, Path.GetFileName(compilationAssembly.ResolvedPath));
File.Copy(compilationAssembly.ResolvedPath, destFileName, overwrite: true);
}
}
}
private ICompilationService GetCompilationService()
{
var originalProvider = CallContextServiceLocator.Locator.ServiceProvider;
var appEnvironment = (IApplicationEnvironment)originalProvider.GetService(typeof(IApplicationEnvironment));
var loaderEngine = (IAssemblyLoaderEngine)originalProvider.GetService(typeof(IAssemblyLoaderEngine));
var libManager = (ILibraryManager)originalProvider.GetService(typeof(ILibraryManager));
var emptyLibExport = new LibraryExport(new List <IMetadataReference>(), new List <ISourceReference>());
var mockLibManager = new Mock <ILibraryManager>();
mockLibManager
.Setup(lm => lm.GetAllExports("Microsoft.Framework.CodeGeneration"))
.Returns(emptyLibExport);
var input = "Microsoft.Framework.CodeGeneration.Templating.Test";
mockLibManager
.Setup(lm => lm.GetAllExports(input))
.Returns(libManager.GetAllExports(input));
return(new RoslynCompilationService(appEnvironment, loaderEngine, mockLibManager.Object));
}
private void ResolveProjectReference(LibraryExport export)
{
var desc = export.Library as ProjectDescription;
if (desc == null || export.Library.Identity.Type != LibraryType.Project)
{
return;
}
if (export.Library.Identity.Name == _context.ProjectFile.Name)
{
return;
}
if (!string.IsNullOrEmpty(desc?.TargetFrameworkInfo?.AssemblyPath))
{
return;
}
_sourceFiles.AddRange(export.SourceReferences.Select(source => source.ResolvedPath));
_projectReferenes.Add(desc);
}
public static IEnumerable <MetadataReference> GetMetadataReferences(this LibraryExport export, bool throwOnError = true)
{
var references = new List <MetadataReference>();
AssemblyMetadata assemblyMetadata;
foreach (var lib in export.CompilationAssemblies)
{
try
{
using (var stream = File.OpenRead(lib.ResolvedPath))
{
var moduleMetadata = ModuleMetadata.CreateFromStream(stream, PEStreamOptions.PrefetchMetadata);
assemblyMetadata = AssemblyMetadata.Create(moduleMetadata);
references.Add(assemblyMetadata.GetReference());
}
}
catch (Exception ex)
when(ex is FileNotFoundException ||
ex is DirectoryNotFoundException ||
ex is NotSupportedException ||
ex is ArgumentException ||
ex is ArgumentOutOfRangeException ||
ex is BadImageFormatException ||
ex is IOException ||
ex is ArgumentNullException)
{
// TODO: Log this
if (throwOnError)
{
throw ex;
}
continue;
}
}
return(references);
}
private static void CopyExport(string outputPath, LibraryExport export)
{
CopyFiles(export.RuntimeAssemblies, outputPath);
CopyFiles(export.NativeLibraries, outputPath);
}
internal static IEnumerable <LibraryAsset> RuntimeAssets(this LibraryExport export)
{
return(export.RuntimeAssemblies.Union(export.NativeLibraries));
}
public LibraryExportWrapper(
LibraryExport internalExports, IReadOnlyList <LibraryExport> additionalExports)
: base(JoinMetadataReferences(internalExports, additionalExports),
JoinSourceReferences(internalExports, additionalExports))
{
}
public void AddAdditionalLibraryExportRegistrations(string name, LibraryExport additionalRegistration)
{
AdditionalLibraryExportRegistrations[name] = additionalRegistration;
}
internal static IEnumerable <string> RuntimeAssets(this LibraryExport export)
{
return(export.RuntimeAssemblies.Union(export.NativeLibraries)
.Select(e => e.ResolvedPath)
.Union(export.RuntimeAssets));
}
private static IEnumerable <string> GenerateLines(LibraryExport export)
{
return(GenerateLines(export, export.RuntimeAssemblies, "runtime")
.Union(GenerateLines(export, export.NativeLibraries, "native")));
}
private Library GetLibrary(LibraryExport export,
bool runtime,
IDictionary <string, Dependency> dependencyLookup)
{
var type = export.Library.Identity.Type;
// TEMPORARY: All packages are serviceable in RC2
// See https://github.com/dotnet/cli/issues/2569
var serviceable = (export.Library as PackageDescription) != null;
var libraryDependencies = new HashSet <Dependency>();
foreach (var libraryDependency in export.Library.Dependencies)
{
// skip build time dependencies
if (libraryDependency.Type.Equals(LibraryDependencyType.Build))
{
continue;
}
Dependency dependency;
if (dependencyLookup.TryGetValue(libraryDependency.Name, out dependency))
{
libraryDependencies.Add(dependency);
}
}
if (runtime)
{
return(new RuntimeLibrary(
type.ToString().ToLowerInvariant(),
export.Library.Identity.Name,
export.Library.Identity.Version.ToString(),
export.Library.Hash,
export.RuntimeAssemblyGroups.Select(CreateRuntimeAssetGroup).ToArray(),
export.NativeLibraryGroups.Select(CreateRuntimeAssetGroup).ToArray(),
export.ResourceAssemblies.Select(CreateResourceAssembly),
libraryDependencies,
serviceable,
GetLibraryPath(export.Library),
GetLibraryHashPath(export.Library)));
}
else
{
IEnumerable <string> assemblies;
if (type == LibraryType.ReferenceAssembly)
{
assemblies = ResolveReferenceAssembliesPath(export.CompilationAssemblies);
}
else
{
assemblies = export.CompilationAssemblies.Select(libraryAsset => libraryAsset.RelativePath);
}
return(new CompilationLibrary(
type.ToString().ToLowerInvariant(),
export.Library.Identity.Name,
export.Library.Identity.Version.ToString(),
export.Library.Hash,
assemblies,
libraryDependencies,
serviceable,
GetLibraryPath(export.Library),
GetLibraryHashPath(export.Library)));
}
}
private Library GetLibrary(LibraryExport export,
bool runtime,
IDictionary <string, Dependency> dependencyLookup)
{
var type = export.Library.Identity.Type;
var serviceable = (export.Library as PackageDescription)?.Library.IsServiceable ?? false;
var libraryDependencies = new HashSet <Dependency>();
var libraryAssets = runtime ? export.RuntimeAssemblies : export.CompilationAssemblies;
foreach (var libraryDependency in export.Library.Dependencies)
{
// skip build time dependencies
if (!libraryDependency.Type.HasFlag(
LibraryDependencyTypeFlag.MainReference |
LibraryDependencyTypeFlag.MainExport |
LibraryDependencyTypeFlag.RuntimeComponent |
LibraryDependencyTypeFlag.BecomesNupkgDependency))
{
continue;
}
Dependency dependency;
if (dependencyLookup.TryGetValue(libraryDependency.Name, out dependency))
{
libraryDependencies.Add(dependency);
}
}
IEnumerable <string> assemblies;
if (type == LibraryType.ReferenceAssembly)
{
assemblies = ResolveReferenceAssembliesPath(libraryAssets);
}
else
{
assemblies = libraryAssets.Select(libraryAsset => libraryAsset.RelativePath);
}
if (runtime)
{
return(new RuntimeLibrary(
type.ToString().ToLowerInvariant(),
export.Library.Identity.Name,
export.Library.Identity.Version.ToString(),
export.Library.Hash,
assemblies.Select(RuntimeAssembly.Create),
export.ResourceAssemblies.Select(CreateResourceAssembly),
export.RuntimeTargets.Select(CreateRuntimeTarget),
libraryDependencies,
serviceable
));
}
else
{
return(new CompilationLibrary(
type.ToString().ToLowerInvariant(),
export.Library.Identity.Name,
export.Library.Identity.Version.ToString(),
export.Library.Hash,
assemblies,
libraryDependencies,
serviceable
));
}
}
private void ProcessExport(LibraryExport export,
IDictionary<string, IMetadataReference> metadataReferences,
IDictionary<string, ISourceReference> sourceReferences)
{
var references = new List<IMetadataReference>(export.MetadataReferences);
foreach (var reference in references)
{
metadataReferences[reference.Name] = reference;
}
if (sourceReferences != null)
{
foreach (var sourceReference in export.SourceReferences)
{
sourceReferences[sourceReference.Name] = sourceReference;
}
}
}
/// <summary>
/// Filters which export's RuntimeAssets should get copied to the output path.
/// </summary>
/// <returns>
/// True if the asset should be copied to the output path; otherwise, false.
/// </returns>
private static bool ShouldCopyExportRuntimeAsset(ProjectContext context, OutputPaths buildOutputPaths, LibraryExport export, LibraryAsset asset)
{
// The current project has the host .exe in its runtime assets, but it shouldn't be copied
// to the output path during publish. The host will come from the export that has the real host in it.
if (context.RootProject.Identity == export.Library.Identity)
{
if (asset.ResolvedPath == buildOutputPaths.RuntimeFiles.Executable)
{
return(false);
}
}
return(true);
}
private static Library GetLibrary(LibraryExport export,
NuGetFramework target,
string configuration,
bool runtime,
IDictionary <string, Dependency> dependencyLookup)
{
var type = export.Library.Identity.Type;
var serviceable = (export.Library as PackageDescription)?.Library.IsServiceable ?? false;
var libraryDependencies = new List <Dependency>();
var libraryAssets = runtime ? export.RuntimeAssemblies : export.CompilationAssemblies;
foreach (var libraryDependenciesGroup in export.Library.Dependencies.GroupBy(d => d.Name))
{
LibraryRange libraryDependency = libraryDependenciesGroup
.OrderByDescending(d => d.Target == LibraryType.ReferenceAssembly)
.First();
Dependency dependency;
if (dependencyLookup.TryGetValue(libraryDependency.Name, out dependency))
{
libraryDependencies.Add(dependency);
}
}
string[] assemblies;
if (type == LibraryType.Project)
{
var isExe = ((ProjectDescription)export.Library)
.Project
.GetCompilerOptions(target, configuration)
.EmitEntryPoint
.GetValueOrDefault(false);
isExe &= target.IsDesktop();
assemblies = new[] { export.Library.Identity.Name + (isExe ? ".exe" : ".dll") };
}
else if (type == LibraryType.ReferenceAssembly)
{
assemblies = ResolveReferenceAssembliesPath(libraryAssets);
}
else
{
assemblies = libraryAssets.Select(libraryAsset => libraryAsset.RelativePath).ToArray();
}
if (runtime)
{
return(new RuntimeLibrary(
type.ToString().ToLowerInvariant(),
export.Library.Identity.Name,
export.Library.Identity.Version.ToString(),
export.Library.Hash,
assemblies,
libraryDependencies.ToArray(),
serviceable
));
}
else
{
return(new CompilationLibrary(
type.ToString().ToLowerInvariant(),
export.Library.Identity.Name,
export.Library.Identity.Version.ToString(),
export.Library.Hash,
assemblies,
libraryDependencies.ToArray(),
serviceable
));
}
}
