SHUTTLE/DCSClient/AliDCSMessage.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.1  2006/11/06 14:22:47  jgrosseo
  19 major update (Alberto)
  20 o) reading of run parameters from the logbook
  21 o) online offline naming conversion
  22 o) standalone DCSclient package
  23
  24 Revision 1.7  2006/10/02 16:38:39  jgrosseo
  25 update (alberto):
  26 fixed memory leaks
  27 storing of objects that failed to be stored to the grid before
  28 interfacing of shuttle status table in daq system
  29
  30 Revision 1.6  2006/08/15 10:50:00  jgrosseo
  31 effc++ corrections (alberto)
  32
  33 Revision 1.5  2006/07/20 09:54:40  jgrosseo
  34 introducing status management: The processing per subdetector is divided into several steps,
  35 after each step the status is stored on disk. If the system crashes in any of the steps the Shuttle
  36 can keep track of the number of failures and skips further processing after a certain threshold is
  37 exceeded. These thresholds can be configured in LDAP.
  38
  39 Revision 1.4  2006/07/04 14:59:57  jgrosseo
  40 revision of AliDCSValue: Removed wrapper classes, reduced storage size per value by factor 2
  41
  42 Revision 1.3  2006/06/12 09:11:16  jgrosseo
  43 coding conventions (Alberto)
  44
  45 Revision 1.2  2006/03/07 07:52:34  hristov
  46 New version (B.Yordanov)
  47
  48 Revision 1.3  2005/11/17 17:47:34  byordano
  49 TList changed to TObjArray
  50
  51 Revision 1.2  2005/11/17 14:43:23  byordano
  52 import to local CVS
  53
  54 Revision 1.1.1.1  2005/10/28 07:33:58  hristov
  55 Initial import as subdirectory in AliRoot
  56
  57 Revision 1.1.1.1  2005/09/12 22:11:40  byordano
  58 SHUTTLE package
  59
  60 Revision 1.2  2005/08/30 10:53:23  byordano
  61 some more descriptions added
  62
  63 */
  64
  65
  66 //
  67 // This class is a wrapper of AliDCSMessage.
  68 // These are the messages which form AliDCSProtocol.
  69 // Every message has header and body. The body size is written in the header.
  70 // There are five message types:
  71 //      1) Request - used by the client to form a single request to DCS server
  72 //      2) Count - returned by the server to inidicate the total number of
  73 //              values which would be sent to the client.
  74 //      3) ResultSet - returned by the server and contains part of values set
  75 //              which forms the server resposen.
  76 //      4) Error - returned by the server in case of error
  77 //      5) MultiRequest - used by the client to form multi request.
  78 //              This is a request which serves many aliases/dp at the same time
  79 //              For all aliases/dp the same time interval is used.
  80 // Short description of the schema:
  81 //      The client sends a request (Request or MultiRequest) and the server
  82 //      returns:
  83 //              1) Count - the total number of values that the client should
  84 //                      expect.
  85 //              2) ResultSet* - every ResultSet message contains a part
  86 //                      of valueSet (some values) which the client should expect
  87 //                      The client can wait for ResultMessage until it gets
  88 //                      all values (total number) which was returned by the
  89 //                      Count message at the beginning of the ResutlSet sereie.
  90 //      In case of error:
  91 //              1) Error - contains the error code and error description
  92 //
  93
  94 #include "AliDCSMessage.h"
  95
  96 #include "AliLog.h"
  97
  98 #include <Bytes.h>
  99 #include <TObjString.h>
 100
 101 #include <ctype.h>
 102 #include <assert.h>
 103
 104 ClassImp(AliDCSMessage)
 105
 106 //______________________________________________________________________
 107 AliDCSMessage::AliDCSMessage():
 108         TObject(), fMessage(NULL), fMessageSize(0), fType(kInvalid),
 109         fRequestType(kNoneType), fStartTime(0), fEndTime(0),
 110         fRequestString(""), fCount(0),
 111         fOwnerIndex(0), fValueType(AliDCSValue::kInvalid), fValues(),
 112         fErrorCode(kNoneError), fErrorString(""),
 113         fRequestStrings()
 114 {
 115 // default constructor
 116         fValues = new TObjArray();
 117         fValues->SetOwner(0);
 118
 119 }
 120
 121 //______________________________________________________________________
 122 AliDCSMessage::AliDCSMessage(const char* message, UInt_t size):
 123         TObject(), fMessage(NULL), fMessageSize(size), fType(kInvalid),
 124         fRequestType(kNoneType), fStartTime(0), fEndTime(0),
 125         fRequestString(""), fCount(0),
 126         fOwnerIndex(0), fValueType(AliDCSValue::kInvalid), fValues(),
 127         fErrorCode(kNoneError), fErrorString(""),
 128         fRequestStrings()
 129 {
 130 // default constructor
 131
 132         fMessage = new char[size];
 133
 134         memcpy(fMessage, message, size);
 135         fValues = new TObjArray();
 136         fValues->SetOwner(0);
 137 }
 138
 139 //______________________________________________________________________
 140 AliDCSMessage::AliDCSMessage(const AliDCSMessage& /*other*/):
 141         TObject(), fMessage(NULL), fMessageSize(0), fType(kInvalid),
 142         fRequestType(kNoneType), fStartTime(0), fEndTime(0),
 143         fRequestString(""), fCount(0),
 144         fOwnerIndex(0), fValueType(AliDCSValue::kInvalid), fValues(),
 145         fErrorCode(kNoneError), fErrorString(""),
 146         fRequestStrings()
 147 {
 148 // copy constructor (not implemented)
 149
 150 }
 151
 152 //______________________________________________________________________
 153 AliDCSMessage &AliDCSMessage::operator=(const AliDCSMessage& /*other*/)
 154 {
 155 // assignment operator (not implemented)
 156
 157 return *this;
 158 }
 159
 160 //______________________________________________________________________
 161 AliDCSMessage::~AliDCSMessage()
 162 {
 163 // destructor
 164
 165         DestroyMessage();
 166         DestroyBuffer();
 167         if(fValues) delete fValues; fValues=0;
 168 }
 169
 170 //______________________________________________________________________
 171 void AliDCSMessage::CreateRequestMessage(RequestType type,
 172         UInt_t startTime, UInt_t endTime, const char* request)
 173 {
 174 // Create request message
 175
 176         DestroyMessage();
 177
 178         fType = AliDCSMessage::kRequest;
 179         fRequestType = type;
 180         fStartTime = startTime;
 181         fEndTime = endTime;
 182         fRequestString = request;
 183 }
 184
 185 //______________________________________________________________________
 186 void AliDCSMessage::CreateMultiRequestMessage(RequestType type,
 187         UInt_t startTime, UInt_t endTime)
 188 {
 189 // Create multi request message
 190
 191         DestroyMessage();
 192
 193         fType = AliDCSMessage::kMultiRequest;
 194         fRequestType = type;
 195         fStartTime = startTime;
 196         fEndTime = endTime;
 197 }
 198
 199 //______________________________________________________________________
 200 void AliDCSMessage::CreateCountMessage(UInt_t count)
 201 {
 202 // Create count request message
 203
 204         DestroyMessage();
 205
 206         fType = AliDCSMessage::kCount;
 207         fCount = count;
 208 }
 209
 210 //______________________________________________________________________
 211 void AliDCSMessage::CreateResultSetMessage(AliDCSValue::Type type)
 212 {
 213   // Create result set message
 214
 215         DestroyMessage();
 216
 217         fType = AliDCSMessage::kResultSet;
 218         fValueType = type;
 219 }
 220
 221 //______________________________________________________________________
 222 void AliDCSMessage::CreateErrorMessage(ErrorCode errorCode,
 223         const char* errorString)
 224 {
 225 // Create error message
 226
 227         DestroyMessage();
 228
 229         fType = AliDCSMessage::kError;
 230         fErrorCode = errorCode;
 231         fErrorString = errorString;
 232 }
 233
 234
 235 void AliDCSMessage::CreateNextMessage() {
 236         DestroyMessage();
 237
 238         fType = AliDCSMessage::kNext;
 239 }
 240
 241 //______________________________________________________________________
 242 void AliDCSMessage::DestroyMessage()
 243 {
 244 // Destroy message
 245
 246         fType = kInvalid;
 247         ClearValues();
 248         ClearRequestStrings();
 249 }
 250
 251 //______________________________________________________________________
 252 void AliDCSMessage::SetBool(char* buf, Bool_t val)
 253 {
 254 // Set bool value to buf
 255
 256         tobuf(buf, val);
 257 }
 258
 259 //______________________________________________________________________
 260 void AliDCSMessage::SetByte(char* buf, Char_t val)
 261 {
 262 // Set byte value to buf
 263
 264         tobuf(buf, val);
 265 }
 266
 267 //______________________________________________________________________
 268 void AliDCSMessage::SetUByte(char* buf, UChar_t val)
 269 {
 270 // Set ubyte value to buf
 271
 272         tobuf(buf, val);
 273 }
 274
 275 //______________________________________________________________________
 276 void AliDCSMessage::SetInt(char* buf, Int_t val)
 277 {
 278 // Set int value to buf
 279
 280         tobuf(buf, val);
 281 }
 282
 283 //______________________________________________________________________
 284 void AliDCSMessage::SetUInt(char* buf, UInt_t val)
 285 {
 286 // Set uint value to buf
 287
 288         tobuf(buf, val);
 289 }
 290
 291 //______________________________________________________________________
 292 void AliDCSMessage::SetFloat(char* buf, Float_t val)
 293 {
 294 // Set float value to buf
 295
 296         tobuf(buf, val);
 297 }
 298
 299 //______________________________________________________________________
 300 Bool_t AliDCSMessage::GetBool(const char* buf)
 301 {
 302 // get bool value from buf
 303
 304         Bool_t val;
 305         char* aBuffer = (char*) buf;
 306
 307         frombuf(aBuffer, &val);
 308
 309         return val;
 310 }
 311
 312 //______________________________________________________________________
 313 Char_t AliDCSMessage::GetByte(const char* buf)
 314 {
 315 // get byte value from buf
 316
 317         Char_t val;
 318         char* aBuffer = (char*) buf;
 319
 320         frombuf(aBuffer, &val);
 321
 322         return val;
 323 }
 324
 325 //______________________________________________________________________
 326 UChar_t AliDCSMessage::GetUByte(const char* buf)
 327 {
 328 // get ubyte value from buf
 329
 330         UChar_t val;
 331         char* aBuffer = (char*) buf;
 332
 333         frombuf(aBuffer, &val);
 334
 335         return val;
 336 }
 337
 338 //______________________________________________________________________
 339 Int_t AliDCSMessage::GetInt(const char* buf)
 340 {
 341 // get int value from buf
 342
 343         Int_t val;
 344         char* aBuffer = (char*) buf;
 345
 346         frombuf(aBuffer, &val);
 347
 348         return val;
 349 }
 350
 351 //______________________________________________________________________
 352 UInt_t AliDCSMessage::GetUInt(const char* buf)
 353 {
 354 // get uint value from buf
 355
 356         UInt_t val;
 357         char* aBuffer = (char*) buf;
 358
 359         frombuf(aBuffer, &val);
 360
 361         return val;
 362 }
 363
 364 //______________________________________________________________________
 365 Float_t AliDCSMessage::GetFloat(const char* buf)
 366 {
 367 // get float value from buf
 368
 369         Float_t val;
 370         char* aBuffer = (char*) buf;
 371
 372         frombuf(aBuffer, &val);
 373
 374         return val;
 375 }
 376
 377 //______________________________________________________________________
 378 TString AliDCSMessage::GetString(const char* buf, Int_t maxLen)
 379 {
 380 // get string from buf
 381
 382         for (Int_t k = 0; k < maxLen; k ++) {
 383                 if (buf[k] == 0) {
 384                         return TString(buf);
 385                 }
 386         }
 387
 388         return TString(buf, maxLen);
 389 }
 390
 391 //______________________________________________________________________
 392 void AliDCSMessage::StoreHeader()
 393 {
 394 // store header message
 395
 396         SetUByte(fMessage + ID_OFFSET, 'A');
 397         SetUByte(fMessage + ID_OFFSET + 1, 'D');
 398
 399         SetUByte(fMessage + VERSION_OFFSET, 2);
 400
 401         SetUByte(fMessage + TYPE_OFFSET, fType);
 402
 403         SetUInt(fMessage + BODY_SIZE_OFFSET, fMessageSize - HEADER_SIZE);
 404 }
 405
 406 //______________________________________________________________________
 407 void AliDCSMessage::StoreRequestMessage()
 408 {
 409 // store request message
 410
 411         fMessageSize = REQUEST_STRING_OFFSET +
 412                 fRequestString.Length() + 1;
 413
 414         fMessage = new char[fMessageSize];
 415
 416         StoreHeader();
 417
 418         SetUByte(fMessage + REQUEST_TYPE_OFFSET, fRequestType);
 419         SetUInt(fMessage + START_TIME_OFFSET, fStartTime);
 420         SetUInt(fMessage + END_TIME_OFFSET, fEndTime);
 421         strcpy(fMessage + REQUEST_STRING_OFFSET, fRequestString.Data());
 422 }
 423
 424 //______________________________________________________________________
 425 void AliDCSMessage::StoreCountMessage()
 426 {
 427 // store count message
 428
 429         fMessageSize = COUNT_OFFSET + sizeof(UInt_t);
 430
 431         fMessage = new char[fMessageSize];
 432
 433         StoreHeader();
 434
 435         SetUInt(fMessage + COUNT_OFFSET, fCount);
 436 }
 437
 438 //______________________________________________________________________
 439 void AliDCSMessage::StoreResultSetMessage()
 440 {
 441 // store result set message
 442
 443   TIter iter(fValues);
 444   AliDCSValue* aValue;
 445
 446   UInt_t valueDataSize = 0;
 447   while ((aValue = (AliDCSValue*) iter.Next())) {
 448     valueDataSize += aValue->GetSize();
 449   }
 450
 451   fMessageSize = VALUES_OFFSET + valueDataSize;
 452
 453   fMessage = new char[fMessageSize];
 454
 455   StoreHeader();
 456
 457   SetUByte(fMessage + SVT_OFFSET, fValueType);
 458   SetUInt(fMessage + VALUE_COUNT_OFFSET, GetValueCount());
 459
 460   UInt_t cursor = VALUES_OFFSET;
 461
 462   iter.Reset();
 463
 464   if (fValueType == AliDCSValue::kBool) {
 465     while ((aValue = (AliDCSValue*) iter.Next())) {
 466       SetBool(fMessage + cursor, aValue->GetBool());
 467       cursor += 1;
 468       SetUInt(fMessage + cursor, aValue->GetTimeStamp());
 469             cursor += sizeof(UInt_t);
 470     }
 471   } else if (fValueType == AliDCSValue::kChar) {
 472     while ((aValue = (AliDCSValue*) iter.Next())) {
 473       SetByte(fMessage + cursor, aValue->GetChar());
 474       cursor += sizeof(Char_t);
 475       SetUInt(fMessage + cursor, aValue->GetTimeStamp());
 476       cursor += sizeof(UInt_t);
 477     }
 478   } else if (fValueType == AliDCSValue::kInt) {
 479     while ((aValue = (AliDCSValue*) iter.Next())) {
 480       SetInt(fMessage + cursor, aValue->GetInt());
 481       cursor += sizeof(Int_t);
 482       SetUInt(fMessage + cursor, aValue->GetTimeStamp());
 483       cursor += sizeof(UInt_t);
 484     }
 485   } else if (fValueType == AliDCSValue::kUInt) {
 486     while ((aValue = (AliDCSValue*) iter.Next())) {
 487       SetUInt(fMessage + cursor, aValue->GetUInt());
 488       cursor += sizeof(UInt_t);
 489       SetUInt(fMessage + cursor, aValue->GetTimeStamp());
 490       cursor += sizeof(UInt_t);
 491     }
 492   } else if (fValueType == AliDCSValue::kFloat) {
 493     while ((aValue = (AliDCSValue*) iter.Next())) {
 494       SetFloat(fMessage + cursor, aValue->GetFloat());
 495       cursor += sizeof(Float_t);
 496       SetUInt(fMessage + cursor, aValue->GetTimeStamp());
 497       cursor += sizeof(UInt_t);
 498     }
 499   } else {
 500     AliError("Invalid or unknown ValueType!");
 501     return;
 502   }
 503
 504 }
 505
 506 //______________________________________________________________________
 507 void AliDCSMessage::StoreErrorMessage()
 508 {
 509 // store error message
 510
 511         fMessageSize = ERROR_STRING_OFFSET + fErrorString.Length() + 1;
 512
 513         fMessage = new char[fMessageSize];
 514
 515         StoreHeader();
 516
 517         SetUByte(fMessage + ERROR_CODE_OFFSET, fErrorCode);
 518         strcpy(fMessage + ERROR_STRING_OFFSET, fErrorString.Data());
 519 }
 520
 521 //______________________________________________________________________
 522 void AliDCSMessage::StoreMultiRequestMessage()
 523 {
 524 // store multi request message
 525
 526         UInt_t requestDataSize = 0;
 527
 528         TIter iter(&fRequestStrings);
 529         TObjString* anObjString;
 530
 531         while ((anObjString = (TObjString*) iter.Next())) {
 532                 requestDataSize += anObjString->String().Length() + 1;
 533         }
 534
 535         fMessageSize = REQUEST_STRINGS_OFFSET + requestDataSize;
 536
 537         fMessage = new char[fMessageSize];
 538
 539         StoreHeader();
 540
 541         SetUByte(fMessage + REQUEST_TYPE_OFFSET, fRequestType);
 542         SetUInt(fMessage + START_TIME_OFFSET, fStartTime);
 543         SetUInt(fMessage + END_TIME_OFFSET, fEndTime);
 544
 545         iter.Reset();
 546
 547         UInt_t cursor = REQUEST_STRINGS_OFFSET;
 548
 549         while ((anObjString = (TObjString*) iter.Next())) {
 550                 UChar_t strLength = anObjString->String().Length();
 551                 strncpy(fMessage + cursor, anObjString->String().Data(),
 552                         strLength);
 553                 cursor += strLength;
 554                 SetUByte(fMessage + cursor, 0);
 555                 cursor += 1;
 556         }
 557 }
 558
 559 //______________________________________________________________________
 560 void AliDCSMessage::StoreNextMessage()
 561 {
 562         fMessageSize = HEADER_SIZE;
 563
 564         fMessage = new char[fMessageSize];
 565
 566         StoreHeader();
 567 }
 568
 569 //______________________________________________________________________
 570 Bool_t AliDCSMessage::ValidateHeader(const char* buf)
 571 {
 572 // validate message header
 573
 574         if (!(buf[ID_OFFSET] == 'A' && buf[ID_OFFSET + 1] == 'D')) {
 575                 AliError("Bad message ID!");
 576                 return kFALSE;
 577         }
 578
 579         if (buf[VERSION_OFFSET] != 2) {
 580                 AliError("Bad message version!");
 581                 return kFALSE;
 582         }
 583
 584         Type type = (Type) GetUByte(buf + TYPE_OFFSET);
 585         switch (type) {
 586                 case kRequest:
 587                 case kCount:
 588                 case kResultSet:
 589                 case kError:
 590                 case kMultiRequest:
 591                         break;
 592                 default:
 593                         AliError("Unknown message type!");
 594                         return kFALSE;
 595         }
 596
 597         UInt_t bodySize = GetInt(buf + BODY_SIZE_OFFSET);
 598         if (bodySize > MAX_BODY_SIZE) {
 599                 AliError("Too big message body size!");
 600                 return kFALSE;
 601         }
 602
 603         return kTRUE;
 604 }
 605
 606 //______________________________________________________________________
 607 void AliDCSMessage::LoadRequestMessage()
 608 {
 609 // load request message
 610
 611         if (fMessageSize < REQUEST_STRING_OFFSET) {
 612                 AliError("Body size is too small for request message!");
 613                 return;
 614         }
 615
 616         fRequestType = (RequestType) GetUByte(fMessage + REQUEST_TYPE_OFFSET);
 617
 618         fStartTime = GetUInt(fMessage + START_TIME_OFFSET);
 619         fEndTime = GetUInt(fMessage + END_TIME_OFFSET);
 620         fRequestString = GetString(fMessage + REQUEST_STRING_OFFSET,
 621                 fMessageSize - REQUEST_STRING_OFFSET);
 622
 623         switch (fRequestType) {
 624                 case kAlias:
 625                 case kDPName:
 626                         fType = kRequest;
 627                         break;
 628                 default:
 629                         AliError("Invalid request type!");
 630         }
 631 }
 632
 633 //______________________________________________________________________
 634 void AliDCSMessage::LoadCountMessage()
 635 {
 636 // load count message
 637
 638         if (fMessageSize < HEADER_SIZE + sizeof(UInt_t)) {
 639                 AliError("Body size is too small for count message!");
 640                 return;
 641         }
 642
 643         fCount = GetUInt(fMessage + COUNT_OFFSET);
 644
 645         fType = kCount;
 646 }
 647
 648 //______________________________________________________________________
 649 void AliDCSMessage::LoadResultSetMessage()
 650 {
 651   // load result message
 652
 653   if (fMessageSize < VALUES_OFFSET) {
 654     AliError("Body size is too small for result set message!");
 655     return;
 656   }
 657
 658   fOwnerIndex = GetInt(fMessage + INDEX_OFFSET);
 659
 660   fValueType = (AliDCSValue::Type) GetUByte(fMessage + SVT_OFFSET);
 661   UInt_t count = GetUInt(fMessage + VALUE_COUNT_OFFSET);
 662
 663   UInt_t cursor = VALUES_OFFSET;
 664
 665   // -1 end of results
 666   if (fOwnerIndex >= 0)
 667   {
 668     if (fValueType == AliDCSValue::kBool) {
 669       if (VALUES_OFFSET + count + count * sizeof(UInt_t) >
 670         fMessageSize) {
 671         AliError("Too many bool values for this buffer size!");
 672         return;
 673       }
 674
 675       for (UInt_t k = 0; k < count; k ++) {
 676         Bool_t aBool = GetBool(fMessage + cursor);
 677         cursor += 1;
 678         UInt_t timeStamp = GetUInt(fMessage + cursor);
 679         cursor += sizeof(UInt_t);
 680         fValues->Add(new AliDCSValue(aBool, timeStamp));
 681       }
 682     } else if (fValueType == AliDCSValue::kChar) {
 683       if (VALUES_OFFSET + count + count * sizeof(UInt_t) >
 684         fMessageSize) {
 685         AliError("Too many byte values for this buffer size!");
 686         return;
 687       }
 688
 689       for (UInt_t k = 0; k < count; k ++) {
 690         Char_t aByte = GetByte(fMessage + cursor);
 691         cursor += sizeof(Char_t);
 692         UInt_t timeStamp = GetUInt(fMessage + cursor);
 693         cursor += sizeof(UInt_t);
 694         fValues->Add(new AliDCSValue(aByte, timeStamp));
 695       }
 696     } else if (fValueType == AliDCSValue::kInt) {
 697       if (VALUES_OFFSET + count * sizeof(Int_t) +
 698         count * sizeof(UInt_t) > fMessageSize) {
 699               AliError("Too many int values for this buffer size!");
 700               return;
 701       }
 702
 703       for (UInt_t k = 0; k < count; k ++) {
 704               Int_t aInt = GetInt(fMessage + cursor);
 705               cursor += sizeof(Int_t);
 706               UInt_t timeStamp = GetUInt(fMessage + cursor);
 707               cursor += sizeof(UInt_t);
 708               fValues->Add(new AliDCSValue(aInt, timeStamp));
 709       }
 710
 711     } else if (fValueType == AliDCSValue::kUInt) {
 712       if (VALUES_OFFSET + count * sizeof(UInt_t) +
 713         count * sizeof(UInt_t) > fMessageSize) {
 714         AliError("Too many uint values for this buffer size!");
 715         return;
 716       }
 717
 718       for (UInt_t k = 0; k < count; k ++) {
 719         UInt_t aUInt = GetUInt(fMessage + cursor);
 720         cursor += sizeof(UInt_t);
 721         UInt_t timeStamp = GetUInt(fMessage + cursor);
 722         cursor += sizeof(UInt_t);
 723         fValues->Add(new AliDCSValue(aUInt, timeStamp));
 724       }
 725     } else if (fValueType == AliDCSValue::kFloat) {
 726       if (VALUES_OFFSET + count * sizeof(Float_t) +
 727         count * sizeof(UInt_t) > fMessageSize) {
 728         AliError("Too many float values for this buffer size!");
 729         return;
 730       }
 731
 732       for (UInt_t k = 0; k < count; k ++) {
 733         Float_t aFloat = GetFloat(fMessage + cursor);
 734         cursor += sizeof(Float_t);
 735         UInt_t timeStamp = GetUInt(fMessage + cursor);
 736         cursor += sizeof(UInt_t);
 737         fValues->Add(new AliDCSValue(aFloat, timeStamp));
 738       }
 739
 740     } else {
 741       AliError("Unknown or invalid value type!");
 742     }
 743   }
 744
 745   fType = kResultSet;
 746 }
 747
 748 //______________________________________________________________________
 749 void AliDCSMessage::LoadErrorMessage()
 750 {
 751 // load error message
 752
 753         if (fMessageSize < ERROR_STRING_OFFSET) {
 754                 AliError("Body size is too small for error message!");
 755                 return;
 756         }
 757
 758         fErrorCode = (ErrorCode) GetUByte(fMessage + ERROR_CODE_OFFSET);
 759         fErrorString = GetString(fMessage + ERROR_STRING_OFFSET,
 760                 fMessageSize - ERROR_STRING_OFFSET);
 761
 762         switch (fErrorCode) {
 763                 case kUnknownAliasDPName:
 764                 case kInvalidTimeRange:
 765                 case kInvalidBufferSize:
 766                 case kInvalidRequest:
 767                 case kUnsupportedType:
 768                 case kUnknownError:
 769                         fType = kError;
 770                         break;
 771                 default:
 772                         AliError("Invalid error code!");
 773         }
 774 }
 775
 776 //______________________________________________________________________
 777 void AliDCSMessage::LoadMultiRequestMessage()
 778 {
 779 // load multi request message
 780
 781         if (fMessageSize - HEADER_SIZE < REQUEST_STRINGS_OFFSET) {
 782                 AliError("Body size is too small for multi request message!");
 783                 return;
 784         }
 785
 786         fRequestType = (RequestType) GetUByte(fMessage + REQUEST_TYPE_OFFSET);
 787
 788         fStartTime = GetUInt(fMessage + START_TIME_OFFSET);
 789         fEndTime = GetUInt(fMessage + END_TIME_OFFSET);
 790
 791         switch (fRequestType) {
 792                 case kAlias:
 793                 case kDPName:
 794                         fType = kRequest;
 795                         break;
 796                 default:
 797                         AliError("Invalid request type!");
 798                         return;
 799         }
 800
 801         UInt_t cursor = REQUEST_STRINGS_OFFSET;
 802
 803         while ((cursor < fMessageSize)) {
 804                 UChar_t strSize = GetUByte(fMessage + cursor);
 805                 cursor += 1;
 806
 807                 if (cursor + strSize > fMessageSize) {
 808                         AliError("Invalid multi request message!");
 809                         return;
 810                 }
 811
 812                 TObjString* anObjString = new TObjString(
 813                         GetString(fMessage + cursor, strSize));
 814                 fRequestStrings.AddLast(anObjString);
 815
 816                 cursor += strSize;
 817         }
 818
 819         fType = kMultiRequest;
 820 }
 821
 822 //______________________________________________________________________
 823 void AliDCSMessage::LoadNextMessage()
 824 {
 825         //
 826
 827         fType = kNext;
 828 }
 829
 830 //______________________________________________________________________
 831 void AliDCSMessage::StoreToBuffer()
 832 {
 833         // Creates an underlying message buffer which can be sent to the socket.
 834
 835         DestroyBuffer();
 836
 837         switch (fType) {
 838                 case kRequest:
 839                         StoreRequestMessage();
 840                         break;
 841                 case kCount:
 842                         StoreCountMessage();
 843                         break;
 844                 case kResultSet:
 845                         StoreResultSetMessage();
 846                         break;
 847                 case kError:
 848                         StoreErrorMessage();
 849                         break;
 850                 case kMultiRequest:
 851                         StoreMultiRequestMessage();
 852                         break;
 853                 case kNext:
 854                         StoreNextMessage();
 855                         break;
 856                 default:
 857                         AliError("Can't store to buffer invalid message!");
 858         }
 859 }
 860
 861 //______________________________________________________________________
 862 void AliDCSMessage::LoadFromBuffer()
 863 {
 864         // Reads the underlying message buffer and if it's valid message
 865         // creates the corresponding message.
 866         // If not set the message type kInvalid.
 867         // This buffer is read from the socket.
 868
 869         DestroyMessage();
 870
 871         if (!fMessage) {
 872                 AliError("Message buffer is empty! Can't load it.");
 873                 return;
 874         }
 875
 876         if (fMessageSize < HEADER_SIZE) {
 877                 AliError("Invalid message buffer. Too small for the header!");
 878                 return;
 879         }
 880
 881         if (!ValidateHeader(fMessage)) {
 882                 AliError("Invalid message header!");
 883                 return;
 884         }
 885
 886         UInt_t bodySize = GetUInt(fMessage + BODY_SIZE_OFFSET);
 887         if (bodySize > fMessageSize - HEADER_SIZE) {
 888                 AliError("Message size is to small for the message body!");
 889                 return;
 890         }
 891
 892         fMessageSize = HEADER_SIZE + bodySize;
 893
 894         Type aType = (Type) GetUByte(fMessage + TYPE_OFFSET);
 895
 896         switch (aType) {
 897                 case kRequest:
 898                         LoadRequestMessage();
 899                         break;
 900                 case kCount:
 901                         LoadCountMessage();
 902                         break;
 903                 case kResultSet:
 904                         LoadResultSetMessage();
 905                         break;
 906                 case kError:
 907                         LoadErrorMessage();
 908                         break;
 909                 case kMultiRequest:
 910                         LoadMultiRequestMessage();
 911                         break;
 912                 case kNext:
 913                         LoadNextMessage();
 914                         break;
 915                 default:
 916                         AliError("Invalid message type!");
 917         }
 918 }
 919
 920 //______________________________________________________________________
 921 AliDCSMessage::RequestType AliDCSMessage::GetRequestType() const
 922 {
 923         // Request and MultiRequest.
 924         // Returns the request type: alias or dp (Data Point)
 925
 926         if (!(fType == kRequest || fType == kMultiRequest)) {
 927                 AliError("Invalid AliDCSMessage type!");
 928                 return kNoneType;
 929         }
 930
 931         return fRequestType;
 932 }
 933
 934 //______________________________________________________________________
 935 UInt_t AliDCSMessage::GetStartTime() const
 936 {
 937         // Request and MultiRequest.
 938         // Returns the request start time. (begining of the time interval).
 939
 940         if (!(fType == kRequest || fType == kMultiRequest)) {
 941                 AliError("Invalid AliDCSMessage type!");
 942                 return 0;
 943         }
 944
 945         return fStartTime;
 946 }
 947
 948 //______________________________________________________________________
 949 UInt_t AliDCSMessage::GetEndTime() const
 950 {
 951         // Request and MultiRequest.
 952         // Returns the request start time. (end of the time interval).
 953
 954
 955         if (!(fType == kRequest || fType == kMultiRequest)) {
 956                 AliError("Invalid AliDCSMessage type!");
 957                 return 0;
 958         }
 959
 960         return  fEndTime;
 961 }
 962
 963 //______________________________________________________________________
 964 TString AliDCSMessage::GetRequestString() const
 965 {
 966         // Request.
 967         // Returns the request string. (alias or dp)
 968
 969         if (fType != kRequest) {
 970                 AliError("Invalid AliDCSMessage type!");
 971                 return TString("");
 972         }
 973
 974         return fRequestString;
 975 }
 976
 977 //______________________________________________________________________
 978 Bool_t AliDCSMessage::AddRequestString(const char* request)
 979 {
 980         // MultRequest.
 981         // Add a request to the request set.
 982         // Returns kFALSE in case of invalid request (too long request string).
 983         // Otherwise returns kTRUE.
 984
 985
 986         if (fType != kMultiRequest) {
 987                 AliError("Invalid AliDCSMessage type!");
 988                 return kFALSE;
 989         }
 990
 991         if (strlen(request) > 255) {
 992                 AliError("Alias/dpName is too long! Max size 255.");
 993                 return kFALSE;
 994         }
 995
 996         fRequestStrings.AddLast(new TObjString(request));
 997         return kTRUE;
 998 }
 999
