mcs/class/Microsoft.Build.Engine/Microsoft.Build.BuildEngine/ConsoleLogger.cs

   1 //
   2 // ConsoleLogger.cs: Outputs to the console
   3 //
   4 // Author:
   5 //   Marek Sieradzki (marek.sieradzki@gmail.com)
   6 //
   7 // (C) 2005 Marek Sieradzki
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 #if NET_2_0
  29
  30 using System;
  31 using System.Runtime.InteropServices;
  32 using System.IO;
  33 using System.Security;
  34 using Microsoft.Build.Framework;
  35
  36 namespace Microsoft.Build.BuildEngine {
  37         public class ConsoleLogger : ILogger {
  38
  39                 string          parameters;
  40                 int             indent;
  41                 LoggerVerbosity verbosity;
  42                 WriteHandler    writeHandler;
  43                 int             errorCount;
  44                 int             warningCount;
  45                 DateTime                buildStart;
  46                 bool            performanceSummary;
  47                 bool            showSummary;
  48                 bool            skipProjectStartedText;
  49
  50                 public ConsoleLogger ()
  51                         : this (LoggerVerbosity.Normal, null, null, null)
  52                 {
  53                 }
  54
  55                 public ConsoleLogger (LoggerVerbosity verbosity)
  56                         : this (LoggerVerbosity.Normal, null, null, null)
  57                 {
  58                 }
  59
  60                 // FIXME: what about colorSet and colorReset?
  61                 public ConsoleLogger (LoggerVerbosity verbosity,
  62                                       WriteHandler write,
  63                                       ColorSetter colorSet,
  64                                       ColorResetter colorReset)
  65                 {
  66                         this.verbosity = verbosity;
  67                         this.indent = 0;
  68                         this.errorCount = 0;
  69                         this.warningCount = 0;
  70                         if (write == null)
  71                                 this.writeHandler += new WriteHandler (WriteHandlerFunction);
  72                         else
  73                                 this.writeHandler += write;
  74                         this.performanceSummary = false;
  75                         this.showSummary = true;
  76                         this.skipProjectStartedText = false;
  77                 }
  78
  79                 public void ApplyParameter (string parameterName,
  80                                             string parameterValue)
  81                 {
  82                         // FIXME: what we should do here? in msbuild it isn't
  83                         // changing "parameters" property
  84                 }
  85
  86                 public virtual void Initialize (IEventSource eventSource)
  87                 {
  88                         eventSource.BuildStarted +=  new BuildStartedEventHandler (BuildStartedHandler);
  89                         eventSource.BuildFinished += new BuildFinishedEventHandler (BuildFinishedHandler);
  90                         eventSource.ProjectStarted += new ProjectStartedEventHandler (ProjectStartedHandler);
  91                         eventSource.ProjectFinished += new ProjectFinishedEventHandler (ProjectFinishedHandler);
  92                         eventSource.TargetStarted += new TargetStartedEventHandler (TargetStartedHandler);
  93                         eventSource.TargetFinished += new TargetFinishedEventHandler (TargetFinishedHandler);
  94                         eventSource.TaskStarted += new TaskStartedEventHandler (TaskStartedHandler);
  95                         eventSource.TaskFinished += new TaskFinishedEventHandler (TaskFinishedHandler);
  96                         eventSource.MessageRaised += new BuildMessageEventHandler (MessageHandler);
  97                         eventSource.WarningRaised += new BuildWarningEventHandler (WarningHandler);
  98                         eventSource.ErrorRaised += new BuildErrorEventHandler (ErrorHandler);
  99                 }
 100
 101                 public void BuildStartedHandler (object sender, BuildStartedEventArgs args)
 102                 {
 103                         WriteLine (String.Empty);
 104                         WriteLine (String.Format ("Build started {0}.", args.Timestamp));
 105                         WriteLine ("__________________________________________________");
 106                         buildStart = args.Timestamp;
 107                 }
 108
 109                 public void BuildFinishedHandler (object sender, BuildFinishedEventArgs args)
 110                 {
 111                         if (args.Succeeded == true) {
 112                                 WriteLine ("Build succeeded.");
 113                         } else {
 114                                 WriteLine ("Build failed.");
 115                         }
 116                         if (performanceSummary == true) {
 117                         }
 118                         if (showSummary == true){
 119                                 TimeSpan timeElapsed = args.Timestamp - buildStart;
 120                                 WriteLine (String.Format ("\t {0} Warning(s)", warningCount));
 121                                 WriteLine (String.Format ("\t {0} Error(s)", errorCount));
 122                                 WriteLine (String.Empty);
 123                                 WriteLine (String.Format ("Time Elapsed {0}", timeElapsed));
 124                         }
 125                 }
 126
 127                 public void ProjectStartedHandler (object sender, ProjectStartedEventArgs args)
 128                 {
 129                         WriteLine (String.Format ("Project \"{0}\" ({1} target(s)):", args.ProjectFile, args.TargetNames));
 130                         WriteLine (String.Empty);
 131                 }
 132
 133                 public void ProjectFinishedHandler (object sender, ProjectFinishedEventArgs args)
 134                 {
 135                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
 136                                 WriteLine (String.Format ("Done building project \"{0}\".{1}", args.ProjectFile,
 137                                                         args.Succeeded ? String.Empty : "-- FAILED"));
 138                                 WriteLine (String.Empty);
 139                         }
 140                 }
 141
 142                 public void TargetStartedHandler (object sender, TargetStartedEventArgs args)
 143                 {
 144                         WriteLine (String.Format ("Target {0}:",args.TargetName));
 145                         indent++;
 146                 }
 147
 148                 public void TargetFinishedHandler (object sender, TargetFinishedEventArgs args)
 149                 {
 150                         indent--;
 151                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Diagnostic))
 152                                 WriteLine (String.Format ("Done building target \"{0}\" in project \"{1}\".{2}",
 153                                         args.TargetName, args.ProjectFile,
 154                                         args.Succeeded ? String.Empty : "-- FAILED"));
 155                         if (!args.Succeeded)
 156                                 errorCount++;
 157                         WriteLine (String.Empty);
 158                 }
 159
 160                 public void TaskStartedHandler (object sender, TaskStartedEventArgs args)
 161                 {
 162                         if (this.verbosity == LoggerVerbosity.Diagnostic)
 163                                 WriteLine (String.Format ("Task \"{0}\"",args.TaskName));
 164                         indent++;
 165                 }
 166
 167                 public void TaskFinishedHandler (object sender, TaskFinishedEventArgs args)
 168                 {
 169                         indent--;
 170                         if (this.verbosity == LoggerVerbosity.Diagnostic) {
 171                                 if (args.Succeeded)
 172                                         WriteLine (String.Format ("Done executing task \"{0}\"", args.TaskName));
 173                                 else {
 174                                         WriteLine (String.Format ("Task \"{0}\" execution failed", args.TaskName));
 175                                         errorCount++;
 176                                 }
 177                         }
 178                 }
 179
 180                 public void MessageHandler (object sender, BuildMessageEventArgs args)
 181                 {
 182                         if (IsMessageOk (args)) {
 183                                 WriteLine (args.Message);
 184                         }
 185                 }
 186
 187                 public void WarningHandler (object sender, BuildWarningEventArgs args)
 188                 {
 189                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal))
 190                                 WriteLineWithoutIndent (FormatWarningEvent (args));
 191                         warningCount++;
 192                 }
 193
 194                 public void ErrorHandler (object sender, BuildErrorEventArgs args)
 195                 {
 196                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Minimal))
 197                                 WriteLineWithoutIndent (FormatErrorEvent (args));
 198                         errorCount++;
 199                 }
 200
 201                 [MonoTODO]
 202                 public void CustomEventHandler (object sender, CustomBuildEventArgs args)
 203                 {
 204                 }
 205
 206                 private void WriteLine (string message)
 207                 {
 208                         for (int i = 0; i < indent; i++)
 209                                 Console.Write ('\t');
 210                         writeHandler (message);
 211                 }
 212
 213                 private void WriteLineWithoutIndent (string message)
 214                 {
 215                         writeHandler (message);
 216                 }
 217
 218                 private void WriteHandlerFunction (string message)
 219                 {
 220                         Console.WriteLine (message);
 221                 }
 222
 223                 private void ParseParameters ()
 224                 {
 225                         string[] splittedParameters = parameters.Split (';');
 226                         foreach (string s in splittedParameters ) {
 227                                 switch (s) {
 228                                 case "PerformanceSummary":
 229                                         this.performanceSummary = true;
 230                                         break;
 231                                 case "NoSummary":
 232                                         this.showSummary = false;
 233                                         break;
 234                                 default:
 235                                         throw new ArgumentException ("Invalid parameter.");
 236                                 }
 237                         }
 238                 }
 239
 240                 public virtual void Shutdown ()
 241                 {
 242                 }
 243
 244                 private string FormatErrorEvent (BuildErrorEventArgs args)
 245                 {
 246                         // FIXME: show more complicated args
 247                         if (args.LineNumber != 0 && args.ColumnNumber != 0) {
 248                                 return String.Format ("{0}({1},{2}): {3} error {4}: {5}", args.File, args.LineNumber, args.ColumnNumber,
 249                                         args.Subcategory, args.Code, args.Message);
 250                         } else {
 251                                 return String.Format ("{0}: {1} error {2}: {3}", args.File, args.Subcategory, args.Code,
 252                                         args.Message);
 253                         }
 254                 }
 255
 256                 private string FormatWarningEvent (BuildWarningEventArgs args)
 257                 {
 258                         // FIXME: show more complicated args
 259                         if (args.LineNumber != 0 && args.ColumnNumber != 0) {
 260                                 return String.Format ("{0}({1},{2}): {3} warning {4}: {5}", args.File, args.LineNumber, args.ColumnNumber,
 261                                         args.Subcategory, args.Code, args.Message);
 262                         } else {
 263                                 return String.Format ("{0}: {1} warning {2}: {3}", args.File, args.Subcategory, args.Code,
 264                                         args.Message);
 265                         }
 266                 }
 267
 268                 private bool IsMessageOk (BuildMessageEventArgs bsea)
 269                 {
 270                         if (bsea.Importance == MessageImportance.High && IsVerbosityGreaterOrEqual (LoggerVerbosity.Minimal)) {
 271                                 return true;
 272                         } else if (bsea.Importance == MessageImportance.Normal && IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
 273                                 return true;
 274                         } else if (bsea.Importance == MessageImportance.Low && IsVerbosityGreaterOrEqual (LoggerVerbosity.Detailed)) {
 275                                 return true;
 276                         } else
 277                                 return false;
 278                 }
 279
 280                 private bool IsVerbosityGreaterOrEqual (LoggerVerbosity v)
 281                 {
 282                                 if (v == LoggerVerbosity.Diagnostic) {
 283                                         return LoggerVerbosity.Diagnostic <= verbosity;
 284                                 } else if (v == LoggerVerbosity.Detailed) {
 285                                         return LoggerVerbosity.Detailed <= verbosity;
 286                                 } else if (v == LoggerVerbosity.Normal) {
 287                                         return LoggerVerbosity.Normal <= verbosity;
 288                                 } else if (v == LoggerVerbosity.Minimal) {
 289                                         return LoggerVerbosity.Minimal <= verbosity;
 290                                 } else if (v == LoggerVerbosity.Quiet) {
 291                                         return true;
 292                                 } else
 293                                         return false;
 294                 }
 295
 296                 public string Parameters {
 297                         get {
 298                                 return parameters;
 299                         }
 300                         set {
 301                                 if (value == null)
 302                                         throw new ArgumentNullException ();
 303                                 parameters = value;
 304                                 if (parameters != String.Empty)
 305                                         ParseParameters ();
 306                         }
 307                 }
 308
 309                 public bool ShowSummary {
 310                         get { return showSummary; }
 311                         set { showSummary = value; }
 312                 }
 313
 314                 public bool SkipProjectStartedText {
 315                         get { return skipProjectStartedText; }
 316                         set { skipProjectStartedText = value; }
 317                 }
 318
 319                 public LoggerVerbosity Verbosity {
 320                         get { return verbosity; }
 321                         set { verbosity = value; }
 322                 }
 323
 324                 protected WriteHandler WriteHandler {
 325                         get { return writeHandler; }
 326                         set { writeHandler = value; }
 327                 }
 328         }
 329 }
 330
 331 #endif