cs/src/Ice/TraceUtil.cs

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 namespace IceInternal
  11 {
  12
  13     using System.Collections.Generic;
  14     using System.Diagnostics;
  15     using System.Globalization;
  16
  17     sealed class TraceUtil
  18     {
  19         internal static void traceSend(BasicStream str, Ice.Logger logger, TraceLevels tl)
  20         {
  21             if(tl.protocol >= 1)
  22             {
  23                 int p = str.pos();
  24                 str.pos(0);
  25
  26                 using(System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture))
  27                 {
  28                     byte type = printMessage(s, str);
  29
  30                     logger.trace(tl.protocolCat, "sending " + getMessageTypeAsString(type) + " " + s.ToString());
  31                 }
  32                 str.pos(p);
  33             }
  34         }
  35
  36         internal static void traceRecv(BasicStream str, Ice.Logger logger, TraceLevels tl)
  37         {
  38             if(tl.protocol >= 1)
  39             {
  40                 int p = str.pos();
  41                 str.pos(0);
  42
  43                 using(System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture))
  44                 {
  45                     byte type = printMessage(s, str);
  46
  47                     logger.trace(tl.protocolCat, "received " + getMessageTypeAsString(type) + " " + s.ToString());
  48                 }
  49                 str.pos(p);
  50             }
  51         }
  52
  53         internal static void trace(string heading, BasicStream str, Ice.Logger logger, TraceLevels tl)
  54         {
  55             if(tl.protocol >= 1)
  56             {
  57                 int p = str.pos();
  58                 str.pos(0);
  59
  60                 using(System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture))
  61                 {
  62                     s.Write(heading);
  63                     printMessage(s, str);
  64
  65                     logger.trace(tl.protocolCat, s.ToString());
  66                 }
  67                 str.pos(p);
  68             }
  69         }
  70
  71         private static HashSet<string> slicingIds = new HashSet<string>();
  72
  73         internal static void traceSlicing(string kind, string typeId, string slicingCat, Ice.Logger logger)
  74         {
  75             lock(typeof(IceInternal.TraceUtil))
  76             {
  77                 if(slicingIds.Add(typeId))
  78                 {
  79                     using(System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture))
  80                     {
  81                         s.Write("unknown " + kind + " type `" + typeId + "'");
  82                         logger.trace(slicingCat, s.ToString());
  83                     }
  84                 }
  85             }
  86         }
  87
  88         public static void dumpStream(BasicStream stream)
  89         {
  90             int pos = stream.pos();
  91             stream.pos(0);
  92
  93             byte[] data = new byte[stream.size()];
  94             stream.readBlob(data);
  95             dumpOctets(data);
  96
  97             stream.pos(pos);
  98         }
  99
 100         public static void dumpOctets(byte[] data)
 101         {
 102             const int inc = 8;
 103
 104             for(int i = 0; i < data.Length; i += inc)
 105             {
 106                 for(int j = i; j - i < inc; j++)
 107                 {
 108                     if(j < data.Length)
 109                     {
 110                         int n = (int)data[j];
 111                         if(n < 0)
 112                         {
 113                             n += 256;
 114                         }
 115                         string s;
 116                         if(n < 10)
 117                         {
 118                             s = "  " + n;
 119                         }
 120                         else if(n < 100)
 121                         {
 122                             s = " " + n;
 123                         }
 124                         else
 125                         {
 126                             s = "" + n;
 127                         }
 128                         System.Console.Out.Write(s + " ");
 129                     }
 130                     else
 131                     {
 132                         System.Console.Out.Write("    ");
 133                     }
 134                 }
 135
 136                 System.Console.Out.Write('"');
 137
 138                 for(int j = i; j < data.Length && j - i < inc; j++)
 139                 {
 140                     // TODO: this needs fixing
 141                     if(data[j] >= (byte)32 && data[j] < (byte)127)
 142                     {
 143                         System.Console.Out.Write((char) data[j]);
 144                     }
 145                     else
 146                     {
 147                         System.Console.Out.Write('.');
 148                     }
 149                 }
 150
 151                 System.Console.Out.WriteLine('"');
 152             }
 153         }
 154
 155         private static void printIdentityFacetOperation(System.IO.StringWriter s, BasicStream str)
 156         {
 157             try
 158             {
 159                 Ice.Identity identity = new Ice.Identity();
 160                 identity.read__(str);
 161                 s.Write("\nidentity = " + str.instance().identityToString(identity));
 162
 163                 string[] facet = str.readStringSeq();
 164                 s.Write("\nfacet = ");
 165                 if(facet.Length > 0)
 166                 {
 167                     s.Write(IceUtilInternal.StringUtil.escapeString(facet[0], ""));
 168                 }
 169
 170                 string operation = str.readString();
 171                 s.Write("\noperation = " + operation);
 172             }
 173             catch(System.IO.IOException)
 174             {
 175                 Debug.Assert(false);
 176             }
 177         }
 178
 179         private static void printRequest(System.IO.StringWriter s, BasicStream str)
 180         {
 181             int requestId = str.readInt();
 182             s.Write("\nrequest id = " + requestId);
 183             if(requestId == 0)
 184             {
 185                 s.Write(" (oneway)");
 186             }
 187
 188             printRequestHeader(s, str);
 189         }
 190
 191         private static void printBatchRequest(System.IO.StringWriter s, BasicStream str)
 192         {
 193             int batchRequestNum = str.readInt();
 194             s.Write("\nnumber of requests = " + batchRequestNum);
 195
 196             for(int i = 0; i < batchRequestNum; ++i)
 197             {
 198                 s.Write("\nrequest #" + i + ':');
 199                 printRequestHeader(s, str);
 200                 str.skipEncaps();
 201             }
 202         }
 203
 204         private static void printReply(System.IO.StringWriter s, BasicStream str)
 205         {
 206             int requestId = str.readInt();
 207             s.Write("\nrequest id = " + requestId);
 208
 209             byte replyStatus = str.readByte();
 210             s.Write("\nreply status = " + (int)replyStatus + ' ');
 211
 212             switch(replyStatus)
 213             {
 214             case ReplyStatus.replyOK:
 215             {
 216                 s.Write("(ok)");
 217                 break;
 218             }
 219
 220             case ReplyStatus.replyUserException:
 221             {
 222                 s.Write("(user exception)");
 223                 break;
 224             }
 225
 226             case ReplyStatus.replyObjectNotExist:
 227             case ReplyStatus.replyFacetNotExist:
 228             case ReplyStatus.replyOperationNotExist:
 229             {
 230                 switch(replyStatus)
 231                 {
 232                 case ReplyStatus.replyObjectNotExist:
 233                 {
 234                     s.Write("(object not exist)");
 235                     break;
 236                 }
 237
 238                 case ReplyStatus.replyFacetNotExist:
 239                 {
 240                     s.Write("(facet not exist)");
 241                     break;
 242                 }
 243
 244                 case ReplyStatus.replyOperationNotExist:
 245                 {
 246                     s.Write("(operation not exist)");
 247                     break;
 248                 }
 249
 250                 default:
 251                 {
 252                     Debug.Assert(false);
 253                     break;
 254                 }
 255                 }
 256
 257                 printIdentityFacetOperation(s, str);
 258                 break;
 259             }
 260
 261             case ReplyStatus.replyUnknownException:
 262             case ReplyStatus.replyUnknownLocalException:
 263             case ReplyStatus.replyUnknownUserException:
 264             {
 265                 switch(replyStatus)
 266                 {
 267                 case ReplyStatus.replyUnknownException:
 268                 {
 269                     s.Write("(unknown exception)");
 270                     break;
 271                 }
 272
 273                 case ReplyStatus.replyUnknownLocalException:
 274                 {
 275                     s.Write("(unknown local exception)");
 276                     break;
 277                 }
 278
 279                 case ReplyStatus.replyUnknownUserException:
 280                 {
 281                     s.Write("(unknown user exception)");
 282                     break;
 283                 }
 284
 285                 default:
 286                 {
 287                     Debug.Assert(false);
 288                     break;
 289                 }
 290                 }
 291
 292                 string unknown = str.readString();
 293                 s.Write("\nunknown = " + unknown);
 294                 break;
 295             }
 296
 297             default:
 298             {
 299                 s.Write("(unknown)");
 300                 break;
 301             }
 302             }
 303         }
 304
 305         private static void printRequestHeader(System.IO.StringWriter s, BasicStream str)
 306         {
 307             printIdentityFacetOperation(s, str);
 308
 309             try
 310             {
 311                 byte mode = str.readByte();
 312                 s.Write("\nmode = " + (int)mode + ' ');
 313                 switch((Ice.OperationMode)mode)
 314                 {
 315                 case Ice.OperationMode.Normal:
 316                 {
 317                     s.Write("(normal)");
 318                     break;
 319                 }
 320
 321                 case Ice.OperationMode.Nonmutating:
 322                 {
 323                     s.Write("(nonmutating)");
 324                     break;
 325                 }
 326
 327                 case Ice.OperationMode.Idempotent:
 328                 {
 329                     s.Write("(idempotent)");
 330                     break;
 331                 }
 332
 333                 default:
 334                 {
 335                     s.Write("(unknown)");
 336                     break;
 337                 }
 338                 }
 339
 340                 int sz = str.readSize();
 341                 s.Write("\ncontext = ");
 342                 while(sz-- > 0)
 343                 {
 344                     string key = str.readString();
 345                     string val = str.readString();
 346                     s.Write(key + '/' + val);
 347                     if(sz > 0)
 348                     {
 349                         s.Write(", ");
 350                     }
 351                 }
 352             }
 353             catch(System.IO.IOException)
 354             {
 355                 Debug.Assert(false);
 356             }
 357         }
 358
 359         private static byte printHeader(System.IO.StringWriter s, BasicStream str)
 360         {
 361             try
 362             {
 363                 str.readByte(); // Don't bother printing the magic number
 364                 str.readByte();
 365                 str.readByte();
 366                 str.readByte();
 367
 368                 /* byte pMajor = */ str.readByte();
 369                 /* byte pMinor = */ str.readByte();
 370                 //s.Write("\nprotocol version = " + (int)pMajor + "." + (int)pMinor);
 371
 372                 /* byte eMajor = */ str.readByte();
 373                 /* byte eMinor = */ str.readByte();
 374                 //s.Write("\nencoding version = " + (int)eMajor + "." + (int)eMinor);
 375
 376                 byte type = str.readByte();
 377                 s.Write("\nmessage type = " + (int)type + " (" + getMessageTypeAsString(type) + ')');
 378
 379                 byte compress = str.readByte();
 380                 s.Write("\ncompression status = " + (int)compress + ' ');
 381                 switch(compress)
 382                 {
 383                 case (byte)0:
 384                 {
 385                     s.Write("(not compressed; do not compress response, if any)");
 386                     break;
 387                 }
 388
 389                 case (byte)1:
 390                 {
 391                     s.Write("(not compressed; compress response, if any)");
 392                     break;
 393                 }
 394
 395                 case (byte)2:
 396                 {
 397                     s.Write("(compressed; compress response, if any)");
 398                     break;
 399                 }
 400
 401                 default:
 402                 {
 403                     s.Write("(unknown)");
 404                     break;
 405                 }
 406                 }
 407
 408                 int size = str.readInt();
 409                 s.Write("\nmessage size = " + size);
 410                 return type;
 411             }
 412             catch(System.IO.IOException)
 413             {
 414                 Debug.Assert(false);
 415                 return 0;
 416             }
 417         }
 418
 419         private static byte printMessage(System.IO.StringWriter s, BasicStream str)
 420         {
 421             byte type = printHeader(s, str);
 422
 423             switch(type)
 424             {
 425             case Protocol.closeConnectionMsg:
 426             case Protocol.validateConnectionMsg:
 427             {
 428                 // We're done.
 429                 break;
 430             }
 431
 432             case Protocol.requestMsg:
 433             {
 434                 printRequest(s, str);
 435                 break;
 436             }
 437
 438             case Protocol.requestBatchMsg:
 439             {
 440                 printBatchRequest(s, str);
 441                 break;
 442             }
 443
 444             case Protocol.replyMsg:
 445             {
 446                 printReply(s, str);
 447                 break;
 448             }
 449
 450             default:
 451             {
 452                 s.Write("(unknown)");
 453                 break;
 454             }
 455             }
 456
 457             return type;
 458         }
 459
 460         internal static void traceHeader(string heading, BasicStream str, Ice.Logger logger, TraceLevels tl)
 461         {
 462             if(tl.protocol >= 1)
 463             {
 464                 int p = str.pos();
 465                 str.pos(0);
 466
 467                 using(System.IO.StringWriter s = new System.IO.StringWriter(CultureInfo.CurrentCulture))
 468                 {
 469                     s.Write(heading);
 470                     printHeader(s, str);
 471
 472                     logger.trace(tl.protocolCat, s.ToString());
 473                 }
 474                 str.pos(p);
 475             }
 476         }
 477
 478         private static string getMessageTypeAsString(byte type)
 479         {
 480             switch(type)
 481             {
 482             case Protocol.requestMsg:
 483                 return "request";
 484             case Protocol.requestBatchMsg:
 485                 return "batch request";
 486             case Protocol.replyMsg:
 487                 return "reply";
 488             case Protocol.closeConnectionMsg:
 489                 return "close connection";
 490             case Protocol.validateConnectionMsg:
 491                 return  "validate connection";
 492             default:
 493                 return "unknown";
 494             }
 495         }
 496     }
 497
 498 }