mcs/class/Microsoft.Build.Utilities/Microsoft.Build.Utilities/TaskLoggingHelper.cs

   1 //
   2 // TaskLoggingHelper.cs: Wrapper aroudn IBuildEngine.
   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
  29 using System;
  30 using System.IO;
  31 using System.Resources;
  32 using System.Text;
  33 using Microsoft.Build.Framework;
  34
  35 namespace Microsoft.Build.Utilities
  36 {
  37         public class TaskLoggingHelper : MarshalByRefObject
  38         {
  39                 IBuildEngine    buildEngine;
  40                 bool            hasLoggedErrors;
  41                 string          helpKeywordPrefix;
  42                 string          taskName;
  43                 ResourceManager taskResources;
  44
  45                 public TaskLoggingHelper (ITask taskInstance)
  46                 {
  47                         if (taskInstance != null)
  48                                 this.buildEngine = taskInstance.BuildEngine;
  49                         taskName = null;
  50                 }
  51
  52                 [MonoTODO]
  53                 public string ExtractMessageCode (string message,
  54                                                   out string messageWithoutCodePrefix)
  55                 {
  56                         if (message == null)
  57                                 throw new ArgumentNullException ("message");
  58
  59                         messageWithoutCodePrefix = String.Empty;
  60                         return String.Empty;
  61                 }
  62
  63                 [MonoTODO]
  64                 public virtual string FormatResourceString (string resourceName,
  65                                                             params object[] args)
  66                 {
  67                         if (resourceName == null)
  68                                 throw new ArgumentNullException ("resourceName");
  69
  70                         return null;
  71                 }
  72
  73                 [MonoTODO]
  74                 public virtual string FormatString (string unformatted,
  75                                                    params object[] args)
  76                 {
  77                         if (unformatted == null)
  78                                 throw new ArgumentNullException ("unformatted");
  79
  80                         if (args == null || args.Length == 0)
  81                                 return unformatted;
  82                         else
  83                                 return String.Format (unformatted, args);
  84                 }
  85
  86                 [MonoTODO]
  87                 public void LogCommandLine (string commandLine)
  88                 {
  89                 }
  90
  91                 [MonoTODO]
  92                 public void LogCommandLine (MessageImportance importance,
  93                                             string commandLine)
  94                 {
  95                 }
  96
  97                 public void LogError (string message,
  98                                      params object[] messageArgs)
  99                 {
 100                         if (message == null)
 101                                 throw new ArgumentNullException ("message");
 102
 103                         BuildErrorEventArgs beea = new BuildErrorEventArgs (
 104                                 null, null, buildEngine.ProjectFileOfTaskNode, 0, 0, 0, 0, FormatString (message, messageArgs),
 105                                 helpKeywordPrefix, null);
 106                         buildEngine.LogErrorEvent (beea);
 107                         hasLoggedErrors = true;
 108                 }
 109
 110                 public void LogError (string subcategory, string errorCode,
 111                                       string helpKeyword, string file,
 112                                       int lineNumber, int columnNumber,
 113                                       int endLineNumber, int endColumnNumber,
 114                                       string message,
 115                                       params object[] messageArgs)
 116                 {
 117                         if (message == null)
 118                                 throw new ArgumentNullException ("message");
 119
 120                         BuildErrorEventArgs beea = new BuildErrorEventArgs (
 121                                 subcategory, errorCode, file, lineNumber,
 122                                 columnNumber, endLineNumber, endColumnNumber,
 123                                 FormatString (message, messageArgs), helpKeyword /*it's helpKeyword*/,
 124                                 null /*it's senderName*/);
 125                         buildEngine.LogErrorEvent (beea);
 126                         hasLoggedErrors = true;
 127                 }
 128
 129                 public void LogErrorFromException (Exception exception)
 130                 {
 131                         LogErrorFromException (exception, true);
 132                 }
 133
 134                 public void LogErrorFromException (Exception exception,
 135                                                    bool showStackTrace)
 136                 {
 137                         LogErrorFromException (exception, showStackTrace, true, String.Empty);
 138                 }
 139
 140                 [MonoTODO ("Arguments @showDetail and @file are not honored")]
 141                 public void LogErrorFromException (Exception exception,
 142                                                    bool showStackTrace, bool showDetail, string file)
 143                 {
 144                         if (exception == null)
 145                                 throw new ArgumentNullException ("exception");
 146
 147                         StringBuilder sb = new StringBuilder ();
 148                         sb.Append (exception.Message);
 149                         if (showStackTrace == true)
 150                                 sb.Append (exception.StackTrace);
 151                         BuildErrorEventArgs beea = new BuildErrorEventArgs (
 152                                 null, null, buildEngine.ProjectFileOfTaskNode, 0, 0, 0, 0, sb.ToString (),
 153                                 exception.HelpLink, exception.Source);
 154                         buildEngine.LogErrorEvent (beea);
 155                         hasLoggedErrors = true;
 156                 }
 157
 158                 public void LogErrorFromResources (string messageResourceName,
 159                                                    params object[] messageArgs)
 160                 {
 161                         LogErrorFromResources (null, null, null, null, 0, 0, 0,
 162                                 0, messageResourceName, null);
 163                 }
 164
 165                 public void LogErrorFromResources (string subcategoryResourceName,
 166                                                    string errorCode,
 167                                                    string helpKeyword,
 168                                                    string file, int lineNumber,
 169                                                    int columnNumber,
 170                                                    int endLineNumber,
 171                                                    int endColumnNumber,
 172                                                    string messageResourceName,
 173                                                    params object[] messageArgs)
 174                 {
 175                         BuildErrorEventArgs beea = new BuildErrorEventArgs (
 176                                 taskResources.GetString (subcategoryResourceName),
 177                                 errorCode, file, lineNumber, columnNumber,
 178                                 endLineNumber, endColumnNumber,
 179                                 taskResources.GetString (messageResourceName),
 180                                 helpKeyword, null );
 181                         buildEngine.LogErrorEvent (beea);
 182                         hasLoggedErrors = true;
 183                 }
 184
 185                 public void LogErrorWithCodeFromResources (string messageResourceName,
 186                                                           params object[] messageArgs)
 187                 {
 188                         // FIXME: there should be something different than normal
 189                         // LogErrorFromResources
 190                         LogErrorFromResources (messageResourceName, messageArgs);
 191                 }
 192
 193                 public void LogErrorWithCodeFromResources (string subcategoryResourceName,
 194                                                           string file,
 195                                                           int lineNumber,
 196                                                           int columnNumber,
 197                                                           int endLineNumber,
 198                                                           int endColumnNumber,
 199                                                           string messageResourceName,
 200                                                           params object[] messageArgs)
 201                 {
 202                         // FIXME: there should be something different than normal
 203                         // LogErrorFromResources
 204                         LogErrorFromResources (subcategoryResourceName, file,
 205                                 lineNumber, columnNumber, endLineNumber,
 206                                 endColumnNumber, messageResourceName,
 207                                 messageArgs);
 208                 }
 209
 210                 public void LogMessage (string message,
 211                                        params object[] messageArgs)
 212                 {
 213                         LogMessage (MessageImportance.Normal, message, messageArgs);
 214                 }
 215
 216                 public void LogMessage (MessageImportance importance,
 217                                         string message,
 218                                         params object[] messageArgs)
 219                 {
 220                         if (message == null)
 221                                 throw new ArgumentNullException ("message");
 222
 223                         LogMessageFromText (FormatString (message, messageArgs), importance);
 224                 }
 225
 226                 public void LogMessageFromResources (string messageResourceName,
 227                                                      params object[] messageArgs)
 228                 {
 229                         LogMessage (taskResources.GetString (messageResourceName),
 230                                 messageArgs);
 231                 }
 232
 233                 public void LogMessageFromResources (MessageImportance importance,
 234                                                      string messageResourceName,
 235                                                      params object[] messageArgs)
 236                 {
 237                         LogMessage (importance, taskResources.GetString (
 238                                 messageResourceName), messageArgs);
 239                 }
 240
 241                 public bool LogMessagesFromFile (string fileName)
 242                 {
 243                         return LogMessagesFromFile (fileName, MessageImportance.Normal);
 244                 }
 245
 246                 public bool LogMessagesFromFile (string fileName,
 247                                                  MessageImportance messageImportance)
 248                 {
 249                         try {
 250                                 StreamReader sr = new StreamReader (fileName);
 251                                 LogMessage (messageImportance, sr.ReadToEnd (),
 252                                         null);
 253                                 sr.Close ();
 254                                 return true;
 255                         }
 256                         catch (Exception) {
 257                                 return false;
 258                         }
 259                 }
 260
 261                 public bool LogMessagesFromStream (TextReader stream,
 262                                                    MessageImportance messageImportance)
 263                 {
 264                         try {
 265                                 LogMessage (messageImportance, stream.ReadToEnd (), null);
 266                                 return true;
 267                         }
 268                         catch (Exception) {
 269                                 return false;
 270                         }
 271                         finally {
 272                                 // FIXME: should it be done here?
 273                                 stream.Close ();
 274                         }
 275                 }
 276
 277                 public bool LogMessageFromText (string lineOfText,
 278                                                 MessageImportance messageImportance)
 279                 {
 280                         if (lineOfText == null)
 281                                 throw new ArgumentNullException ("lineOfText");
 282
 283                         BuildMessageEventArgs bmea = new BuildMessageEventArgs (
 284                                 lineOfText, helpKeywordPrefix,
 285                                 null, messageImportance);
 286                         buildEngine.LogMessageEvent (bmea);
 287
 288                         return true;
 289                 }
 290
 291                 public void LogWarning (string message,
 292                                        params object[] messageArgs)
 293                 {
 294                         // FIXME: what about all the parameters?
 295                         BuildWarningEventArgs bwea = new BuildWarningEventArgs (
 296                                 null, null, buildEngine.ProjectFileOfTaskNode, 0, 0, 0, 0, FormatString (message, messageArgs),
 297                                 helpKeywordPrefix, null);
 298                         buildEngine.LogWarningEvent (bwea);
 299                 }
 300
 301                 public void LogWarning (string subcategory, string warningCode,
 302                                         string helpKeyword, string file,
 303                                         int lineNumber, int columnNumber,
 304                                         int endLineNumber, int endColumnNumber,
 305                                         string message,
 306                                         params object[] messageArgs)
 307                 {
 308                         BuildWarningEventArgs bwea = new BuildWarningEventArgs (
 309                                 subcategory, warningCode, file, lineNumber,
 310                                 columnNumber, endLineNumber, endColumnNumber,
 311                                 FormatString (message, messageArgs), helpKeyword, null);
 312                         buildEngine.LogWarningEvent (bwea);
 313                 }
 314
 315                 public void LogWarningFromException (Exception exception)
 316                 {
 317                         LogWarningFromException (exception, false);
 318                 }
 319
 320                 public void LogWarningFromException (Exception exception,
 321                                                      bool showStackTrace)
 322                 {
 323                         StringBuilder sb = new StringBuilder ();
 324                         sb.Append (exception.Message);
 325                         if (showStackTrace)
 326                                 sb.Append (exception.StackTrace);
 327                         LogWarning (null, null, null, null, 0, 0, 0, 0,
 328                                 sb.ToString (), null);
 329                 }
 330
 331                 public void LogWarningFromResources (string messageResourceName,
 332                                                      params object[] messageArgs)
 333                 {
 334                         LogWarning (taskResources.GetString (messageResourceName),
 335                                 messageArgs);
 336                 }
 337
 338                 public void LogWarningFromResources (string subcategoryResourceName,
 339                                                      string warningCode,
 340                                                      string helpKeyword,
 341                                                      string file,
 342                                                      int lineNumber,
 343                                                      int columnNumber,
 344                                                      int endLineNumber,
 345                                                      int endColumnNumber,
 346                                                      string messageResourceName,
 347                                                      params object[] messageArgs)
 348                 {
 349                         LogWarning (taskResources.GetString (subcategoryResourceName),
 350                                 warningCode, helpKeyword, file, lineNumber,
 351                                 columnNumber, endLineNumber, endColumnNumber,
 352                                 taskResources.GetString (messageResourceName),
 353                                 messageArgs);
 354                 }
 355
 356                 public void LogWarningWithCodeFromResources (string messageResourceName,
 357                                                              params object[] messageArgs)
 358                 {
 359                         // FIXME: what's different from normal logwarning?
 360                         LogWarningFromResources (messageResourceName, messageArgs);
 361                 }
 362
 363                 public void LogWarningWithCodeFromResources (string subcategoryResourceName,
 364                                                              string file,
 365                                                              int lineNumber,
 366                                                              int columnNumber,
 367                                                              int endLineNumber,
 368                                                              int endColumnNumber,
 369                                                              string messageResourceName,
 370                                                              params object[] messageArgs)
 371                 {
 372                         LogWarningFromResources (subcategoryResourceName, file,
 373                                 lineNumber, columnNumber, endLineNumber,
 374                                 endColumnNumber, messageResourceName,
 375                                 messageArgs);
 376                 }
 377
 378                 [MonoTODO]
 379                 public void LogExternalProjectFinished (string message,
 380                                                         string helpKeyword,
 381                                                         string projectFile,
 382                                                         bool succeeded)
 383                 {
 384                 }
 385
 386                 [MonoTODO]
 387                 public void LogExternalProjectStarted (string message,
 388                                                        string helpKeyword,
 389                                                        string projectFile,
 390                                                        string targetNames)
 391                 {
 392                 }
 393
 394                 protected IBuildEngine BuildEngine {
 395                         get {
 396                                 return buildEngine;
 397                         }
 398                 }
 399
 400                 public bool HasLoggedErrors {
 401                         get {
 402                                 return hasLoggedErrors;
 403                         }
 404                 }
 405
 406                 public string HelpKeywordPrefix {
 407                         get {
 408                                 return helpKeywordPrefix;
 409                         }
 410                         set {
 411                                 helpKeywordPrefix = value;
 412                         }
 413                 }
 414
 415                 protected string TaskName {
 416                         get {
 417                                 return taskName;
 418                         }
 419                 }
 420
 421                 public ResourceManager TaskResources {
 422                         get {
 423                                 return taskResources;
 424                         }
 425                         set {
 426                                 taskResources = value;
 427                         }
 428                 }
 429         }
 430 }
 431