SHUTTLE/AliShuttleConfig.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.27  2007/12/17 03:23:32  jgrosseo
  19 several bugfixes
  20 added "empty preprocessor" as placeholder for Acorde in FDR
  21
  22 Revision 1.26  2007/12/07 19:14:36  acolla
  23 in AliShuttleTrigger:
  24
  25 Added automatic collection of new runs on a regular time basis (settable from the configuration)
  26
  27 in AliShuttleConfig: new members
  28
  29 - triggerWait: time to wait for DIM trigger (s) before starting automatic collection of new runs
  30 - mode: run mode (test, prod) -> used to build log folder (logs or logs_PROD)
  31
  32 in AliShuttle:
  33
  34 - logs now stored in logs/#RUN/DET_#RUN.log
  35
  36 Revision 1.25  2007/11/26 16:58:37  acolla
  37 Monalisa configuration added: host and table name
  38
  39 Revision 1.24  2007/10/24 10:44:08  acolla
  40
  41 debug AliInfo removed
  42
  43 Revision 1.23  2007/09/28 15:27:40  acolla
  44
  45 AliDCSClient "multiSplit" option added in the DCS configuration
  46 in AliDCSMessage: variable MAX_BODY_SIZE set to 500000
  47
  48 Revision 1.22  2007/09/27 16:53:13  acolla
  49 Detectors can have more than one AMANDA server. SHUTTLE queries the servers sequentially,
  50 merges the dcs aliases/DPs in one TMap and sends it to the preprocessor.
  51
  52 Revision 1.21  2007/04/27 07:06:48  jgrosseo
  53 GetFileSources returns empty list in case of no files, but successful query
  54 No mails sent in testmode
  55
  56 Revision 1.20  2007/04/04 10:33:36  jgrosseo
  57 1) Storing of files to the Grid is now done _after_ your preprocessors succeeded. This is transparent, which means that you can still use the same functions (Store, StoreReferenceData) to store files to the Grid. However, the Shuttle first stores them locally and transfers them after the preprocessor finished. The return code of these two functions has changed from UInt_t to Bool_t which gives you the success of the storing.
  58 In case of an error with the Grid, the Shuttle will retry the storing later, the preprocessor does not need to be run again.
  59
  60 2) The meaning of the return code of the preprocessor has changed. 0 is now success and any other value means failure. This value is stored in the log and you can use it to keep details about the error condition.
  61
  62 3) New function StoreReferenceFile to _directly_ store a file (without opening it) to the reference storage.
  63
  64 4) The memory usage of the preprocessor is monitored. If it exceeds 2 GB it is terminated.
  65
  66 5) New function AliPreprocessor::ProcessDCS(). If you do not need to have DCS data in all cases, you can skip the processing by implemting this function and returning kFALSE under certain conditions. E.g. if there is a certain run type.
  67 If you always need DCS data (like before), you do not need to implement it.
  68
  69 6) The run type has been added to the monitoring page
  70
  71 Revision 1.19  2007/02/28 10:41:56  acolla
  72 Run type field added in SHUTTLE framework. Run type is read from "run type" logbook and retrieved by
  73 AliPreprocessor::GetRunType() function.
  74 Added some ldap definition files.
  75
  76 Revision 1.18  2007/01/23 19:20:03  acolla
  77 Removed old ldif files, added TOF, MCH ldif files. Added some options in
  78 AliShuttleConfig::Print. Added in Ali Shuttle: SetShuttleTempDir and
  79 SetShuttleLogDir
  80
  81 Revision 1.17  2007/01/18 11:17:47  jgrosseo
  82 changing spaces to tabs ;-)
  83
  84 Revision 1.16  2007/01/18 11:10:35  jgrosseo
  85 adding the possibility of defining DCS alias and data points with patterns
  86 first pattern introduced: [N..M] to add all names between the two digits, this works also recursively.
  87
  88 Revision 1.15  2007/01/15 18:27:11  acolla
  89 implementation of sending mail to subdetector expert in case the preprocessor fails.
  90 shuttle.schema updated with expert's email entry
  91
  92 Revision 1.13  2006/12/07 08:51:26  jgrosseo
  93 update (alberto):
  94 table, db names in ldap configuration
  95 added GRP preprocessor
  96 DCS data can also be retrieved by data point
  97
  98 Revision 1.12  2006/11/16 16:16:48  jgrosseo
  99 introducing strict run ordering flag
 100 removed giving preprocessor name to preprocessor, they have to know their name themselves ;-)
 101
 102 Revision 1.11  2006/11/06 14:23:04  jgrosseo
 103 major update (Alberto)
 104 o) reading of run parameters from the logbook
 105 o) online offline naming conversion
 106 o) standalone DCSclient package
 107
 108 Revision 1.10  2006/10/20 15:22:59  jgrosseo
 109 o) Adding time out to the execution of the preprocessors: The Shuttle forks and the parent process monitors the child
 110 o) Merging Collect, CollectAll, CollectNew function
 111 o) Removing implementation of empty copy constructors (declaration still there!)
 112
 113 Revision 1.9  2006/10/02 16:38:39  jgrosseo
 114 update (alberto):
 115 fixed memory leaks
 116 storing of objects that failed to be stored to the grid before
 117 interfacing of shuttle status table in daq system
 118
 119 Revision 1.8  2006/08/15 10:50:00  jgrosseo
 120 effc++ corrections (alberto)
 121
 122 Revision 1.7  2006/07/20 09:54:40  jgrosseo
 123 introducing status management: The processing per subdetector is divided into several steps,
 124 after each step the status is stored on disk. If the system crashes in any of the steps the Shuttle
 125 can keep track of the number of failures and skips further processing after a certain threshold is
 126 exceeded. These thresholds can be configured in LDAP.
 127
 128 Revision 1.6  2006/07/19 10:09:55  jgrosseo
 129 new configuration, accesst to DAQ FES (Alberto)
 130
 131 Revision 1.5  2006/07/10 13:01:41  jgrosseo
 132 enhanced storing of last sucessfully processed run (alberto)
 133
 134 Revision 1.4  2006/06/12 09:11:16  jgrosseo
 135 coding conventions (Alberto)
 136
 137 Revision 1.3  2006/06/06 14:26:40  jgrosseo
 138 o) removed files that were moved to STEER
 139 o) shuttle updated to follow the new interface (Alberto)
 140
 141 Revision 1.7  2006/05/12 09:07:16  colla
 142 12/05/06
 143 New configuration complete
 144
 145 Revision 1.2  2006/03/07 07:52:34  hristov
 146 New version (B.Yordanov)
 147
 148 Revision 1.4  2005/11/19 14:20:31  byordano
 149 logbook config added to AliShuttleConfig
 150
 151 Revision 1.3  2005/11/17 19:24:25  byordano
 152 TList changed to TObjArray in AliShuttleConfig
 153
 154 Revision 1.2  2005/11/17 14:43:23  byordano
 155 import to local CVS
 156
 157 Revision 1.1.1.1  2005/10/28 07:33:58  hristov
 158 Initial import as subdirectory in AliRoot
 159
 160 Revision 1.1.1.1  2005/09/12 22:11:40  byordano
 161 SHUTTLE package
 162
 163 Revision 1.3  2005/08/30 09:13:02  byordano
 164 some docs added
 165
 166 */
 167
 168
 169 //
 170 // This class keeps the AliShuttle configuration.
 171 // It reads the configuration for LDAP server.
 172 // For every child entry in basedn which has schema type 'shuttleConfig'
 173 // it creates a detector configuration. This configuration includes:
 174 // DCS server host and port and the set of aliases for which data from
 175 // will be retrieved (used by AliShuttle).
 176 //
 177
 178 #include <Riostream.h>
 179 #include "AliShuttleConfig.h"
 180 #include "AliShuttleInterface.h"
 181
 182 #include "AliLog.h"
 183
 184 #include <TSystem.h>
 185 #include <TObjString.h>
 186 #include <TLDAPResult.h>
 187 #include <TLDAPEntry.h>
 188 #include <TLDAPAttribute.h>
 189 #include <TKey.h>
 190
 191
 192 AliShuttleConfig::AliShuttleDCSConfigHolder::AliShuttleDCSConfigHolder(const TLDAPEntry* entry):
 193 fDCSHost(""),
 194 fDCSPort(0),
 195 fMultiSplit(100),
 196 fDCSAliases(0),
 197 fDCSDataPoints(0),
 198 fDCSAliasesComp(0),
 199 fDCSDataPointsComp(0),
 200 fIsValid(kFALSE)
 201 {
 202 // constructor of the shuttle DCS configuration holder
 203
 204         TLDAPAttribute* anAttribute;
 205         fDCSAliases = new TObjArray();
 206         fDCSAliases->SetOwner(1);
 207         fDCSDataPoints = new TObjArray();
 208         fDCSDataPoints->SetOwner(1);
 209         fDCSAliasesComp = new TObjArray();
 210         fDCSAliasesComp->SetOwner(1);
 211         fDCSDataPointsComp = new TObjArray();
 212         fDCSDataPointsComp->SetOwner(1);
 213
 214
 215         anAttribute = entry->GetAttribute("dcsHost");
 216         if (!anAttribute)
 217         {
 218                 AliError("Unexpected: no DCS host!");
 219                 return;
 220         }
 221
 222         fDCSHost = anAttribute->GetValue();
 223
 224         anAttribute = entry->GetAttribute("dcsPort");
 225         if (!anAttribute)
 226         {
 227                 AliError("Unexpected: no DCS port!");
 228                 return;
 229         }
 230         TString portStr = anAttribute->GetValue();
 231         fDCSPort = portStr.Atoi();
 232
 233         anAttribute = entry->GetAttribute("multiSplit"); // MAY
 234         if (anAttribute)
 235         {
 236                 TString multiSplitStr = anAttribute->GetValue();
 237                 fMultiSplit = multiSplitStr.Atoi();
 238                 if(fMultiSplit == 0) {
 239                         AliError("MultiSplit must be a positive integer!");
 240                         return;
 241                 }
 242
 243         }
 244
 245         anAttribute = entry->GetAttribute("dcsAlias"); // MAY
 246         if (anAttribute)
 247         {
 248                 const char* anAlias;
 249                 while ((anAlias = anAttribute->GetValue()))
 250                 {
 251                         fDCSAliasesComp->AddLast(new TObjString(anAlias));
 252                         ExpandAndAdd(fDCSAliases, anAlias);
 253                 }
 254         }
 255
 256         anAttribute = entry->GetAttribute("dcsDP"); // MAY
 257         if (anAttribute)
 258         {
 259                 const char* aDataPoint;
 260                 while ((aDataPoint = anAttribute->GetValue()))
 261                 {
 262                 fDCSDataPointsComp->AddLast(new TObjString(aDataPoint));
 263                 ExpandAndAdd(fDCSDataPoints, aDataPoint);
 264                 }
 265         }
 266
 267         fIsValid = kTRUE;
 268 }
 269 //______________________________________________________________________________________________
 270 void AliShuttleConfig::AliShuttleDCSConfigHolder::ExpandAndAdd(TObjArray* target, const char* entry)
 271 {
 272         //
 273         // adds <entry> to <target> applying expanding of the name
 274         // [N..M] creates M-N+1 names with the corresponding digits
 275         //
 276
 277         TString entryStr(entry);
 278
 279         Int_t begin = entryStr.Index("[");
 280         Int_t end = entryStr.Index("]");
 281         if (begin != -1 && end != -1 && end > begin)
 282         {
 283                 TString before(entryStr(0, begin));
 284                 TString after(entryStr(end+1, entryStr.Length()));
 285
 286                 AliDebug(2, Form("Found [] pattern. Splitted input string %s %s", before.Data(), after.Data()));
 287
 288                 Int_t dotdot = entryStr.Index("..");
 289
 290                 TString nStr(entryStr(begin+1, dotdot-begin-1));
 291                 TString mStr(entryStr(dotdot+2, end-dotdot-2));
 292
 293                 AliDebug(2, Form("Found [N..M] pattern. %s %s", nStr.Data(), mStr.Data()));
 294
 295                 if (nStr.IsDigit() && mStr.IsDigit())
 296                 {
 297                         Int_t n = nStr.Atoi();
 298                         Int_t m = mStr.Atoi();
 299
 300                         Int_t nDigits = nStr.Length();
 301                         TString formatStr;
 302                         formatStr.Form("%%s%%0%dd%%s", nDigits);
 303
 304                         AliDebug(2, Form("Format string is %s", formatStr.Data()));
 305
 306                         for (Int_t current = n; current<=m; ++current)
 307                         {
 308                                 TString newEntry;
 309                                 newEntry.Form(formatStr.Data(), before.Data(), current, after.Data());
 310
 311                                 AliDebug(2, Form("Calling recursive with %s", newEntry.Data()));
 312
 313                                 // and go recursive
 314                                 ExpandAndAdd(target, newEntry);
 315                         }
 316
 317                         // return here because we processed the entries already recursively.
 318                         return;
 319                 }
 320         }
 321
 322         AliDebug(2, Form("Adding name %s", entry));
 323         target->AddLast(new TObjString(entry));
 324 }
 325
 326 //______________________________________________________________________________________________
 327 AliShuttleConfig::AliShuttleDCSConfigHolder::~AliShuttleDCSConfigHolder()
 328 {
 329 // destructor of the shuttle configuration holder
 330
 331         delete fDCSAliases;
 332         delete fDCSDataPoints;
 333         delete fDCSAliasesComp;
 334         delete fDCSDataPointsComp;
 335 }
 336
 337 //______________________________________________________________________________________________
 338 AliShuttleConfig::AliShuttleDetConfigHolder::AliShuttleDetConfigHolder(const TLDAPEntry* entry):
 339 fDetector(""),
 340 fDCSConfig(),
 341 fResponsibles(0),
 342 fIsValid(kFALSE),
 343 fSkipDCSQuery(kFALSE),
 344 fStrictRunOrder(kFALSE)
 345 {
 346 // constructor of the shuttle configuration holder
 347
 348         TLDAPAttribute* anAttribute;
 349
 350         fResponsibles = new TObjArray();
 351         fResponsibles->SetOwner(1);
 352         fDCSConfig = new TObjArray();
 353         fDCSConfig->SetOwner(1);
 354
 355         anAttribute = entry->GetAttribute("det"); // MUST
 356         if (!anAttribute)
 357         {
 358                 AliError(Form("No \"det\" attribute!"));
 359                 return;
 360         }
 361         fDetector = anAttribute->GetValue();
 362
 363         anAttribute = entry->GetAttribute("strictRunOrder"); // MAY
 364         if (!anAttribute)
 365         {
 366                 AliWarning(Form("%s did not set strictRunOrder flag - the default is FALSE",
 367                                 fDetector.Data()));
 368         } else {
 369                 TString strictRunStr = anAttribute->GetValue();
 370                 if (!(strictRunStr == "0" || strictRunStr == "1"))
 371                 {
 372                         AliError("strictRunOrder flag must be 0 or 1!");
 373                         return;
 374                 }
 375                 fStrictRunOrder = (Bool_t) strictRunStr.Atoi();
 376         }
 377
 378         anAttribute = entry->GetAttribute("responsible"); // MAY
 379         if (!anAttribute)
 380         {
 381                 AliDebug(2, "Warning! No \"responsible\" attribute!");
 382         }
 383         else
 384         {
 385                 const char* aResponsible;
 386                 while ((aResponsible = anAttribute->GetValue()))
 387                 {
 388                         fResponsibles->AddLast(new TObjString(aResponsible));
 389                 }
 390         }
 391
 392         fIsValid = kTRUE;
 393 }
 394
 395 //______________________________________________________________________________________________
 396 AliShuttleConfig::AliShuttleDetConfigHolder::~AliShuttleDetConfigHolder()
 397 {
 398 // destructor of the shuttle configuration holder
 399
 400         delete fResponsibles;
 401         delete fDCSConfig;
 402 }
 403
 404 //______________________________________________________________________________________________
 405 const char* AliShuttleConfig::AliShuttleDetConfigHolder::GetDCSHost(Int_t iServ) const
 406 {
 407         //
 408         // returns DCS server host
 409         //
 410
 411         if (iServ < 0 || iServ >= GetNServers()) return 0;
 412
 413         AliShuttleDCSConfigHolder *aHolder = dynamic_cast<AliShuttleDCSConfigHolder *>
 414                                                         (fDCSConfig->At(iServ));
 415
 416         return aHolder->GetDCSHost();
 417 }
 418
 419 //______________________________________________________________________________________________
 420 Int_t AliShuttleConfig::AliShuttleDetConfigHolder::GetDCSPort(Int_t iServ) const
 421 {
 422         //
 423         // returns DCS server port
 424         //
 425
 426         if (iServ < 0 || iServ >= GetNServers()) return 0;
 427
 428         AliShuttleDCSConfigHolder *aHolder = dynamic_cast<AliShuttleDCSConfigHolder *>
 429                                                         (fDCSConfig->At(iServ));
 430
 431         return aHolder->GetDCSPort();
 432 }
 433
 434 //______________________________________________________________________________________________
 435 Int_t AliShuttleConfig::AliShuttleDetConfigHolder::GetMultiSplit(Int_t iServ) const
 436 {
 437         //
 438         // returns DCS "multi split" value
 439         //
 440
 441         if (iServ < 0 || iServ >= GetNServers()) return 0;
 442
 443         AliShuttleDCSConfigHolder *aHolder = dynamic_cast<AliShuttleDCSConfigHolder *>
 444                                                         (fDCSConfig->At(iServ));
 445
 446         return aHolder->GetMultiSplit();
 447 }
 448
 449 //______________________________________________________________________________________________
 450 const TObjArray* AliShuttleConfig::AliShuttleDetConfigHolder::GetDCSAliases(Int_t iServ) const
 451 {
 452         //
 453         // returns collection of TObjString which represents the set of aliases
 454         // which used for data retrieval for particular detector
 455         //
 456
 457         if (iServ < 0 || iServ >= GetNServers()) return 0;
 458
 459         AliShuttleDCSConfigHolder *aHolder = dynamic_cast<AliShuttleDCSConfigHolder *>
 460                                                         (fDCSConfig->At(iServ));
 461
 462         return aHolder->GetDCSAliases();
 463 }
 464
 465 //______________________________________________________________________________________________
 466 const TObjArray* AliShuttleConfig::AliShuttleDetConfigHolder::GetDCSDataPoints(Int_t iServ) const
 467 {
 468         //
 469         // returns collection of TObjString which represents the set of aliases
 470         // which used for data retrieval for particular detector
 471         //
 472
 473         if (iServ < 0 || iServ >= GetNServers()) return 0;
 474
 475         AliShuttleDCSConfigHolder *aHolder = dynamic_cast<AliShuttleDCSConfigHolder *>
 476                                                         (fDCSConfig->At(iServ));
 477
 478         return aHolder->GetDCSDataPoints();
 479 }
 480
 481 //______________________________________________________________________________________________
 482 const TObjArray* AliShuttleConfig::AliShuttleDetConfigHolder::GetCompactDCSAliases(Int_t iServ) const
 483 {
 484         //
 485         // returns collection of TObjString which represents the set of aliases
 486         // which used for data retrieval for particular detector (Compact style)
 487         //
 488
 489         if (iServ < 0 || iServ >= GetNServers()) return 0;
 490
 491         AliShuttleDCSConfigHolder *aHolder = dynamic_cast<AliShuttleDCSConfigHolder *>
 492                                                         (fDCSConfig->At(iServ));
 493
 494         return aHolder->GetCompactDCSAliases();
 495 }
 496
 497 //______________________________________________________________________________________________
 498 const TObjArray* AliShuttleConfig::AliShuttleDetConfigHolder::GetCompactDCSDataPoints(Int_t iServ) const
 499 {
 500         //
 501         // returns collection of TObjString which represents the set of aliases
 502         // which used for data retrieval for particular detector (Compact style)
 503         //
 504
 505         if (iServ < 0 || iServ >= GetNServers()) return 0;
 506
 507         AliShuttleDCSConfigHolder *aHolder = dynamic_cast<AliShuttleDCSConfigHolder *>
 508                                                         (fDCSConfig->At(iServ));
 509
 510         return aHolder->GetCompactDCSDataPoints();
 511 }
 512
 513 //______________________________________________________________________________________________
 514 void AliShuttleConfig::AliShuttleDetConfigHolder::AddDCSConfig(AliShuttleDCSConfigHolder* holder)
 515 {
 516         //
 517         // adds a DCS configuration set in the array of DCS configurations
 518         //
 519
 520         if(!holder) return;
 521         fDCSConfig->AddLast(holder);
 522 }
 523
 524 ClassImp(AliShuttleConfig)
 525
 526 //______________________________________________________________________________________________
 527 AliShuttleConfig::AliShuttleConfig(const char* host, Int_t port,
 528         const char* binddn, const char* password, const char* basedn):
 529         fConfigHost(host),
 530         fAlienPath(""),
 531         fDAQlbHost(""),
 532         fDAQlbPort(),
 533         fDAQlbUser(""),
 534         fDAQlbPass(""),
 535         fDAQlbDB(""),
 536         fDAQlbTable(""),
 537         fShuttlelbTable(""),
 538         fRunTypelbTable(""),
 539         fPasswdFilePath(""),
 540         fTerminateFilePath(""),
 541         fMaxRetries(0),
 542         fPPTimeOut(0),
 543         fDCSTimeOut(0),
 544         fDCSRetries(0),
 545         fDCSQueryOffset(0),
 546         fDCSDelay(0),
 547         fPPMaxMem(0),
 548         fMonitorHost(""),
 549         fMonitorTable(""),
 550         fTriggerWait(3600),
 551         fShuttleFileSystem("/"),
 552         fFreeDiskWarningThreshold(20),
 553         fFreeDiskFatalThreshold(10),
 554         fRunMode(kTest),
 555         fDetectorMap(),
 556         fDetectorList(),
 557         fAdmin(),
 558         fShuttleInstanceHost(""),
 559         fProcessedDetectors(),
 560         fKeepDCSMap(kFALSE),
 561         fKeepTempFolder(kFALSE),
 562         fSendMail(kFALSE),
 563         fProcessAll(kFALSE),
 564         fIsValid(kFALSE)
 565
 566 {
 567         //
 568         // host: ldap server host
 569         // port: ldap server port
 570         // binddn: binddn used for ldap binding (simple bind is used!).
 571         // password: password for binddn
 572         // basedn: this is basedn whose childeren entries which have
 573         //
 574
 575         fDetectorMap.SetOwner(1);
 576         fDetectorList.SetOwner(0); //fDetectorList and fDetectorMap share the same object!
 577         fProcessedDetectors.SetOwner();
 578
 579         for (int i=0; i<6; i++)
 580         {
 581                 fAdmin[i] = new TObjArray();
 582                 fAdmin[i]->SetOwner();
 583         }
 584
 585         TLDAPServer aServer(host, port, binddn, password, 3);
 586
 587         if (!aServer.IsConnected()) {
 588                 AliError(Form("Can't connect to ldap server %s:%d",
 589                                 host, port));
 590                 return;
 591         }
 592
 593         // reads configuration for the shuttle running on this machine
 594
 595         TLDAPResult* aResult = 0;
 596         TLDAPEntry* anEntry = 0;
 597
 598         TList dcsList;
 599         dcsList.SetOwner(1);
 600         TList detList;
 601         detList.SetOwner(1);
 602         TList globalList;
 603         globalList.SetOwner(1);
 604         TList sysList;
 605         sysList.SetOwner(1);
 606         TList hostList;
 607         hostList.SetOwner(1);
 608
 609         aResult = aServer.Search(basedn, LDAP_SCOPE_SUBTREE, 0, 0);
 610
 611         if (!aResult)
 612         {
 613                 AliError(Form("Can't find configuration with base DN: %s !", basedn));
 614                 return;
 615         }
 616
 617         while ((anEntry = aResult->GetNext()))
 618         {
 619                 TString dn = anEntry->GetDn();
 620
 621                 if (dn.BeginsWith("dcsHost="))
 622                 {
 623                         dcsList.Add(anEntry);
 624                 }
 625                 else if (dn.BeginsWith("det="))
 626                 {
 627                         detList.Add(anEntry);
 628                 }
 629                 else if (dn.BeginsWith("name=globalConfig"))
 630                 {
 631                         globalList.Add(anEntry);
 632                 }
 633                 else if (dn.BeginsWith("system="))
 634                 {
 635                         sysList.Add(anEntry);
 636                 }
 637                 else if (dn.BeginsWith("shuttleHost="))
 638                 {
 639                         hostList.Add(anEntry);
 640                 }
 641                 else
 642                 {
 643                         delete anEntry;
 644                 }
 645
 646         }
 647         delete aResult;
 648
 649         Int_t result=0;
 650
 651         result += SetGlobalConfig(&globalList);
 652         result += SetSysConfig(&sysList);
 653         result += SetPasswords();
 654         result += SetDetConfig(&detList,&dcsList);
 655         result += SetHostConfig(&hostList);
 656
 657         if(result)
 658         {
 659                 AliError("Configuration is INVALID!");
 660         }
 661         else
 662         {
 663                 fIsValid = kTRUE;
 664         }
 665 }
 666
 667 //______________________________________________________________________________________________
 668 AliShuttleConfig::~AliShuttleConfig()
 669 {
 670 // destructor
 671
 672         fDetectorMap.DeleteAll();
 673         fDetectorList.Clear();
 674         fProcessedDetectors.Delete();
 675 }
 676
 677 //______________________________________________________________________________________________
 678 const TObjArray* AliShuttleConfig::GetDetectors() const
 679 {
 680         //
 681         // returns collection of TObjString which contains the name
 682         // of every detector which is in the configuration.
 683         //
 684
 685         return &fDetectorList;
 686 }
 687
 688 //______________________________________________________________________________________________
 689 Bool_t AliShuttleConfig::HasDetector(const char* detector) const
 690 {
 691         //
 692         // checks for paricular detector in the configuration.
 693         //
 694         return fDetectorMap.GetValue(detector) != NULL;
 695 }
 696
 697 //______________________________________________________________________________________________
 698 Int_t AliShuttleConfig::GetNServers(const char* detector) const
 699 {
 700         //
 701         // returns number of DCS servers for detector
 702         //
 703
 704         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 705         if (!aHolder) {
 706                 AliError(Form("There isn't configuration for detector: %s",
 707                         detector));
 708                 return 0;
 709         }
 710
 711         return aHolder->GetNServers();
 712 }
 713
 714
 715 //______________________________________________________________________________________________
 716 const char* AliShuttleConfig::GetDCSHost(const char* detector, Int_t iServ) const
 717 {
 718         //
 719         // returns i-th DCS server host used by particular detector
 720         //
 721
 722         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 723         if (!aHolder) {
 724                 AliError(Form("There isn't configuration for detector: %s",
 725                         detector));
 726                 return NULL;
 727         }
 728
 729         return aHolder->GetDCSHost(iServ);
 730 }
 731
 732 //______________________________________________________________________________________________
 733 Int_t AliShuttleConfig::GetDCSPort(const char* detector, Int_t iServ) const
 734 {
 735         //
 736         // returns i-th DCS server port used by particular detector
 737         //
 738
 739
 740         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 741         if (!aHolder) {
 742                 AliError(Form("There isn't configuration for detector: %s",
 743                         detector));
 744                 return 0;
 745         }
 746
 747         return aHolder->GetDCSPort(iServ);
 748 }
 749
 750 //______________________________________________________________________________________________
 751 Int_t AliShuttleConfig::GetMultiSplit(const char* detector, Int_t iServ) const
 752 {
 753         //
 754         // returns i-th DCS "multi split" value
 755         //
 756
 757
 758         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 759         if (!aHolder) {
 760                 AliError(Form("There isn't configuration for detector: %s",
 761                         detector));
 762                 return 0;
 763         }
 764
 765         return aHolder->GetMultiSplit(iServ);
 766 }
 767
 768 //______________________________________________________________________________________________
 769 const TObjArray* AliShuttleConfig::GetDCSAliases(const char* detector, Int_t iServ) const
 770 {
 771         //
 772         // returns collection of TObjString which represents the i-th set of aliases
 773         // which used for data retrieval for particular detector
 774         //
 775
 776         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 777         if (!aHolder) {
 778                 AliError(Form("There isn't configuration for detector: %s",
 779                         detector));
 780                 return NULL;
 781         }
 782
 783         return aHolder->GetDCSAliases(iServ);
 784 }
 785
 786 //______________________________________________________________________________________________
 787 const TObjArray* AliShuttleConfig::GetDCSDataPoints(const char* detector, Int_t iServ) const
 788 {
 789         //
 790         // returns collection of TObjString which represents the set of aliases
 791         // which used for data retrieval for particular detector
 792         //
 793
 794         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 795         if (!aHolder) {
 796                 AliError(Form("There isn't configuration for detector: %s",
 797                         detector));
 798                 return NULL;
 799         }
 800
 801         return aHolder->GetDCSDataPoints(iServ);
 802 }
 803
 804 //______________________________________________________________________________________________
 805 const TObjArray* AliShuttleConfig::GetCompactDCSAliases(const char* detector, Int_t iServ) const
 806 {
 807         //
 808         // returns collection of TObjString which represents the i-th set of aliases
 809         // which used for data retrieval for particular detector (Compact style)
 810         //
 811
 812         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 813         if (!aHolder) {
 814                 AliError(Form("There isn't configuration for detector: %s",
 815                         detector));
 816                 return NULL;
 817         }
 818
 819         return aHolder->GetCompactDCSAliases(iServ);
 820 }
 821
 822 //______________________________________________________________________________________________
 823 const TObjArray* AliShuttleConfig::GetCompactDCSDataPoints(const char* detector, Int_t iServ) const
 824 {
 825         //
 826         // returns collection of TObjString which represents the set of aliases
 827         // which used for data retrieval for particular detector (Compact style)
 828         //
 829
 830         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 831         if (!aHolder) {
 832                 AliError(Form("There isn't configuration for detector: %s",
 833                         detector));
 834                 return NULL;
 835         }
 836
 837         return aHolder->GetCompactDCSDataPoints(iServ);
 838 }
 839
 840 //______________________________________________________________________________________________
 841 const TObjArray* AliShuttleConfig::GetResponsibles(const char* detector) const
 842 {
 843         //
 844         // returns collection of TObjString which represents the list of mail addresses
 845         // of the detector's responsible(s)
 846         //
 847
 848         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 849         if (!aHolder) {
 850                 AliError(Form("There isn't configuration for detector: %s",
 851                         detector));
 852                 return NULL;
 853         }
 854
 855         return aHolder->GetResponsibles();
 856 }
 857
 858 //______________________________________________________________________________________________
 859 const TObjArray* AliShuttleConfig::GetAdmins(Int_t sys) const
 860 {
 861         //
 862         // returns collection of TObjString which represents the list of mail addresses
 863         // of the system's administrator(s) (DAQ, DCS, HLT, Global, Amanda, DQM)
 864         //
 865
 866         if (sys < 0 || sys > 5) return 0;
 867         return fAdmin[sys];
 868 }
 869
 870 //______________________________________________________________________________________________
 871 Bool_t AliShuttleConfig::HostProcessDetector(const char* detector) const
 872 {
 873         // return TRUE if detector is handled by host or if fProcessAll is TRUE
 874
 875         if(fProcessAll) return kTRUE;
 876         TIter iter(&fProcessedDetectors);
 877         TObjString* detName;
 878         while((detName = (TObjString*) iter.Next())){
 879                 if(detName->String() == detector) return kTRUE;
 880         }
 881         return kFALSE;
 882 }
 883
 884 //______________________________________________________________________________________________
 885 Bool_t AliShuttleConfig::StrictRunOrder(const char* detector) const
 886 {
 887         // return TRUE if detector wants strict run ordering of stored data
 888
 889         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
 890         if (!aHolder)
 891         {
 892                 AliError(Form("There isn't configuration for detector: %s",
 893                         detector));
 894                 return kTRUE;
 895         }
 896
 897         return aHolder->StrictRunOrder();
 898 }
 899
 900 //______________________________________________________________________________________________
 901 UInt_t AliShuttleConfig::SetGlobalConfig(TList* list)
 902 {
 903         // Set the global configuration (DAQ Logbook + preprocessor monitoring settings)
 904
 905
 906         TLDAPEntry* anEntry = 0;
 907         TLDAPAttribute* anAttribute = 0;
 908
 909         if (list->GetEntries() == 0)
 910         {
 911                 AliError("Global configuration not found!");
 912                 return 1;
 913         }
 914         else if (list->GetEntries() > 1)
 915         {
 916                 AliError("More than one global configuration found!");
 917                 return 2;
 918         }
 919
 920         anEntry = dynamic_cast<TLDAPEntry*> (list->At(0));
 921
 922         if (!anEntry)
 923         {
 924                 AliError("Unexpected! Global list does not contain a TLDAPEntry");
 925                 return 3;
 926         }
 927
 928
 929         anAttribute = anEntry->GetAttribute("AlienPath");
 930         if (!anAttribute) {
 931                 AliError("Can't find AlienPath attribute!");
 932                 return 4;
 933         }
 934         fAlienPath = anAttribute->GetValue();
 935
 936         anAttribute = anEntry->GetAttribute("daqLbHost");
 937         if (!anAttribute) {
 938                 AliError("Can't find daqLbHost attribute!");
 939                 return 4;
 940         }
 941         fDAQlbHost = anAttribute->GetValue();
 942
 943         anAttribute = anEntry->GetAttribute("daqLbPort"); // MAY
 944         if (anAttribute)
 945         {
 946                 fDAQlbPort = ((TString) anAttribute->GetValue()).Atoi();
 947         } else {
 948                 fDAQlbPort = 3306; // mysql
 949         }
 950
 951         anAttribute = anEntry->GetAttribute("daqLbUser");
 952         if (!anAttribute) {
 953                 AliError("Can't find daqLbUser attribute!");
 954                 return 4;
 955         }
 956         fDAQlbUser = anAttribute->GetValue();
 957
 958         anAttribute = anEntry->GetAttribute("daqLbDB");
 959         if (!anAttribute) {
 960                 AliError("Can't find daqLbDB attribute!");
 961                 return 4;
 962         }
 963         fDAQlbDB = anAttribute->GetValue();
 964
 965         anAttribute = anEntry->GetAttribute("daqLbTable");
 966         if (!anAttribute) {
 967                 AliError("Can't find daqLbTable attribute!");
 968                 return 4;
 969         }
 970         fDAQlbTable = anAttribute->GetValue();
 971
 972         anAttribute = anEntry->GetAttribute("shuttleLbTable");
 973         if (!anAttribute) {
 974                 AliError("Can't find shuttleLbTable attribute!");
 975                 return 4;
 976         }
 977         fShuttlelbTable = anAttribute->GetValue();
 978
 979         anAttribute = anEntry->GetAttribute("runTypeLbTable");
 980         if (!anAttribute) {
 981                 AliError("Can't find runTypeLbTable attribute!");
 982                 return 4;
 983         }
 984         fRunTypelbTable = anAttribute->GetValue();
 985
 986         anAttribute = anEntry->GetAttribute("ppmaxRetries");
 987         if (!anAttribute) {
 988                 AliError("Can't find ppmaxRetries attribute!");
 989                 return 4;
 990         }
 991         TString tmpStr = anAttribute->GetValue();
 992         fMaxRetries = tmpStr.Atoi();
 993
 994         anAttribute = anEntry->GetAttribute("terminateFilePath");
 995         if (anAttribute) {
 996                 fTerminateFilePath = anAttribute->GetValue();
 997         }
 998
 999         anAttribute = anEntry->GetAttribute("ppTimeOut");
1000         if (!anAttribute) {
1001                 AliError("Can't find ppTimeOut attribute!");
1002                 return 4;
1003         }
1004         tmpStr = anAttribute->GetValue();
1005         fPPTimeOut = tmpStr.Atoi();
1006
1007         anAttribute = anEntry->GetAttribute("dcsTimeOut");
1008         if (!anAttribute) {
1009                 AliError("Can't find dcsTimeOut attribute!");
1010                 return 4;
1011         }
1012         tmpStr = anAttribute->GetValue();
1013         fDCSTimeOut = tmpStr.Atoi();
1014
1015         anAttribute = anEntry->GetAttribute("nDCSretries");
1016         if (!anAttribute) {
1017                 AliError("Can't find dcsTimeOut attribute!");
1018                 return 4;
1019         }
1020         tmpStr = anAttribute->GetValue();
1021         fDCSRetries = tmpStr.Atoi();
1022
1023         anAttribute = anEntry->GetAttribute("DCSQueryOffset");
1024         if (!anAttribute) {
1025                 AliError("Can't find DCSQueryOffset attribute!");
1026                 return 4;
1027         }
1028         tmpStr = anAttribute->GetValue();
1029         fDCSQueryOffset = tmpStr.Atoi();
1030
1031         anAttribute = anEntry->GetAttribute("DCSDelay");
1032         if (!anAttribute) {
1033                 AliError("Can't find DCSDelay attribute!");
1034                 return 4;
1035         }
1036         tmpStr = anAttribute->GetValue();
1037         fDCSDelay = tmpStr.Atoi();
1038
1039         anAttribute = anEntry->GetAttribute("ppMaxMem");
1040         if (!anAttribute) {
1041                 AliError("Can't find ppMaxMem attribute!");
1042                 return 4;
1043         }
1044         tmpStr = anAttribute->GetValue();
1045         fPPMaxMem = tmpStr.Atoi();
1046
1047         anAttribute = anEntry->GetAttribute("monitorHost");
1048         if (!anAttribute) {
1049                 AliError("Can't find monitorHost attribute!");
1050                 return 4;
1051         }
1052         fMonitorHost = anAttribute->GetValue();
1053
1054         anAttribute = anEntry->GetAttribute("monitorTable");
1055         if (!anAttribute) {
1056                 AliError("Can't find monitorTable attribute!");
1057                 return 4;
1058         }
1059         fMonitorTable = anAttribute->GetValue();
1060
1061         anAttribute = anEntry->GetAttribute("triggerWait"); // MAY
1062         if (!anAttribute) {
1063                 AliWarning(Form("triggerWait not set! default = %d", fTriggerWait));
1064         }
1065         tmpStr = anAttribute->GetValue();
1066         fTriggerWait = tmpStr.Atoi();
1067
1068         anAttribute = anEntry->GetAttribute("ShuttleFileSystem");
1069         if (!anAttribute) {
1070                 AliWarning(Form("ShuttleFileSystem not set! default = %s", fShuttleFileSystem.Data()));
1071         }
1072         fShuttleFileSystem = anAttribute->GetValue();
1073
1074         anAttribute = anEntry->GetAttribute("FreeDiskWarningThreshold"); // MAY
1075         if (!anAttribute) {
1076                 AliWarning(Form("FreeDiskWarningThreshold not set! default = %d", fFreeDiskWarningThreshold));
1077         }
1078         tmpStr = anAttribute->GetValue();
1079         fFreeDiskWarningThreshold = tmpStr.Atoi();
1080
1081         anAttribute = anEntry->GetAttribute("FreeDiskFatalThreshold"); // MAY
1082         if (!anAttribute) {
1083                 AliWarning(Form("FreeDiskFatalThreshold not set! default = %d", fFreeDiskFatalThreshold));
1084         }
1085         tmpStr = anAttribute->GetValue();
1086         fFreeDiskFatalThreshold = tmpStr.Atoi();
1087
1088         anAttribute = anEntry->GetAttribute("mode");
1089         if (!anAttribute) {
1090                 AliWarning("Run mode not set! Running in test mode.");
1091         } else {
1092           tmpStr = anAttribute->GetValue();
1093           if (tmpStr == "test")
1094           {
1095             fRunMode = kTest;
1096           } else if (tmpStr == "prod") {
1097             fRunMode = kProd;
1098           } else {
1099             AliWarning(Form("Not a valid run mode: %s", tmpStr.Data()));
1100             AliWarning("Valid run modes are \"test\" and \"prod\". Running in test mode.");
1101           }
1102         }
1103
1104         anAttribute = anEntry->GetAttribute("keepDCSMap"); // MAY
1105         if (!anAttribute)
1106         {
1107                 AliWarning("keepDCSMap flag not set - default is FALSE");
1108         } else {
1109                 TString keepDCSMapStr = anAttribute->GetValue();
1110                 if (!(keepDCSMapStr == "0" || keepDCSMapStr == "1"))
1111                 {
1112                         AliError("keepDCSMap flag must be 0 or 1!");
1113                         return 4;
1114                 }
1115                 fKeepDCSMap = (Bool_t) keepDCSMapStr.Atoi();
1116         }
1117
1118         anAttribute = anEntry->GetAttribute("keepTempFolder"); // MAY
1119         if (!anAttribute)
1120         {
1121                 AliWarning("keepTempFolder flag not set - default is FALSE");
1122         } else {
1123                 TString keepTempFolderStr = anAttribute->GetValue();
1124                 if (!(keepTempFolderStr == "0" || keepTempFolderStr == "1"))
1125                 {
1126                         AliError("keepTempFolder flag must be 0 or 1!");
1127                         return 4;
1128                 }
1129                 fKeepTempFolder = (Bool_t) keepTempFolderStr.Atoi();
1130         }
1131
1132
1133         anAttribute = anEntry->GetAttribute("shuttleAdmin"); // MAY
1134         if (!anAttribute)
1135         {
1136                 AliDebug(2, "Warning! No \"shuttleAdmin\" attribute!");
1137         }
1138         else
1139         {
1140                 const char* anAdmin;
1141                 while ((anAdmin = anAttribute->GetValue()))
1142                 {
1143                         fAdmin[kGlobal]->AddLast(new TObjString(anAdmin));
1144                 }
1145         }
1146
1147         anAttribute = anEntry->GetAttribute("amandaAdmin"); // MAY
1148         if (!anAttribute)
1149         {
1150                 AliDebug(2, "Warning! No \"amandaAdmin\" attribute!");
1151         }
1152         else
1153         {
1154                 const char* anAdmin;
1155                 while ((anAdmin = anAttribute->GetValue()))
1156                 {
1157                         fAdmin[kAmanda]->AddLast(new TObjString(anAdmin));
1158                 }
1159         }
1160
1161         anAttribute = anEntry->GetAttribute("sendMail"); // MAY
1162         if (!anAttribute)
1163         {
1164                 AliWarning("sendMail flag not set - default is FALSE");
1165         } else {
1166                 TString sendMailStr = anAttribute->GetValue();
1167                 if (!(sendMailStr == "0" || sendMailStr == "1"))
1168                 {
1169                         AliError("sendMail flag must be 0 or 1!");
1170                         return 4;
1171                 }
1172                 fSendMail = (Bool_t) sendMailStr.Atoi();
1173         }
1174
1175         anAttribute = anEntry->GetAttribute("passwdFilePath");
1176         if (!anAttribute) {
1177                 AliError("Can't find Passwords File Path attribute!");
1178                 return 4;
1179         }
1180         fPasswdFilePath = anAttribute->GetValue();
1181
1182         return 0;
1183 }
1184
1185 //______________________________________________________________________________________________
1186 UInt_t AliShuttleConfig::SetSysConfig(TList* list)
1187 {
1188         // Set the online FXS configuration (DAQ + DCS + HLT + DQM)
1189
1190
1191         TLDAPEntry* anEntry = 0;
1192         TLDAPAttribute* anAttribute = 0;
1193
1194         if (list->GetEntries() != 4)
1195         {
1196                 AliError(Form("Wrong number of online systems found: %d !", list->GetEntries()));
1197                 return 1;
1198         }
1199
1200         TIter iter(list);
1201         Int_t count = 0;
1202         SystemCode iSys=kDAQ;
1203
1204         while ((anEntry = dynamic_cast<TLDAPEntry*> (iter.Next())))
1205         {
1206                 anAttribute = anEntry->GetAttribute("system");
1207                 TString sysName = anAttribute->GetValue();
1208
1209                 if (sysName == "DAQ")
1210                 {
1211                         iSys = kDAQ;
1212                         count += 1;
1213                 }
1214                 else if (sysName == "DCS")
1215                 {
1216                         iSys = kDCS;
1217                         count += 10;
1218                 }
1219                 else if (sysName == "HLT")
1220                 {
1221                         iSys = kHLT;
1222                         count += 100;
1223                 }
1224                 else if (sysName == "DQM")
1225                 {
1226                         iSys = kDQM;
1227                         count += 1000;
1228                 }
1229
1230                 anAttribute = anEntry->GetAttribute("dbHost");
1231                 if (!anAttribute) {
1232                         AliError(Form ("Can't find dbHost attribute for %s!!",
1233                                                 AliShuttleInterface::GetSystemName(iSys)));
1234                         return 5;
1235                 }
1236                 fFXSdbHost[iSys] = anAttribute->GetValue();
1237
1238                 anAttribute = anEntry->GetAttribute("dbPort"); // MAY
1239                 if (anAttribute)
1240                 {
1241                         fFXSdbPort[iSys] = ((TString) anAttribute->GetValue()).Atoi();
1242                 } else {
1243                         fFXSdbPort[iSys] = 3306; // mysql
1244                 }
1245
1246                 anAttribute = anEntry->GetAttribute("dbUser");
1247                 if (!anAttribute) {
1248                         AliError(Form ("Can't find dbUser attribute for %s!!",
1249                                                 AliShuttleInterface::GetSystemName(iSys)));
1250                         return 5;
1251                 }
1252                 fFXSdbUser[iSys] = anAttribute->GetValue();
1253
1254                 anAttribute = anEntry->GetAttribute("dbName");
1255                 if (!anAttribute) {
1256                         AliError(Form ("Can't find dbName attribute for %s!!",
1257                                                 AliShuttleInterface::GetSystemName(iSys)));
1258                         return 5;
1259                 }
1260
1261                 fFXSdbName[iSys] = anAttribute->GetValue();
1262                 anAttribute = anEntry->GetAttribute("dbTable");
1263                 if (!anAttribute) {
1264                         AliError(Form ("Can't find dbTable attribute for %s!!",
1265                                                 AliShuttleInterface::GetSystemName(iSys)));
1266                         return 5;
1267                 }
1268                 fFXSdbTable[iSys] = anAttribute->GetValue();
1269
1270                 anAttribute = anEntry->GetAttribute("fxsHost");
1271                 if (!anAttribute) {
1272                         AliError(Form ("Can't find fxsHost attribute for %s!!",
1273                                                 AliShuttleInterface::GetSystemName(iSys)));
1274                         return 5;
1275                 }
1276                 fFXSHost[iSys] = anAttribute->GetValue();
1277
1278                 anAttribute = anEntry->GetAttribute("fxsPort"); // MAY
1279                 if (anAttribute)
1280                 {
1281                         fFXSPort[iSys] = ((TString) anAttribute->GetValue()).Atoi();
1282                 } else {
1283                         fFXSPort[iSys] = 22; // scp port number
1284                 }
1285
1286                 anAttribute = anEntry->GetAttribute("fxsUser");
1287                 if (!anAttribute) {
1288                         AliError(Form ("Can't find fxsUser attribute for %s!!",
1289                                                 AliShuttleInterface::GetSystemName(iSys)));
1290                         return 5;
1291                 }
1292                 fFXSUser[iSys] = anAttribute->GetValue();
1293
1294                 anAttribute = anEntry->GetAttribute("fxsPasswd");
1295                 if (anAttribute) fFXSPass[iSys] = anAttribute->GetValue();
1296
1297                 anAttribute = anEntry->GetAttribute("fxsBaseFolder");
1298                 if (anAttribute) fFXSBaseFolder[iSys] = anAttribute->GetValue();
1299
1300                 anAttribute = anEntry->GetAttribute("fxsAdmin"); // MAY
1301                 if (!anAttribute)
1302                 {
1303                         AliDebug(2, "Warning! No \"fxsAdmin\" attribute!");
1304                 }
1305                 else
1306                 {
1307                         const char* anAdmin;
1308                         while ((anAdmin = anAttribute->GetValue()))
1309                         {
1310                                 fAdmin[iSys]->AddLast(new TObjString(anAdmin));
1311                         }
1312                 }
1313
1314         }
1315
1316         if(count != 1111) {
1317                 AliError(Form("Wrong system configuration! (code = %d)", count));
1318                 return 6;
1319         }
1320
1321         return 0;
1322 }
1323
1324 //______________________________________________________________________________________________
1325 UInt_t AliShuttleConfig::SetPasswords(){
1326
1327         AliInfo("Setting Passwords");
1328
1329         // Retrieving Passwords for DAQ lb, DAQ/DCS/HLT/DQM FXS
1330
1331         ifstream *inputfile = new ifstream(fPasswdFilePath.Data());
1332         if (!*inputfile) {
1333                 AliError(Form("Error opening file %s !", fPasswdFilePath.Data()));
1334                 inputfile->close();
1335                 delete inputfile;
1336                 return 1;
1337         }
1338
1339         TString line;
1340         Int_t nPwd=0;
1341         Int_t nPwdFake=0;
1342         while (line.ReadLine(*inputfile)) {
1343                 TObjArray *tokens = line.Tokenize(" \t");
1344                 TString system = ((TObjString *)tokens->At(0))->String();
1345                 TString password = ((TObjString *)tokens->At(1))->String();
1346                 delete tokens;
1347                 if (system.Contains("DAQ_LB")){
1348                         fDAQlbPass=password;
1349                         nPwd++;
1350                         AliDebug(3,Form("DAQ_LB: Password %s for %s found", password.Data(), system.Data()));
1351                 }
1352                 else if (system.Contains("DAQ_DB")){
1353                         fFXSdbPass[0]=password;
1354                         nPwd++;
1355                         AliDebug(3,Form("DAQ_DB: Password %s for %s found", password.Data(), system.Data()));
1356                 }
1357                 else if (system.Contains("DCS_DB")){
1358                         fFXSdbPass[1]=password;
1359                         nPwd++;
1360                         AliDebug(3,Form("DCS_DB: Password %s for %s found", password.Data(), system.Data()));
1361                 }
1362                 else if (system.Contains("HLT_DB")){
1363                         fFXSdbPass[2]=password;
1364                         nPwd++;
1365                         AliDebug(3,Form("HLT_DB: Password %s for %s found", password.Data(), system.Data()));
1366                 }
1367                 else if (system.Contains("DQM_DB")){
1368                         fFXSdbPass[3]=password;
1369                         nPwd++;
1370                         AliDebug(3,Form("DQM_DB: Password %s for %s found", password.Data(), system.Data()));
1371                 }
1372                 else {
1373                         nPwdFake++;
1374                         AliDebug(3,Form("%i fake line(s) found in file %s", nPwdFake, fPasswdFilePath.Data()));
1375                         continue;
1376                 }
1377         }
1378
1379         inputfile->close();
1380         delete inputfile;
1381
1382         if (nPwd!=5){
1383                 AliError(Form("Wrong file for DAQ Logbook password found %s (some passwors missing), please Check!", fPasswdFilePath.Data()));
1384                 return 2;
1385         }
1386
1387         return 0;
1388
1389 }
1390 //______________________________________________________________________________________________
1391 UInt_t AliShuttleConfig::SetDetConfig(TList* detList, TList* dcsList)
1392 {
1393         // Set the detector configuration (general settings + DCS amanda server and alias/DP lists)
1394
1395         TLDAPEntry* anEntry = 0;
1396
1397         TIter iter(detList);
1398         while ((anEntry = dynamic_cast<TLDAPEntry*> (iter.Next())))
1399         {
1400
1401                 AliShuttleDetConfigHolder* detHolder = new AliShuttleDetConfigHolder(anEntry);
1402
1403                 if (!detHolder->IsValid()) {
1404                         AliError("Detector configuration error!");
1405                         delete detHolder;
1406                         return 7;
1407                 }
1408
1409                 TObjString* detStr = new TObjString(detHolder->GetDetector());
1410
1411                 // Look for DCS Configuration
1412                 TIter dcsIter(dcsList);
1413                 TLDAPEntry *dcsEntry = 0;
1414                 while ((dcsEntry = dynamic_cast<TLDAPEntry*> (dcsIter.Next())))
1415                 {
1416                         TString dn = dcsEntry->GetDn();
1417                         if(dn.Contains(detStr->GetName())) {
1418                                 AliDebug(2, Form("Found DCS configuration: dn = %s",dn.Data()));
1419                                 AliShuttleDCSConfigHolder* dcsHolder = new AliShuttleDCSConfigHolder(dcsEntry);
1420                                 if (!dcsHolder->IsValid()) {
1421                                         AliError("DCS configuration error!");
1422                                         delete detHolder;
1423                                         delete dcsHolder;
1424                                         return 7;
1425                                 }
1426                                 detHolder->AddDCSConfig(dcsHolder);
1427                         }
1428                 }
1429
1430
1431                 fDetectorMap.Add(detStr, detHolder);
1432                 fDetectorList.AddLast(detStr);
1433         }
1434
1435         return 0;
1436 }
1437
1438 //______________________________________________________________________________________________
1439 UInt_t AliShuttleConfig::SetHostConfig(TList* list)
1440 {
1441         // Set the Shuttle machines configuration (which detectors processes each machine)
1442
1443         TLDAPEntry* anEntry = 0;
1444         TLDAPAttribute* anAttribute = 0;
1445
1446         fShuttleInstanceHost = gSystem->HostName();
1447
1448         TIter iter(list);
1449         while ((anEntry = dynamic_cast<TLDAPEntry*> (iter.Next())))
1450         {
1451
1452                 TString dn(anEntry->GetDn());
1453                 if (!dn.Contains(Form("shuttleHost=%s", fShuttleInstanceHost.Data()))) continue;
1454
1455                 if (!fProcessAll)
1456                 {
1457                         anAttribute = anEntry->GetAttribute("detectors");
1458                         const char *detName;
1459                         while((detName = anAttribute->GetValue())){
1460                                 TObjString *objDet= new TObjString(detName);
1461                                 fProcessedDetectors.Add(objDet);
1462                         }
1463                 }
1464         }
1465
1466         return 0;
1467 }
1468
1469
1470 //______________________________________________________________________________________________
1471 void AliShuttleConfig::Print(Option_t* option) const
1472 {
1473 // print configuration
1474 // options : "": print configuration for all detectors, aliases and DPs in compacted format
1475 //           "uncompact": print configuration for all detectors, aliases and DPs in uncompacted format
1476 //           "DET": print configuration for DET, aliases and DPs in compacted format
1477 //           "DET, uncompact": print configuration for DET, aliases and DPs in uncompacted format
1478
1479         TString result;
1480         result += '\n';
1481
1482         TString mode = "test";
1483         if (fRunMode == kProd) mode = "production";
1484
1485         result += "########################################################################\n";
1486         result += Form(" Shuttle configuration from %s - Run Mode: <%s> \n",
1487                                         fConfigHost.Data(), mode.Data());
1488         result += "########################################################################\n";
1489         result += Form("\nShuttle running on %s \n", fShuttleInstanceHost.Data());
1490
1491         if(fProcessAll) {
1492                 result += Form("All detectors will be processed! \n");
1493         } else {
1494                 result += "Detectors processed by this host: ";
1495                 TIter it(&fProcessedDetectors);
1496                 TObjString* aDet;
1497                 while ((aDet = (TObjString*) it.Next())) {
1498                         result += Form("%s ", aDet->String().Data());
1499                 }
1500                 result += "\n";
1501         }
1502
1503         result += Form("PP time out = %d - DCS time out = %d - max PP mem size = %d KB - max retries = %d "
1504                        "- DIM trigger waiting timeout = %d\n",
1505                                 fPPTimeOut, fDCSTimeOut, fPPMaxMem, fMaxRetries, fTriggerWait);
1506         result += Form("FLAGS: keepDCSMap = %d - keepTempFolder = %d - SendMail = %d \n",
1507                                 fKeepDCSMap, fKeepTempFolder, fSendMail);
1508         const TObjArray* shuttleAdmins = GetAdmins(kGlobal);
1509         if (shuttleAdmins->GetEntries() != 0)
1510         {
1511                 result += "SHUTTLE administrator(s): ";
1512                 TIter it(shuttleAdmins);
1513                 TObjString* anAdmin;
1514                 while ((anAdmin = (TObjString*) it.Next()))
1515                 {
1516                         result += Form("%s ", anAdmin->String().Data());
1517                 }
1518                 result += "\n";
1519         }
1520         const TObjArray* amandaAdmins = GetAdmins(kAmanda);
1521         if (amandaAdmins->GetEntries() != 0)
1522         {
1523                 result += "Amanda server administrator(s): ";
1524                 TIter it(amandaAdmins);
1525                 TObjString* anAdmin;
1526                 while ((anAdmin = (TObjString*) it.Next()))
1527                 {
1528                         result += Form("%s ", anAdmin->String().Data());
1529                 }
1530                 result += "\n\n";
1531         }
1532         result += "------------------------------------------------------\n";
1533
1534         result += Form("Logbook Configuration \n\n \tHost: %s:%d; \tUser: %s; ",
1535                 fDAQlbHost.Data(), fDAQlbPort, fDAQlbUser.Data());
1536
1537         result += Form("\tDB: %s; \tTables: %s, %s, %s\n",
1538                 fDAQlbDB.Data(), fDAQlbTable.Data(), fShuttlelbTable.Data(), fRunTypelbTable.Data());
1539
1540         result += Form("Terminate file path: %s\n", fTerminateFilePath.Data());
1541
1542         result += "\n\n";
1543
1544         result += "------------------------------------------------------\n";
1545         result += "FXS configuration\n\n";
1546
1547         for(int iSys=0;iSys<4;iSys++){
1548                 result += Form("*** %s ***\n", AliShuttleInterface::GetSystemName(iSys));
1549                 result += Form("\tDB  host: %s:%d; \tUser: %s; \tName: %s; \tTable: %s\n",
1550                                                 fFXSdbHost[iSys].Data(), fFXSdbPort[iSys], fFXSdbUser[iSys].Data(),
1551                                                 fFXSdbName[iSys].Data(), fFXSdbTable[iSys].Data());
1552                 result += Form("\tFXS host: %s:%d; \tUser: %s\n", fFXSHost[iSys].Data(), fFXSPort[iSys],
1553                                                 fFXSUser[iSys].Data());
1554                 const TObjArray* fxsAdmins = GetAdmins(iSys);
1555                 if (fxsAdmins->GetEntries() != 0)
1556                 {
1557                         result += "\tAdministrator(s): ";
1558                         TIter it(fxsAdmins);
1559                         TObjString* anAdmin;
1560                         while ((anAdmin = (TObjString*) it.Next()))
1561                         {
1562                                 result += Form("%s ", anAdmin->String().Data());
1563                         }
1564                         result += "\n\n";
1565                 }
1566         }
1567
1568         result += "------------------------------------------------------\n";
1569         result += "MonaLisa configuration\n\n";
1570
1571         result += Form("\tHost: %s; \tTable name: %s",
1572                 fMonitorHost.Data(), fMonitorTable.Data());
1573
1574         result += "\n\n";
1575
1576         TString optStr(option);
1577
1578         result += "------------------------------------------------------\n";
1579         result += "Detector-specific configuration\n\n";
1580
1581         TIter iter(fDetectorMap.GetTable());
1582         TPair* aPair = 0;
1583
1584         while ((aPair = (TPair*) iter.Next())) {
1585                 AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) aPair->Value();
1586                 if (optStr != "" && !optStr.Contains(aHolder->GetDetector()) &&
1587                                 optStr.CompareTo("uncompact",TString::kIgnoreCase) != 0 )
1588                                 continue;
1589
1590                 result += Form("*** %s *** \n", aHolder->GetDetector());
1591
1592                 const TObjArray* responsibles = aHolder->GetResponsibles();
1593                 if (responsibles->GetEntries() != 0)
1594                 {
1595                         result += "\tDetector responsible(s): ";
1596                         TIter it(responsibles);
1597                         TObjString* aResponsible;
1598                         while ((aResponsible = (TObjString*) it.Next()))
1599                         {
1600                                 result += Form("%s ", aResponsible->String().Data());
1601                         }
1602                         result += "\n";
1603                 }
1604
1605                 result += Form("\tStrict run ordering: %s \n\n", aHolder->StrictRunOrder() ? "YES" : "NO");
1606
1607                 const TObjArray* dcsConfig = aHolder->GetDCSConfig();
1608
1609                 AliShuttleDCSConfigHolder* dcsHolder = 0;
1610                 TIter dcsIter(dcsConfig);
1611                 Int_t count=0;
1612                 while ((dcsHolder = dynamic_cast<AliShuttleDCSConfigHolder*> (dcsIter.Next())))
1613                 {
1614                         result += Form("\tAmanda server [%d]: %s:%d - MultiSplit = %d\n", count,
1615                                 dcsHolder->GetDCSHost(), dcsHolder->GetDCSPort(), dcsHolder->GetMultiSplit());
1616
1617                         const TObjArray* aliases = 0;
1618                         if (optStr.Contains("uncompact",TString::kIgnoreCase))
1619                         {
1620                                 aliases = dcsHolder->GetDCSAliases();
1621                         } else {
1622                                 aliases = dcsHolder->GetCompactDCSAliases();
1623                         }
1624
1625                         if (aliases->GetEntries() != 0)
1626                         {
1627                                 result += Form("\tDCS Aliases [%d]: ", count);
1628                                 TIter it(aliases);
1629                                 TObjString* anAlias;
1630                                 while ((anAlias = (TObjString*) it.Next()))
1631                                 {
1632                                         result += Form("%s ", anAlias->String().Data());
1633                                 }
1634                                 result += "\n";
1635                         }
1636
1637                         const TObjArray* dataPoints = 0;
1638                         if (optStr.Contains("uncompact",TString::kIgnoreCase))
1639                         {
1640                                 dataPoints = dcsHolder->GetDCSDataPoints();
1641                         } else {
1642                                 dataPoints = dcsHolder->GetCompactDCSDataPoints();
1643                         }
1644                         if (dataPoints->GetEntries() != 0)
1645                         {
1646                                 result += Form("\tDCS Data Points [%d]: ", count);
1647                                 TIter it(dataPoints);
1648                                 TObjString* aDataPoint;
1649                                 while ((aDataPoint = (TObjString*) it.Next())) {
1650                                         result += Form("%s ", aDataPoint->String().Data());
1651                                 }
1652                                 result += "\n";
1653                         }
1654                         count++;
1655                         result += "\n";
1656                 }
1657         }
1658         if(!fIsValid) result += "\n\n********** !!!!! Configuration is INVALID !!!!! **********\n";
1659
1660         AliInfo(result);
1661 }