private static Task <BuildResult> ExecuteAsync(this BuildSubmission submission)
{
var tcs = new TaskCompletionSource <BuildResult>();
submission.ExecuteAsync(s => tcs.SetResult(s.BuildResult), null);
return(tcs.Task);
}
public bool Build(string solutionDirectory, string outputPath)
{
string projectFilePath = Path.Combine(solutionDirectory);
ProjectCollection pc = new ProjectCollection();
// THERE ARE A LOT OF PROPERTIES HERE, THESE MAP TO THE MSBUILD CLI PROPERTIES
Dictionary <string, string> globalProperty = new Dictionary <string, string>();
globalProperty.Add("OutputPath", outputPath);
globalProperty.Add("Configuration", "Debug");
globalProperty.Add("Platform", "Any CPU");
BuildParameters bp = new BuildParameters(pc);
bp.Loggers = new[] {
new FileLogger
{
Verbosity = LoggerVerbosity.Detailed,
ShowSummary = true,
SkipProjectStartedText = true
}
};
BuildManager.DefaultBuildManager.BeginBuild(bp);
BuildRequestData BuildRequest = new BuildRequestData(projectFilePath, globalProperty, "4.7", new string[] { "Build" }, null);
BuildSubmission BuildSubmission = BuildManager.DefaultBuildManager.PendBuildRequest(BuildRequest);
BuildSubmission.Execute();
BuildManager.DefaultBuildManager.EndBuild();
return(BuildSubmission.BuildResult.OverallResult == BuildResultCode.Success ? true : false);
}
/// <summary>
/// Builds all the content files which have been added to the project,
/// dynamically creating .xnb files in the OutputDirectory.
/// Returns an error message if the build fails.
/// </summary>
public string Build()
{
// Clear any previous errors.
errorLogger.Errors.Clear();
// Create and submit a new asynchronous build request.
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
BuildRequestData request = new BuildRequestData(buildProject.CreateProjectInstance(), new string[0]);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(request);
submission.ExecuteAsync(null, null);
// Wait for the build to finish.
submission.WaitHandle.WaitOne();
BuildManager.DefaultBuildManager.EndBuild();
// If the build failed, return an error string.
if (submission.BuildResult.OverallResult == BuildResultCode.Failure)
{
return(string.Join("\n", errorLogger.Errors.ToArray()));
}
return(null);
}
private static BuildResult Build(BuildRequestData buildRequestData, IEnumerable <ILogger> loggers)
{
lock (LockObject)
{
BuildParameters buildParameters = new BuildParameters
{
EnableNodeReuse = false,
MaxNodeCount = Environment.ProcessorCount,
ResetCaches = true,
Loggers = loggers,
};
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
try
{
BuildSubmission buildSubmission = BuildManager.DefaultBuildManager.PendBuildRequest(buildRequestData);
SetCurrentHost(BuildManager.DefaultBuildManager);
BuildResult buildResult = buildSubmission.Execute();
if (buildResult.Exception != null)
{
throw buildResult.Exception;
}
return(buildResult);
}
finally
{
BuildManager.DefaultBuildManager.EndBuild();
}
}
}
private void Build(string[] targets, BuildOutput buildOutput, out bool result, out IDictionary <string, TargetResult> targetOutputs)
{
lock (BuildManager.DefaultBuildManager)
{
BuildRequestData restoreRequest = new BuildRequestData(
ProjectInstance,
targetsToBuild: targets ?? ProjectInstance.DefaultTargets.ToArray(),
hostServices: null,
flags: BuildRequestDataFlags.ReplaceExistingProjectInstance);
BuildParameters buildParameters = new BuildParameters
{
Loggers = new List <Framework.ILogger>(ProjectCollection.Loggers.Concat(buildOutput.AsEnumerable())),
};
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
try
{
BuildSubmission buildSubmission = BuildManager.DefaultBuildManager.PendBuildRequest(restoreRequest);
BuildResult buildResult = buildSubmission.Execute();
result = buildResult.OverallResult == BuildResultCode.Success;
targetOutputs = buildResult.ResultsByTarget;
}
finally
{
BuildManager.DefaultBuildManager.EndBuild();
}
}
}
internal static Task <Microsoft.Build.Execution.BuildResult> ExecuteAsync(this BuildSubmission submission)
{
var tcs = new TaskCompletionSource <Microsoft.Build.Execution.BuildResult>();
submission.ExecuteAsync(s => tcs.SetResult(s.BuildResult), null);
return(tcs.Task);
}
public static Task <BuildResult> ExecuteAsync(this BuildSubmission submission)
{
var tcs = new TaskCompletionSource <BuildResult>();
submission.ExecuteAsync(SetBuildComplete, tcs);
return(tcs.Task);
}
public static Task <BuildResult> ExecuteAsync(this BuildSubmission buildSubmission)
{
var taskCompletionSource = new TaskCompletionSource <BuildResult>();
buildSubmission.ExecuteAsync(BuildSubmissionCompleteCallbackFunction, taskCompletionSource);
return(taskCompletionSource.Task);
}
public void BuildAndAnalyze()
{
var globalProps = new Dictionary <string, string> {
{ "VisualStudioVersion", "12.0" }
};
pc = new ProjectCollection(globalProps);
var diagLogger = new DiagnosticXmlLogger(this);
diagLogger.LogFile = _logFilepath;
project = pc.LoadProject(_projectFilepath, "12.0");
projInst = project.CreateProjectInstance();
buildManager = new BuildManager();
var buildParams = new BuildParameters();
buildParams.Loggers = new ILogger[] { diagLogger };
buildManager.BeginBuild(buildParams);
var brd = new BuildRequestData(projInst, _targets, null, BuildRequestDataFlags.ReplaceExistingProjectInstance);
submission = buildManager.PendBuildRequest(brd);
buildResult = submission.Execute();
buildManager.EndBuild();
}
public override bool Build(string projectFileName, string[] targetNames, IDictionary targetOutputs)
{
try
{
this.buildManager.BeginBuild(this.buildParameters);
BuildRequestData buildRequestData = new BuildRequestData(this.currentProjectInstance, targetNames, null, BuildRequestDataFlags.ReplaceExistingProjectInstance);
BuildSubmission submission = this.buildManager.PendBuildRequest(buildRequestData);
BuildResult buildResult = submission.Execute();
bool buildSucceeded = buildResult.OverallResult == BuildResultCode.Success;
this.buildManager.EndBuild();
// Fill in empty lists for each target so that heat will look at the item group later.
foreach (string target in targetNames)
{
targetOutputs.Add(target, new List <object>());
}
return(buildSucceeded);
}
catch (Exception e)
{
throw new WixException(VSErrors.CannotBuildProject(projectFileName, e.Message));
}
}
// FIXME: take max nodes into account here, and get throttling working.
BuildNode TakeNode(BuildSubmission build)
{
var host = BuildManager.OngoingBuildParameters.HostServices;
NodeAffinity affinity;
if (host == null)
{
affinity = NodeAffinity.Any;
}
else
{
affinity = host.GetNodeAffinity(build.BuildRequest.ProjectFullPath);
}
BuildNode n = GetReusableNode(affinity);
if (n != null)
{
n.Assign(build);
}
else
{
n = new BuildNode(this, affinity == NodeAffinity.Any ? NodeAffinity.InProc : affinity);
n.Assign(build);
if (n.Affinity == NodeAffinity.InProc)
{
in_proc_nodes.Add(n);
}
else
{
out_proc_nodes.Add(n);
}
}
return(n);
}
void StartOneBuild(BuildSubmission build)
{
var node = TakeNode(build);
// FIXME: Task (non-generic) here causes NotImplementedException in somewhere in Interlocked. It does not make sense.
ongoing_builds [build] = task_factory.StartNew(node.ExecuteBuild);
//new Thread (() => { node.ExecuteBuild (); }).Start ();
}
// no loggers
internal static bool BuildInstance(ProjectNode projectNode, ProjectInstance instance, string target)
{
BuildSubmission submission = projectNode.DoMSBuildSubmission(BuildKind.Sync, target, ref instance, null);
if (submission == null)
{
return(false);
}
return(submission.BuildResult.OverallResult == BuildResultCode.Success);
}
public void BuildWithMuxLoggerEquivalentToNormalLogger()
{
string projectBody = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='Test'>
<Message Text='Foo'/>
<Error Text='Error'/>
</Target>
</Project>
");
BuildManager buildManager = BuildManager.DefaultBuildManager;
// Build with a 'normal' logger
MockLogger mockLogger2 = new MockLogger();
mockLogger2.LogBuildFinished = false;
ProjectCollection projectCollection = new ProjectCollection();
ProjectInstance project = (new Project(XmlReader.Create(new StringReader(projectBody)), null, "4.0", projectCollection)).CreateProjectInstance();
BuildParameters parameters = new BuildParameters(projectCollection);
parameters.Loggers = new ILogger[] { mockLogger2 };
buildManager.Build(parameters, new BuildRequestData(project, new string[0], null));
// Build with the mux logger
MuxLogger muxLogger = new MuxLogger();
muxLogger.Verbosity = LoggerVerbosity.Normal;
projectCollection = new ProjectCollection();
project = (new Project(XmlReader.Create(new StringReader(projectBody)), null, "4.0", projectCollection)).CreateProjectInstance();
parameters = new BuildParameters(projectCollection);
parameters.Loggers = new ILogger[] { muxLogger };
buildManager.BeginBuild(parameters);
MockLogger mockLogger = new MockLogger();
mockLogger.LogBuildFinished = false;
try
{
BuildSubmission submission = buildManager.PendBuildRequest(new BuildRequestData(project, new string[0], null));
muxLogger.RegisterLogger(submission.SubmissionId, mockLogger);
submission.Execute();
}
finally
{
buildManager.EndBuild();
}
Assert.True(mockLogger2.BuildFinishedEvents.Count > 0);
Assert.Equal(mockLogger2.BuildFinishedEvents.Count, mockLogger.BuildFinishedEvents.Count);
Assert.Equal(mockLogger2.BuildFinishedEvents[0].Succeeded, mockLogger.BuildFinishedEvents[0].Succeeded);
Assert.Equal(mockLogger2.FullLog, mockLogger.FullLog);
}
public BuildEngine4(BuildSubmission submission)
{
this.submission = submission;
event_source = new Microsoft.Build.BuildEngine.EventSource();
if (submission.BuildManager.OngoingBuildParameters.Loggers != null)
{
foreach (var l in submission.BuildManager.OngoingBuildParameters.Loggers)
{
l.Initialize(event_source);
}
}
}
private static void build()
{
buildParameters = new BuildParameters();
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
BuildRequestData request = new BuildRequestData(buildProject.CreateProjectInstance(), new string[0]);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(request);
submission.ExecuteAsync(null, null);
submission.WaitHandle.WaitOne();
BuildManager.DefaultBuildManager.EndBuild();
}
/// <summary>
/// Attempts to run the Restore target for the current project with a unique evaluation context.
/// </summary>
/// <param name="result">A value indicating the result of the restore.</param>
/// <param name="buildOutput">A <see cref="BuildOutput"/> object that captured the logging from the restore.</param>
/// <param name="targetOutputs">A <see cref="IDictionary{String,TargetResult}" /> containing the target outputs.</param>
/// <returns>The current <see cref="ProjectCreator"/>.</returns>
public ProjectCreator TryRestore(out bool result, out BuildOutput buildOutput, out IDictionary <string, TargetResult> targetOutputs)
{
Save();
buildOutput = BuildOutput.Create();
lock (BuildManager.DefaultBuildManager)
{
BuildRequestData restoreRequest = new BuildRequestData(
FullPath,
new Dictionary <string, string>
{
["ExcludeRestorePackageImports"] = "true",
["MSBuildRestoreSessionId"] = Guid.NewGuid().ToString("D"),
},
ProjectCollection.DefaultToolsVersion,
targetsToBuild: new[] { "Restore" },
hostServices: null,
flags: BuildRequestDataFlags.ClearCachesAfterBuild | BuildRequestDataFlags.SkipNonexistentTargets | BuildRequestDataFlags.IgnoreMissingEmptyAndInvalidImports);
BuildParameters buildParameters = new BuildParameters
{
Loggers = new List <Framework.ILogger>
{
buildOutput,
},
};
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
try
{
BuildSubmission buildSubmission = BuildManager.DefaultBuildManager.PendBuildRequest(restoreRequest);
BuildResult buildResult = buildSubmission.Execute();
result = buildResult.OverallResult == BuildResultCode.Success;
targetOutputs = buildResult.ResultsByTarget;
}
finally
{
BuildManager.DefaultBuildManager.EndBuild();
}
}
Project.MarkDirty();
Project.ReevaluateIfNecessary();
return(this);
}
public void RegisteringLoggerDuringBuildThrowsException()
{
string projectBody = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='Test'>
<Exec Command='Sleep 1' />
</Target>
</Project>
");
ProjectInstance project = (new Project(XmlReader.Create(new StringReader(projectBody)))).CreateProjectInstance();
BuildManager buildManager = BuildManager.DefaultBuildManager;
MuxLogger muxLogger = new MuxLogger();
BuildParameters parameters = new BuildParameters(ProjectCollection.GlobalProjectCollection);
AutoResetEvent projectStartedEvent = new AutoResetEvent(false);
parameters.Loggers = new ILogger[] { muxLogger, new EventingLogger(projectStartedEvent) };
MockLogger mockLogger = new MockLogger();
bool gotException = false;
buildManager.BeginBuild(parameters);
try
{
BuildSubmission submission = buildManager.PendBuildRequest(new BuildRequestData(project, new string[0], null));
submission.ExecuteAsync(null, null);
projectStartedEvent.WaitOne();
try
{
muxLogger.RegisterLogger(submission.SubmissionId, mockLogger);
}
catch (InvalidOperationException)
{
gotException = true;
}
catch
{
}
}
finally
{
buildManager.EndBuild();
}
Assert.True(gotException); // "Failed to get exception registering logger during build."
}
public void OneSubmissionTwoLoggers()
{
string projectBody = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='Test'>
<Message Text='Foo'/>
<Error Text='Error'/>
</Target>
</Project>
");
ProjectInstance project = (new Project(XmlReader.Create(new StringReader(projectBody)))).CreateProjectInstance();
BuildManager buildManager = BuildManager.DefaultBuildManager;
MuxLogger muxLogger = new MuxLogger();
BuildParameters parameters = new BuildParameters(ProjectCollection.GlobalProjectCollection);
parameters.Loggers = new ILogger[] { muxLogger };
MockLogger mockLogger1 = new MockLogger();
MockLogger mockLogger2 = new MockLogger();
buildManager.BeginBuild(parameters);
try
{
BuildSubmission submission = buildManager.PendBuildRequest(new BuildRequestData(project, new string[0], null));
muxLogger.RegisterLogger(submission.SubmissionId, mockLogger1);
muxLogger.RegisterLogger(submission.SubmissionId, mockLogger2);
submission.Execute();
}
finally
{
buildManager.EndBuild();
}
mockLogger1.AssertLogContains("Foo");
mockLogger1.AssertLogContains("Error");
Assert.Equal(1, mockLogger1.ErrorCount);
mockLogger1.AssertNoWarnings();
mockLogger2.AssertLogContains("Foo");
mockLogger2.AssertLogContains("Error");
Assert.Equal(1, mockLogger2.ErrorCount);
mockLogger2.AssertNoWarnings();
Assert.Equal(mockLogger1.FullLog, mockLogger2.FullLog);
}
private void SetTaskCompletionResult(BuildSubmission buildSubmission, TaskCompletionSource <BuildResult> tcs)
{
if (buildSubmission.BuildResult.Exception != null)
{
if (buildSubmission.BuildResult.Exception is BuildAbortedException)
{
tcs.SetCanceled();
}
else
{
tcs.TrySetException(buildSubmission.BuildResult.Exception);
}
}
else
{
tcs.SetResult(buildSubmission.BuildResult);
}
}
/// <summary>
/// Builds all the content files which have been added to the project,
/// dynamically creating .xnb files in the OutputDirectory.
/// Returns an error message if the build fails.
/// </summary>
public string Build()
{
// Create and submit a new asynchronous build request.
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
BuildRequestData request = new BuildRequestData(buildProject.CreateProjectInstance(), new string[0]);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(request);
submission.ExecuteAsync(null, null);
// Wait for the build to finish.
submission.WaitHandle.WaitOne();
BuildManager.DefaultBuildManager.EndBuild();
return(null);
}
public bool Build(string outPath)
{
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
BuildRequestData request = new BuildRequestData(buildProject.CreateProjectInstance( ), new string[0]);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(request);
submission.ExecuteAsync(null, null);
submission.WaitHandle.WaitOne( );
BuildManager.DefaultBuildManager.EndBuild( );
if (submission.BuildResult.OverallResult == BuildResultCode.Failure)
{
return(false);
}
this.copyBuiltContent(outPath);
Thread.Sleep(250);
this.deleteTempDirectory( );
return(true);
}
public string Build()
{
_errorLogger.Errors.Clear();
BuildManager.DefaultBuildManager.BeginBuild(_buildParameters);
BuildRequestData request = new BuildRequestData(_buildProject.CreateProjectInstance(), new string[0]);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(request);
submission.ExecuteAsync(null, null);
submission.WaitHandle.WaitOne();
BuildManager.DefaultBuildManager.EndBuild();
if (submission.BuildResult.OverallResult == BuildResultCode.Failure)
{
return(string.Join("\n", _errorLogger.Errors.ToArray()));
}
return(null);
}
public string Build()
{
// Clear any previous errors.
_errorLogger.Errors.Clear();
// Create and submit a new asynchronous build request.
BuildManager.DefaultBuildManager.BeginBuild(_buildParameters);
var request = new BuildRequestData(_buildProject.CreateProjectInstance(), new string[0]);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(request);
submission.ExecuteAsync(null, null);
// Wait for the build to finish.
submission.WaitHandle.WaitOne();
BuildManager.DefaultBuildManager.EndBuild();
var output = new StringBuilder();
if (submission.BuildResult.OverallResult == BuildResultCode.Failure)
{
output.Append(string.Join("\n", _errorLogger.Errors.ToArray()));
}
// handle error output
var secondaryImporterErrors = _secondaryImporters.Where(kvp => kvp.Value.Item2.Any())
.Select(kvp => kvp.Value)
.SelectMany(item => item.Item2.Select(file =>
{
var errorResult = item.Item1.Invoke(file);
return(string.IsNullOrWhiteSpace(errorResult) ? null : string.Format("{0}: {1}\n", file.AssetName, errorResult));
}))
.Where(outputString => !string.IsNullOrWhiteSpace(outputString))
.Aggregate("", (acc, item) => acc + "\n" + item);
output.AppendLine(secondaryImporterErrors);
return(output.ToString());
}
public void RegisteringLoggerDuringBuildThrowsException()
{
string projectBody = ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
<Target Name='Test'>
<Exec Command='Sleep 1' />
</Target>
</Project>
");
ProjectInstance project = (new Project(XmlReader.Create(new StringReader(projectBody)))).CreateProjectInstance();
BuildManager buildManager = BuildManager.DefaultBuildManager;
MuxLogger muxLogger = new MuxLogger();
BuildParameters parameters = new BuildParameters(ProjectCollection.GlobalProjectCollection);
AutoResetEvent projectStartedEvent = new AutoResetEvent(false);
parameters.Loggers = new ILogger[] { muxLogger, new EventingLogger(projectStartedEvent) };
MockLogger mockLogger = new MockLogger();
buildManager.BeginBuild(parameters);
Should.Throw <InvalidOperationException>(() =>
{
try
{
BuildSubmission submission = buildManager.PendBuildRequest(new BuildRequestData(project, Array.Empty <string>(), null));
submission.ExecuteAsync(null, null);
projectStartedEvent.WaitOne();
// This call should throw an InvalidOperationException
muxLogger.RegisterLogger(submission.SubmissionId, mockLogger);
}
finally
{
buildManager.EndBuild();
}
});
}
private bool BuildProject(Project buildProject)
{
OnError("Compiling project...");
// Create and submit a new asynchronous build request.
BuildParameters buildParameters = new BuildParameters(ProjectCollection.GlobalProjectCollection)
{
Loggers = new ILogger[] { new ErrorLogger(OnError) }
};
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
BuildRequestData request = new BuildRequestData(buildProject.CreateProjectInstance(), new string[0]);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(request);
BuildResult result = submission.Execute();
BuildManager.DefaultBuildManager.EndBuild();
OnError("Project compilation complete.");
return(result.OverallResult == BuildResultCode.Success);
}
public void Build(string[] projectPaths, string target, bool parallelBuild, int maxNodeCount = 1)
{
Console.WriteLine("========================================");
BuildParameters buildParameters = new BuildParameters(ProjectCollection.GlobalProjectCollection)
{
Loggers = new[] { _logger },
MaxNodeCount = maxNodeCount
};
if (!parallelBuild)
{
foreach (string projectPath in projectPaths)
{
Console.WriteLine("Building {0}...", projectPath);
BuildResult buildResult = _buildManager.Build(buildParameters, CreateRequest(projectPath, target));
Console.WriteLine("=====> [{0}] {1}", buildResult.OverallResult, projectPath);
}
}
else
{
_buildManager.BeginBuild(buildParameters);
using (CountdownEvent countdownEvent = new CountdownEvent(projectPaths.Length))
{
foreach (string projectPath in projectPaths)
{
Console.WriteLine("Building {0} in parallel...", projectPath);
BuildSubmission submission = _buildManager.PendBuildRequest(CreateRequest(projectPath, target));
submission.ExecuteAsync(o => {
Console.WriteLine("=====> [{0}] {1}", o.BuildResult.OverallResult, projectPath);
countdownEvent.Signal();
}, null);
}
countdownEvent.Wait();
}
_buildManager.EndBuild();
}
}
public bool Build(IVsProject project, BuildCallback buildCallback, BuildLogger buildLogger, string platform, string configuration)
{
return(project.WithProject((MSBuildProject msproject) =>
{
//
// We need to set this before we acquire the build resources otherwise Msbuild
// will not see the changes.
//
bool onlyLogCriticalEvents = msproject.ProjectCollection.OnlyLogCriticalEvents;
msproject.ProjectCollection.Loggers.Add(buildLogger);
msproject.ProjectCollection.OnlyLogCriticalEvents = false;
uint cookie;
int err = BuildManagerAccessor.AcquireBuildResources(VSBUILDMANAGERRESOURCE.VSBUILDMANAGERRESOURCE_DESIGNTIME |
VSBUILDMANAGERRESOURCE.VSBUILDMANAGERRESOURCE_UITHREAD, out cookie);
if (err != VSConstants.E_PENDING && err != VSConstants.S_OK)
{
ErrorHandler.ThrowOnFailure(err);
}
if (err == VSConstants.E_PENDING)
{
msproject.ProjectCollection.Loggers.Remove(buildLogger);
msproject.ProjectCollection.OnlyLogCriticalEvents = onlyLogCriticalEvents;
Dispatcher = Dispatcher.CurrentDispatcher;
BuildAvailableEvent = new ManualResetEvent(false);
BuildAvailableEvent.SafeWaitHandle = new SafeWaitHandle(BuildManagerAccessor.DesignTimeBuildAvailable, false);
Thread t = new Thread(() =>
{
BuildAvailableEvent.WaitOne();
Dispatcher.BeginInvoke(new Action(() =>
{
Package.Instance.BuildNextProject();
}));
});
t.Start();
return false;
}
else
{
try
{
Dictionary <string, string> properties = new Dictionary <string, string>();
properties["Platform"] = platform;
properties["Configuration"] = configuration;
BuildRequestData buildRequest = new BuildRequestData(
msproject.FullPath,
properties,
null,
new string[] { "SliceCompile" },
msproject.ProjectCollection.HostServices,
BuildRequestDataFlags.ProvideProjectStateAfterBuild |
BuildRequestDataFlags.IgnoreExistingProjectState |
BuildRequestDataFlags.ReplaceExistingProjectInstance);
BuildSubmission submission = BuildManager.DefaultBuildManager.PendBuildRequest(buildRequest);
ErrorHandler.ThrowOnFailure(BuildManagerAccessor.RegisterLogger(submission.SubmissionId, buildLogger));
Dispatcher.BeginInvoke(DispatcherPriority.Send, new Action(() =>
{
buildCallback.BeginBuild(platform, configuration);
}));
submission.ExecuteAsync(s =>
{
Dispatcher.BeginInvoke(DispatcherPriority.Send, new Action(() =>
{
msproject.ProjectCollection.Loggers.Remove(buildLogger);
msproject.ProjectCollection.OnlyLogCriticalEvents = onlyLogCriticalEvents;
BuildManagerAccessor.ReleaseBuildResources(cookie);
s.BuildManager.ResetCaches();
BuildManagerAccessor.UnregisterLoggers(s.SubmissionId);
buildCallback.EndBuild(s.BuildResult.OverallResult == BuildResultCode.Success);
}));
}, null);
return true;
}
catch (Exception)
{
msproject.ProjectCollection.Loggers.Remove(buildLogger);
msproject.ProjectCollection.OnlyLogCriticalEvents = onlyLogCriticalEvents;
BuildManagerAccessor.ReleaseBuildResources(cookie);
throw;
}
}
}));
}
public override async Task <bool> Process(Resource resource)
{
var solution = Path.Combine(resource.Path, resource.Info["clr_solution"]);
// set global properties
var globalProperties = new Dictionary <string, string>();
globalProperties["Configuration"] = "Release";
globalProperties["OutputPath"] = Path.GetFullPath(Path.Combine(Path.Combine(Program.RootDirectory, "cache/resource_bin"), resource.Name)) + "/";
globalProperties["IntermediateOutputPath"] = Path.GetFullPath(Path.Combine(Path.Combine(Program.RootDirectory, "cache/resource_obj"), resource.Name)) + "/";
globalProperties["OutDir"] = globalProperties["OutputPath"]; // for Mono?
try
{
// prepare the project file
var projectRoot = ProjectRootElement.Open(Path.GetFullPath(solution));
// disable any Citizen profiles
foreach (var property in projectRoot.Properties)
{
if (property.Name == "TargetFrameworkProfile")
{
property.Value = "";
}
}
// we don't want the system mscorlib
projectRoot.AddProperty("NoStdLib", "true");
// add hint paths for all references
Func <string, string> getPath = a => Path.GetFullPath(Path.Combine(Path.Combine(Program.RootDirectory, "system/clrcore"), a + ".dll"));
foreach (var item in projectRoot.Items)
{
if (item.ItemType == "Reference")
{
// remove existing hint paths
item.Metadata.Where(a => a.Name == "HintPath").ToList().ForEach(a => item.RemoveChild(a));
item.AddMetadata("HintPath", getPath(item.Include));
item.AddMetadata("Private", "false");
}
}
// add our own mscorlib
projectRoot.AddItem("Reference", "mscorlib", new Dictionary <string, string>()
{
{ "HintPath", getPath("mscorlib") },
{ "Private", "false" }
});
// create an instance and build request
var projectInstance = new ProjectInstance(projectRoot, globalProperties, "4.0", ProjectCollection.GlobalProjectCollection);
var buildRequest = new BuildRequestData(projectInstance, new[] { "Build" }, null);
BuildSubmission buildSubmission = null;
// run this in a separate task
await Task.Run(() =>
{
// building is mutually-exclusive thanks to MSBuild working directory affinity
lock (_compileLock)
{
// set the working directory
var oldDirectory = Environment.CurrentDirectory;
Environment.CurrentDirectory = Path.GetFullPath(Path.GetDirectoryName(solution));
// set the build parameters
var buildParameters = new BuildParameters();
buildParameters.Loggers = new[] { this };
BuildManager.DefaultBuildManager.BeginBuild(buildParameters);
// create a build submission and execute
buildSubmission = BuildManager.DefaultBuildManager.PendBuildRequest(buildRequest);
buildSubmission.Execute();
// end building
BuildManager.DefaultBuildManager.EndBuild();
// put the current directory back
Environment.CurrentDirectory = oldDirectory;
}
});
this.Log().Info("Build for {0} complete - result: {1}", resource.Name, buildSubmission.BuildResult.OverallResult);
var success = (buildSubmission.BuildResult.OverallResult == BuildResultCode.Success);
if (success)
{
// the targets producing 'interesting' items (resource_bin/*.dll)
var targetList = new[] { "Build", "CoreBuild" }; // CoreBuild is needed on Mono
// callback to run on each target
Action <TargetResult> iterateResult = buildResult =>
{
if (buildResult.Items != null)
{
foreach (var item in buildResult.Items)
{
var baseName = Path.GetFileName(item.ItemSpec);
resource.ExternalFiles[string.Format("bin/{0}", baseName)] = new FileInfo(item.ItemSpec);
}
}
};
// loop through the targets
foreach (var target in targetList)
{
TargetResult result;
// if it's a resulting target
if (buildSubmission.BuildResult.ResultsByTarget.TryGetValue(target, out result))
{
iterateResult(result);
}
}
}
else
{
foreach (var logItem in m_logDump)
{
this.Log().Error(logItem);
}
}
m_logDump.Clear();
// unload the project so it will not get cached
ProjectCollection.GlobalProjectCollection.UnloadProject(projectRoot);
return(success);
}
catch (Exception e)
{
this.Log().Error(() => "Building assembly failed: " + e.Message, e);
return(false);
}
}
private static void SetBuildComplete(BuildSubmission submission)
{
var tcs = (TaskCompletionSource <BuildResult>)submission.AsyncContext;
tcs.SetResult(submission.BuildResult);
}
