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                 }
  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)
  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, null, 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 e)
 130                 {
 131                         LogErrorFromException (e, true);
 132                 }
 133
 134                 public void LogErrorFromException (Exception e,
 135                                                    bool showStackTrace)
 136                 {
 137                         if (e == null)
 138                                 throw new ArgumentNullException ("e");
 139
 140                         StringBuilder sb = new StringBuilder ();
 141                         sb.Append (e.Message);
 142                         if (showStackTrace == true)
 143                                 sb.Append (e.StackTrace);
 144                         BuildErrorEventArgs beea = new BuildErrorEventArgs (
 145                                 null, null, null, 0, 0, 0, 0, sb.ToString (),
 146                                 e.HelpLink, e.Source);
 147                         buildEngine.LogErrorEvent (beea);
 148                         hasLoggedErrors = true;
 149                 }
 150
 151                 public void LogErrorFromResources (string messageResourceName,
 152                                                    params object[] messageArgs)
 153                 {
 154                         LogErrorFromResources (null, null, null, null, 0, 0, 0,
 155                                 0, messageResourceName, null);
 156                 }
 157
 158                 public void LogErrorFromResources (string subcategoryResourceName,
 159                                                    string errorCode,
 160                                                    string helpKeyword,
 161                                                    string file, int lineNumber,
 162                                                    int columnNumber,
 163                                                    int endLineNumber,
 164                                                    int endColumnNumber,
 165                                                    string messageResourceName,
 166                                                    params object[] messageArgs)
 167                 {
 168                         BuildErrorEventArgs beea = new BuildErrorEventArgs (
 169                                 taskResources.GetString (subcategoryResourceName),
 170                                 errorCode, file, lineNumber, columnNumber,
 171                                 endLineNumber, endColumnNumber,
 172                                 taskResources.GetString (messageResourceName),
 173                                 helpKeyword, null );
 174                         buildEngine.LogErrorEvent (beea);
 175                         hasLoggedErrors = true;
 176                 }
 177
 178                 public void LogErrorWithCodeFromResources (string messageResourceName,
 179                                                           params object[] messageArgs)
 180                 {
 181                         // FIXME: there should be something different than normal
 182                         // LogErrorFromResources
 183                         LogErrorFromResources (messageResourceName, messageArgs);
 184                 }
 185
 186                 public void LogErrorWithCodeFromResources (string subcategoryResourceName,
 187                                                           string file,
 188                                                           int lineNumber,
 189                                                           int columnNumber,
 190                                                           int endLineNumber,
 191                                                           int endColumnNumber,
 192                                                           string messageResourceName,
 193                                                           params object[] messageArgs)
 194                 {
 195                         // FIXME: there should be something different than normal
 196                         // LogErrorFromResources
 197                         LogErrorFromResources (subcategoryResourceName, file,
 198                                 lineNumber, columnNumber, endLineNumber,
 199                                 endColumnNumber, messageResourceName,
 200                                 messageArgs);
 201                 }
 202
 203                 public void LogMessage (string message,
 204                                        params object[] messageArgs)
 205                 {
 206                         LogMessage (MessageImportance.Normal, message, messageArgs);
 207                 }
 208
 209                 public void LogMessage (MessageImportance importance,
 210                                         string message,
 211                                         params object[] messageArgs)
 212                 {
 213                         if (message == null)
 214                                 throw new ArgumentNullException ("message");
 215
 216                         BuildMessageEventArgs bmea = new BuildMessageEventArgs (
 217                                 FormatString (message, messageArgs), helpKeywordPrefix,
 218                                 null, importance);
 219                         buildEngine.LogMessageEvent (bmea);
 220                 }
 221
 222                 public void LogMessageFromResources (string messageResourceName,
 223                                                      params object[] messageArgs)
 224                 {
 225                         LogMessage (taskResources.GetString (messageResourceName),
 226                                 messageArgs);
 227                 }
 228
 229                 public void LogMessageFromResources (MessageImportance importance,
 230                                                      string messageResourceName,
 231                                                      params object[] messageArgs)
 232                 {
 233                         LogMessage (importance, taskResources.GetString (
 234                                 messageResourceName), messageArgs);
 235                 }
 236
 237                 public bool LogMessagesFromFile (string filename)
 238                 {
 239                         return LogMessagesFromFile (filename, MessageImportance.Normal);
 240                 }
 241
 242                 public bool LogMessagesFromFile (string filename,
 243                                                  MessageImportance messageImportance)
 244                 {
 245                         try {
 246                                 StreamReader sr = new StreamReader (filename);
 247                                 LogMessage (messageImportance, sr.ReadToEnd (),
 248                                         null);
 249                                 sr.Close ();
 250                                 return true;
 251                         }
 252                         catch (Exception) {
 253                                 return false;
 254                         }
 255                 }
 256
 257                 public bool LogMessagesFromStream (TextReader stream,
 258                                                    MessageImportance messageImportance)
 259                 {
 260                         try {
 261                                 LogMessage (messageImportance, stream.ReadToEnd (), null);
 262                                 return true;
 263                         }
 264                         catch (Exception) {
 265                                 return false;
 266                         }
 267                         finally {
 268                                 // FIXME: should it be done here?
 269                                 stream.Close ();
 270                         }
 271                 }
 272
 273                 [MonoTODO]
 274                 public bool LogMessageFromText (string lineOfText,
 275                                                 MessageImportance importance)
 276                 {
 277                         if (lineOfText == null)
 278                                 throw new ArgumentNullException ("lineOfText");
 279                         return true;
 280                 }
 281
 282                 public void LogWarning (string message,
 283                                        params object[] messageArgs)
 284                 {
 285                         // FIXME: what about all the parameters?
 286                         BuildWarningEventArgs bwea = new BuildWarningEventArgs (
 287                                 null, null, null, 0, 0, 0, 0, FormatString (message, messageArgs),
 288                                 helpKeywordPrefix, null);
 289                         buildEngine.LogWarningEvent (bwea);
 290                 }
 291
 292                 public void LogWarning (string subcategory, string warningCode,
 293                                         string helpKeyword, string file,
 294                                         int lineNumber, int columnNumber,
 295                                         int endLineNumber, int endColumnNumber,
 296                                         string message,
 297                                         params object[] messageArgs)
 298                 {
 299                         BuildWarningEventArgs bwea = new BuildWarningEventArgs (
 300                                 subcategory, warningCode, file, lineNumber,
 301                                 columnNumber, endLineNumber, endColumnNumber,
 302                                 FormatString (message, messageArgs), helpKeyword, null);
 303                         buildEngine.LogWarningEvent (bwea);
 304                 }
 305
 306                 public void LogWarningFromException (Exception e)
 307                 {
 308                         LogWarningFromException (e, false);
 309                 }
 310
 311                 public void LogWarningFromException (Exception e,
 312                                                      bool showStackTrace)
 313                 {
 314                         StringBuilder sb = new StringBuilder ();
 315                         sb.Append (e.Message);
 316                         if (showStackTrace)
 317                                 sb.Append (e.StackTrace);
 318                         LogWarning (null, null, null, null, 0, 0, 0, 0,
 319                                 sb.ToString (), null);
 320                 }
 321
 322                 public void LogWarningFromResources (string messageResourceName,
 323                                                      params object[] messageArgs)
 324                 {
 325                         LogWarning (taskResources.GetString (messageResourceName),
 326                                 messageArgs);
 327                 }
 328
 329                 public void LogWarningFromResources (string subcategoryResourceName,
 330                                                      string warningCode,
 331                                                      string helpKeyword,
 332                                                      string file,
 333                                                      int lineNumber,
 334                                                      int columnNumber,
 335                                                      int endLineNumber,
 336                                                      int endColumnNumber,
 337                                                      string messageResourceName,
 338                                                      params object[] messageArgs)
 339                 {
 340                         LogWarning (taskResources.GetString (subcategoryResourceName),
 341                                 warningCode, helpKeyword, file, lineNumber,
 342                                 columnNumber, endLineNumber, endColumnNumber,
 343                                 taskResources.GetString (messageResourceName),
 344                                 messageArgs);
 345                 }
 346
 347                 public void LogWarningWithCodeFromResources (string messageResourceName,
 348                                                              params object[] messageArgs)
 349                 {
 350                         // FIXME: what's different from normal logwarning?
 351                         LogWarningFromResources (messageResourceName, messageArgs);
 352                 }
 353
 354                 public void LogWarningWithCodeFromResources (string subcategoryResourceName,
 355                                                              string file,
 356                                                              int lineNumber,
 357                                                              int columnNumber,
 358                                                              int endLineNumber,
 359                                                              int endColumnNumber,
 360                                                              string messageResourceName,
 361                                                              params object[] messageArgs)
 362                 {
 363                         LogWarningFromResources (subcategoryResourceName, file,
 364                                 lineNumber, columnNumber, endLineNumber,
 365                                 endColumnNumber, messageResourceName,
 366                                 messageArgs);
 367                 }
 368
 369                 [MonoTODO]
 370                 public void LogExternalProjectFinished (string message,
 371                                                         string helpKeyword,
 372                                                         string projectFile,
 373                                                         bool succeeded)
 374                 {
 375                 }
 376
 377                 [MonoTODO]
 378                 public void LogExternalProjectStarted (string message,
 379                                                        string helpKeyword,
 380                                                        string projectFile,
 381                                                        string targetNames)
 382                 {
 383                 }
 384
 385                 protected IBuildEngine BuildEngine {
 386                         get {
 387                                 return buildEngine;
 388                         }
 389                 }
 390
 391                 public bool HasLoggedErrors {
 392                         get {
 393                                 return hasLoggedErrors;
 394                         }
 395                 }
 396
 397                 public string HelpKeywordPrefix {
 398                         get {
 399                                 return helpKeywordPrefix;
 400                         }
 401                         set {
 402                                 helpKeywordPrefix = value;
 403                         }
 404                 }
 405
 406                 protected string TaskName {
 407                         get {
 408                                 return taskName;
 409                         }
 410                 }
 411
 412                 public ResourceManager TaskResources {
 413                         get {
 414                                 return taskResources;
 415                         }
 416                         set {
 417                                 taskResources = value;
 418                         }
 419                 }
 420         }
 421 }
 422
 423 #endif