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            summary;
  48
  49                 public ConsoleLogger ()
  50                         : this (LoggerVerbosity.Normal)
  51                 {
  52                 }
  53
  54                 public ConsoleLogger (LoggerVerbosity verbosity)
  55                 {
  56                         this.verbosity = verbosity;
  57                         this.indent = 0;
  58                         this.errorCount = 0;
  59                         this.warningCount = 0;
  60                         this.writeHandler += new WriteHandler (WriteHandlerFunction);
  61                         this.performanceSummary = false;
  62                         this.summary = true;
  63                 }
  64
  65                 public virtual void ApplyParameter (string parameterName,
  66                                                     string parameterValue)
  67                 {
  68                         // FIXME: what we should do here? in msbuild it isn't
  69                         // changing "parameters" property
  70                 }
  71
  72                 public virtual void Initialize (IEventSource eventSource)
  73                 {
  74                         eventSource.BuildStarted +=  new BuildStartedEventHandler (BuildStarted);
  75                         eventSource.BuildFinished += new BuildFinishedEventHandler (BuildFinished);
  76                         eventSource.ProjectStarted += new ProjectStartedEventHandler (ProjectStarted);
  77                         eventSource.ProjectFinished += new ProjectFinishedEventHandler (ProjectFinished);
  78                         eventSource.TargetStarted += new TargetStartedEventHandler (TargetStarted);
  79                         eventSource.TargetFinished += new TargetFinishedEventHandler (TargetFinished);
  80                         eventSource.TaskStarted += new TaskStartedEventHandler (TaskStarted);
  81                         eventSource.TaskFinished += new TaskFinishedEventHandler (TaskFinished);
  82                         eventSource.MessageRaised += new BuildMessageEventHandler (MessageRaised);
  83                         eventSource.WarningRaised += new BuildWarningEventHandler (WarningRaised);
  84                         eventSource.ErrorRaised += new BuildErrorEventHandler (ErrorRaised);
  85                 }
  86
  87                 public void BuildStarted (object sender, BuildStartedEventArgs args)
  88                 {
  89                         WriteLine ("");
  90                         WriteLine (String.Format ("Build started {0}.", args.TimeStamp));
  91                         WriteLine ("__________________________________________________");
  92                         buildStart = args.TimeStamp;
  93                 }
  94
  95                 public void BuildFinished (object sender, BuildFinishedEventArgs args)
  96                 {
  97                         if (args.Succeeded == true) {
  98                                 WriteLine ("Build succeeded.");
  99                         } else {
 100                                 WriteLine ("Build failed.");
 101                         }
 102                         if (performanceSummary == true)
 103                                 ;
 104                         if (summary == true){
 105                                 TimeSpan timeElapsed = args.TimeStamp - buildStart;
 106                                 WriteLine (String.Format ("\t {0} Warning(s)", warningCount));
 107                                 WriteLine (String.Format ("\t {0} Error(s)", errorCount));
 108                                 WriteLine ("");
 109                                 WriteLine (String.Format ("Time Elapsed {0}", timeElapsed));
 110                         }
 111                 }
 112
 113                 public void ProjectStarted (object sender, ProjectStartedEventArgs args)
 114                 {
 115                         WriteLine (String.Format ("Project \"{0}\" ({1} target(s)):", args.ProjectFile, args.TargetNames));
 116                         WriteLine ("");
 117                 }
 118
 119                 public void ProjectFinished (object sender, ProjectFinishedEventArgs args)
 120                 {
 121                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Diagnostic)) {
 122                                 WriteLine (String.Format ("Done building project \"{0}\".", args.ProjectFile));
 123                                 WriteLine ("");
 124                         }
 125                 }
 126
 127                 public void TargetStarted (object sender, TargetStartedEventArgs args)
 128                 {
 129                         WriteLine (String.Format ("Target {0}:",args.TargetName));
 130                         indent++;
 131                 }
 132
 133                 public void TargetFinished (object sender, TargetFinishedEventArgs args)
 134                 {
 135                         indent--;
 136                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Diagnostic))
 137                                 WriteLine (String.Format ("Done building target \"{0}\" in project \"{1}\".",
 138                                         args.TargetName, args.ProjectFile));
 139                         WriteLine ("");
 140                 }
 141
 142                 public void TaskStarted (object sender, TaskStartedEventArgs args)
 143                 {
 144                         if (this.verbosity == LoggerVerbosity.Diagnostic)
 145                                 WriteLine (String.Format ("Task \"{0}\"",args.TaskName));
 146                         indent++;
 147                 }
 148
 149                 public void TaskFinished (object sender, TaskFinishedEventArgs args)
 150                 {
 151                         indent--;
 152                         if (this.verbosity == LoggerVerbosity.Diagnostic)
 153                                 WriteLine (String.Format ("Done executing task \"{0}\"",args.TaskName));
 154                 }
 155
 156                 public void MessageRaised (object sender, BuildMessageEventArgs args)
 157                 {
 158                         if (IsMessageOk (args)) {
 159                                 WriteLine (args.Message);
 160                         }
 161                 }
 162
 163                 public void WarningRaised (object sender, BuildWarningEventArgs args)
 164                 {
 165                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal))
 166                                 WriteLineWithoutIndent (FormatWarningEvent (args));
 167                         warningCount++;
 168                 }
 169
 170                 public void ErrorRaised (object sender, BuildErrorEventArgs args)
 171                 {
 172                         if (IsVerbosityGreaterOrEqual (LoggerVerbosity.Minimal))
 173                                 WriteLineWithoutIndent (FormatErrorEvent (args));
 174                         errorCount++;
 175                 }
 176
 177                 private void WriteLine (string message)
 178                 {
 179                         for (int i = 0; i < indent; i++)
 180                                 Console.Write ('\t');
 181                         writeHandler (message);
 182                 }
 183
 184                 private void WriteLineWithoutIndent (string message)
 185                 {
 186                         writeHandler (message);
 187                 }
 188
 189                 private void WriteLineWithSender (object sender, string message)
 190                 {
 191                         if ((string) sender == "MSBuild")
 192                                 WriteLine (message);
 193                         else
 194                                 WriteLine ((string) sender + ": " + message);
 195                 }
 196
 197                 private void WriteHandlerFunction (string message)
 198                 {
 199                         Console.WriteLine (message);
 200                 }
 201
 202                 private void ParseParameters ()
 203                 {
 204                         string[] splittedParameters = parameters.Split (';');
 205                         foreach (string s in splittedParameters ) {
 206                                 switch (s) {
 207                                 case "PerformanceSummary":
 208                                         this.performanceSummary = true;
 209                                         break;
 210                                 case "NoSummary":
 211                                         this.summary = false;
 212                                         break;
 213                                 default:
 214                                         throw new ArgumentException ("Invalid parameter.");
 215                                 }
 216                         }
 217                 }
 218
 219                 public virtual void Shutdown ()
 220                 {
 221                 }
 222
 223                 private string FormatErrorEvent (BuildErrorEventArgs args)
 224                 {
 225                         // FIXME: show more complicated args
 226                         if (args.LineNumber != 0 && args.ColumnNumber != 0) {
 227                                 return String.Format ("{0}({1},{2}): {3} error {4}: {5}", args.File, args.LineNumber, args.ColumnNumber,
 228                                         args.Subcategory, args.Code, args.Message);
 229                         } else {
 230                                 return String.Format ("{0}: {1} error {2}: {3}", args.File, args.Subcategory, args.Code,
 231                                         args.Message);
 232                         }
 233                 }
 234
 235                 private string FormatWarningEvent (BuildWarningEventArgs args)
 236                 {
 237                         // FIXME: show more complicated args
 238                         if (args.LineNumber != 0 && args.ColumnNumber != 0) {
 239                                 return String.Format ("{0}({1},{2}): {3} warning {4}: {5}", args.File, args.LineNumber, args.ColumnNumber,
 240                                         args.Subcategory, args.Code, args.Message);
 241                         } else {
 242                                 return String.Format ("{0}: {1} warning {2}: {3}", args.File, args.Subcategory, args.Code,
 243                                         args.Message);
 244                         }
 245                 }
 246
 247                 private bool IsMessageOk (BuildMessageEventArgs bsea)
 248                 {
 249                         if (bsea.Importance == MessageImportance.High && IsVerbosityGreaterOrEqual (LoggerVerbosity.Minimal)) {
 250                                 return true;
 251                         } else if (bsea.Importance == MessageImportance.Normal && IsVerbosityGreaterOrEqual (LoggerVerbosity.Normal)) {
 252                                 return true;
 253                         } else if (bsea.Importance == MessageImportance.Low && IsVerbosityGreaterOrEqual (LoggerVerbosity.Detailed)) {
 254                                 return true;
 255                         } else
 256                                 return false;
 257                 }
 258
 259                 private bool IsVerbosityGreaterOrEqual (LoggerVerbosity v)
 260                 {
 261                                 if (v == LoggerVerbosity.Diagnostic) {
 262                                         return LoggerVerbosity.Diagnostic <= verbosity;
 263                                 } else if (v == LoggerVerbosity.Detailed) {
 264                                         return LoggerVerbosity.Detailed <= verbosity;
 265                                 } else if (v == LoggerVerbosity.Normal) {
 266                                         return LoggerVerbosity.Normal <= verbosity;
 267                                 } else if (v == LoggerVerbosity.Minimal) {
 268                                         return LoggerVerbosity.Minimal <= verbosity;
 269                                 } else if (v == LoggerVerbosity.Quiet) {
 270                                         return true;
 271                                 } else
 272                                         return false;
 273                 }
 274
 275                 public string Parameters {
 276                         get {
 277                                 return parameters;
 278                         }
 279                         set {
 280                                 if (value == null)
 281                                         throw new ArgumentNullException ();
 282                                 parameters = value;
 283                                 if (parameters != String.Empty)
 284                                         ParseParameters ();
 285                         }
 286                 }
 287
 288                 public LoggerVerbosity Verbosity {
 289                         get {
 290                                 return verbosity;
 291                         }
 292                         set {
 293                                 verbosity = value;
 294                         }
 295                 }
 296
 297                 protected WriteHandler WriteHandler {
 298                         get {
 299                                 return writeHandler;
 300                         }
 301                         set {
 302                                 writeHandler = value;
 303                         }
 304                 }
 305         }
 306 }
 307
 308 #endif