public void TaskFinished(object sender, BuildEventArgs e) { var task = (CscTask)e.Task; var generator = (GenerateMsBuildTask)sender; var projectFileName = String.Format( "{0}{1}{2}.csproj", task.Sources.BaseDirectory.FullName, Path.DirectorySeparatorChar, Path.GetFileNameWithoutExtension(task.OutputFile.Name)); ProjectRootElement project = null; if (!File.Exists(projectFileName)) project = ProjectRootElement.Create(projectFileName); else project = ProjectRootElement.Open(projectFileName); var projectManipulator = new MB.Project(project); project.DefaultTargets = "Build"; SetKnownProperties(project, task); GenerateReferences(project, projectManipulator, task, generator); GenerateCompileIncludes(project, projectManipulator, task); project.EnsureImportExists("$(MSBuildToolsPath)\\Microsoft.CSharp.targets"); generator.RegisterProjectInSolution(project); project.Save(); }
public void BuildFinished(object sender, BuildEventArgs e) { if (e.Exception == null && e.Project == Project) { GenerateSolutionFile(Project); } }
private static void OnMessageLogged(object sender, BuildEventArgs e) { if (Loggers.IsEmpty) { // tiny race. ((Project)sender).MessageLogged -= OnMessageLogged; return; } var msg = FormatMessage(e); if (msg == null) return; foreach (var log in Loggers) { try { log.Value.WriteLine(msg); log.Value.Flush(); } catch (Exception) { } } }
public void TaskFinished(object sender, BuildEventArgs e) { // resources embedded in csc tasks are already handled if (typeof(CscTask) != e.Task.Parent.GetType()) { throw new NotImplementedException(); } }
public void BuildStarted(Object sender, BuildEventArgs be) { autoTrace = be.Project.Properties.Contains("trace.ant.disableAutoTrace") && be.Project.Properties["trace.ant.disableAutoTrace"].Equals("true", StringComparison.InvariantCultureIgnoreCase); TraceManager.BeginTrace(); if (autoTrace) TraceManager.Trace.BeginEntry(String.Format("Start build '{0}'.", be.Project.ProjectName), severityType.INFO); }
public LogEvent(String sourceName, Object sender, BuildEventArgs args, LogEventType eventType) { _sourceName = sourceName; _sender = sender; _args = args; _eventType = eventType; _exception = null; }
public void TaskFinished(object sender, BuildEventArgs e) { if (e.Exception == null && !string.IsNullOrEmpty(e.Task.Name)) { if (taskTranslators.ContainsKey(e.Task.Name)) { taskTranslators[e.Task.Name].TaskFinished(this, e); } } }
public void TaskStarted(object sender, BuildEventArgs e) { _taskStartedFired = true; if (e.Task != null) { if (_executedTasks.ContainsKey(e.Task.Name)) { _executedTasks[e.Task.Name] = ((int) _executedTasks[e.Task.Name]) + 1; } else { _executedTasks.Add(e.Task.Name, 1); } } }
public void TargetStarted(object sender, BuildEventArgs e) { _targetStartedFired = true; if (e.Target != null) { if (_executedTargets.ContainsKey(e.Target.Name)) { _executedTargets[e.Target.Name] = ((int) _executedTargets[e.Target.Name]) + 1; } else { _executedTargets.Add(e.Target.Name, 1); } _targetStartTimes[e.Target.Name] = DateTime.UtcNow; } }
public void BuildStarted(object sender, BuildEventArgs e) { string host = e.Project.Properties[PROP_HOST]; if (host == null) { host = DEFAULT_HOST; } string port = e.Project.Properties[PROP_PORT]; if (port == null) { port = DEFAULT_PORT; } int portInt = int.Parse(port); reporter = new UdpBuildReporter(host, portInt); report("BUILD_STARTED", e); }
public void ParseMessage(BuildEventArgs e, out MessagePriority priority, out string file, out int lineNumber, out string code, out string message) { switch(e.MessageLevel) { case Level.Warning: priority = MessagePriority.WARNING; break; case Level.Error: priority = MessagePriority.ERROR; break; default: priority = MessagePriority.INFO; break; } file = null; code = null; lineNumber = 0; message = e.Message; Match match = messageRegex.Match(message); if (match.Success) { if (match.Groups["category"].Value == "warning") { priority = MessagePriority.WARNING; } else { priority = MessagePriority.ERROR; } file = match.Groups["file"].Value; string lineString = match.Groups["line"].Value; if (lineString != "") { lineNumber = int.Parse(lineString); } code = match.Groups["code"].Value; message = match.Groups["message"].Value; } }
/// <summary> /// Outputs an indented message to the build log if its priority is /// greather than or equal to the <see cref="Threshold" /> of the /// logger. /// </summary> /// <param name="e">The event to output.</param> private void OutputMessage(BuildEventArgs e) { int indentationLength = 0; if (e.Project != null) { indentationLength = e.Project.IndentationLevel * e.Project.IndentationSize; } OutputMessage(e, indentationLength); }
private static BuildEventArgs CreateBuildEvent(Level messageLevel, string message) { BuildEventArgs buildEvent = new BuildEventArgs(); buildEvent.MessageLevel = messageLevel; buildEvent.Message = message; return buildEvent; }
/// <summary> /// Signals that a task has started. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> public virtual void TaskStarted(object sender, BuildEventArgs e) { }
/// <summary> /// Signals that a task has finished. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// This event will still be fired if an error occurred during the build. /// </remarks> public virtual void TaskFinished(object sender, BuildEventArgs e) { }
/// <summary> /// Signals that a task has finished. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// This event will still be fired if an error occurred during the build. /// </remarks> public virtual void TaskFinished(object sender, BuildEventArgs e) { }
public void MessageLogged(object sender, BuildEventArgs e) { Enqueue(new LogEvent(_src, sender, e, LogEventType.MessageLogged)); }
public void TaskFinished(object sender, BuildEventArgs e) { Enqueue(new LogEvent(_src, sender, e, LogEventType.TaskFinished)); }
/// <summary> /// Signals that a task has finished. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// This event will still be fired if an error occurred during the build. /// </remarks> public void TaskFinished(object sender, BuildEventArgs e) { lock (_xmlWriter) { // output total target duration WriteDuration(); // close task element _xmlWriter.WriteEndElement(); _xmlWriter.Flush(); } }
/// <summary> /// Signals that a build has started. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// This event is fired before any targets have started. /// </remarks> public void BuildStarted(object sender, BuildEventArgs e) { lock (_xmlWriter) { _stopWatchStack.PushStart(); _xmlWriter.WriteStartElement(Elements.BuildResults); _xmlWriter.WriteAttributeString(Attributes.Project, e.Project.ProjectName); } // add an item to the project stack _projectStack.Push(null); }
/// <summary> /// Signals that a build has started. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// This event is fired before any targets have started. /// </remarks> public virtual void BuildStarted(object sender, BuildEventArgs e) { _buildReports.Push(new BuildReport(DateTime.Now)); }
/// <summary> /// Signals that the last target has finished. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// This event will still be fired if an error occurred during the build. /// </remarks> public virtual void BuildFinished(object sender, BuildEventArgs e) { Exception error = e.Exception; int indentationLevel = 0; if (e.Project != null) { indentationLevel = e.Project.IndentationLevel * e.Project.IndentationSize; } BuildReport report = (BuildReport)_buildReports.Pop(); if (error == null) { OutputMessage(Level.Info, string.Empty, indentationLevel); if (report.Errors == 0 && report.Warnings == 0) { OutputMessage(Level.Info, "BUILD SUCCEEDED", indentationLevel); } else { OutputMessage(Level.Info, string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_BuildSucceeded"), report.Errors, report.Warnings), indentationLevel); } OutputMessage(Level.Info, string.Empty, indentationLevel); } else { OutputMessage(Level.Error, string.Empty, indentationLevel); if (report.Errors == 0 && report.Warnings == 0) { OutputMessage(Level.Error, "BUILD FAILED", indentationLevel); } else { OutputMessage(Level.Info, string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_BuildFailed"), report.Errors, report.Warnings), indentationLevel); } OutputMessage(Level.Error, string.Empty, indentationLevel); if (error is BuildException) { if (Threshold <= Level.Verbose) { OutputMessage(Level.Error, error.ToString(), indentationLevel); } else { if (error.Message != null) { OutputMessage(Level.Error, error.Message, indentationLevel); } // output nested exceptions Exception nestedException = error.InnerException; int exceptionIndentationLevel = indentationLevel; int indentShift = 4; //e.Project.IndentationSize; while (nestedException != null && !StringUtils.IsNullOrEmpty(nestedException.Message)) { exceptionIndentationLevel += indentShift; OutputMessage(Level.Error, nestedException.Message, exceptionIndentationLevel); nestedException = nestedException.InnerException; } } } else { OutputMessage(Level.Error, "INTERNAL ERROR", indentationLevel); OutputMessage(Level.Error, string.Empty, indentationLevel); OutputMessage(Level.Error, error.ToString(), indentationLevel); OutputMessage(Level.Error, string.Empty, indentationLevel); OutputMessage(Level.Error, "Please send bug report to [email protected].", indentationLevel); } OutputMessage(Level.Error, string.Empty, indentationLevel); } // output total build time TimeSpan buildTime = DateTime.Now - report.StartTime; OutputMessage(Level.Info, string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_TotalTime") + Environment.NewLine, Math.Round(buildTime.TotalSeconds, 1)), indentationLevel); // make sure all messages are written to the underlying storage Flush(); }
/// <summary> /// Signals that a task has started. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> public virtual void TaskStarted(object sender, BuildEventArgs e) { }
/// <summary> /// Outputs an indented message to the build log if its priority is /// greather than or equal to the <see cref="Threshold" /> of the /// logger. /// </summary> /// <param name="e">The event to output.</param> /// <param name="indentationLength">TODO</param> private void OutputMessage(BuildEventArgs e, int indentationLength) { if (!_stopped && (e.MessageLevel >= Threshold)) { if (OutputWriter == null) { throw new BuildException(string.Format(CultureInfo.InvariantCulture, "Tried to write to an invalid FileLogListener instance '{0}'!", Name), Location.UnknownLocation); } string txt = e.Message; // beautify the message a bit txt = txt.Replace("\t", " "); // replace tabs with spaces txt = txt.Replace("\r", ""); // get rid of carriage returns // split the message by lines - the separator is "\n" since we've eliminated // \r characters string[] lines = txt.Split('\n'); string label = String.Empty; if (e.Task != null && !EmacsMode) { label = "[" + e.Task.Name + "] "; label = label.PadLeft(e.Project.IndentationSize); } if (indentationLength > 0) { label = new String(' ', indentationLength) + label; } foreach (string line in lines) { StringBuilder sb = new StringBuilder(); sb.Append(label); sb.Append(line); string indentedMessage = sb.ToString(); OutputWriter.WriteLine(indentedMessage); Log(indentedMessage); } } }
/// <summary> /// Signals that the last target has finished. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// This event will still be fired if an error occurred during the build. /// </remarks> public virtual void BuildFinished(object sender, BuildEventArgs e) { Exception error = e.Exception; int indentationLevel = 0; if (e.Project != null) { indentationLevel = e.Project.IndentationLevel * e.Project.IndentationSize; } if (error == null) { OutputMessage(Level.Info, "", indentationLevel); OutputMessage(Level.Info, "BUILD SUCCEEDED", indentationLevel); OutputMessage(Level.Info, "", indentationLevel); } else { OutputMessage(Level.Error, "", indentationLevel); OutputMessage(Level.Error, "BUILD FAILED", indentationLevel); OutputMessage(Level.Error, "", indentationLevel); if (error is BuildException) { if (Threshold <= Level.Verbose) { OutputMessage(Level.Error, error.ToString(), indentationLevel); } else { if (error.Message != null) { OutputMessage(Level.Error, error.Message, indentationLevel); } if (error.InnerException != null && error.InnerException.Message != null) { OutputMessage(Level.Error, error.InnerException.Message, indentationLevel); } } } else { OutputMessage(Level.Error, "INTERNAL ERROR", indentationLevel); OutputMessage(Level.Error, "", indentationLevel); OutputMessage(Level.Error, error.ToString(), indentationLevel); OutputMessage(Level.Error, "", indentationLevel); OutputMessage(Level.Error, "Please send bug report to [email protected].", indentationLevel); } OutputMessage(Level.Info, "", indentationLevel); } // make sure all messages are written to the underlying storage Flush(); }
public void TargetStarted(object sender, BuildEventArgs e) { if (e.Target != null && e.Target.Name == _hideTarget) { return; } Enqueue(new LogEvent(_src, sender, e, LogEventType.TargetStarted)); }
/// <summary> /// Signals that a message has been logged. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// Only messages with a priority higher or equal to the threshold of /// the logger will actually be output in the build log. /// </remarks> public virtual void MessageLogged(object sender, BuildEventArgs e) { // output the message OutputMessage(e); }
public void BuildStarted(object sender, BuildEventArgs e) { Enqueue(new LogEvent(_src, sender, e, LogEventType.BuildStarted)); }
/// <summary> /// Signals that a target has started. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> public virtual void TargetStarted(object sender, BuildEventArgs e) { int indentationLevel = 0; if (e.Project != null) { indentationLevel = e.Project.IndentationLevel * e.Project.IndentationSize; } if (e.Target != null) { OutputMessage(Level.Info, string.Empty, indentationLevel); OutputMessage(Level.Info, string.Format(CultureInfo.InvariantCulture, "{0}:", e.Target.Name), indentationLevel); OutputMessage(Level.Info, string.Empty, indentationLevel); } }
/// <summary> /// Signals that the last target has finished. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// This event will still be fired if an error occurred during the build. /// </remarks> public void BuildFinished(object sender, BuildEventArgs e) { lock (_xmlWriter) { if (e.Exception != null) { _xmlWriter.WriteStartElement("failure"); WriteErrorNode(e.Exception); _xmlWriter.WriteEndElement(); } // output total build duration WriteDuration(); // close buildresults node _xmlWriter.WriteEndElement(); _xmlWriter.Flush(); } // remove an item from the project stack _projectStack.Pop(); // check if there are still nested projects executing if (_projectStack.Count != 0) { // do not yet persist build results, as the main project is // not finished yet return; } try { // write results to file if (OutputWriter != null) { OutputWriter.Write(_buffer.ToString()); OutputWriter.Flush(); } else { // Xmlogger is used as BuildListener string outFileName = e.Project.Properties["XmlLogger.file"]; if (outFileName == null) { outFileName = "log.xml"; } // convert to full path relative to project base directory outFileName = e.Project.GetFullPath(outFileName); // write build log to file using (StreamWriter writer = new StreamWriter(new FileStream(outFileName, FileMode.Create, FileAccess.Write, FileShare.Read), Encoding.UTF8)) { writer.Write(_buffer.ToString()); } } } catch (Exception ex) { throw new BuildException("Unable to write to log file.", ex); } }
/// <summary> /// Signals that the last target has finished, and send an e-mail with /// the build results. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> public override void BuildFinished(object sender, BuildEventArgs e) { base.BuildFinished(sender, e); // remove an item from the project stack _projectStack.Pop(); // check if there are still nested projects executing if (_projectStack.Count != 0) { // do not yet send the mail, as it should only be sent when the // main project is finished return; } Encoding bodyEncoding = null; Project project = e.Project; PropertyDictionary properties = project.Properties; bool success = (e.Exception == null); string prefix = success ? "success" : "failure"; try { string propertyValue = GetPropertyValue(properties, prefix + ".notify", "true"); bool notify = true; try { notify = Convert.ToBoolean(propertyValue, CultureInfo.InvariantCulture); } catch { notify = true; } propertyValue = GetPropertyValue(properties, "body.encoding", ""); try { if (propertyValue != null && propertyValue.Length > 0) { bodyEncoding = Encoding.GetEncoding(propertyValue); } } catch { // ignore invalid encoding } if (!notify) { return; } MailMessage mailMessage = new MailMessage(); mailMessage.From = GetPropertyValue(properties, "from", null); mailMessage.To = GetPropertyValue(properties, prefix + ".to", null); mailMessage.Subject = GetPropertyValue(properties, prefix + ".subject", (success) ? "Build Success" : "Build Failure"); mailMessage.Body = _buffer.ToString(); if (bodyEncoding != null) { mailMessage.BodyEncoding = bodyEncoding; } // send the message SmtpMail.SmtpServer = GetPropertyValue(properties, "mailhost", "localhost"); SmtpMail.Send(mailMessage); } catch (Exception ex) { Console.WriteLine("MailLogger failed to send e-mail!"); Console.WriteLine(ex.ToString()); } }
/// <summary> /// Signals that a message has been logged. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// Only messages with a priority higher or equal to the threshold of /// the logger will actually be output in the build log. /// </remarks> public void MessageLogged(object sender, BuildEventArgs e) { if (e.MessageLevel >= Threshold) { string rawMessage = StripFormatting(e.Message.Trim()); if (IsJustWhiteSpace(rawMessage)) { return; } lock (_xmlWriter) { _xmlWriter.WriteStartElement(Elements.Message); // write message level as attribute _xmlWriter.WriteAttributeString(Attributes.MessageLevel, e.MessageLevel.ToString()); if (IsValidXml(rawMessage)) { rawMessage = Regex.Replace(rawMessage, @"<\?.*\?>", string.Empty); _xmlWriter.WriteRaw(rawMessage); } else { _xmlWriter.WriteCData(StripCData(rawMessage)); } _xmlWriter.WriteEndElement(); _xmlWriter.Flush(); } } }
/// <summary> /// Signals that a message has been logged. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> /// <remarks> /// Only messages with a priority higher or equal to the threshold of /// the logger will actually be output in the build log. /// </remarks> public virtual void MessageLogged(object sender, BuildEventArgs e) { if (_buildReports.Count > 0) { if (e.MessageLevel == Level.Error) { BuildReport report = (BuildReport) _buildReports.Peek(); report.Errors++; } else if (e.MessageLevel == Level.Warning) { BuildReport report = (BuildReport) _buildReports.Peek(); report.Warnings++; } } // output the message OutputMessage(e); }
/// <summary> /// Signals that a task has started. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param> public void TaskStarted(object sender, BuildEventArgs e) { lock (_xmlWriter) { _stopWatchStack.PushStart(); _xmlWriter.WriteStartElement(Elements.Task); WriteNameAttribute(e.Task.Name); _xmlWriter.Flush(); } }
/// <summary> /// Outputs an indented message to the build log if its priority is /// greather than or equal to the <see cref="Threshold" /> of the /// logger. /// </summary> /// <param name="e">The event to output.</param> /// <param name="indentationLength">The number of characters that the message should be indented.</param> private void OutputMessage(BuildEventArgs e, int indentationLength) { if (e.MessageLevel >= Threshold) { string txt = e.Message; // beautify the message a bit txt = txt.Replace("\t", " "); // replace tabs with spaces txt = txt.Replace("\r", ""); // get rid of carriage returns // split the message by lines - the separator is "\n" since we've eliminated // \r characters string[] lines = txt.Split('\n'); string label = String.Empty; if (e.Task != null && !EmacsMode) { label = "[" + e.Task.Name + "] "; label = label.PadLeft(e.Project.IndentationSize); } if (indentationLength > 0) { label = new String(' ', indentationLength) + label; } foreach (string line in lines) { StringBuilder sb = new StringBuilder(); sb.Append(label); sb.Append(line); string indentedMessage = sb.ToString(); // output the message to the console Console.Out.WriteLine(indentedMessage); // if an OutputWriter was set, write the message to it if (OutputWriter != null) { OutputWriter.WriteLine(indentedMessage); } Log(indentedMessage); } } }