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