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