/// <summary>
/// Builds the specified target and returns the build result.
/// </summary>
/// <param name="project">The project to build</param>
/// <param name="logger">The build logger to use. If null then a default logger will be used that dumps the build output to the console.</param>
/// <param name="targets">Optional list of targets to execute</param>
public static BuildResult BuildTargets(ProjectInstance projectInstance, ILogger logger, params string[] targets)
{
if (projectInstance == null)
{
throw new ArgumentNullException("projectInstance");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
BuildParameters parameters = new BuildParameters();
parameters.Loggers = new ILogger[] { logger ?? new BuildLogger() };
parameters.UseSynchronousLogging = true;
parameters.ShutdownInProcNodeOnBuildFinish = true; // required, other we can get an "Attempted to access an unloaded AppDomain" exception when the test finishes.
BuildRequestData requestData = new BuildRequestData(projectInstance, targets);
BuildResult result = null;
BuildManager mgr = new BuildManager();
try
{
result = mgr.Build(parameters, requestData);
result.ProjectStateAfterBuild = projectInstance;
BuildUtilities.DumpProjectProperties(projectInstance, "Project properties post-build");
}
finally
{
mgr.ShutdownAllNodes();
mgr.ResetCaches();
mgr.Dispose();
}
return(result);
}
public void VerifyNoOverCreationOfNodesWithBuildLoop()
{
// Since we're creating our own BuildManager, we need to make sure that the default
// one has properly relinquished the inproc node
NodeProviderInProc nodeProviderInProc = ((IBuildComponentHost)BuildManager.DefaultBuildManager).GetComponent(BuildComponentType.InProcNodeProvider) as NodeProviderInProc;
nodeProviderInProc?.Dispose();
_host = new MockHost();
_host.BuildParameters.MaxNodeCount = 3;
_scheduler = new Scheduler();
_scheduler.InitializeComponent(_host);
_parameters = new BuildParameters();
_parameters.ShutdownInProcNodeOnBuildFinish = true;
_buildManager = new BuildManager();
CreateConfiguration(99, "parent.proj");
_defaultParentRequest = CreateBuildRequest(99, 99, new string[] { }, null);
CreateConfiguration(1, "foo.proj");
BuildRequest request1 = CreateBuildRequest(1, 1, new string[] { "foo" }, NodeAffinity.OutOfProc, _defaultParentRequest);
CreateConfiguration(2, "foo2.proj");
BuildRequest request2 = CreateBuildRequest(2, 2, new string[] { "bar" }, NodeAffinity.OutOfProc, _defaultParentRequest);
CreateConfiguration(3, "foo3.proj");
BuildRequest request3 = CreateBuildRequest(3, 3, new string[] { "bar" }, NodeAffinity.InProc, _defaultParentRequest);
List <ScheduleResponse> responses = new List <ScheduleResponse>(_scheduler.ReportRequestBlocked(1, new BuildRequestBlocker(-1, new string[] { }, new BuildRequest[] { _defaultParentRequest, request1, request2, request3 })));
int nextNodeId = 1;
bool inProcNodeExists = false;
MockPerformSchedulingActions(responses, ref nextNodeId, ref inProcNodeExists);
Assert.Equal(4, nextNodeId); // 3 nodes
}
protected override void OnBuildInitialized()
{
Parameters = new BuildParameters(this);
Information("Building version {0} of Avalonia ({1}) using version {2} of Nuke.",
Parameters.Version,
Parameters.Configuration,
typeof(NukeBuild).Assembly.GetName().Version.ToString());
if (Parameters.IsLocalBuild)
{
Information("Repository Name: " + Parameters.RepositoryName);
Information("Repository Branch: " + Parameters.RepositoryBranch);
}
Information("Configuration: " + Parameters.Configuration);
Information("IsLocalBuild: " + Parameters.IsLocalBuild);
Information("IsRunningOnUnix: " + Parameters.IsRunningOnUnix);
Information("IsRunningOnWindows: " + Parameters.IsRunningOnWindows);
Information("IsRunningOnAzure:" + Parameters.IsRunningOnAzure);
Information("IsPullRequest: " + Parameters.IsPullRequest);
Information("IsMainRepo: " + Parameters.IsMainRepo);
Information("IsMasterBranch: " + Parameters.IsMasterBranch);
Information("IsReleaseBranch: " + Parameters.IsReleaseBranch);
Information("IsReleasable: " + Parameters.IsReleasable);
Information("IsMyGetRelease: " + Parameters.IsMyGetRelease);
Information("IsNuGetRelease: " + Parameters.IsNuGetRelease);
void ExecWait(string preamble, string command, string args)
{
Console.WriteLine(preamble);
Process.Start(new ProcessStartInfo(command, args)
{
UseShellExecute = false
}).WaitForExit();
}
ExecWait("dotnet version:", "dotnet", "--info");
ExecWait("dotnet workloads:", "dotnet", "workload list");
}
protected override void OnBuildInitialized()
{
Parameters = new BuildParameters(this);
Information("Building version {0} of NetVips ({1}).",
Parameters.Version,
Parameters.Configuration);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Information("OS: Windows");
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
Information("OS: Linux");
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
Information("OS: macOS");
}
Information("Bitness: " + (Environment.Is64BitProcess ? "64 bit" : "32 bit"));
Information("Host type: " + Host);
if (!string.IsNullOrWhiteSpace(Parameters.VipsVersion))
{
Information("Version of libvips: " + Parameters.VipsVersion);
}
Information("Configuration: " + Parameters.Configuration);
void ExecWait(string preamble, string command, string args)
{
Console.WriteLine(preamble);
Process.Start(new ProcessStartInfo(command, args)
{
UseShellExecute = false
})?.WaitForExit();
}
ExecWait("dotnet version:", "dotnet", "--version");
}
public IEnumerable <StatBuilderResult> Concretize(BuildParameters parameters, StatBuilderResult result)
{
var applyToSkillDamage = _applyToSkillDamage.GetValueOrDefault(false);
var applyToAilmentDamage = _applyToAilmentDamage.GetValueOrDefault(false);
var applyToAny = applyToSkillDamage || applyToAilmentDamage;
var results = new List <StatBuilderResult>();
var sourceStats = new List <IStat>();
// This method is the hot path of building modifiers from builders. Using HashSet instead of this array
// would be much slower (HashSet.Add() would be 60% of this method's execution time, array is negligible).
var sourceSkillDamageSources = new bool[Enums.GetMemberCount <DamageSource>()];
foreach (var spec in _specificationBuilder.Build())
{
var stats = ConcretizeStats(spec, result.Stats);
var valueConverter = ValueConverterForResult(parameters, result, spec);
results.Add(new StatBuilderResult(stats, result.ModifierSource, valueConverter));
if (applyToSkillDamage && spec.IsSkillDamage())
{
sourceSkillDamageSources[(int)spec.DamageSource] = true;
}
if (applyToAny)
{
sourceStats.AddRange(stats);
}
}
if (applyToSkillDamage)
{
results.AddRange(ApplyToSkillDamage(parameters, result, sourceStats, sourceSkillDamageSources));
}
if (applyToAilmentDamage)
{
results.AddRange(ApplyToAilmentDamage(parameters, result, sourceStats));
}
return(results);
}
public void InitializeComponent()
{
IBuildComponent logServiceComponent = (IBuildComponent)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1);
BuildParameters parameters = new BuildParameters();
parameters.MaxNodeCount = 4;
parameters.OnlyLogCriticalEvents = true;
IBuildComponentHost loggingHost = new MockHost(parameters);
// Make sure we are in the Instantiated state before initializing
Assert.Equal(((LoggingService)logServiceComponent).ServiceState, LoggingServiceState.Instantiated);
logServiceComponent.InitializeComponent(loggingHost);
// Makesure that the parameters in the host are set in the logging service
LoggingService service = (LoggingService)logServiceComponent;
Assert.Equal(service.ServiceState, LoggingServiceState.Initialized);
Assert.Equal(4, service.MaxCPUCount);
Assert.True(service.OnlyLogCriticalEvents);
}
private void BuildProject()
{
var projectCollection = new ProjectCollection(ToolsetDefinitionLocations.Registry | ToolsetDefinitionLocations.ConfigurationFile);
BuildRequestData requestData = new BuildRequestData(_project.FullPath, Properties, _project.ToolsVersion, new string[0], null);
BuildParameters parameters = new BuildParameters(projectCollection);
parameters.Loggers = new[] { new ConsoleLogger()
{
Verbosity = LoggerVerbosity.Quiet
} };
parameters.NodeExeLocation = typeof(ProjectFactory).Assembly.Location;
parameters.ToolsetDefinitionLocations = projectCollection.ToolsetLocations;
BuildResult result = BuildManager.DefaultBuildManager.Build(parameters, requestData);
// Build the project so that the outputs are created
if (result.OverallResult == BuildResultCode.Failure)
{
// If the build fails, report the error
throw new CommandLineException(NuGetResources.FailedToBuildProject, Path.GetFileName(_project.FullPath));
}
TargetPath = ResolveTargetPath(result);
}
public void Deploy(string configTransformName, string deployPath)
{
var loggers = new ILogger[] { new ConsoleLogger(LoggerVerbosity.Normal) };
var parameters = new BuildParameters {
Loggers = loggers
};
var globalProperties = new Dictionary <string, string>
{
{ "Configuration", configTransformName },
{ "_PackageTempDir", deployPath }
};
var requestData = new BuildRequestData(_projectLocation.ProjectName, globalProperties, null,
new[] { "Clean", "Package" }, null);
var result = BuildManager.DefaultBuildManager.Build(parameters, requestData);
if (result.OverallResult != BuildResultCode.Success || !Directory.Exists(deployPath))
{
throw new Exception("Build failed.");
}
}
public static bool Build(string msbuildFileName, string destinationLogFolder, string fileLogName,
string Configuration, string Platform)
{
try
{
var projectCollection = new ProjectCollection();
var buildParamters = new BuildParameters(projectCollection);
buildParamters.Loggers = new List <ILogger>
{
new FileLogger {
Parameters = $"logfile={destinationLogFolder} \\{fileLogName}Build.log"
}
};
var globalProperty = new Dictionary <String, String>();
globalProperty.Add("Configuration", Configuration);
globalProperty.Add("Platform", Platform);
BuildManager.DefaultBuildManager.ResetCaches();
var buildRequest = new BuildRequestData(msbuildFileName, globalProperty, null, new[] { "Clean", "Build" },
null);
var buildResult = BuildManager.DefaultBuildManager.Build(buildParamters, buildRequest);
return(buildResult.OverallResult == BuildResultCode.Success);
}
catch (Exception ex)
{
LogEngine.WriteLog(ConfigurationBag.EngineName,
"Configuration.WebApiEndPoint key empty, internal Web Api interface disable",
Constant.LogLevelError,
Constant.TaskCategoriesError,
ex,
Constant.LogLevelWarning);
return(false);
}
}
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));
}
}
}
}
private static async Task <BuildResult> ResolveReferencesAsync(Project project)
{
var projectInstance = project.CreateProjectInstance();
string target = IsMultitargetingProject(project) ? "DispatchToInnerBuilds" : "ResolveReferences";
var buildRequestData = new BuildRequestData(projectInstance, new string[] { target });
var buildManager = BuildManager.DefaultBuildManager;
var buildParameters = new BuildParameters(project.ProjectCollection);
#if DEBUG
// Log output in debug mode
string logFilePath = Path.Combine(
project.DirectoryPath,
projectInstance.GetPropertyValue("BaseIntermediateOutputPath"), // "obj" subfolder
LogFileName);
buildParameters.Loggers = new ILogger[]
{
new FileLogger()
{
Verbosity = LoggerVerbosity.Detailed,
Parameters = $"LogFile={logFilePath}"
}
};
#endif
await _buildManagerSemaphore.WaitAsync();
try
{
return(await RunBuildAsync(projectInstance, buildRequestData, buildManager, buildParameters));
}
finally
{
_buildManagerSemaphore.Release();
}
}
public void OneSubmissionOneLogger()
{
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 };
buildManager.BeginBuild(parameters);
MockLogger mockLogger = new MockLogger();
try
{
BuildSubmission submission = buildManager.PendBuildRequest(new BuildRequestData(project, new string[0], null));
muxLogger.RegisterLogger(submission.SubmissionId, mockLogger);
submission.Execute();
}
finally
{
buildManager.EndBuild();
}
mockLogger.AssertLogContains("Foo");
mockLogger.AssertLogContains("Error");
Assert.Equal(1, mockLogger.ErrorCount);
mockLogger.AssertNoWarnings();
}
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();
}
}
/// <summary>
/// Set up parametrs of build and make build, NuGets must be RESTORED!
/// </summary>
/// <param name="configProvider">Provides configuration</param>
/// <param name="buildable">Represents buildable .NET solution</param>
private void MakeBuild(IConfigProvider configProvider, IBuildable buildable)
{
try
{
ProjectCollection pc = new ProjectCollection();
Dictionary <string, string> globalProperty = new Dictionary <string, string>
{
{ "Configuration", "Release" },
{ "Platform", "Any CPU" },
{ "OutputPath", buildable.OutputBuildPath + "\\build" }
};
BuildParameters bp = new BuildParameters(pc);
File.WriteAllText(buildable.OutputBuildPath + "\\build.log", "");
bp.Loggers = new[] {
new FileLogger
{
Verbosity = LoggerVerbosity.Detailed,
ShowSummary = true,
SkipProjectStartedText = false,
Parameters = buildable.OutputBuildPath + "\\build.log"
}
};
BuildRequestData buidlRequest = new BuildRequestData(Directory.GetFiles(buildable.SolutionRootPath, "*.sln", SearchOption.AllDirectories).First(), globalProperty, "4.0", new[] { "Build" }, null);
BuildResult buildResult = BuildManager.DefaultBuildManager.Build(bp, buidlRequest);
if (buildResult.OverallResult != BuildResultCode.Success)
{
throw new ArgumentException("Provided buildable is not valid :( " + buildable.SolutionRootPath);
}
}
catch (Exception e)
{
throw new ArgumentException("Provided buildable is not valid.", e);
}
}
/* public BuildSolutionResult Build(string solutionFile, Action<string> projectBuildStarted, Action<string, bool, string> projectBuildComplete, Action<string, string, string, int, int, string> errorLogger)
* {
* nugetPackageManager.RestoreSolutionPackages(solutionFile);
* return this.BuildInternal(solutionFile, projectBuildStarted, projectBuildComplete, errorLogger);
* }
*/
private BuildSolutionResult BuildInternal(string targetFile, Action <string> projectBuildStarted, Action <string, bool, string> projectBuildComplete, Action <string, Exception> errorLogger)
{
ProjectCollection projectCollection = new ProjectCollection();
Dictionary <string, string> globalProperty = new Dictionary <string, string>
{
{ "Configuration", "Release" },
{ "VisualStudioVersion", "14.0" },
//{"Platform", "Any CPU"}
};
BuildRequestData buildRequestData = new BuildRequestData(
targetFile,
globalProperty,
null,
new[]
{
"Rebuild"
},
null);
BuildParameters buildParameters = new BuildParameters(projectCollection);
buildParameters.MaxNodeCount = 4;
buildParameters.Loggers = new List <ILogger>
{
new MSBuildLogger(projectBuildStarted, projectBuildComplete, errorLogger)
};
BuildResult buildResult = BuildManager.DefaultBuildManager.Build(buildParameters, buildRequestData);
return(new BuildSolutionResult
{
IsSuccess = buildResult.OverallResult == BuildResultCode.Success
});
}
/*-------------build the csproj in the given path--------------*/
public void BuildCsproj(string proPath, string outpath)
{
string logName = portNum + "-log" + logCount++;
string projectFileName = proPath;
buildSucceed = false;
ConsoleLogger logger = new ConsoleLogger();
FileLogger Flogger = new FileLogger()
{
Parameters = @"logfile=" + chdLogPath + "/" + logName, Verbosity = LoggerVerbosity.Normal
};
Dictionary <string, string> GlobalProperty = new Dictionary <string, string>();
GlobalProperty.Add("Configuration", "Debug");
GlobalProperty.Add("Platform", "Any CPU");
GlobalProperty.Add("OutputType", "Library");
GlobalProperty.Add("OutputPath", outpath);
BuildRequestData BuildRequest = new BuildRequestData(projectFileName, GlobalProperty, null, new string[] { "Rebuild" }, null);
BuildParameters bp = new BuildParameters();
bp.Loggers = new List <ILogger> {
logger, Flogger
};
BuildResult buildResult = BuildManager.DefaultBuildManager.Build(bp, BuildRequest);
if (buildResult.OverallResult == BuildResultCode.Success)
{
buildSucceed = true;
sendTestRequest();
}
postLogFile(logName);
Console.WriteLine();
}
public void AddAddsFromStatsCorrectly()
{
var expectedStats = new[] { new StatStub(), };
var expectedForm = Form.BaseSet;
var expectedValue = new Constant(42);
var expectedModifierSource = GlobalSource;
var expected = new[]
{
new Modifier(expectedStats, expectedForm, expectedValue, expectedModifierSource)
};
var buildParams = new BuildParameters(expectedModifierSource, Entity.Enemy, expectedForm);
var formBuilderMock = new Mock <IFormBuilder>();
formBuilderMock.Setup(b => b.Build())
.Returns((expectedForm, Funcs.Identity));
var statBuilderMock = new Mock <IStatBuilder>();
statBuilderMock.Setup(b => b.Build(buildParams))
.Returns(new[] { new StatBuilderResult(expectedStats, expectedModifierSource, Funcs.Identity), });
var valueBuilder = Mock.Of <IValueBuilder>(b => b.Build(buildParams) == expectedValue);
var intermediateModifier = ModifierBuilder.Empty
.WithForm(formBuilderMock.Object).WithStat(statBuilderMock.Object).WithValue(valueBuilder)
.Build();
var givenStats = new[]
{
Mock.Of <IGivenStats>(s =>
s.AffectedEntities == new[] { Entity.Enemy } &&
s.GivenStatLines == new string[0] &&
s.GivenModifiers == new[] { intermediateModifier })
};
var actual = GivenStatsParser.Parse(Mock.Of <ICoreParser>(), givenStats);
Assert.AreEqual(expected, actual);
}
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 void GetParameterValue_TeamcityBuildConfName_ValueReturned()
{
var teamCityBuildPropertiesFileRetriever = A.Fake <ITeamCityBuildPropertiesFileRetriever>();
A.CallTo(() => teamCityBuildPropertiesFileRetriever.GetTeamCityBuildPropertiesFilePath()).Returns(@"C:\properties.file.txt");
var dictionary = new Dictionary <string, string> {
{ "teamcity.buildConfName", "FluentTc" }
};
var propertiesFileParser = A.Fake <IPropertiesFileParser>();
A.CallTo(() => propertiesFileParser.ParsePropertiesFile(@"C:\properties.file.txt"))
.Returns(dictionary);
var buildParameters = new BuildParameters(teamCityBuildPropertiesFileRetriever, A.Fake <ITeamCityWriterFactory>(),
propertiesFileParser);
// Act
string buildConfName = buildParameters.TeamcityBuildConfName;
// Assert
buildConfName.Should().Be("FluentTc");
}
public void SetParameterValue_NotTeamCityMode_ValueSet()
{
// Arrange
var teamCityWriter = A.Fake <ITeamCityWriter>();
var teamCityBuildPropertiesFileRetriever = A.Fake <ITeamCityBuildPropertiesFileRetriever>();
A.CallTo(() => teamCityBuildPropertiesFileRetriever.GetTeamCityBuildPropertiesFilePath()).Returns(null);
var teamCityWriterFactory = A.Fake <ITeamCityWriterFactory>();
A.CallTo(() => teamCityWriterFactory.CreateTeamCityWriter()).Returns(teamCityWriter);
var buildParameters = new BuildParameters(teamCityBuildPropertiesFileRetriever, teamCityWriterFactory,
A.Fake <IPropertiesFileParser>());
// Act
buildParameters.SetBuildParameter("param1", "newValue");
var parameterValue = buildParameters.GetBuildParameter <string>("param1");
// Assert
parameterValue.Should().Be("newValue");
A.CallTo(() => teamCityWriter.WriteBuildParameter("param1", "newValue")).MustHaveHappened();
}
/// <summary>
/// Set up
/// </summary>
public Scheduler_Tests()
{
// Since we're creating our own BuildManager, we need to make sure that the default
// one has properly relinquished the inproc node
NodeProviderInProc nodeProviderInProc = ((IBuildComponentHost)BuildManager.DefaultBuildManager).GetComponent(BuildComponentType.InProcNodeProvider) as NodeProviderInProc;
nodeProviderInProc?.Dispose();
_host = new MockHost();
_scheduler = new Scheduler();
_scheduler.InitializeComponent(_host);
CreateConfiguration(99, "parent.proj");
_defaultParentRequest = CreateBuildRequest(99, 99, new string[] { }, null);
// Set up the scheduler with one node to start with.
_scheduler.ReportNodesCreated(new NodeInfo[] { new NodeInfo(1, NodeProviderType.InProc) });
_scheduler.ReportRequestBlocked(1, new BuildRequestBlocker(-1, new string[] { }, new BuildRequest[] { _defaultParentRequest }));
_logger = new MockLogger();
_parameters = new BuildParameters();
_parameters.Loggers = new ILogger[] { _logger };
_parameters.ShutdownInProcNodeOnBuildFinish = true;
_buildManager = new BuildManager();
}
/// <summary>
/// Creates a temporary MSBuild content project in memory.
/// </summary>
void CreateBuildProject()
{
string projectPath = Path.Combine(buildDirectory, "content.contentproj");
//string outputPath = Path.Combine(buildDirectory, "bin");
string CurrentDirectory = Directory.GetCurrentDirectory();
string outputPath = Directory.GetParent(Directory.GetCurrentDirectory()).FullName;
// Create the build project.
projectRootElement = ProjectRootElement.Create(outputPath + "\\Content");
// Include the standard targets file that defines how to build XNA Framework content.
/*projectRootElement.AddImport("$(MSBuildExtensionsPath)\\Microsoft\\XNA Game Studio\\" +
* "v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets");*/
projectRootElement.AddImport(CurrentDirectory + "\\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);
// 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);
buildParameters.Loggers = new ILogger[] { errorLogger };
}
public void TaskIsPrcessed()
{
var man = BuildManager.DefaultBuildManager;
var bp = new BuildParameters();
var brd = new BuildRequestData(Path.Combine(Tmpdir, "mainp.proj"), new Dictionary <string, string>
{
{
"AssemblyPath",
typeof(QorpentDsl).Assembly.CodeBase.
Replace("file:///", "")
}
}, null, new[] { "Test" }, null,
BuildRequestDataFlags.None);
ILogger l = new ConsoleLogger();
bp.Loggers = new[] { l };
man.Build(bp, brd);
Assert.True(File.Exists(Path.Combine(Tmpdir, "A.cs")));
Assert.True(File.Exists(Path.Combine(Tmpdir, "B.cs")));
Assert.True(File.Exists(Path.Combine(Tmpdir, "C.cs")));
Assert.AreEqual("namespace X{ public partial class A{}}", File.ReadAllText(Path.Combine(Tmpdir, "A.cs")));
}
/// <summary>
/// Builds a project.
/// </summary>
/// <param name="projectInstance">The project to build.</param>
/// <param name="targetsToBuild">The targets to build. If not specified, the project's default target will be invoked.</param>
/// <returns>A task whose result is the result of the build.</returns>
public static async Task <BuildResultAndLogs> ExecuteAsync(ProjectInstance projectInstance, ITestOutputHelper testLogger = null, params string[] targetsToBuild)
{
targetsToBuild = (targetsToBuild == null || targetsToBuild.Length == 0) ? projectInstance.DefaultTargets.ToArray() : targetsToBuild;
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 brdFlags = BuildRequestDataFlags.ProvideProjectStateAfterBuild;
var requestData = new BuildRequestData(projectInstance, targetsToBuild, null, brdFlags);
var submission = buildManager.PendBuildRequest(requestData);
result = await submission.ExecuteAsync();
}
finally
{
buildManager.EndBuild();
}
}
return(new BuildResultAndLogs(result, logger.LogEvents, logLines));
}
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 }
};
}
internal static async Task <BuildResult> BuildAsync(this BuildManager buildManager, ITestOutputHelper logger, ProjectCollection projectCollection, ProjectRootElement project, string target, IDictionary <string, string> globalProperties = 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);
parameters.Loggers = new ILogger[]
{
new ConsoleLogger(LoggerVerbosity.Detailed, s => logger.WriteLine(s.TrimEnd('\r', '\n')), null, null),
};
buildManager.BeginBuild(parameters);
var result = await buildManager.BuildAsync(brd);
buildManager.EndBuild();
return(result);
}
/*
* This method uses MSBuild to build a .csproj file.
* The csproj file is configured to build as Debug/AnyCPU
* Therefore, there is no need to specify the parameters here.
* This is useful for the build server because it should be as
* general as it can get. The build server shouldn't have to
* specify different build parameters for each project.
* Instead, the csproj file sets the configuration settings.
*
* In the csproj file, the OutputPath is set to "csproj_Debug"
* for the Debug configuration, and "csproj_Release" for the
* Release configuration. Moreover, if Debug was selected, the
* project will be build into an x86 library (DLL), while if Release
* was selected, the project will build into an x64 executable (EXE)
*
* To change the default configuration, the first PropertyGroup
* in the ..\..\..\files\Builder.csproj must be modified.
*/
public void BuildCsproj()
{
string projectFileName = @"..\..\..\Execute\BuilderStorage";
projectFileName = Path.GetFullPath(projectFileName);
var Builderfolders = Directory.EnumerateFiles(projectFileName, "*.csproj", SearchOption.AllDirectories);
//get all the .csproj files that conclude build information in them, and then build each of them
foreach (string file in Builderfolders)
{
ConsoleLogger logger = new ConsoleLogger();
Dictionary <string, string> GlobalProperty = new Dictionary <string, string>();
BuildRequestData BuildRequest = new BuildRequestData(file, GlobalProperty, null, new string[] { "Rebuild" }, null);
BuildParameters bp = new BuildParameters();
bp.Loggers = new List <ILogger> {
logger
};
BuildResult buildResult = BuildManager.DefaultBuildManager.Build(bp, BuildRequest);
Console.WriteLine();
}
}
static void Main(string[] args)
{
var pc = new ProjectCollection();
var path = Directory.CreateDirectory(Path.GetTempPath() + Guid.NewGuid().ToString("N") + "\\");
var props = new Dictionary <string, string>
{
{ "Configuration", "Debug" },
{ "Platform", "AnyCPU" },
{ "OutputPath", path.FullName }
};
var buildParams = new BuildParameters(pc)
{
DetailedSummary = true,
Loggers = new List <ILogger> {
new ConsoleLogger()
},
DefaultToolsVersion = "14.0"
};
var targets = new List <string> {
"PrepareForBuild", "Clean", "Build", "Publish"
};
var reqData = new BuildRequestData(GetProjectPath(), props, "14.0", targets.ToArray(), null);
try
{
Log("Starting MSBuild build");
BuildManager.DefaultBuildManager.BeginBuild(buildParams);
var buildResult = BuildManager.DefaultBuildManager.BuildRequest(reqData);
Log($"MSBuild build complete: {buildResult.OverallResult}");
}
catch (InvalidCastException ex)
{
Log(ex.Message);
throw;
}
}
/// <summary>
/// Creates a temporary MSBuild content project in memory.
/// </summary>
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("$(MSBuildExtensionsPath)\\Microsoft\\XNA Game Studio\\" +
"v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets");
buildProject = new Project(projectRootElement);
ProjectItemGroupElement teste = projectRootElement.AddItemGroup();
teste.AddItem("ProjectReference", @"C:\Users\Renann\Desktop\StrategyGame\StrategyGameLibrary\StrategyGameLibrary.csproj");
buildProject.SetProperty("XnaPlatform", "Windows");
buildProject.SetProperty("XnaProfile", "Reach");
buildProject.SetProperty("XnaFrameworkVersion", "v4.0");
buildProject.SetProperty("Configuration", "Release");
buildProject.SetProperty("OutputPath", outputPath);
// 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);
buildParameters.Loggers = new ILogger[] { errorLogger };
}
/// <summary>
/// 开始构建
/// </summary>
public bool Run(BuildParameters buildParameters)
{
// 清空旧数据
_buildContext.ClearAllContext();
// 构建参数
var buildParametersContext = new BuildParametersContext(buildParameters);
_buildContext.SetContextObject(buildParametersContext);
// 执行构建流程
List <IBuildTask> pipeline = new List <IBuildTask>
{
new TaskPrepare(), //前期准备工作
new TaskGetBuildMap(), //获取构建列表
new TaskBuilding(), //开始执行构建
new TaskCheckCycle(), //检测循环依赖
new TaskEncryption(), //加密资源文件
new TaskCreatePatchManifest(), //创建清单文件
new TaskCreateReadme(), //创建说明文件
new TaskCreatePatchPackage(), //制作补丁包
new TaskCopyBuildinFiles(), //拷贝内置文件
};
bool succeed = BuildRunner.Run(pipeline, _buildContext);
if (succeed)
{
BuildLogger.Log($"构建成功！");
}
else
{
BuildLogger.Warning($"构建失败！");
}
return(succeed);
}