1000 //______________________________________________________________________
1001 void AliDCSMessage::ClearRequestStrings()
1002 {
1003         // MultRequest.
1004         // Clears the request set.
1005
1006         fRequestStrings.Delete();
1007 }
1008
1009 //______________________________________________________________________
1010 void AliDCSMessage::GetRequestStrings(TObjArray& result) const
1011 {
1012         // MultRequest.
1013         // Returns all request strings in this message.
1014         // result: container where the requests are returned. Collection of
1015         // TObjString.
1016
1017
1018         if (fType != kMultiRequest) {
1019                 AliError("Invalid AliDCSMessage type!");
1020                 return;
1021         }
1022
1023         TIter iter(&fRequestStrings);
1024         TObjString* anObjString;
1025
1026         while ((anObjString = (TObjString*) iter.Next())) {
1027                 result.AddLast(new TObjString(*anObjString));
1028         }
1029 }
1030
1031 //______________________________________________________________________
1032 UInt_t AliDCSMessage::GetCount() const
1033 {
1034         // Count.
1035         // Returns the total number of values.
1036
1037
1038         if (fType != kCount) {
1039                 AliError("Invalid AliDCSMessage type!");
1040                 return 0;
1041         }
1042
1043         return fCount;
1044 }
1045
1046 //______________________________________________________________________
1047 AliDCSValue::Type AliDCSMessage::GetValueType() const
1048 {
1049   // ResultSet.
1050   // Returns simple value type (see AliDCSValue) for the values
1051   // in this ResultSet.
1052
1053   if (fType != kResultSet) {
1054           AliError("Invalid AliDCSMessage type!");
1055           return AliDCSValue::kInvalid;
1056   }
1057
1058   return fValueType;
1059 }
1060
1061 //______________________________________________________________________
1062 UInt_t AliDCSMessage::GetValueCount() const
1063 {
1064   // ResultSet.
1065   // Returns the count of values in this ResultSet.
1066
1067
1068   if (fType != kResultSet) {
1069           AliError("Invalid AliDCSMessage type!");
1070           return 0;
1071   }
1072
1073   return fValues->GetEntriesFast();
1074 }
1075
1076 //______________________________________________________________________
1077 UInt_t AliDCSMessage::GetValues(TObjArray* result) const
1078 {
1079   // ResultSet.
1080   // Returns the number of values got from the message.
1081   // result: used to return the values. Collection of AliDCSValue.
1082   // result must be owner of the AliDCSValues because fVaule is not!
1083   // creator of the result array and used GetValues to fill it must delete object by himself!
1084
1085   // TODO do not copy -> corrected?
1086
1087         if (fType != kResultSet) {
1088                 AliError("Invalid AliDCSMessage type!");
1089                 return 0;
1090         }
1091
1092         TIter iter(fValues);
1093         AliDCSValue* aValue;
1094
1095         while ((aValue = (AliDCSValue*) iter.Next())) {
1096                 result->AddLast(aValue);
1097         }
1098
1099         return fValues->GetEntriesFast();
1100 }
1101
1102
1103 //______________________________________________________________________
1104 Bool_t AliDCSMessage::AddValue(AliDCSValue& value)
1105 {
1106   // Adds value to the ResultSet value list.
1107   // Returns kFALSE in case of error.
1108   // Otherwise returns kTRUE;
1109
1110   if (fType != kResultSet) {
1111     AliError("Invalid AliDCSMessage type!");
1112     return kFALSE;
1113   }
1114
1115   if (value.GetType() != fValueType) {
1116     AliError(Form("Can't add value with type %d to this message!", value.GetType()));
1117     return kFALSE;
1118   }
1119
1120   fValues->Add(&value);
1121
1122   return kTRUE;
1123 }
1124
1125
1126 //______________________________________________________________________
1127 void AliDCSMessage::ClearValues()
1128 {
1129 // clear values array
1130
1131         if(fValues) fValues->Clear();
1132 }
1133
1134 //______________________________________________________________________
1135 AliDCSMessage::ErrorCode AliDCSMessage::GetErrorCode() const
1136 {
1137         //
1138         // Error.
1139         // Returns the error code which has this error message.
1140         //
1141
1142         if (fType != kError) {
1143                 AliError("Invalid AliDCSMessage type!");
1144                 return kNoneError;
1145         }
1146
1147         return fErrorCode;
1148 }
1149
1150 //______________________________________________________________________
1151 TString AliDCSMessage::GetErrorString() const
1152 {
1153         //
1154         // Error.
1155         // Returns the error string (error description) which has this
1156         // error message.
1157         //
1158
1159         if (GetType() != kError) {
1160                 AliError("Invalid AliDCSMessage type!");
1161                 return TString("");
1162         }
1163
1164         return fErrorString;
1165 }
1166
1167
1168 //______________________________________________________________________
1169 void AliDCSMessage::Print(Option_t* /*option*/) const
1170 {
1171 // print message
1172
1173         if (AliLog::GetGlobalDebugLevel() < 2) {
1174                 return;
1175         }
1176
1177         TString printString;
1178         printString += "\n <<AliDCSMessage>>\n";
1179
1180         printString += " Size: ";
1181         printString += fMessageSize;
1182         printString += '\n';
1183
1184         printString += " Type: ";
1185         switch (GetType()) {
1186                 case kRequest: {
1187                         printString += "Request\n";
1188
1189                         printString += " RequestType: ";
1190                         if (GetRequestType() == kDPName) {
1191                                 printString += "DPName";
1192                         } else {
1193                                 printString += "Alias";
1194                         }
1195                         printString += '\n';
1196
1197                         printString += " RequestString: ";
1198                         printString += GetRequestString();
1199                         printString += '\n';
1200                         printString += " StartTime: ";
1201                         printString += GetStartTime();
1202                         printString += '\n';
1203                         printString += " EndTime: ";
1204                         printString += GetEndTime();
1205                         printString += '\n';
1206                         break;
1207                 }
1208
1209                 case kCount: {
1210                         printString += "Count\n";
1211                         printString += " Count: ";
1212                         printString += GetCount();
1213                         printString += '\n';
1214                         break;
1215                 }
1216
1217                 case kResultSet: {
1218                         printString += "ResultSet\n";
1219                         printString += " OwnerIndex: ";
1220                         printString += fOwnerIndex;
1221                         printString += '\n';
1222                         printString += " SimpleValueType: ";
1223                         printString += fValueType;
1224                         printString += '\n';
1225                         printString += " ValueCount: ";
1226                         printString += GetValueCount();
1227                         printString += '\n';
1228                         break;
1229                 }
1230
1231                 case kError: {
1232                         printString += "Error\n";
1233                         printString += " ErrorCode: ";
1234                         switch (GetErrorCode()) {
1235                                 case AliDCSMessage::kNoneError:
1236                                         printString += "NoneError";
1237                                         break;
1238                                 case AliDCSMessage::kUnknownAliasDPName:
1239                                         printString += "UnknownAliasDPName";
1240                                         break;
1241                                 case AliDCSMessage::kInvalidTimeRange:
1242                                         printString += "InvalidTimeRange";
1243                                         break;
1244                                 case AliDCSMessage::kInvalidBufferSize:
1245                                         printString += "InvalidBufferSize";
1246                                         break;
1247                                 case AliDCSMessage::kInvalidRequest:
1248                                         printString += "InvalidRequest";
1249                                         break;
1250                                 case AliDCSMessage::kUnsupportedType:
1251                                         printString += "UnsupportedType";
1252                                         break;
1253                                 case AliDCSMessage::kUnknownError:
1254                                         printString += "UnknownError";
1255                                         break;
1256                                 default:
1257                                         printString += "Invalid";
1258                         }
1259
1260                         printString += '\n';
1261                         printString += " ErrorString: ";
1262                         printString += GetErrorString();
1263                         printString += '\n';
1264                         break;
1265                 }
1266
1267                 case kMultiRequest: {
1268                         printString += "MultiRequest\n";
1269
1270                         printString += " RequestType: ";
1271                         if (GetRequestType() == kDPName) {
1272                                 printString += "DPName";
1273                         } else {
1274                                 printString += "Alias";
1275                         }
1276                         printString += '\n';
1277
1278                         printString += " RequestStrings: ";
1279                         TIter iter(&fRequestStrings);
1280                         TObjString* anObjString;
1281                         while ((anObjString = (TObjString*) iter.Next())) {
1282                                 printString += anObjString->String();
1283                                 printString += ' ';
1284                         }
1285                         printString += '\n';
1286
1287                         printString += " StartTime: ";
1288                         printString += GetStartTime();
1289                         printString += '\n';
1290                         printString += " EndTime: ";
1291                         printString += GetEndTime();
1292                         printString += '\n';
1293                         break;
1294                 }
1295
1296                 case kNext: {
1297                         printString += "Next\n";
1298                         break;
1299                 }
1300
1301                 default:
1302                         printString += "Invalid\n";
1303         }
1304
1305         if (AliLog::GetGlobalDebugLevel() >= 3 && fMessage) {
1306                 PrintBuffer(fMessage, fMessageSize, printString);
1307         }
1308
1309         AliDebug(2, printString);
1310 }
1311
1312 //______________________________________________________________________
1313 Bool_t AliDCSMessage::SetRawHeader(const char* header)
1314 {
1315         //
1316         // Checks if the header buffer represents a valid header message.
1317         // If so it creates a message buffer with the appropriate body size
1318         // and returns true.
1319         // If not returns false.
1320         // header: header buffer
1321         //
1322
1323         if (!ValidateHeader(header)) {
1324                 AliError("Invalid message header!");
1325                 return kFALSE;
1326         }
1327
1328         DestroyBuffer();
1329
1330         UInt_t bodySize = GetUInt(header + BODY_SIZE_OFFSET);
1331         fMessageSize = HEADER_SIZE + bodySize;
1332
1333         fMessage = new char[fMessageSize];
1334
1335         memcpy(fMessage, header, HEADER_SIZE);
1336
1337         return kTRUE;
1338 }
1339
1340
1341 //______________________________________________________________________
1342 void AliDCSMessage::DestroyBuffer()
1343 {
1344         //
1345         // Destroy the underlying message buffer.
1346         //
1347
1348         if (fMessage) {
1349                 delete[] fMessage;
1350                 fMessage = NULL;
1351         }
1352
1353         fMessageSize = 0;
1354 }
1355
1356 //______________________________________________________________________
1357 void AliDCSMessage::PrintBuffer(const char* buffer, UInt_t size,
1358                 TString& output)
1359 {
1360 // print buffer
1361
1362         UInt_t index = 0;
1363
1364         while (index < size) {
1365                 if (!(index % 16)) {
1366                         output += Form("\n %.4x:", index);
1367                 }
1368
1369                 if (!(index % 8)) {
1370                         output += ' ';
1371                 }
1372
1373                 output += Form(" %.2x", (UChar_t) buffer[index]);
1374
1375                 if (!((index + 1) % 16) || index + 1 == size) {
1376                         if (index + 1 == size) {
1377                                 output.Append(' ',3 * (15 - index % 16));
1378                                 if (index % 16 < 8) {
1379                                         output.Append(' ');
1380                                 }
1381                         }
1382
1383                         output.Append(' ', 2);
1384                         for (Int_t k = index % 16; k >= 0; k --) {
1385                                 Char_t aChar = buffer[index - k];
1386                                 output += isgraph(aChar) ? aChar: '.';
1387                         }
1388                 }
1389
1390                 index ++;
1391         }
1392
1393         output += '\n';
1394 }