/// <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); }