protected async Task <BuildInfo> BuildAsync(string taskName, MSB.Framework.ITaskHost taskHost, CancellationToken cancellationToken) { // create a project instance to be executed by build engine. // The executed project will hold the final model of the project after execution via msbuild. var executedProject = _loadedProject.CreateProjectInstance(); if (!executedProject.Targets.ContainsKey("Compile")) { return(new BuildInfo(executedProject, null)); } var hostServices = new Microsoft.Build.Execution.HostServices(); // connect the host "callback" object with the host services, so we get called back with the exact inputs to the compiler task. hostServices.RegisterHostObject(_loadedProject.FullPath, "CoreCompile", taskName, taskHost); var buildParameters = new MSB.Execution.BuildParameters(_loadedProject.ProjectCollection); var buildRequestData = new MSB.Execution.BuildRequestData(executedProject, new string[] { "Compile" }, hostServices); BuildResult result = await this.BuildAsync(buildParameters, buildRequestData, cancellationToken).ConfigureAwait(continueOnCapturedContext: false); if (result.OverallResult == BuildResultCode.Failure) { return(new BuildInfo(executedProject, result.Exception?.Message ?? "")); } else { return(new BuildInfo(executedProject, null)); } }
public static string[] Build(string solutionFile) { Console.Error.Write("// Building '{0}'... ", Path.GetFileName(solutionFile)); var pc = new ProjectCollection(); var parms = new BuildParameters(pc); var globalProperties = new Dictionary<string, string>(); var request = new BuildRequestData(solutionFile, globalProperties, null, new string[] { "Build" }, null); parms.Loggers = new[] { new ConsoleLogger(LoggerVerbosity.Quiet) }; var result = BuildManager.DefaultBuildManager.Build(parms, request); var resultFiles = new HashSet<string>(); Console.Error.WriteLine("done."); foreach (var kvp in result.ResultsByTarget) { var targetResult = kvp.Value; if (targetResult.Exception != null) Console.Error.WriteLine("// Compilation failed for target '{0}':\r\n{1}", kvp.Key, targetResult.Exception.Message); else { foreach (var filename in targetResult.Items) resultFiles.Add(filename.ItemSpec); } } return resultFiles.ToArray(); }
internal static async Task<BuildResult> BuildAsync(this BuildManager buildManager, ITestOutputHelper logger, ProjectCollection projectCollection, ProjectRootElement project, string target, IDictionary<string, string> globalProperties = null, LoggerVerbosity logVerbosity = LoggerVerbosity.Detailed, ILogger[] additionalLoggers = null) { Requires.NotNull(buildManager, nameof(buildManager)); Requires.NotNull(projectCollection, nameof(projectCollection)); Requires.NotNull(project, nameof(project)); globalProperties = globalProperties ?? new Dictionary<string, string>(); var projectInstance = new ProjectInstance(project, globalProperties, null, projectCollection); var brd = new BuildRequestData(projectInstance, new[] { target }, null, BuildRequestDataFlags.ProvideProjectStateAfterBuild); var parameters = new BuildParameters(projectCollection); var loggers = new List<ILogger>(); loggers.Add(new ConsoleLogger(logVerbosity, s => logger.WriteLine(s.TrimEnd('\r', '\n')), null, null)); loggers.AddRange(additionalLoggers); parameters.Loggers = loggers.ToArray(); buildManager.BeginBuild(parameters); var result = await buildManager.BuildAsync(brd); buildManager.EndBuild(); return result; }
/// <summary> /// Constructor /// </summary> public MockHost(BuildParameters buildParameters) { _buildParameters = buildParameters; _buildParameters.ProjectRootElementCache = new ProjectRootElementCache(false); _configCache = new ConfigCache(); ((IBuildComponent)_configCache).InitializeComponent(this); // We are a logging service _loggingService = this; _legacyThreadingData = new LegacyThreadingData(); _requestEngine = new BuildRequestEngine(); ((IBuildComponent)_requestEngine).InitializeComponent(this); _resultsCache = new ResultsCache(); ((IBuildComponent)_resultsCache).InitializeComponent(this); _requestBuilder = new Microsoft.Build.UnitTests.BackEnd.BuildRequestEngine_Tests.MockRequestBuilder(); ((IBuildComponent)_requestBuilder).InitializeComponent(this); _targetBuilder = new TestTargetBuilder(); ((IBuildComponent)_targetBuilder).InitializeComponent(this); }
public BuildResult Build (BuildParameters parameters, BuildRequestData requestData) { BeginBuild (parameters); var ret = BuildRequest (requestData); EndBuild (); return ret; }
private BuildResult Build(IEnumerable<ILogger> loggers) { // 1) Clean previous deployment. // 2) Do a build of the website project with the "Package" target. This will copy all // the necessary website files into a directory similar to the following: // MyProject/obj/Test/Package/PackageTmp var parameters = new BuildParameters { Loggers = loggers }; var projectFilePath = Path.Combine(_siteRoot, _projectFileName); var globalProperties = new Dictionary<string, string> { { "Configuration", "Test" } }; if (!string.IsNullOrWhiteSpace(_solutionDir)) globalProperties.Add("SolutionDir", _solutionDir); if (!string.IsNullOrWhiteSpace(_projectDir)) globalProperties.Add("ProjectDir", _projectDir); var requestData = new BuildRequestData( projectFilePath, globalProperties, null, _targets, null); return BuildManager.DefaultBuildManager.Build(parameters, requestData); }
static void Main(string[] args) { try { Console.WriteLine("LiteDevelop MSBuild"); var arguments = CommandLineArguments.Parse(args); if (!File.Exists(arguments.InputFile)) throw new ArgumentException("File does not exist."); var buildParameters = new BuildParameters(); buildParameters.DetailedSummary = arguments.DetailedSummary; buildParameters.Loggers = new ILogger[] { new ConsoleLogger() { Verbosity = arguments.Verbosity } }; Dictionary<string, string> properties = new Dictionary<string, string>(); var buildRequest = new BuildRequestData(arguments.InputFile, properties, null, new string[] { arguments.Target.ToString() }, null); // Microsoft.Build.Execution.BuildManager.DefaultBuildManager. var results = Microsoft.Build.Execution.BuildManager.DefaultBuildManager.Build(buildParameters, buildRequest); } catch (Exception ex) { Console.WriteLine("error: line=0 column=0 file=\"LiteDevelop.MSBuild.exe\" => " + ex.Message); Console.WriteLine("This program should only be executed by LiteDevelop itself. If you believe this is a bug, please report the issue."); } }
public static BuildResult Build(string projectOrSolution, string targets, Dictionary<string, string> properties = null, ILogger logger = null) { if (!Path.IsPathRooted(projectOrSolution)) projectOrSolution = Path.Combine(ModuleInitializer.BaseDirectory, projectOrSolution); if (!File.Exists(projectOrSolution)) throw new FileNotFoundException($"Project or solution to build {projectOrSolution} was not found.", projectOrSolution); // Without this, builds end up running in process and colliding with each other, // especially around the current directory used to resolve relative paths in projects. Environment.SetEnvironmentVariable("MSBUILDNOINPROCNODE", "1"); using (var manager = new BuildManager(Guid.NewGuid().ToString())) { properties = properties ?? new Dictionary<string, string>(); // If file is not a solution, build up a fake solution configuration so P2P references just work if (Path.GetExtension(projectOrSolution) != ".sln") AddSolutionConfiguration(projectOrSolution, properties); var request = new BuildRequestData(projectOrSolution, properties, "14.0", targets.Split(','), null); var parameters = new BuildParameters { GlobalProperties = properties, }; if (logger != null) parameters.Loggers = new[] { logger }; return manager.Build(parameters, request); } }
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark) { lock (buildLock) { var projectFileName = Path.Combine(generateResult.DirectoryPath, ClassicGenerator.MainClassName + ".csproj"); var exeFilePath = Path.Combine(generateResult.DirectoryPath, ClassicGenerator.MainClassName + ".exe"); var consoleLogger = new MsBuildConsoleLogger(logger); var globalProperties = new Dictionary<string, string>(); var buildRequest = new BuildRequestData(projectFileName, globalProperties, null, new[] { "Build" }, null); var buildParameters = new BuildParameters(new ProjectCollection()) { DetailedSummary = false, Loggers = new Microsoft.Build.Framework.ILogger[] { consoleLogger } }; var buildResult = BuildManager.DefaultBuildManager.Build(buildParameters, buildRequest); if (buildResult.OverallResult != BuildResultCode.Success && !File.Exists(exeFilePath)) { logger.WriteLineInfo("BuildManager.DefaultBuildManager can't build this project. =("); logger.WriteLineInfo("Let's try to build it via BuildBenchmark.bat!"); var buildProcess = new Process { StartInfo = { FileName = Path.Combine(generateResult.DirectoryPath, "BuildBenchmark.bat"), WorkingDirectory = generateResult.DirectoryPath, UseShellExecute = false, RedirectStandardOutput = false, } }; buildProcess.Start(); buildProcess.WaitForExit(); if (File.Exists(exeFilePath)) return new BuildResult(generateResult, true, null, exeFilePath); } return new BuildResult(generateResult, buildResult.OverallResult == BuildResultCode.Success, buildResult.Exception, exeFilePath); } }
public void PropertiesDefault () { var bp = new BuildParameters (); Assert.IsTrue (bp.EnableNodeReuse, "#1"); Assert.IsTrue (bp.EnvironmentProperties.Count > 0, "#2"); Assert.AreEqual (CultureInfo.CurrentCulture, bp.Culture, "#3"); }
public void Execute(WebsiteContext context) { Logger.Log("Building the solution..."); var solutionFilePath = Directory.GetFiles(context.CurrentDirectory).FirstOrDefault(x => x.EndsWith(".sln")); var properties = new Dictionary<string, string> { {"Configuration", "Debug"} }; var buildParameters = new BuildParameters(); var buildLoggger = new InMemoryBuildLogger(); buildParameters.Loggers = new[] {buildLoggger}; var buildRequest = new BuildRequestData(solutionFilePath, properties, null, new[] { "Build" }, null); var buildResult = BuildManager.DefaultBuildManager.Build(buildParameters, buildRequest); if (buildResult.OverallResult == BuildResultCode.Failure) { Logger.Error("Failed to build the solution!"); Logger.Space(); foreach (var buildError in buildLoggger.BuildErrors) { Logger.Error(buildError); } Logger.Space(); } else Logger.Success("Solution successfully built."); }
private static void Main() { try { // Run this in debug otherwise the files in CreateInstallers will be locked. :) const string projectFileName = @"..\..\..\wix-custom-ba-issue.sln"; var pc = new ProjectCollection(); var globalProperty = new Dictionary<string, string> {{"Configuration", "Release"}}; var buildRequestData = new BuildRequestData(projectFileName, globalProperty, null, new[] {"Rebuild"}, null); var buildParameters = new BuildParameters(pc) { DetailedSummary = true, Loggers = new List<ILogger> {new ConsoleLogger()} }; foreach (var version in new List<string> {"0.0.6.0", "1.0.0.0"}) BuildExamples(version, buildParameters, buildRequestData); } catch (Exception e) { Console.WriteLine("Failed!", e); Console.WriteLine(e.ToString()); } }
private static void BuildExamples(string versionString, BuildParameters buildParameters, BuildRequestData buildRequestData) { const string versionFileName = @"..\..\..\.config\VersionInfo.txt"; File.WriteAllText(versionFileName, versionString); var buildResult = BuildManager.DefaultBuildManager.Build(buildParameters, buildRequestData); if (buildResult.OverallResult == BuildResultCode.Success) { var output = buildResult.ResultsByTarget["Rebuild"].Items.First(x => x.ItemSpec.Contains("Bootstrapper")) .ItemSpec; var temp = Path.GetTempPath(); var productName = Path.GetFileNameWithoutExtension(output); var fileName = Path.GetFileName(output); if (productName != null) { var directory = Path.Combine(temp, productName, versionString); if (Directory.Exists(directory)) Directory.Delete(directory, true); Directory.CreateDirectory(directory); if (fileName != null) File.Copy(output, Path.Combine(directory, fileName)); } } }
/// <summary> /// Builds a project. /// </summary> /// <param name="projectPath">The absolute path to the project.</param> /// <param name="targetsToBuild">The targets to build. If not specified, the project's default target will be invoked.</param> /// <param name="properties">The optional global properties to pass to the project. May come from the <see cref="MSBuild.Properties"/> static class.</param> /// <returns>A task whose result is the result of the build.</returns> public static async Task<BuildResultAndLogs> ExecuteAsync(string projectPath, string[] targetsToBuild = null, IDictionary<string, string> properties = null, ITestOutputHelper testLogger = null) { targetsToBuild = targetsToBuild ?? new string[0]; var logger = new EventLogger(); var logLines = new List<string>(); var parameters = new BuildParameters { Loggers = new List<ILogger> { new ConsoleLogger(LoggerVerbosity.Detailed, logLines.Add, null, null), new ConsoleLogger(LoggerVerbosity.Minimal, v => testLogger?.WriteLine(v.TrimEnd()), null, null), logger, }, }; BuildResult result; using (var buildManager = new BuildManager()) { buildManager.BeginBuild(parameters); try { var requestData = new BuildRequestData(projectPath, properties ?? Properties.Default, null, targetsToBuild, null); var submission = buildManager.PendBuildRequest(requestData); result = await submission.ExecuteAsync(); } finally { buildManager.EndBuild(); } } return new BuildResultAndLogs(result, logger.LogEvents, logLines); }
private MSB.Execution.BuildResult Build(MSB.Execution.BuildParameters parameters, MSB.Execution.BuildRequestData requestData, CancellationToken cancellationToken) { using (buildManagerLock.DisposableWait()) { var buildManager = MSB.Execution.BuildManager.DefaultBuildManager; buildManager.BeginBuild(parameters); // enable cancellation of build CancellationTokenRegistration registration = default(CancellationTokenRegistration); if (cancellationToken.CanBeCanceled) { registration = cancellationToken.Register(() => { buildManager.CancelAllSubmissions(); }); } // execute build sync try { return(buildManager.BuildRequest(requestData)); } finally { if (registration != default(CancellationTokenRegistration)) { registration.Dispose(); } buildManager.EndBuild(); } } }
bool Compile(params string[] targets) { using (var t = new ChangingOutput("Compiling target(s) {0} . . .", string.Join(", ", targets))) { t.FinishLine(); var logger = new ConsoleLogger(LoggerVerbosity.Quiet); logger.SkipProjectStartedText = true; var props = new Dictionary<string, string> { {"Configuration", _release ? "Release" : "Debug"}, }; var request = new BuildRequestData(_slnPath, props, null, targets, null); var p = new BuildParameters() { Loggers = new[] {logger}, GlobalProperties = props }; var result = BuildManager.DefaultBuildManager.Build(p, request); t.PrintResult(result.OverallResult == BuildResultCode.Success); return result.OverallResult == BuildResultCode.Success; } }
protected async Task <BuildResult> BuildAsync(string taskName, MSB.Framework.ITaskHost taskHost, CancellationToken cancellationToken) { // prepare for building var buildTargets = new BuildTargets(loadedProject, "Compile"); // Don't execute this one. It will build referenced projects. // Even when DesignTimeBuild is defined above, it will still add the referenced project's output to the references list // which we don't want. buildTargets.Remove("ResolveProjectReferences"); // don't execute anything after CoreCompile target, since we've // already done everything we need to compute compiler inputs by then. buildTargets.RemoveAfter("CoreCompile", includeTargetInRemoval: false); // create a project instance to be executed by build engine. // The executed project will hold the final model of the project after execution via msbuild. var executedProject = loadedProject.CreateProjectInstance(); var hostServices = new Microsoft.Build.Execution.HostServices(); // connect the host "callback" object with the host services, so we get called back with the exact inputs to the compiler task. hostServices.RegisterHostObject(this.loadedProject.FullPath, "CoreCompile", taskName, taskHost); var buildParameters = new MSB.Execution.BuildParameters(loadedProject.ProjectCollection); var buildRequestData = new MSB.Execution.BuildRequestData(executedProject, buildTargets.Targets, hostServices); var result = await this.BuildAsync(buildParameters, buildRequestData, cancellationToken).ConfigureAwait(continueOnCapturedContext: false); return(new BuildResult(result, executedProject)); }
private bool BuildSolution_VS() { if (_SolutionPath == "") return false; try { string projectFilePath = Path.Combine(_SolutionPath); _OutputPath = _SolutionPath.Replace(Path.GetFileName(_SolutionPath), "") + "\\bin\\" + BuildInterface_Configuration.Text + "\\"; ProjectCollection pc = new ProjectCollection(); Dictionary<string, string> globalProperty = new Dictionary<string, string>(); globalProperty.Add("OutputPath", _OutputPath); BuildParameters bp = new BuildParameters(pc); BuildRequestData buildRequest = new BuildRequestData(projectFilePath, globalProperty, "4.0", new string[] { "Build" }, null); BuildResult buildResult = BuildManager.DefaultBuildManager.Build(bp, buildRequest); if (buildResult.OverallResult == BuildResultCode.Success) { return true; } else { MessageBox.Show("There Are Errors", "Error"); } } catch { MessageBox.Show("Build Failed Unexpectedly", "Error"); } return false; }
void CreateBuildProject() { string projectPath = Path.Combine(buildDirectory, "content.contentproj"); string outputPath = Path.Combine(buildDirectory, "bin"); // Create the build project. projectRootElement = ProjectRootElement.Create(projectPath); // Include the standard targets file that defines how to build XNA Framework content. projectRootElement.AddImport(Application.StartupPath + "\\Exporters\\FBX\\XNA\\XNA Game Studio\\" + "v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets"); buildProject = new Project(projectRootElement); buildProject.SetProperty("XnaPlatform", "Windows"); buildProject.SetProperty("XnaProfile", "Reach"); buildProject.SetProperty("XnaFrameworkVersion", "v4.0"); buildProject.SetProperty("Configuration", "Release"); buildProject.SetProperty("OutputPath", outputPath); buildProject.SetProperty("ContentRootDirectory", "."); buildProject.SetProperty("ReferencePath", Application.StartupPath); // Register any custom importers or processors. foreach (string pipelineAssembly in pipelineAssemblies) { buildProject.AddItem("Reference", pipelineAssembly); } // Hook up our custom error logger. errorLogger = new ErrorLogger(); buildParameters = new BuildParameters(ProjectCollection.GlobalProjectCollection) {Loggers = new ILogger[] {errorLogger}}; }
private async Task <MSB.Execution.BuildResult> BuildAsync(MSB.Execution.BuildParameters parameters, MSB.Execution.BuildRequestData requestData, CancellationToken cancellationToken) { // only allow one build to use the default build manager at a time using (await s_buildManagerLock.DisposableWaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)) { return(await BuildAsync(MSB.Execution.BuildManager.DefaultBuildManager, parameters, requestData, cancellationToken).ConfigureAwait(continueOnCapturedContext: false)); } }
private static bool _BuildSolutionFile(string solutionFile, string configuration) { var buildProperties = new Dictionary<string,string>(); buildProperties["Configuration"] = configuration; var buildRequest = new BuildRequestData(solutionFile, buildProperties, null, new string[] { "Build" }, null); var buildParameters = new BuildParameters(); var buildResult = BuildManager.DefaultBuildManager.Build(buildParameters, buildRequest); return buildResult.OverallResult == BuildResultCode.Success; }
public void EmptyBuildWithNoLoggers() { BuildManager buildManager = BuildManager.DefaultBuildManager; MuxLogger muxLogger = new MuxLogger(); BuildParameters parameters = new BuildParameters(); parameters.Loggers = new ILogger[] { muxLogger }; buildManager.BeginBuild(parameters); buildManager.EndBuild(); }
public BuildResult BuildProject(string directoryPath, IBenchmarkLogger logger) { string projectFileName = Path.Combine(directoryPath, MainClassName + ".csproj"); var consoleLogger = new MSBuildConsoleLogger(logger); var globalProperties = new Dictionary<string, string>(); var buildRequest = new BuildRequestData(projectFileName, globalProperties, null, new[] { "Build" }, null); var buildParameters = new BuildParameters(new ProjectCollection()) { DetailedSummary = false, Loggers = new ILogger[] { consoleLogger } }; var buildResult = BuildManager.DefaultBuildManager.Build(buildParameters, buildRequest); return buildResult; }
public BenchmarkBuildResult Build(BenchmarkGenerateResult generateResult) { var projectFileName = Path.Combine(generateResult.DirectoryPath, BenchmarkClassicGenerator.MainClassName + ".csproj"); var consoleLogger = new MSBuildConsoleLogger(logger); var globalProperties = new Dictionary<string, string>(); var buildRequest = new BuildRequestData(projectFileName, globalProperties, null, new[] { "Build" }, null); var buildParameters = new BuildParameters(new ProjectCollection()) { DetailedSummary = false, Loggers = new ILogger[] { consoleLogger } }; var buildResult = BuildManager.DefaultBuildManager.Build(buildParameters, buildRequest); return new BenchmarkBuildResult(generateResult, buildResult.OverallResult == BuildResultCode.Success, buildResult.Exception); }
ContentProject(ILogger logger) { Logger = logger; buildParameters = new BuildParameters(); if (Logger != null) { buildParameters.Loggers = new ILogger[] { Logger }; } }
public bool DoBuild(BuildJob job, ILogger logger) { BuildParameters parameters = new BuildParameters(); parameters.MaxNodeCount = 1; parameters.Loggers = new ILogger[] { logger }; Program.Log("Building target '" + job.Target + "' in " + job.ProjectFileName); string[] targets = job.Target.Split(';'); BuildRequestData request = new BuildRequestData(job.ProjectFileName, job.Properties, null, targets, null); BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, request); return result.OverallResult == BuildResultCode.Success; }
private Microsoft.Build.Execution.BuildResult BuildWithManagedApi(ILogger logger, string projectFilePath) { var consoleLogger = new MsBuildConsoleLogger(logger); var globalProperties = new Dictionary<string, string>(); var buildRequest = new BuildRequestData(projectFilePath, globalProperties, null, new[] { "Build" }, null); var buildParameters = new BuildParameters(new ProjectCollection()) { DetailedSummary = false, Loggers = new Microsoft.Build.Framework.ILogger[] { consoleLogger } }; return BuildManager.DefaultBuildManager.Build(buildParameters, buildRequest); }
public Assembly CompileProject(string projectFilename, string configuration = "Debug") { var mgr = new BuildManager(); var parms = new BuildParameters(); var proj = new ProjectInstance(projectFilename); var req = new BuildRequestData(proj, new string[] {configuration}); BuildResult result = mgr.Build(parms, req); Console.WriteLine("Overall build result: {0}", result.OverallResult); throw new NotImplementedException("Not fully implemented yet"); }
public void GetToolset () { var bp = new BuildParameters (ProjectCollection.GlobalProjectCollection); Assert.IsNull (bp.GetToolset ("0.1"), "#1"); var ts = bp.GetToolset ("2.0"); // They are equal Assert.AreEqual (ProjectCollection.GlobalProjectCollection.Toolsets.First (t => t.ToolsVersion == "2.0"), ts, "#2"); bp = new BuildParameters (); Assert.IsNull (bp.GetToolset ("0.1"), "#1"); ts = bp.GetToolset ("2.0"); // They are NOT equal, because ProjectCollection seems to be different. Assert.AreNotEqual (ProjectCollection.GlobalProjectCollection.Toolsets.First (t => t.ToolsVersion == "2.0"), ts, "#2"); }
public void SetUp() { // Ensure that any previous tests which may have been using the default BuildManager do not conflict with us. BuildManager.DefaultBuildManager.Dispose(); _logger = new MockLogger(); _parameters = new BuildParameters(); _parameters.ShutdownInProcNodeOnBuildFinish = true; _parameters.Loggers = new ILogger[] { _logger }; _parameters.EnableNodeReuse = false; _buildManager = new BuildManager(); _projectCollection = new ProjectCollection(); Environment.SetEnvironmentVariable("MSBUILDINPROCENVCHECK", "1"); }
public MSBuild12Project(HarvesterCore harvesterCore, string configuration, string platform) : base(null, null, null, null) { this.buildParameters = new BuildParameters(); try { HarvestLogger logger = new HarvestLogger(); logger.HarvesterCore = harvesterCore; List<ILogger> loggers = new List<ILogger>(); loggers.Add(logger); this.buildParameters.Loggers = loggers; // MSBuild can't handle storing operating environments for nested builds. if (Util.RunningInMsBuild) { this.buildParameters.SaveOperatingEnvironment = false; } } catch (Exception e) { if (harvesterCore != null) { harvesterCore.OnMessage(VSWarnings.NoLogger(e.Message)); } } this.buildManager = new BuildManager(); if (configuration != null || platform != null) { Dictionary<string, string> globalVariables = new Dictionary<string, string>(); if (configuration != null) { globalVariables.Add("Configuration", configuration); } if (platform != null) { globalVariables.Add("Platform", platform); } this.projectCollection = new ProjectCollection(globalVariables); } else { this.projectCollection = new ProjectCollection(); } }
public bool BuildProject(string projectFile, string outputDir, Dictionary<string, string> extraParams) { extraParams.Add("OutputPath", outputDir); var coll = new ProjectCollection(); var parameters = new BuildParameters(coll) { Loggers = new[] {Logger} }; var request = new BuildRequestData(projectFile, extraParams, "4.0", new[] {"Build"}, null); var result = BuildManager.DefaultBuildManager.Build(parameters, request); return result.OverallResult == BuildResultCode.Success; }
public static string[] Build(string solutionFile, string buildConfiguration = null, string buildPlatform = null) { string configString = String.Format("{0}|{1}", buildConfiguration ?? "<default>", buildPlatform ?? "<default>"); if ((buildConfiguration ?? buildPlatform) != null) Console.Error.Write("// Building '{0}' ({1}) ...", Program.ShortenPath(solutionFile), configString); else Console.Error.Write("// Building '{0}' ...", Program.ShortenPath(solutionFile)); var pc = new ProjectCollection(); var parms = new BuildParameters(pc); var globalProperties = new Dictionary<string, string>(); if (buildConfiguration != null) globalProperties["Configuration"] = buildConfiguration; if (buildPlatform != null) globalProperties["Platform"] = buildPlatform; var request = new BuildRequestData( solutionFile, globalProperties, null, new string[] { "Build" }, null, BuildRequestDataFlags.ReplaceExistingProjectInstance ); parms.Loggers = new[] { new ConsoleLogger(LoggerVerbosity.Quiet) }; var manager = BuildManager.DefaultBuildManager; var result = manager.Build(parms, request); var resultFiles = new HashSet<string>(); Console.Error.WriteLine(" done."); foreach (var kvp in result.ResultsByTarget) { var targetResult = kvp.Value; if (targetResult.Exception != null) Console.Error.WriteLine("// Compilation failed for target '{0}':\r\n{1}", kvp.Key, targetResult.Exception.Message); else { foreach (var filename in targetResult.Items) resultFiles.Add(filename.ItemSpec); } } return resultFiles.ToArray(); }
public static Response Compile(CompileRequest request) { var logger = new CompilerLogger(); logger.Verbosity = LoggerVerbosity.Detailed; var pc = new ProjectCollection(); var globalProperty = new Dictionary<string, string>(); globalProperty.Add("Configuration", request.Configuration ?? "Release"); //globalProperty.Add("Platform", "AnyCPU"); globalProperty.Add("VisualStudioVersion", "14.0"); if (!string.IsNullOrEmpty(request.OutputDirectory)) { globalProperty.Add("OutputDirectory", request.OutputDirectory); } if (!string.IsNullOrEmpty(request.SigningKey)) { globalProperty.Add("SignAssembly", "true"); globalProperty.Add("AssemblyOriginatorKeyFile", request.SigningKey); } if (!request.SkipCodeAnalysis) { globalProperty.Add("RunCodeAnalysis", "true"); globalProperty.Add("CodeAnalysisRuleSet", Path.Combine(BuilderAssemblyDirectory, "AllRules.ruleset")); globalProperty.Add("MBSBuilderPath", BuilderAssemblyDirectory); globalProperty.Add("CustomBeforeMicrosoftCSharpTargets", Path.Combine(BuilderAssemblyDirectory, "ImportStyleCop.targets")); } else { globalProperty.Add("RunCodeAnalysis", "false"); globalProperty.Add("CodeAnalysisRuleSet", string.Empty); } var buildRequest = new BuildRequestData(request.SolutionPath, globalProperty, "14.0", new [] { request.Target }, null); var parameters = new BuildParameters(pc); parameters.Loggers = new ILogger[] { logger }; parameters.DetailedSummary = true; var buildResult = BuildManager.DefaultBuildManager.Build(parameters, buildRequest); if (buildResult.OverallResult == BuildResultCode.Failure) { logger.Messages.Add(Message.CreateError("BuildResult is false")); } return new Response(logger.Messages); }
private static MSBE.BuildResult BuildAsync(MSBE.BuildParameters parameters, MSBE.BuildRequestData requestData) { var buildManager = MSBE.BuildManager.DefaultBuildManager; var taskSource = new TaskCompletionSource <MSB.Execution.BuildResult>(); buildManager.BeginBuild(parameters); // enable cancellation of build CancellationTokenRegistration registration = default(CancellationTokenRegistration); // execute build async try { buildManager.PendBuildRequest(requestData).ExecuteAsync(sub => { // when finished try { var result = sub.BuildResult; buildManager.EndBuild(); registration.Dispose(); taskSource.TrySetResult(result); } catch (Exception e) { taskSource.TrySetException(e); } }, null); } catch (Exception e) { taskSource.SetException(e); } return(taskSource.Task.Result); }
protected async Task <ProjectInstance> BuildAsync(string taskName, MSB.Framework.ITaskHost taskHost, CancellationToken cancellationToken) { // prepare for building var buildTargets = new BuildTargets(_loadedProject, "Compile"); // don't execute anything after CoreCompile target, since we've // already done everything we need to compute compiler inputs by then. buildTargets.RemoveAfter("CoreCompile", includeTargetInRemoval: false); // create a project instance to be executed by build engine. // The executed project will hold the final model of the project after execution via msbuild. var executedProject = _loadedProject.CreateProjectInstance(); if (!executedProject.Targets.ContainsKey("Compile")) { return(executedProject); } var hostServices = new Microsoft.Build.Execution.HostServices(); // connect the host "callback" object with the host services, so we get called back with the exact inputs to the compiler task. hostServices.RegisterHostObject(_loadedProject.FullPath, "CoreCompile", taskName, taskHost); var buildParameters = new MSB.Execution.BuildParameters(_loadedProject.ProjectCollection); var buildRequestData = new MSB.Execution.BuildRequestData(executedProject, buildTargets.Targets, hostServices); var result = await this.BuildAsync(buildParameters, buildRequestData, cancellationToken).ConfigureAwait(continueOnCapturedContext: false); if (result.Exception != null) { throw result.Exception; } return(executedProject); }
public static ProjectDetails LoadProjectDetails(string projectFile, string configuration) { var key = Tuple.Create(projectFile, configuration); ProjectDetails details; if (_allProjects.TryGetValue(key, out details)) { if (!details.HasChanged()) { if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug)) { _log.Debug($"Using cached project file details for [{projectFile}]"); } return(details); } else { if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug)) { _log.Debug($"Reloading project file details [{projectFile}] as one of its imports has been modified."); } } } if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug)) { _log.Debug($"Loading project file [{projectFile}]"); } details = new ProjectDetails(); var properties = new Dictionary <string, string>(ImmutableDictionary <string, string> .Empty); properties["DesignTimeBuild"] = "true"; // this will tell msbuild to not build the dependent projects properties["BuildingInsideVisualStudio"] = "true"; // this will force CoreCompile task to execute even if all inputs and outputs are up to date properties["BuildingInsideUnoSourceGenerator"] = "true"; // this will force prevent the task to run recursively properties["Configuration"] = configuration; properties["UseHostCompilerIfAvailable"] = "true"; properties["UseSharedCompilation"] = "true"; // Platform is intentionally kept as not defined, to avoid having // dependent projects being loaded with a platform they don't support. // properties["Platform"] = _platform; var xmlReader = XmlReader.Create(projectFile); var collection = new Microsoft.Build.Evaluation.ProjectCollection(); collection.RegisterLogger(new Microsoft.Build.Logging.ConsoleLogger() { Verbosity = LoggerVerbosity.Normal }); collection.OnlyLogCriticalEvents = false; var xml = Microsoft.Build.Construction.ProjectRootElement.Create(xmlReader, collection); // When constructing a project from an XmlReader, MSBuild cannot determine the project file path. Setting the // path explicitly is necessary so that the reserved properties like $(MSBuildProjectDirectory) will work. xml.FullPath = Path.GetFullPath(projectFile); var loadedProject = new Microsoft.Build.Evaluation.Project( xml, properties, toolsVersion: null, projectCollection: collection ); var buildTargets = new BuildTargets(loadedProject, "Compile"); // don't execute anything after CoreCompile target, since we've // already done everything we need to compute compiler inputs by then. buildTargets.RemoveAfter("CoreCompile", includeTargetInRemoval: false); details.Configuration = configuration; details.LoadedProject = loadedProject; // create a project instance to be executed by build engine. // The executed project will hold the final model of the project after execution via msbuild. details.ExecutedProject = loadedProject.CreateProjectInstance(); var hostServices = new Microsoft.Build.Execution.HostServices(); // connect the host "callback" object with the host services, so we get called back with the exact inputs to the compiler task. hostServices.RegisterHostObject(loadedProject.FullPath, "CoreCompile", "Csc", null); var buildParameters = new Microsoft.Build.Execution.BuildParameters(loadedProject.ProjectCollection); // This allows for the loggers to buildParameters.Loggers = collection.Loggers; var buildRequestData = new Microsoft.Build.Execution.BuildRequestData(details.ExecutedProject, buildTargets.Targets, hostServices); var result = BuildAsync(buildParameters, buildRequestData); if (result.Exception == null) { ValidateOutputPath(details.ExecutedProject); var projectFilePath = Path.GetFullPath(Path.GetDirectoryName(projectFile)); details.References = details.ExecutedProject.GetItems("ReferencePath").Select(r => r.EvaluatedInclude).ToArray(); if (details.References.None()) { LogFailedTargets(projectFile, result); return(details); } } else { LogFailedTargets(projectFile, result); } _allProjects.TryAdd(key, details); details.BuildImportsMap(); return(details); }
private void HandleNodeConfiguration(NodeConfiguration configuration) { // Grab the system parameters. _buildParameters = configuration.BuildParameters; _buildParameters.ProjectRootElementCache = s_projectRootElementCacheBase; // Snapshot the current environment _savedEnvironment = CommunicationsUtilities.GetEnvironmentVariables(); // Change to the startup directory try { NativeMethodsShared.SetCurrentDirectory(BuildParameters.StartupDirectory); } catch (DirectoryNotFoundException) { // Somehow the startup directory vanished. This can happen if build was started from a USB Key and it was removed. NativeMethodsShared.SetCurrentDirectory(BuildEnvironmentHelper.Instance.CurrentMSBuildToolsDirectory); } // Replicate the environment. First, unset any environment variables set by the previous configuration. if (_currentConfiguration != null) { foreach (string key in _currentConfiguration.BuildParameters.BuildProcessEnvironment.Keys) { Environment.SetEnvironmentVariable(key, null); } } // Now set the new environment foreach (KeyValuePair <string, string> environmentPair in _buildParameters.BuildProcessEnvironment) { Environment.SetEnvironmentVariable(environmentPair.Key, environmentPair.Value); } // We want to make sure the global project collection has the toolsets which were defined on the parent // so that any custom toolsets defined can be picked up by tasks who may use the global project collection but are // executed on the child node. ICollection <Toolset> parentToolSets = _buildParameters.ToolsetProvider.Toolsets; if (parentToolSets != null) { ProjectCollection.GlobalProjectCollection.RemoveAllToolsets(); foreach (Toolset toolSet in parentToolSets) { ProjectCollection.GlobalProjectCollection.AddToolset(toolSet); } } // Set the culture. CultureInfo.CurrentCulture = _buildParameters.Culture; CultureInfo.CurrentUICulture = _buildParameters.UICulture; // Get the node ID. _buildParameters.NodeId = configuration.NodeId; _buildParameters.IsOutOfProc = true; #if FEATURE_APPDOMAIN // And the AppDomainSetup _buildParameters.AppDomainSetup = configuration.AppDomainSetup; #endif // Set up the logging service. LoggingServiceFactory loggingServiceFactory = new LoggingServiceFactory(LoggerMode.Asynchronous, configuration.NodeId); _componentFactories.ReplaceFactory(BuildComponentType.LoggingService, loggingServiceFactory.CreateInstance); _loggingService = _componentFactories.GetComponent(BuildComponentType.LoggingService) as ILoggingService; BuildEventArgTransportSink sink = new BuildEventArgTransportSink(SendPacket); _shutdownException = null; if (configuration.LoggingNodeConfiguration.IncludeEvaluationMetaprojects) { _loggingService.IncludeEvaluationMetaprojects = true; } if (configuration.LoggingNodeConfiguration.IncludeEvaluationProfiles) { _loggingService.IncludeEvaluationProfile = true; } if (configuration.LoggingNodeConfiguration.IncludeTaskInputs) { _loggingService.IncludeTaskInputs = true; } if (configuration.LoggingNodeConfiguration.IncludeEvaluationPropertiesAndItems) { _loggingService.IncludeEvaluationPropertiesAndItems = true; } try { // If there are no node loggers to initialize dont do anything if (configuration.LoggerDescriptions?.Length > 0) { _loggingService.InitializeNodeLoggers(configuration.LoggerDescriptions, sink, configuration.NodeId); } } catch (Exception ex) when(!ExceptionHandling.IsCriticalException(ex)) { OnEngineException(ex); } _loggingService.OnLoggingThreadException += OnLoggingThreadException; string forwardPropertiesFromChild = Environment.GetEnvironmentVariable("MSBUILDFORWARDPROPERTIESFROMCHILD"); string[] propertyListToSerialize = null; // Get a list of properties which should be serialized if (!String.IsNullOrEmpty(forwardPropertiesFromChild)) { propertyListToSerialize = forwardPropertiesFromChild.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries); } _loggingService.PropertiesToSerialize = propertyListToSerialize; _loggingService.RunningOnRemoteNode = true; string forwardAllProperties = Environment.GetEnvironmentVariable("MSBUILDFORWARDALLPROPERTIESFROMCHILD"); if (String.Equals(forwardAllProperties, "1", StringComparison.OrdinalIgnoreCase) || _buildParameters.LogInitialPropertiesAndItems) { _loggingService.SerializeAllProperties = true; } else { _loggingService.SerializeAllProperties = false; } // Now prep the buildRequestEngine for the build. _loggingContext = new NodeLoggingContext(_loggingService, configuration.NodeId, false /* inProcNode */); if (_shutdownException != null) { HandleShutdown(out Exception exception); throw exception; } _buildRequestEngine.InitializeForBuild(_loggingContext); // Finally store off this configuration packet. _currentConfiguration = configuration; }
private static Task <MSB.Execution.BuildResult> BuildAsync(MSB.Execution.BuildManager buildManager, MSB.Execution.BuildParameters parameters, MSB.Execution.BuildRequestData requestData, CancellationToken cancellationToken) { var taskSource = new TaskCompletionSource <MSB.Execution.BuildResult>(); buildManager.BeginBuild(parameters); // enable cancellation of build CancellationTokenRegistration registration = default(CancellationTokenRegistration); if (cancellationToken.CanBeCanceled) { registration = cancellationToken.Register(() => { try { buildManager.CancelAllSubmissions(); buildManager.EndBuild(); registration.Dispose(); } finally { taskSource.TrySetCanceled(); } }); } // execute build async try { buildManager.PendBuildRequest(requestData).ExecuteAsync(sub => { // when finished try { var result = sub.BuildResult; buildManager.EndBuild(); registration.Dispose(); taskSource.TrySetResult(result); } catch (Exception e) { taskSource.TrySetException(e); } }, null); } catch (Exception e) { taskSource.SetException(e); } return(taskSource.Task); }
public BuildResult Build(BuildParameters parameters, BuildRequestData requestData) { throw new NotImplementedException(); }
public void BeginBuild(BuildParameters parameters) { throw new NotImplementedException(); }
public static ProjectDetails LoadProjectDetails(BuildEnvironment environment) { var key = Tuple.Create(environment.ProjectFile, environment.Configuration); ProjectDetails details; if (_allProjects.TryGetValue(key, out details)) { if (!details.HasChanged()) { if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug)) { _log.LogDebug($"Using cached project file details for [{environment.ProjectFile}]"); } return(details); } else { if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug)) { _log.LogDebug($"Reloading project file details [{environment.ProjectFile}] as one of its imports has been modified."); } } } if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug)) { _log.LogDebug($"Loading project file [{environment.ProjectFile}]"); } details = new ProjectDetails(); var properties = new Dictionary <string, string>(ImmutableDictionary <string, string> .Empty) { ["DesignTimeBuild"] = "true", // this will tell msbuild to not build the dependent projects ["BuildingInsideVisualStudio"] = "true", // this will force CoreCompile task to execute even if all inputs and outputs are up to date ["BuildingInsideUnoSourceGenerator"] = "true", // this will force prevent the task to run recursively ["Configuration"] = environment.Configuration, ["UseHostCompilerIfAvailable"] = "true", ["UseSharedCompilation"] = "true", ["VisualStudioVersion"] = environment.VisualStudioVersion, // Force the intermediate path to be different from the VS default path // so that the generated files don't mess up the file count for incremental builds. ["IntermediateOutputPath"] = Path.Combine(environment.OutputPath, "obj") + Path.DirectorySeparatorChar }; // Target framework is required for the MSBuild 15.0 Cross Compilation. // Loading a project without the target framework results in an empty project, which interatively // sets the TargetFramework property. if (environment.TargetFramework.HasValue()) { properties["TargetFramework"] = environment.TargetFramework; } // TargetFrameworkRootPath is used by VS4Mac to determine the // location of frameworks like Xamarin.iOS. if (environment.TargetFrameworkRootPath.HasValue()) { properties["TargetFrameworkRootPath"] = environment.TargetFrameworkRootPath; } // Platform is intentionally kept as not defined, to avoid having // dependent projects being loaded with a platform they don't support. // properties["Platform"] = _platform; var xmlReader = XmlReader.Create(environment.ProjectFile); var collection = new Microsoft.Build.Evaluation.ProjectCollection(); // Change this logger details to troubleshoot project loading details. collection.RegisterLogger(new Microsoft.Build.Logging.ConsoleLogger() { Verbosity = LoggerVerbosity.Minimal }); // Uncomment this to enable file logging for debugging purposes. // collection.RegisterLogger(new Microsoft.Build.BuildEngine.FileLogger() { Verbosity = LoggerVerbosity.Diagnostic, Parameters = $@"logfile=c:\temp\build\MSBuild.{Guid.NewGuid()}.log" }); collection.OnlyLogCriticalEvents = false; var xml = Microsoft.Build.Construction.ProjectRootElement.Create(xmlReader, collection); // When constructing a project from an XmlReader, MSBuild cannot determine the project file path. Setting the // path explicitly is necessary so that the reserved properties like $(MSBuildProjectDirectory) will work. xml.FullPath = Path.GetFullPath(environment.ProjectFile); var loadedProject = new Microsoft.Build.Evaluation.Project( xml, properties, toolsVersion: null, projectCollection: collection ); var buildTargets = new BuildTargets(loadedProject, "Compile"); // don't execute anything after CoreCompile target, since we've // already done everything we need to compute compiler inputs by then. buildTargets.RemoveAfter("CoreCompile", includeTargetInRemoval: true); details.Configuration = environment.Configuration; details.LoadedProject = loadedProject; // create a project instance to be executed by build engine. // The executed project will hold the final model of the project after execution via msbuild. details.ExecutedProject = loadedProject.CreateProjectInstance(); var hostServices = new Microsoft.Build.Execution.HostServices(); // connect the host "callback" object with the host services, so we get called back with the exact inputs to the compiler task. hostServices.RegisterHostObject(loadedProject.FullPath, "CoreCompile", "Csc", null); var buildParameters = new Microsoft.Build.Execution.BuildParameters(loadedProject.ProjectCollection); // This allows for the loggers to buildParameters.Loggers = collection.Loggers; var buildRequestData = new Microsoft.Build.Execution.BuildRequestData(details.ExecutedProject, buildTargets.Targets, hostServices); var result = BuildAsync(buildParameters, buildRequestData); if (result.Exception == null) { ValidateOutputPath(details.ExecutedProject); var projectFilePath = Path.GetFullPath(Path.GetDirectoryName(environment.ProjectFile)); details.References = details.ExecutedProject.GetItems("ReferencePath").Select(r => r.EvaluatedInclude).ToArray(); if (!details.References.Any()) { if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Error)) { _log.LogError($"Project has no references."); } LogFailedTargets(environment.ProjectFile, result); details.Generators = new (Type, Func <SourceGenerator>)[0];