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 )); } }