public int Execute() { _options.Reports.Information.WriteLine("Listing dependencies for {0} ({1})", _options.Project.Name, _options.Project.ProjectFilePath); string frameworkSelectionError; var frameworks = FrameworkSelectionHelper.SelectFrameworks(_options.Project, _options.TargetFrameworks, _fallbackFramework, out frameworkSelectionError); if (frameworks == null) { _options.Reports.Error.WriteLine(frameworkSelectionError); return(1); } foreach (var framework in frameworks) { var operation = new DependencyListOperation(_options, framework); if (!operation.Execute()) { _options.Reports.Error.WriteLine("There was an error listing the dependencies"); return(3); } } return(0); }
private bool BuildInternal(string projectPath) { var projectDiagnostics = new List <DiagnosticMessage>(); if (!Runtime.Project.TryGetProject(projectPath, out _currentProject, projectDiagnostics)) { LogError(string.Format("Unable to locate {0}.", Runtime.Project.ProjectFileName)); return(false); } var sw = Stopwatch.StartNew(); var baseOutputPath = GetBuildOutputDir(_currentProject); var configurations = _buildOptions.Configurations.DefaultIfEmpty("Debug"); string frameworkSelectionError; var frameworks = FrameworkSelectionHelper.SelectFrameworks(_currentProject, _buildOptions.TargetFrameworks, _applicationEnvironment.RuntimeFramework, out frameworkSelectionError); if (frameworks == null) { LogError(frameworkSelectionError); return(false); } var success = true; var allDiagnostics = new List <DiagnosticMessage>(); // Build all specified configurations foreach (var configuration in configurations) { success &= BuildConfiguration(baseOutputPath, frameworks, allDiagnostics, configuration); } sw.Stop(); if (projectDiagnostics.Any()) { // Add a new line to separate the project diagnostics information from compilation diagnostics _buildOptions.Reports.Information.WriteLine(); projectDiagnostics.ForEach(d => LogWarning(d.FormattedMessage)); } allDiagnostics.AddRange(projectDiagnostics); WriteSummary(allDiagnostics); _buildOptions.Reports.Information.WriteLine("Time elapsed {0}", sw.Elapsed); return(success); }
private bool BuildInternal(string projectPath) { var projectDiagnostics = new List <DiagnosticMessage>(); if (!Runtime.Project.TryGetProject(projectPath, out _currentProject, projectDiagnostics)) { LogError(string.Format("Unable to locate {0}.", Runtime.Project.ProjectFileName)); return(false); } var sw = Stopwatch.StartNew(); var baseOutputPath = GetBuildOutputDir(_currentProject); var configurations = _buildOptions.Configurations.DefaultIfEmpty("Debug"); string frameworkSelectionError; var frameworks = FrameworkSelectionHelper.SelectFrameworks(_currentProject, _buildOptions.TargetFrameworks, _applicationEnvironment.RuntimeFramework, out frameworkSelectionError); if (frameworks == null) { LogError(frameworkSelectionError); return(false); } if (_buildOptions.GeneratePackages && !ScriptExecutor.Execute(_currentProject, "prepack", GetScriptVariable)) { LogError(ScriptExecutor.ErrorMessage); return(false); } if (!ScriptExecutor.Execute(_currentProject, "prebuild", GetScriptVariable)) { LogError(ScriptExecutor.ErrorMessage); return(false); } var success = true; var allDiagnostics = new List <DiagnosticMessage>(); PackageBuilder packageBuilder = null; PackageBuilder symbolPackageBuilder = null; InstallBuilder installBuilder = null; SourceBuilder sourceBuilder = null; // Build all specified configurations foreach (var configuration in configurations) { if (_buildOptions.GeneratePackages) { // Create a new builder per configuration packageBuilder = new PackageBuilder(); symbolPackageBuilder = new PackageBuilder(); InitializeBuilder(_currentProject, packageBuilder); InitializeBuilder(_currentProject, symbolPackageBuilder); installBuilder = new InstallBuilder(_currentProject, packageBuilder, _buildOptions.Reports); sourceBuilder = new SourceBuilder(_currentProject, packageBuilder, _buildOptions.Reports); } var configurationSuccess = true; var outputPath = Path.Combine(baseOutputPath, configuration); // Build all target frameworks a project supports foreach (var targetFramework in frameworks) { _buildOptions.Reports.Information.WriteLine(); _buildOptions.Reports.Information.WriteLine("Building {0} for {1}", _currentProject.Name, targetFramework.ToString().Yellow().Bold()); var diagnostics = new List <DiagnosticMessage>(); var context = new BuildContext(_compilationEngine, _currentProject, targetFramework, configuration, outputPath); context.Initialize(_buildOptions.Reports.Quiet); if (context.Build(diagnostics)) { if (_buildOptions.GeneratePackages) { context.PopulateDependencies(packageBuilder); context.AddLibs(packageBuilder, "*.dll"); context.AddLibs(packageBuilder, "*.xml"); context.PopulateDependencies(symbolPackageBuilder); context.AddLibs(symbolPackageBuilder, "*.*"); context.AddLibs(packageBuilder, "*.resources.dll", recursiveSearch: true); } } else { configurationSuccess = false; } allDiagnostics.AddRange(diagnostics); WriteDiagnostics(diagnostics); } success = success && configurationSuccess; if (_buildOptions.GeneratePackages) { // Create a package per configuration string nupkg = GetPackagePath(_currentProject, outputPath); string symbolsNupkg = GetPackagePath(_currentProject, outputPath, symbols: true); if (configurationSuccess) { // Generates the application package only if this is an application packages configurationSuccess = installBuilder.Build(outputPath); success = success && configurationSuccess; } if (configurationSuccess) { configurationSuccess = sourceBuilder.Build(outputPath); success = success && configurationSuccess; } if (configurationSuccess) { var packDiagnostics = new List <DiagnosticMessage>(); foreach (var sharedFile in _currentProject.Files.SharedFiles) { var file = new PhysicalPackageFile(); file.SourcePath = sharedFile; file.TargetPath = String.Format(@"shared\{0}", Path.GetFileName(sharedFile)); packageBuilder.Files.Add(file); } var root = _currentProject.ProjectDirectory; if (_currentProject.Files.PackInclude != null && _currentProject.Files.PackInclude.Any()) { AddPackageFiles(_currentProject.ProjectDirectory, _currentProject.Files.PackInclude, packageBuilder, packDiagnostics); } success &= !packDiagnostics.HasErrors(); allDiagnostics.AddRange(packDiagnostics); foreach (var path in _currentProject.Files.SourceFiles) { var srcFile = new PhysicalPackageFile(); srcFile.SourcePath = path; srcFile.TargetPath = Path.Combine("src", PathUtility.GetRelativePath(root, path)); symbolPackageBuilder.Files.Add(srcFile); } // Write the packages as long as we're still in a success state. if (success) { using (var fs = File.Create(nupkg)) { packageBuilder.Save(fs); _buildOptions.Reports.Quiet.WriteLine("{0} -> {1}", _currentProject.Name, Path.GetFullPath(nupkg)); } if (symbolPackageBuilder.Files.Any()) { using (var fs = File.Create(symbolsNupkg)) { symbolPackageBuilder.Save(fs); _buildOptions.Reports.Quiet.WriteLine("{0} -> {1}", _currentProject.Name, Path.GetFullPath(symbolsNupkg)); } } } WriteDiagnostics(packDiagnostics); } } } // Run post-build steps if (success) { if (!ScriptExecutor.Execute(_currentProject, "postbuild", GetScriptVariable)) { LogError(ScriptExecutor.ErrorMessage); success = false; } if (_buildOptions.GeneratePackages && !ScriptExecutor.Execute(_currentProject, "postpack", GetScriptVariable)) { LogError(ScriptExecutor.ErrorMessage); success = false; } } sw.Stop(); if (projectDiagnostics.Any()) { // Add a new line to separate the project diagnostics information from compilation diagnostics _buildOptions.Reports.Information.WriteLine(); projectDiagnostics.ForEach(d => LogWarning(d.FormattedMessage)); } allDiagnostics.AddRange(projectDiagnostics); WriteSummary(allDiagnostics); _buildOptions.Reports.Information.WriteLine("Time elapsed {0}", sw.Elapsed); return(success); }
public bool Publish() { var warnings = new List <DiagnosticMessage>(); Runtime.Project project; if (!Runtime.Project.TryGetProject(_options.ProjectDir, out project, warnings)) { _options.Reports.Error.WriteLine("Unable to locate {0}.".Red(), Runtime.Project.ProjectFileName); return(false); } foreach (var warning in warnings) { _options.Reports.Information.WriteLine(warning.FormattedMessage.Yellow()); } if (string.IsNullOrEmpty(_options.WwwRoot) && File.Exists(Path.Combine(project.ProjectDirectory, "hosting.json"))) { var jsonObj = JObject.Parse(File.ReadAllText(Path.Combine(project.ProjectDirectory, "hosting.json"))); _options.WwwRoot = PublishOperations.GetWebRootJson(jsonObj)?.ToString(); } if (string.IsNullOrEmpty(_options.WwwRoot) && Directory.Exists(Path.Combine(project.ProjectDirectory, "wwwroot"))) { _options.WwwRoot = "wwwroot"; } _options.WwwRoot = _options.WwwRoot ?? ""; _options.WwwRootOut = _options.WwwRootOut ?? _options.WwwRoot; if (string.IsNullOrEmpty(_options.WwwRoot) && !string.IsNullOrEmpty(_options.WwwRootOut)) { _options.Reports.Error.WriteLine( "'--wwwroot-out' option can be used only when the '--wwwroot' option or 'webroot' in project.json is specified.".Red()); return(false); } if (string.Equals(_options.WwwRootOut, PublishRoot.AppRootName, StringComparison.OrdinalIgnoreCase)) { _options.Reports.Error.WriteLine( "'{0}' is a reserved folder name. Please choose another name for the wwwroot-out folder.".Red(), PublishRoot.AppRootName); return(false); } var sw = Stopwatch.StartNew(); string outputPath = _options.OutputDir; var projectDir = project.ProjectDirectory; var frameworkContexts = new Dictionary <Tuple <FrameworkName, string>, DependencyContext>(); var root = new PublishRoot(project, outputPath, _options.Reports) { Configuration = _options.Configuration, NoSource = _options.NoSource, IncludeSymbols = _options.IncludeSymbols, IISCommand = _options.IISCommand }; Func <string, string> getVariable = key => { return(null); }; if (!ScriptExecutor.Execute(project, "prepare", getVariable)) { _options.Reports.Error.WriteLine(ScriptExecutor.ErrorMessage); return(false); } if (!ScriptExecutor.Execute(project, "prepublish", getVariable)) { _options.Reports.Error.WriteLine(ScriptExecutor.ErrorMessage); return(false); } if (!ResolveActualRuntimeNames(_options.Runtimes)) { return(false); } foreach (var runtime in _options.Runtimes) { // Calculate the runtime name by taking the last path segment (since it could be a path), // but first strip off any trailing '\' or '/' in case the path provided was something like // "C:\Foo\Bar\dnx-clr-win-x64...\" var runtimeName = new DirectoryInfo(runtime).Name; var frameworkName = DependencyContext.SelectFrameworkNameForRuntime( project.GetTargetFrameworks().Select(x => x.FrameworkName), runtimeName); if (frameworkName == null) { _options.Reports.Error.WriteLine( "The project being published does not support the runtime '{0}'", runtime.ToString().Red().Bold()); return(false); } var runtimeLocated = TryAddRuntime(root, frameworkName, runtime); List <string> runtimeProbePaths = null; if (!runtimeLocated) { runtimeProbePaths = new List <string>(); runtimeProbePaths.Add(runtime); var runtimeHome = Environment.GetEnvironmentVariable(EnvironmentNames.Home); var pathSeparator = Path.PathSeparator; if (string.IsNullOrEmpty(runtimeHome)) { var runtimeGlobalPath = DnuEnvironment.GetFolderPath(DnuFolderPath.DnxGlobalPath); var defaultRuntimeHome = DnuEnvironment.GetFolderPath(DnuFolderPath.DefaultDnxHome); runtimeHome = $"{defaultRuntimeHome}{pathSeparator}{runtimeGlobalPath}"; } foreach (var portion in runtimeHome.Split(new[] { pathSeparator }, StringSplitOptions.RemoveEmptyEntries)) { var packagesPath = Path.Combine( Environment.ExpandEnvironmentVariables(portion), "runtimes", runtime); if (TryAddRuntime(root, frameworkName, packagesPath)) { runtimeLocated = true; break; } runtimeProbePaths.Add(packagesPath); } } if (!runtimeLocated) { _options.Reports.Error.WriteLine(string.Format("Unable to locate runtime '{0}'", runtime.Red().Bold())); if (runtimeProbePaths != null) { _options.Reports.Error.WriteLine(string.Format("Locations probed:{0}{1}", Environment.NewLine, string.Join(Environment.NewLine, runtimeProbePaths))); } return(false); } if (!frameworkContexts.ContainsKey(Tuple.Create(frameworkName, string.Empty))) { frameworkContexts[Tuple.Create(frameworkName, string.Empty)] = CreateDependencyContext(project, frameworkName, Enumerable.Empty <string>()); } foreach (var rid in DependencyContext.GetRuntimeIdentifiers(runtimeName)) { root.RuntimeIdentifiers.Add(rid); if (!frameworkContexts.ContainsKey(Tuple.Create(frameworkName, rid))) { frameworkContexts[Tuple.Create(frameworkName, rid)] = CreateDependencyContext(project, frameworkName, new[] { rid }); } } } // If there is no target framework filter specified with '--runtime', // the published output targets all frameworks specified in project.json if (!_options.Runtimes.Any()) { IEnumerable <FrameworkName> frameworksToPublish; if (!_options.TargetFrameworks.Any()) { frameworksToPublish = project .GetTargetFrameworks() .Select(fx => fx.FrameworkName); } else { string frameworkSelectionError; frameworksToPublish = FrameworkSelectionHelper.SelectFrameworks(project, _options.TargetFrameworks, _applicationEnvironment.RuntimeFramework, out frameworkSelectionError)?.ToList(); if (frameworksToPublish == null) { _options.Reports.WriteError(frameworkSelectionError); return(false); } foreach (var framework in frameworksToPublish) { root.Frameworks.Add(framework, null); } } // Add runtime IDs for the currently running platform foreach (var runtime in PlatformServices.Default.Runtime.GetDefaultRestoreRuntimes()) { root.RuntimeIdentifiers.Add(runtime); } foreach (var framework in frameworksToPublish) { if (!frameworkContexts.ContainsKey(Tuple.Create(framework, string.Empty))) { frameworkContexts[Tuple.Create(framework, string.Empty)] = CreateDependencyContext(project, framework, Enumerable.Empty <string>()); } foreach (var rid in RuntimeEnvironmentHelper.RuntimeEnvironment.GetDefaultRestoreRuntimes()) { root.RuntimeIdentifiers.Add(rid); if (!frameworkContexts.ContainsKey(Tuple.Create(framework, rid))) { frameworkContexts[Tuple.Create(framework, rid)] = CreateDependencyContext(project, framework, new[] { rid }); } } } } if (!frameworkContexts.Any()) { // We can only get here if the project has no frameworks section, which we don't actually support any more _options.Reports.Error.WriteLine("The project being published has no frameworks listed in the 'frameworks' section."); return(false); } root.SourcePackagesPath = frameworkContexts.First().Value.PackagesDirectory; bool anyUnresolvedDependency = false; foreach (var dependencyContext in frameworkContexts.Values) { foreach (var library in dependencyContext.LibraryManager.GetLibraryDescriptions()) { if (!library.Resolved) { // If there's any unresolved dependencies then complain and keep working _options.Reports.Quiet.WriteLine(" Unable to resolve dependency {0}", library.Identity.ToString().Red().Bold()); anyUnresolvedDependency = true; } else { if (library.Type == Runtime.LibraryTypes.Project) { if (!root.Projects.Any(p => p.Library.Name == library.Identity.Name)) { var publishProject = new PublishProject((ProjectDescription)library); if (publishProject.Library.Name == project.Name) { publishProject.WwwRoot = _options.WwwRoot; publishProject.WwwRootOut = _options.WwwRootOut; } root.Projects.Add(publishProject); } } else if (library.Type == Runtime.LibraryTypes.Package) { if (!root.Packages.Any(p => p.Library.Name == library.Identity.Name && p.Library.Version == library.Identity.Version)) { root.Packages.Add(new PublishPackage((PackageDescription)library)); } } } } } NativeImageGenerator nativeImageGenerator = null; if (_options.Native) { nativeImageGenerator = NativeImageGenerator.Create(_options, root, frameworkContexts.Values); if (nativeImageGenerator == null) { _options.Reports.Error.WriteLine("Fail to initiate native image generation process.".Red()); return(false); } } var success = root.Emit(); if (!ScriptExecutor.Execute(project, "postpublish", getVariable)) { _options.Reports.Error.WriteLine(ScriptExecutor.ErrorMessage); return(false); } if (_options.Native && !nativeImageGenerator.BuildNativeImages(root)) { _options.Reports.Error.WriteLine("Native image generation failed."); return(false); } sw.Stop(); _options.Reports.Information.WriteLine("Time elapsed {0}", sw.Elapsed); return(!anyUnresolvedDependency && success); }