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 ("");
 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 ("");
 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 ("");
 131                 }
 132
 133                 public void ProjectFinishedHandler (object sender, ProjectFinishedEventArgs args)
 134                 {
 135                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Diagnostic)) {
 136                                 WriteLine (String.Format ("Done building project \"{0}\".", args.ProjectFile));
 137                                 WriteLine ("");
 138                         }
 139                 }
 140
 141                 public void TargetStartedHandler (object sender, TargetStartedEventArgs args)
 142                 {
 143                         WriteLine (String.Format ("Target {0}:",args.TargetName));
 144                         indent++;
 145                 }
 146
 147                 public void TargetFinishedHandler (object sender, TargetFinishedEventArgs args)
 148                 {
 149                         indent--;
 150                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Diagnostic))
 151                                 WriteLine (String.Format ("Done building target \"{0}\" in project \"{1}\".",
 152                                         args.TargetName, args.ProjectFile));
 153                         WriteLine ("");
 154                 }
 155
 156                 public void TaskStartedHandler (object sender, TaskStartedEventArgs args)
 157                 {
 158                         if (this.verbosity == LoggerVerbosity.Diagnostic)
 159                                 WriteLine (String.Format ("Task \"{0}\"",args.TaskName));
 160                         indent++;
 161                 }
 162
 163                 public void TaskFinishedHandler (object sender, TaskFinishedEventArgs args)
 164                 {
 165                         indent--;
 166                         if (this.verbosity == LoggerVerbosity.Diagnostic)
 167                                 WriteLine (String.Format ("Done executing task \"{0}\"",args.TaskName));
 168                 }
 169
 170                 public void MessageHandler (object sender, BuildMessageEventArgs args)
 171                 {
 172                         if (IsMessageOk (args)) {
 173                                 WriteLine (args.Message);
 174                         }
 175                 }
 176
 177                 public void WarningHandler (object sender, BuildWarningEventArgs args)
 178                 {
 179                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal))
 180                                 WriteLineWithoutIndent (FormatWarningEvent (args));
 181                         warningCount++;
 182                 }
 183
 184                 public void ErrorHandler (object sender, BuildErrorEventArgs args)
 185                 {
 186                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Minimal))
 187                                 WriteLineWithoutIndent (FormatErrorEvent (args));
 188                         errorCount++;
 189                 }
 190
 191                 [MonoTODO]
 192                 public void CustomEventHandler (object sender, CustomBuildEventArgs args)
 193                 {
 194                 }
 195
 196                 private void WriteLine (string message)
 197                 {
 198                         for (int i = 0; i < indent; i++)
 199                                 Console.Write ('\t');
 200                         writeHandler (message);
 201                 }
 202
 203                 private void WriteLineWithoutIndent (string message)
 204                 {
 205                         writeHandler (message);
 206                 }
 207
 208                 private void WriteHandlerFunction (string message)
 209                 {
 210                         Console.WriteLine (message);
 211                 }
 212
 213                 private void ParseParameters ()
 214                 {
 215                         string[] splittedParameters = parameters.Split (';');
 216                         foreach (string s in splittedParameters ) {
 217                                 switch (s) {
 218                                 case "PerformanceSummary":
 219                                         this.performanceSummary = true;
 220                                         break;
 221                                 case "NoSummary":
 222                                         this.showSummary = false;
 223                                         break;
 224                                 default:
 225                                         throw new ArgumentException ("Invalid parameter.");
 226                                 }
 227                         }
 228                 }
 229
 230                 public virtual void Shutdown ()
 231                 {
 232                 }
 233
 234                 private string FormatErrorEvent (BuildErrorEventArgs args)
 235                 {
 236                         // FIXME: show more complicated args
 237                         if (args.LineNumber != 0 && args.ColumnNumber != 0) {
 238                                 return String.Format ("{0}({1},{2}): {3} error {4}: {5}", args.File, args.LineNumber, args.ColumnNumber,
 239                                         args.Subcategory, args.Code, args.Message);
 240                         } else {
 241                                 return String.Format ("{0}: {1} error {2}: {3}", args.File, args.Subcategory, args.Code,
 242                                         args.Message);
 243                         }
 244                 }
 245
 246                 private string FormatWarningEvent (BuildWarningEventArgs args)
 247                 {
 248                         // FIXME: show more complicated args
 249                         if (args.LineNumber != 0 && args.ColumnNumber != 0) {
 250                                 return String.Format ("{0}({1},{2}): {3} warning {4}: {5}", args.File, args.LineNumber, args.ColumnNumber,
 251                                         args.Subcategory, args.Code, args.Message);
 252                         } else {
 253                                 return String.Format ("{0}: {1} warning {2}: {3}", args.File, args.Subcategory, args.Code,
 254                                         args.Message);
 255                         }
 256                 }
 257
 258                 private bool IsMessageOk (BuildMessageEventArgs bsea)
 259                 {
 260                         if (bsea.Importance == MessageImportance.High && IsVerbosityGreaterOrEqual (LoggerVerbosity.Minimal)) {
 261                                 return true;
 262                         } else if (bsea.Importance == MessageImportance.Normal && IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
 263                                 return true;
 264                         } else if (bsea.Importance == MessageImportance.Low && IsVerbosityGreaterOrEqual (LoggerVerbosity.Detailed)) {
 265                                 return true;
 266                         } else
 267                                 return false;
 268                 }
 269
 270                 private bool IsVerbosityGreaterOrEqual (LoggerVerbosity v)
 271                 {
 272                                 if (v == LoggerVerbosity.Diagnostic) {
 273                                         return LoggerVerbosity.Diagnostic <= verbosity;
 274                                 } else if (v == LoggerVerbosity.Detailed) {
 275                                         return LoggerVerbosity.Detailed <= verbosity;
 276                                 } else if (v == LoggerVerbosity.Normal) {
 277                                         return LoggerVerbosity.Normal <= verbosity;
 278                                 } else if (v == LoggerVerbosity.Minimal) {
 279                                         return LoggerVerbosity.Minimal <= verbosity;
 280                                 } else if (v == LoggerVerbosity.Quiet) {
 281                                         return true;
 282                                 } else
 283                                         return false;
 284                 }
 285
 286                 public string Parameters {
 287                         get {
 288                                 return parameters;
 289                         }
 290                         set {
 291                                 if (value == null)
 292                                         throw new ArgumentNullException ();
 293                                 parameters = value;
 294                                 if (parameters != String.Empty)
 295                                         ParseParameters ();
 296                         }
 297                 }
 298
 299                 public bool ShowSummary {
 300                         get { return showSummary; }
 301                         set { showSummary = value; }
 302                 }
 303
 304                 public bool SkipProjectStartedText {
 305                         get { return skipProjectStartedText; }
 306                         set { skipProjectStartedText = value; }
 307                 }
 308
 309                 public LoggerVerbosity Verbosity {
 310                         get { return verbosity; }
 311                         set { verbosity = value; }
 312                 }
 313
 314                 protected WriteHandler WriteHandler {
 315                         get { return writeHandler; }
 316                         set { writeHandler = value; }
 317                 }
 318         }
 319 }
 320
 321 #endif