public override bool Execute() { try { var files = Directory.GetFiles(OutputPath, "*.*"); foreach (var file in files) { try { Log.LogCommandLine(MessageImportance.Normal, string.Format("Clean: \"{0}\"", file)); File.Delete(file); } catch (Exception ex) { throw new Exception(string.Format("Failed to delete \"{0}\": {1}", file, ex.Message)); } } } catch (Exception e) { var error = new BuildErrorEventArgs(null, null, "", 0, 0, 0, 0, e.Message, null, "Clean", DateTime.UtcNow); BuildEngine.LogErrorEvent(error); return(false); } return(true); }
public virtual void Flush() { var message = stringBuilder.ToString(); message = message.Substring(0, message.Length - 2); BuildEngine.LogMessageEvent(new BuildMessageEventArgs(message, "", "Costura", MessageImportance)); }
protected void LogMessage(string message, MessageImportance importance = MessageImportance.High) { if (BuildEngine != null) { BuildEngine.LogMessageEvent(new BuildMessageEventArgs("DnnPackager: " + message, "DnnPackager", "DnnPackager", importance)); } }
protected void LogError(string code, string message) { if (BuildEngine != null) { BuildEngine.LogErrorEvent(new BuildErrorEventArgs("DnnPackager", code, null, 0, 0, 0, 0, message, "DnnPackager", "DnnPackager")); } }
private void LogMessage(string message, MessageImportance importance) { if (BuildEngine != null) { BuildEngine.LogMessageEvent(new BuildMessageEventArgs(message, null, null, importance)); } }
private void LogWarning(string message, string code, string file, int lineNumber, int columnNumber) { if (BuildEngine != null) { BuildEngine.LogWarningEvent(new BuildWarningEventArgs("BinarySerialization", code, file, lineNumber, columnNumber, lineNumber, columnNumber, message, null, null)); } }
public override bool Execute() { BuildEngine.LogMessageEvent(new BuildMessageEventArgs("ILRepackTask Executing (Change MessageImportance to get more or less info)", "", "ILRepackTask", Microsoft.Build.Framework.MessageImportance.High)); var stopwatch = Stopwatch.StartNew(); try { logger = new Logger { SenderName = "ILRepackTask", BuildEngine = BuildEngine, }; logger.Initialise(MessageImportance); Inner(); } catch (Exception exception) { HandleException(exception); } finally { stopwatch.Stop(); logger.Flush(); BuildEngine.LogMessageEvent(new BuildMessageEventArgs(string.Format("\tFinished ({0}ms)", stopwatch.ElapsedMilliseconds), "", "ILRepackTask", Microsoft.Build.Framework.MessageImportance.High)); } return(!logger.ErrorHasBeenRaised); }
public void MessagesByImportance(string value) { const string expectedMessage = "D2C36BFAE11847CE95B4135775E0156F"; MessageImportance importance = (MessageImportance)Enum.Parse(typeof(MessageImportance), value); BuildEngine buildEngine = GetBuildEngineWithEvents(i => i.LogMessageEvent(new BuildMessageEventArgs(expectedMessage, null, null, importance))); string actualItem = buildEngine.Messages.ShouldHaveSingleItem(); actualItem.ShouldBe(expectedMessage); switch (importance) { case MessageImportance.High: buildEngine.Messages.High.ShouldHaveSingleItem().ShouldBe(actualItem); break; case MessageImportance.Normal: buildEngine.Messages.Normal.ShouldHaveSingleItem().ShouldBe(actualItem); break; case MessageImportance.Low: buildEngine.Messages.Low.ShouldHaveSingleItem().ShouldBe(actualItem); break; } }
private void CreateDotNetFrameworkVisualizer() { //if dot net visualizer exists already don't create it again if (FS.FileSystem.File.Exists(Path.Combine(VisualizerDestinationFolder, DotNetVisualizerAssemblyName))) { return; } try { //this is where the current assembly being built is saved string targetFolder = Path.GetDirectoryName(Assembly); //this is the place where the mapped dot net visualizer will be saved and then read string sourceDotNetAssemblyVisualizerFilePath = Path.Combine(targetFolder, DotNetVisualizerAssemblyName); //this is the target location for the dot net visualizer string targetDotNetAssemblyVisualizerFilePath = Path.Combine(VisualizerDestinationFolder, DotNetVisualizerAssemblyName); //map dot net framework types only if the assembly does not exist //it create such maps in the building folder MapDotNetFrameworkTypes(targetDotNetAssemblyVisualizerFilePath); //delete the temporary visualizer to avoid it dangling in the output folder (Debug/Release) FS.FileSystem.File.Delete(sourceDotNetAssemblyVisualizerFilePath); FS.FileSystem.File.Delete(Path.ChangeExtension(sourceDotNetAssemblyVisualizerFilePath, "pdb")); } catch (Exception exception) { const string errorMessage = "Error Mapping .Net Framework types"; Log.Write(exception, errorMessage); BuildWarningEventArgs errorEvent = new BuildWarningEventArgs("Debugger Visualizer Creator", "", "MapperBuildTask", 0, 0, 0, 0, $"There was an error creating custom debugger visualizers for .Net Framework Types.", "", "LINQBridgeVs"); BuildEngine.LogWarningEvent(errorEvent); exception.Capture(VisualStudioVer, message: errorMessage); } }
private void CreateDebuggerVisualizer() { try { Log.Write("Visualizer Assembly location {0}", _dynamicVisualizerDllAssemblyPath); VisualizerAttributeInjector attributeInjector = new VisualizerAttributeInjector(_dynamicVisualizerDllAssemblyPath, VisualStudioVer); attributeInjector.MapTypesFromAssembly(Assembly); string targetInstallationFilePath = Path.Combine(VisualizerDestinationFolder, TargetVisualizerAssemblyName); attributeInjector.SaveDebuggerVisualizer(targetInstallationFilePath); Log.Write("Assembly {0} Mapped", Assembly); } catch (Exception e) { BuildErrorEventArgs errorEvent = new BuildErrorEventArgs("Debugger Visualizer Creator", "", "MapperBuildTask", 0, 0, 0, 0, $"There was an error creating custom debugger visualizers for project {Assembly}", "", "LINQBridgeVs"); BuildEngine.LogErrorEvent(errorEvent); const string errorMessage = "Error creating debugger visualizers"; Log.Write(e, errorMessage); e.Capture(VisualStudioVer, message: errorMessage); } }
public bool Execute() { Log.VisualStudioVersion = VisualStudioVer; try { string visualizerAssemblyName = VisualizerAssemblyNameFormat.GetTargetVisualizerAssemblyName(VisualStudioVer, Assembly); string targetInstallationPath = VisualStudioOption.GetVisualizerDestinationFolder(VisualStudioVer); string visualizerFullPath = Path.Combine(targetInstallationPath, visualizerAssemblyName); if (FS.FileSystem.File.Exists(visualizerFullPath)) { FS.FileSystem.File.Delete(visualizerFullPath); } //check if pdb also exists and delete it string visualizerPdbFullPath = Path.ChangeExtension(visualizerFullPath, "pdb"); if (FS.FileSystem.File.Exists(visualizerPdbFullPath)) { FS.FileSystem.File.Delete(visualizerPdbFullPath); } } catch (System.Exception exception) { Log.Write(exception, "Error During cleanup"); BuildWarningEventArgs errorEvent = new BuildWarningEventArgs("Debugger Visualizer Cleanup", "", "CleanBuildTask", 0, 0, 0, 0, $"There was an error cleaning custom debugger visualizers", "", "LINQBridgeVs"); BuildEngine.LogWarningEvent(errorEvent); exception.Capture(VisualStudioVer, message: "Error during project cleaning"); } return(true); }
void engine_ProjectPostBuild(BuildEngine engine, ProjectPostBuildEventArgs args) { if (args.BuildFailed) { args.Cancel = true; } }
protected void WaitForCompletion() { WaitHandle[] handles = new WaitHandle[] { logDataAvailable, errorDataAvailable, warningDataAvailable, customDataAvailable, taskCancelled, completed, }; try { while (isRunning) { var index = (WaitHandleIndex)System.Threading.WaitHandle.WaitAny(handles, TimeSpan.FromMilliseconds(10)); switch (index) { case WaitHandleIndex.LogDataAvailable: LogInternal <BuildMessageEventArgs> (logMessageQueue, (e) => { #pragma warning disable 618 Log.LogMessage(e.Importance, e.Message); #pragma warning restore 618 }, logDataAvailable); break; case WaitHandleIndex.ErrorDataAvailable: LogInternal <BuildErrorEventArgs> (errorMessageQueue, (e) => { #pragma warning disable 618 Log.LogCodedError(e.Code, file: e.File, lineNumber: e.LineNumber, message: e.Message); #pragma warning restore 618 }, errorDataAvailable); break; case WaitHandleIndex.WarningDataAvailable: LogInternal <BuildWarningEventArgs> (warningMessageQueue, (e) => { #pragma warning disable 618 Log.LogCodedWarning(e.Code, file: e.File, lineNumber: e.LineNumber, message: e.Message); #pragma warning restore 618 }, warningDataAvailable); break; case WaitHandleIndex.CustomDataAvailable: LogInternal <CustomBuildEventArgs> (customMessageQueue, (e) => { BuildEngine.LogCustomEvent(e); }, customDataAvailable); break; case WaitHandleIndex.TaskCancelled: tcs.Cancel(); isRunning = false; break; case WaitHandleIndex.Completed: isRunning = false; break; } } } finally { } }
public void LogErrorFromResources(string subcategoryResourceName, string errorCode, string helpKeyword, string file, int lineNumber, int columnNumber, int endLineNumber, int endColumnNumber, string messageResourceName, params object[] messageArgs) { if (messageResourceName == null) { throw new ArgumentNullException("messageResourceName"); } ThrowInvalidOperationIf(BuildEngine == null, "Task is attempting to log before it was initialized"); string subcategory = null; if (!String.IsNullOrEmpty(subcategoryResourceName)) { subcategory = taskResources.GetString(subcategoryResourceName); } BuildErrorEventArgs beea = new BuildErrorEventArgs( subcategory, errorCode, file, lineNumber, columnNumber, endLineNumber, endColumnNumber, FormatResourceString(messageResourceName, messageArgs), helpKeyword, null); BuildEngine.LogErrorEvent(beea); hasLoggedErrors = true; }
public bool Execute() { if (!File.Exists(ProjectFile)) { BuildEngine.LogMessageEvent(new BuildMessageEventArgs( $"Failed to find project file \"{ProjectFile}\"", string.Empty, "GetProjectVersions", MessageImportance.High )); return(false); } try { UpdateValuesFromFile(ProjectFile); return(true); } catch (Exception e) { BuildEngine.LogMessageEvent(new BuildMessageEventArgs( $"Failed to load versions from file \"{ProjectFile}\", {e.Message}", string.Empty, "GetProjectVersions", MessageImportance.High )); } return(false); }
protected override int Run(BuildEngine engine) { foreach (ProjectInfo item in engine.Projects) { if (!String.IsNullOrEmpty(item.Properties[MSProp.SolutionDir])) { continue; } //To attempt to gracefully handle those those that use SolutionDir in build rules... string solutiondir = Path.GetDirectoryName(item.ProjectFile); DirectoryInfo parent = new DirectoryInfo(solutiondir); while (parent != null) { if (parent.GetFiles("*.sln").Length > 0) { solutiondir = parent.FullName; break; } parent = parent.Parent; } if (!solutiondir.EndsWith(@"\")) { solutiondir += @"\"; } item.Properties[MSProp.SolutionDir] = solutiondir; } return(0); }
public void A_Reserved_Word_As_A_Property_In_The_Source_Should_Throw_An_Error_With_The_Correct_Error_Exposed() { var compressor = GetJavascriptCompressorFor("Issue9719"); compressor.Execute(); Assert.That(BuildEngine.ContainsError(compressor.BuildEngine, ("invalid property id"))); }
public ProjectBuilder (BuildEngine buildEngine, Engine engine, string file) { this.file = file; this.engine = engine; this.buildEngine = buildEngine; consoleLogger = new MDConsoleLogger (LoggerVerbosity.Normal, LogWriteLine, null, null); }
public bool Execute() { Log.VisualStudioVersion = VisualStudioVer; if (!CommonRegistryConfigurations.IsSolutionEnabled(SolutionName, VisualStudioVer)) { return(true); } try { string snkCertificate = File.Exists(Snk) ? Snk : null; using (SInjection sInjection = new SInjection(Assembly, snkCertificate)) { return(sInjection.Patch()); } } catch (Exception e) { const string errorMessage = "Error Executing MSBuild Task SInjectionBuildTask"; Log.Write(e, errorMessage); e.Capture(VisualStudioVer, message: errorMessage); BuildWarningEventArgs errorEvent = new BuildWarningEventArgs("Debugger Visualizer Creator", "", "SInjectionBuildTask", 0, 0, 0, 0, $"There was an error adding the serializable attributes to type of the project {Assembly}. Please change serialization method from Binary to Json or Xml in Tools->Options->BridgeVs->SerializationOption. ", "", "LINQBridgeVs"); BuildEngine.LogWarningEvent(errorEvent); } return(true); }
public bool Execute() { var files = InputFiles .Select(x => x.ItemSpec) .Where(Generator.IsMetaSharpFile) .ToImmutableArray(); var buildConstants = new BuildConstants( intermediateOutputPath: IntermediateOutputPath, targetPath: OutDir, generatorMode: GeneratorMode.MsBuild ); var code = RealEnvironmentGenerator.Generate( files, buildConstants, error => BuildEngine.LogErrorEvent(ToBuildError(error)), output => OutputFiles = output.Select(x => new TaskItem(x)).ToArray() ); return(code == GeneratorResultCode.Success); //var type = compilation.GlobalNamespace.GetNamespaceMembers().ElementAt(0).GetNamespaceMembers().ElementAt(0).GetTypeMembers().Single(); //var tree = type.Locations.Single().SourceTree; //if(tree == compilation.SyntaxTrees.Single()) { //} //var node = compilation.SyntaxTrees.Single().GetRoot().DescendantNodes().OfType<ClassDeclarationSyntax>().First(); //var model = compilation.GetSemanticModel(compilation.SyntaxTrees.Single()); //var symbol = model.GetDeclaredSymbol(node); //if(symbol == type) { //} }
public void ProducesAssemblyWithOneWorkingExport() { using (var testEnv = new TestEnvironment()) { var testCode = @"namespace Test { public class TestClassA { [NXPorts.Attributes.DllExport] public static string DoSomething() { return ""TestReturnValue""; } } }"; if (!testEnv.CreateTestDLL("test", new[] { testCode })) { Assert.Fail("Test compile failed."); } using (var testExportAttributedAssembly = new ExportAttributedAssembly("./test.dll")) { var writer = new AssemblyExportWriterTask(); writer.BuildEngine = BuildEngine.Create(); writer.Write(testExportAttributedAssembly, "./test.dll"); } Assert.That.RunsWithoutError <DoSomethingDelegate>( "./test.dll", "DoSomething", d => { Assert.AreEqual("TestReturnValue", d()); } ); } }
public void ProducesAssemblyWithoutExportAttributes() { using (var testEnv = new TestEnvironment()) { var testCode = @"namespace Test { public class TestClassA { [NXPorts.Attributes.DllExport] public static void DoSomething() { } } }"; if (!testEnv.CreateTestDLL("test", new[] { testCode })) { Assert.Fail("Test compile failed."); } using (var testExportAttributedAssembly = new ExportAttributedAssembly("./test.dll")) { var writer = new AssemblyExportWriterTask(); writer.BuildEngine = BuildEngine.Create(); writer.Write(testExportAttributedAssembly, "./test.dll"); } using (var resultModule = ModuleDefMD.Load("./test.dll")) { var methodsWithOffendingAttribute = from t in resultModule.Types from m in t.Methods from ca in m.CustomAttributes where ca.TypeFullName == typeof(Attributes.DllExportAttribute).FullName select m; Assert.AreEqual(0, methodsWithOffendingAttribute.Count(), $"Assembly was left with one ore more {nameof(Attributes.DllExportAttribute)} occurences."); } } }
public void TraversalReferencesWork() { ProjectCreator projectB = ProjectCreator .Create(GetTempFileName()) .Save(); ProjectCreator projectA = ProjectCreator .Create(GetTempFileName()) .ItemProjectReference(projectB) .Save(); ProjectCreator dirsProj = ProjectCreator .Create(GetTempFileName()) .Property("IsTraversal", "true") .ItemInclude("ProjectFile", projectA.FullPath) .Save(); BuildEngine buildEngine = BuildEngine.Create(); MSBuildProjectLoader loader = new MSBuildProjectLoader(null, MSBuildToolsVersion, buildEngine); ProjectCollection projectCollection = loader.LoadProjectsAndReferences(new[] { dirsProj.FullPath }); projectCollection.LoadedProjects.Select(i => i.FullPath).ShouldBe( new[] { dirsProj.FullPath, projectA.FullPath, projectB.FullPath }, ignoreOrder: true); }
public void InvalidProjectsLogGoodInfo() { ProjectCreator projectA = ProjectCreator .Create(GetTempFileName()) .Import(@"$(Foo)\foo.props") .Save(); ProjectCreator dirsProj = ProjectCreator .Create(GetTempFileName()) .Property("IsTraversal", "true") .ItemInclude("ProjectFile", projectA.FullPath) .Save(); BuildEngine buildEngine = BuildEngine.Create(); MSBuildProjectLoader loader = new MSBuildProjectLoader(null, MSBuildToolsVersion, buildEngine); loader.LoadProjectsAndReferences(new[] { dirsProj.FullPath }); BuildErrorEventArgs errorEventArgs = buildEngine.ErrorEvents.ShouldHaveSingleItem(); errorEventArgs.Code.ShouldBe("MSB4019"); errorEventArgs.ColumnNumber.ShouldBe(3); errorEventArgs.HelpKeyword.ShouldBe("MSBuild.ImportedProjectNotFound"); errorEventArgs.LineNumber.ShouldBe(3); errorEventArgs.File.ShouldBe(projectA.FullPath); }
public bool Execute() { //Debugger.Launch(); OutputPath = OutputPath ?? AssemblyFile; var outputPdb = GetPdbPath(OutputPath); var input = AssemblyFile; var inputPdb = GetPdbPath(input); // Make a copy and delete the original file to prevent MSBuild from thinking that everything is OK if (OriginalCopyPath != null) { File.Copy(AssemblyFile, OriginalCopyPath, true); input = OriginalCopyPath; File.Delete(AssemblyFile); if (File.Exists(inputPdb)) { var copyPdb = GetPdbPath(OriginalCopyPath); File.Copy(inputPdb, copyPdb, true); File.Delete(inputPdb); inputPdb = copyPdb; } } var msg = $"CompileRobustXamlTask -> AssemblyFile:{AssemblyFile}, ProjectDirectory:{ProjectDirectory}, OutputPath:{OutputPath}"; BuildEngine.LogMessage(msg, MessageImportance.High); var res = XamlCompiler.Compile(BuildEngine, input, File.ReadAllLines(ReferencesFilePath).Where(l => !string.IsNullOrWhiteSpace(l)).ToArray(), ProjectDirectory, OutputPath, (SignAssembly && !DelaySign) ? AssemblyOriginatorKeyFile : null); if (!res.success) { return(false); } if (!res.writtentofile) { File.Copy(input, OutputPath, true); if (File.Exists(inputPdb)) { File.Copy(inputPdb, outputPdb, true); } } if (!string.IsNullOrEmpty(UpdateBuildIndicator)) { if (!File.Exists(UpdateBuildIndicator)) { File.Create(UpdateBuildIndicator).Dispose(); } else { File.SetLastWriteTime(UpdateBuildIndicator, DateTime.Now); } } return(true); }
/// <summary> /// Attempts to get the current <see cref="ProjectInstance"/> of the executing task via reflection. /// </summary> /// <returns>A <see cref="ProjectInstance"/> object if one could be determined, otherwise null..</returns> private ProjectInstance GetProjectInstance() { try { FieldInfo requestEntryFieldInfo = BuildEngine.GetType().GetField("_requestEntry", BindingFlags.Instance | BindingFlags.NonPublic); if (requestEntryFieldInfo != null && BuildRequestEntryTypeLazy.Value != null && BuildRequestConfigurationTypeLazy.Value != null) { object requestEntry = requestEntryFieldInfo.GetValue(BuildEngine); if (requestEntry != null && BuildRequestEntryRequestConfigurationPropertyInfo.Value != null) { object requestConfiguration = BuildRequestEntryRequestConfigurationPropertyInfo.Value.GetValue(requestEntry); if (requestConfiguration != null && BuildRequestConfigurationProjectPropertyInfo.Value != null) { return(BuildRequestConfigurationProjectPropertyInfo.Value.GetValue(requestConfiguration) as ProjectInstance); } } } } catch { // Ignored because we never want this method to throw since its using reflection to access internal members that could go away with any future release of MSBuild } return(null); }
protected override int Run(BuildEngine engine) { FrameworkVersions currentTools = engine.Framework; foreach (ProjectInfo item in engine.Projects) { FrameworkVersions myFramework = currentTools; string projFramework = item.Properties[MSProp.TargetFrameworkVersion]; if (!String.IsNullOrEmpty(projFramework)) { myFramework = (FrameworkVersions)Enum.Parse(typeof(FrameworkVersions), projFramework.Replace(".", "")); } foreach (ReferenceInfo r in item.References) { if (r.RequiresVersion != null) { if (r.RequiresVersion.Value > myFramework) { item.References.Remove(r); } } } } return(0); }
public bool Execute() { var projectDir = Path.GetDirectoryName(BuildEngine.ProjectFileOfTaskNode); for (int i = 0; i < InputFiles.Length; i++) { BuildEngine.LogMessageEvent(new BuildMessageEventArgs(string.Format("Generating kernel wrappers for {0}", Path.GetFileName(InputFiles[i].ItemSpec)), "Kernel", "OpenCL.Net", MessageImportance.High)); foreach (var mi in InputFiles[i].MetadataNames) { BuildEngine.LogMessageEvent(new BuildMessageEventArgs(string.Format("\tMetadata: {0}: {1}", mi.ToString(), InputFiles[i].GetMetadata(mi.ToString())), "Kernel", "OpenCL.Net", MessageImportance.High)); } var link = InputFiles[i].GetMetadata(MetadataLink); var isLink = !string.IsNullOrEmpty(link); var identity = InputFiles[i].GetMetadata(MetadataIdentity); var copy = InputFiles[i].GetMetadata(MetadataCopyToOutputDirectory); var copyToOutputDirectory = !string.IsNullOrEmpty(copy) || (copy == "PreserveNewest") || (copy == "Always"); var fullPath = InputFiles[i].GetMetadata(MetadataFullPath); var embedSource = !copyToOutputDirectory; var outputPath = isLink ? link : identity; File.WriteAllText(OutputFiles[i].ItemSpec, ProcessKernelFile(fullPath, File.ReadAllText(InputFiles[i].ItemSpec), embedSource, outputPath)); if (copyToOutputDirectory) { InputFiles[i].RemoveMetadata(MetadataCopyToOutputDirectory); OutputFiles[i].RemoveMetadata(MetadataCopyToOutputDirectory); } } BuildEngine.LogMessageEvent(new BuildMessageEventArgs("Done.", "Kernel", "OpenCL.Net", MessageImportance.High)); return(true); }
public void ProducesAssemblyWithoutAnyReferenceToNXPortAttributes() { using (var testEnv = new TestEnvironment()) { var testCode = @"namespace Test { public class TestClassA { [NXPorts.Attributes.DllExport] public static void DoSomething() { } } }"; if (!testEnv.CreateTestDLL("test", new[] { testCode })) { Assert.Fail("Test compile failed."); } using (var testExportAttributedAssembly = new ExportAttributedAssembly("./test.dll")) { var writer = new AssemblyExportWriterTask(); writer.BuildEngine = BuildEngine.Create(); writer.Write(testExportAttributedAssembly, "./testOut.dll"); } using (var resultModule = ModuleDefMD.Load("./testOut.dll")) { var simpleNameOfAttributeAssembly = typeof(NXPorts.Attributes.DllExportAttribute).Assembly.GetName().Name; Assert.AreEqual( null, resultModule.GetAssemblyRef(simpleNameOfAttributeAssembly), $"Assembly was left with a reference to assembly '{simpleNameOfAttributeAssembly}'." ); } } }
private void GenericMSBuildLog(string message, MessageImportance messageImportance) { if (BuildEngine != null) { BuildEngine.LogMessageEvent(new BuildMessageEventArgs(message, HELP_KEYWORD, "git", messageImportance)); } }
private void LogError(CompilerError error) { switch (error.Severity) { case ErrorSeverity.Error: BuildEngine.LogErrorEvent(new BuildErrorEventArgs( string.Empty, $"{error.StatusCode}", error.File, error.Line, error.Column, 0, 0, error.Message, string.Empty, nameof(CompileSassFiles))); break; case ErrorSeverity.Warning: BuildEngine.LogWarningEvent(new BuildWarningEventArgs( string.Empty, $"{error.StatusCode}", error.File, error.Line, error.Column, 0, 0, error.Message, string.Empty, nameof(CompileSassFiles))); break; } }
//private static PluginResolver pluginManager; private static void BuildStepsRecursively(BuildEngine.Builder builder, ICollection<BuildStep> steps, int stepsPerLevel, int maxLevel, BuildStep curParent = null, int curLevel = 0) { if (curLevel == maxLevel) return; for (var i = 0; i < stepsPerLevel; ++i) { BuildStep step = builder.Root.Add(new DoNothingCommand()); if (curParent != null) BuildStep.LinkBuildSteps(curParent, step); BuildStepsRecursively(builder, steps, stepsPerLevel, maxLevel, step, curLevel + 1); steps.Add(step); } }
public string CommandLineArguments(string pathToBuildFile, BuildEngine buildEngine, IPackageTree packageTree, FrameworkVersion version) { buildFile = pathToBuildFile; return GenerateParameters(buildEngine.Parameters); }