public bool Build()
{
var projectDiagnostics = new List<ICompilationMessage>();
Runtime.Project project;
if (!Runtime.Project.TryGetProject(_buildOptions.ProjectDir, out project, projectDiagnostics))
{
LogError(string.Format("Unable to locate {0}.", Runtime.Project.ProjectFileName));
return false;
}
var sw = Stopwatch.StartNew();
var baseOutputPath = GetBuildOutputDir(_buildOptions);
var configurations = _buildOptions.Configurations.DefaultIfEmpty("Debug");
string frameworkSelectionError;
var frameworks = FrameworkSelectionHelper.SelectFrameworks(project,
_buildOptions.TargetFrameworks,
_applicationEnvironment.RuntimeFramework,
out frameworkSelectionError);
if (frameworks == null)
{
LogError(frameworkSelectionError);
return false;
}
if (_buildOptions.GeneratePackages &&
!ScriptExecutor.Execute(project, "prepack", GetScriptVariable))
{
LogError(ScriptExecutor.ErrorMessage);
return false;
}
if (!ScriptExecutor.Execute(project, "prebuild", GetScriptVariable))
{
LogError(ScriptExecutor.ErrorMessage);
return false;
}
var success = true;
var allDiagnostics = new List<ICompilationMessage>();
var cacheContextAccessor = new CacheContextAccessor();
var cache = new Cache(cacheContextAccessor);
PackageBuilder packageBuilder = null;
PackageBuilder symbolPackageBuilder = null;
InstallBuilder installBuilder = 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(project, packageBuilder);
InitializeBuilder(project, symbolPackageBuilder);
installBuilder = new InstallBuilder(project, packageBuilder, _buildOptions.Reports);
}
var configurationSuccess = true;
baseOutputPath = 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}",
project.Name, targetFramework.ToString().Yellow().Bold());
var diagnostics = new List<ICompilationMessage>();
var context = new BuildContext(_hostServices,
_applicationEnvironment,
cache,
cacheContextAccessor,
project,
targetFramework,
configuration,
baseOutputPath);
context.Initialize(_buildOptions.Reports.Quiet);
if (context.Build(diagnostics))
{
if (_buildOptions.GeneratePackages)
{
context.PopulateDependencies(packageBuilder);
context.AddLibs(packageBuilder, "*.dll");
context.AddLibs(packageBuilder, "*.xml");
context.AddLibs(symbolPackageBuilder, "*.*");
}
}
else
{
configurationSuccess = false;
}
allDiagnostics.AddRange(diagnostics);
WriteDiagnostics(diagnostics);
}
success = success && configurationSuccess;
if (_buildOptions.GeneratePackages)
{
// Create a package per configuration
string nupkg = GetPackagePath(project, baseOutputPath);
string symbolsNupkg = GetPackagePath(project, baseOutputPath, symbols: true);
if (configurationSuccess)
{
// Generates the application package only if this is an application packages
configurationSuccess = installBuilder.Build(baseOutputPath);
success = success && configurationSuccess;
}
if (configurationSuccess)
{
foreach (var sharedFile in project.Files.SharedFiles)
{
var file = new PhysicalPackageFile();
file.SourcePath = sharedFile;
file.TargetPath = String.Format(@"shared\{0}", Path.GetFileName(sharedFile));
packageBuilder.Files.Add(file);
}
var root = project.ProjectDirectory;
foreach (var path in project.Files.SourceFiles)
{
var srcFile = new PhysicalPackageFile();
srcFile.SourcePath = path;
srcFile.TargetPath = Path.Combine("src", PathUtility.GetRelativePath(root, path));
symbolPackageBuilder.Files.Add(srcFile);
}
using (var fs = File.Create(nupkg))
{
packageBuilder.Save(fs);
_buildOptions.Reports.Quiet.WriteLine("{0} -> {1}", project.Name, nupkg);
}
if (symbolPackageBuilder.Files.Any())
{
using (var fs = File.Create(symbolsNupkg))
{
symbolPackageBuilder.Save(fs);
}
_buildOptions.Reports.Quiet.WriteLine("{0} -> {1}", project.Name, symbolsNupkg);
}
}
}
}
if (!ScriptExecutor.Execute(project, "postbuild", GetScriptVariable))
{
LogError(ScriptExecutor.ErrorMessage);
return false;
}
if (_buildOptions.GeneratePackages &&
!ScriptExecutor.Execute(project, "postpack", GetScriptVariable))
{
LogError(ScriptExecutor.ErrorMessage);
return 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;
}
private bool BuildInternal(string projectPath)
{
var projectDiagnostics = new List <ICompilationMessage>();
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 <ICompilationMessage>();
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 <ICompilationMessage>();
var context = new BuildContext(_hostServices,
_applicationEnvironment,
_cache,
_cacheContextAccessor,
_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, "*.*");
}
}
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)
{
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;
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);
}
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));
}
}
}
}
}
if (!success)
{
return(false);
}
if (!ScriptExecutor.Execute(_currentProject, "postbuild", GetScriptVariable))
{
LogError(ScriptExecutor.ErrorMessage);
return(false);
}
if (_buildOptions.GeneratePackages &&
!ScriptExecutor.Execute(_currentProject, "postpack", GetScriptVariable))
{
LogError(ScriptExecutor.ErrorMessage);
return(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);
}