private void WriteDepsFileAndCopyProjectDependencies(LibraryExporter exporter) { var exports = exporter.GetAllExports().ToList(); var exportsLookup = exports.ToDictionary(e => e.Library.Identity.Name, StringComparer.OrdinalIgnoreCase); var platformExclusionList = _context.GetPlatformExclusionList(exportsLookup); var filteredExports = exports.FilterExports(platformExclusionList); WriteConfigurationFiles(exports, filteredExports, exports, includeDevConfig: true); var projectExports = exporter.GetAllProjectTypeDependencies(); CopyAssemblies(projectExports); CopyAssets(projectExports); var packageExports = exporter.GetDependencies(LibraryType.Package); CopyAssets(packageExports); }
/// <summary> /// Publish the project for given 'framework (ex - netcoreapp1.0)' and 'runtimeID (ex - win7-x64)' /// </summary> /// <param name="context">project that is to be published</param> /// <param name="baseOutputPath">Location of published files</param> /// <param name="configuration">Debug or Release</param> /// <param name="nativeSubdirectories"></param> /// <returns>Return 0 if successful else return non-zero</returns> private bool PublishProjectContext(ProjectContext context, string buildBasePath, string outputPath, string configuration, bool nativeSubdirectories) { var target = context.TargetFramework.DotNetFrameworkName; if (!string.IsNullOrEmpty(context.RuntimeIdentifier)) { target = $"{target}/{context.RuntimeIdentifier}"; } Reporter.Output.WriteLine($"Publishing {context.RootProject.Identity.Name.Yellow()} for {target.Yellow()}"); var options = context.ProjectFile.GetCompilerOptions(context.TargetFramework, configuration); var outputPaths = context.GetOutputPaths(configuration, buildBasePath, outputPath); if (string.IsNullOrEmpty(outputPath)) { outputPath = Path.Combine(outputPaths.RuntimeOutputPath, PublishSubfolderName); } var contextVariables = new Dictionary <string, string> { { "publish:ProjectPath", context.ProjectDirectory }, { "publish:Configuration", configuration }, { "publish:OutputPath", outputPath }, { "publish:TargetFramework", context.TargetFramework.GetShortFolderName() }, { "publish:FullTargetFramework", context.TargetFramework.DotNetFrameworkName }, { "publish:Runtime", context.RuntimeIdentifier }, }; RunScripts(context, ScriptNames.PrePublish, contextVariables); if (!Directory.Exists(outputPath)) { Directory.CreateDirectory(outputPath); } // Compile the project (and transitively, all it's dependencies) if (ShouldBuild && !InvokeBuildOnProject(context, buildBasePath, configuration)) { return(false); } // Use a library exporter to collect publish assets var exporter = context.CreateExporter(configuration, buildBasePath); // Get the output paths used by the call to `dotnet build` above (since we didn't pass `--output`, they will be different from // our current output paths) var buildOutputPaths = context.GetOutputPaths(configuration, buildBasePath); var exports = exporter.GetAllExports(); var exportsLookup = exports.ToDictionary(e => e.Library.Identity.Name, StringComparer.OrdinalIgnoreCase); var platformExclusionList = context.GetPlatformExclusionList(exportsLookup); var buildExclusionList = context.GetTypeBuildExclusionList(exportsLookup); var allExclusionList = new HashSet <string>(platformExclusionList); allExclusionList.UnionWith(buildExclusionList); var filteredExports = exports.FilterExports(allExclusionList); foreach (var export in filteredExports) { Reporter.Verbose.WriteLine($"publish: Publishing {export.Library.Identity.ToString().Green().Bold()} ..."); PublishAssetGroups(export.RuntimeAssemblyGroups, outputPath, nativeSubdirectories: false, includeRuntimeGroups: context.IsPortable); PublishAssetGroups(export.NativeLibraryGroups, outputPath, nativeSubdirectories, includeRuntimeGroups: context.IsPortable); var runtimeAssetsToCopy = export.RuntimeAssets.Where(a => ShouldCopyExportRuntimeAsset(context, buildOutputPaths, export, a)); runtimeAssetsToCopy.StructuredCopyTo(outputPath, outputPaths.IntermediateOutputDirectoryPath); foreach (var resourceAsset in export.ResourceAssemblies) { var dir = Path.Combine(outputPath, resourceAsset.Locale); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } File.Copy(resourceAsset.Asset.ResolvedPath, Path.Combine(dir, resourceAsset.Asset.FileName), overwrite: true); } } foreach (var export in exports) { if (options.PreserveCompilationContext.GetValueOrDefault()) { PublishRefs(export, outputPath); } } if (context.ProjectFile.HasRuntimeOutput(configuration) && !context.TargetFramework.IsDesktop()) { // Make executable in the new location var executable = new Executable(context, buildOutputPaths, outputPath, buildOutputPaths.IntermediateOutputDirectoryPath, exporter, configuration); var runtimeExports = filteredExports; var compilationExports = exports.FilterExports(buildExclusionList); executable.WriteConfigurationFiles(exports, runtimeExports, compilationExports, includeDevConfig: false); } var contentFiles = new ContentFiles(context); if (context.ProjectFile.PublishOptions != null) { var includeEntries = IncludeFilesResolver.GetIncludeFiles( context.ProjectFile.PublishOptions, PathUtility.EnsureTrailingSlash(outputPath), diagnostics: null); contentFiles.StructuredCopyTo(outputPath, includeEntries); } else { contentFiles.StructuredCopyTo(outputPath); } // Publish a host if this is an application if (options.EmitEntryPoint.GetValueOrDefault() && !string.IsNullOrEmpty(context.RuntimeIdentifier)) { Reporter.Verbose.WriteLine($"publish: Renaming native host in output to create fully standalone output."); RenamePublishedHost(context, outputPath, options); } RunScripts(context, ScriptNames.PostPublish, contextVariables); Reporter.Output.WriteLine($"publish: Published to {outputPath}".Green().Bold()); return(true); }