High_gain/low_gain calculation added; histogram names changed to satisfy AliPHOSDA1...
[u/mrichter/AliRoot.git] / 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
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
190
191 AliShuttleConfig::AliShuttleDCSConfigHolder::AliShuttleDCSConfigHolder(const TLDAPEntry* entry):
192 fDCSHost(""),
193 fDCSPort(0),
194 fMultiSplit(100),
195 fDCSAliases(0),
196 fDCSDataPoints(0),
197 fDCSAliasesComp(0),
198 fDCSDataPointsComp(0),
199 fIsValid(kFALSE)
200 {
201 // constructor of the shuttle DCS configuration holder
202
203         TLDAPAttribute* anAttribute;
204         fDCSAliases = new TObjArray();
205         fDCSAliases->SetOwner(1);
206         fDCSDataPoints = new TObjArray();
207         fDCSDataPoints->SetOwner(1);
208         fDCSAliasesComp = new TObjArray();
209         fDCSAliasesComp->SetOwner(1);
210         fDCSDataPointsComp = new TObjArray();
211         fDCSDataPointsComp->SetOwner(1);
212
213         
214         anAttribute = entry->GetAttribute("dcsHost"); 
215         if (!anAttribute)
216         {
217                 AliError("Unexpected: no DCS host!");
218                 return;
219         }
220
221         fDCSHost = anAttribute->GetValue();
222
223         anAttribute = entry->GetAttribute("dcsPort");
224         if (!anAttribute)
225         {
226                 AliError("Unexpected: no DCS port!");
227                 return;
228         }
229         TString portStr = anAttribute->GetValue();
230         fDCSPort = portStr.Atoi();
231
232         anAttribute = entry->GetAttribute("multiSplit"); // MAY
233         if (anAttribute)
234         {
235                 TString multiSplitStr = anAttribute->GetValue();
236                 fMultiSplit = multiSplitStr.Atoi();
237                 if(fMultiSplit == 0) {
238                         AliError("MultiSplit must be a positive integer!");
239                         return;
240                 }
241                 
242         }
243         
244         anAttribute = entry->GetAttribute("dcsAlias"); // MAY
245         if (anAttribute)
246         {
247                 const char* anAlias;
248                 while ((anAlias = anAttribute->GetValue()))
249                 {
250                         fDCSAliasesComp->AddLast(new TObjString(anAlias));
251                         ExpandAndAdd(fDCSAliases, anAlias);
252                 }
253         }
254
255         anAttribute = entry->GetAttribute("dcsDP"); // MAY
256         if (anAttribute)
257         {
258                 const char* aDataPoint;
259                 while ((aDataPoint = anAttribute->GetValue()))
260                 {
261                 fDCSDataPointsComp->AddLast(new TObjString(aDataPoint));
262                 ExpandAndAdd(fDCSDataPoints, aDataPoint);
263                 }
264         }
265         
266         fIsValid = kTRUE;
267 }
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         fDAQlbHost(""), 
531         fDAQlbPort(), 
532         fDAQlbUser(""), 
533         fDAQlbPass(""),
534         fDAQlbDB(""), 
535         fDAQlbTable(""), 
536         fShuttlelbTable(""), 
537         fRunTypelbTable(""),
538         fMaxRetries(0), 
539         fPPTimeOut(0), 
540         fPPMaxMem(0), 
541         fMonitorHost(""), 
542         fMonitorTable(""), 
543         fTriggerWait(3600),
544         fRunMode(kTest),
545         fDetectorMap(), 
546         fDetectorList(),
547         fAdmin(),
548         fShuttleInstanceHost(""), 
549         fProcessedDetectors(), 
550         fKeepDCSMap(kFALSE),
551         fKeepTempFolder(kFALSE),
552         fSendMail(kFALSE),
553         fProcessAll(kFALSE), 
554         fIsValid(kFALSE)
555
556 {
557         //
558         // host: ldap server host
559         // port: ldap server port
560         // binddn: binddn used for ldap binding (simple bind is used!).
561         // password: password for binddn
562         // basedn: this is basedn whose childeren entries which have
563         //
564
565         fDetectorMap.SetOwner(1);
566         fDetectorList.SetOwner(0); //fDetectorList and fDetectorMap share the same object!
567         fProcessedDetectors.SetOwner();
568         
569         for (int i=0; i<5; i++)
570         {
571                 fAdmin[i] = new TObjArray(); 
572                 fAdmin[i]->SetOwner();
573         }
574
575         TLDAPServer aServer(host, port, binddn, password, 3);
576
577         if (!aServer.IsConnected()) {
578                 AliError(Form("Can't connect to ldap server %s:%d",
579                                 host, port));
580                 return;
581         }
582
583         // reads configuration for the shuttle running on this machine
584         
585         TLDAPResult* aResult = 0;
586         TLDAPEntry* anEntry = 0;
587         
588         TList dcsList;
589         dcsList.SetOwner(1);
590         TList detList;
591         detList.SetOwner(1);
592         TList globalList;
593         globalList.SetOwner(1);
594         TList sysList;
595         sysList.SetOwner(1);
596         TList hostList;
597         hostList.SetOwner(1);
598         
599         aResult = aServer.Search(basedn, LDAP_SCOPE_SUBTREE, 0, 0);
600         
601         if (!aResult) 
602         {
603                 AliError(Form("Can't find configuration with base DN: %s !", basedn));
604                 return;
605         }
606         
607         while ((anEntry = aResult->GetNext())) 
608         {
609                 TString dn = anEntry->GetDn();
610                 
611                 if (dn.BeginsWith("dcsHost=")) 
612                 {
613                         dcsList.Add(anEntry);
614                 } 
615                 else if (dn.BeginsWith("det="))
616                 {
617                         detList.Add(anEntry);
618                 }
619                 else if (dn.BeginsWith("name=globalConfig"))
620                 {
621                         globalList.Add(anEntry);
622                 }
623                 else if (dn.BeginsWith("system="))
624                 {
625                         sysList.Add(anEntry);
626                 }
627                 else if (dn.BeginsWith("shuttleHost="))
628                 {
629                         hostList.Add(anEntry);
630                 }
631                 else 
632                 {
633                         delete anEntry;
634                 }
635         
636         }
637         delete aResult;
638         
639         Int_t result=0;
640         
641         result += SetGlobalConfig(&globalList);
642         result += SetSysConfig(&sysList);
643         result += SetDetConfig(&detList,&dcsList);
644         result += SetHostConfig(&hostList);
645         
646         if(result) 
647         {
648                 AliError("Configuration is INVALID!");
649         }
650         else 
651         {
652                 fIsValid = kTRUE;
653         }
654 }
655
656 //______________________________________________________________________________________________
657 AliShuttleConfig::~AliShuttleConfig()
658 {
659 // destructor
660
661         fDetectorMap.DeleteAll();
662         fDetectorList.Clear();
663         fProcessedDetectors.Delete();
664         
665         delete[] fAdmin;
666         
667 }
668
669 //______________________________________________________________________________________________
670 const TObjArray* AliShuttleConfig::GetDetectors() const
671 {
672         //
673         // returns collection of TObjString which contains the name
674         // of every detector which is in the configuration.
675         //
676
677         return &fDetectorList;
678 }
679
680 //______________________________________________________________________________________________
681 Bool_t AliShuttleConfig::HasDetector(const char* detector) const
682 {
683         //
684         // checks for paricular detector in the configuration.
685         //
686         return fDetectorMap.GetValue(detector) != NULL;
687 }
688
689 //______________________________________________________________________________________________
690 Int_t AliShuttleConfig::GetNServers(const char* detector) const
691 {
692         //
693         // returns number of DCS servers for detector
694         //
695         
696         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
697         if (!aHolder) {
698                 AliError(Form("There isn't configuration for detector: %s",
699                         detector));
700                 return 0;
701         }
702
703         return aHolder->GetNServers();
704 }
705
706
707 //______________________________________________________________________________________________
708 const char* AliShuttleConfig::GetDCSHost(const char* detector, Int_t iServ) const
709 {
710         //
711         // returns i-th DCS server host used by particular detector
712         //
713         
714         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
715         if (!aHolder) {
716                 AliError(Form("There isn't configuration for detector: %s",
717                         detector));
718                 return NULL;
719         }
720
721         return aHolder->GetDCSHost(iServ);
722 }
723
724 //______________________________________________________________________________________________
725 Int_t AliShuttleConfig::GetDCSPort(const char* detector, Int_t iServ) const
726 {
727         //
728         // returns i-th DCS server port used by particular detector
729         //
730
731
732         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
733         if (!aHolder) {
734                 AliError(Form("There isn't configuration for detector: %s",
735                         detector));
736                 return 0;
737         }
738
739         return aHolder->GetDCSPort(iServ);
740 }
741
742 //______________________________________________________________________________________________
743 Int_t AliShuttleConfig::GetMultiSplit(const char* detector, Int_t iServ) const
744 {
745         //
746         // returns i-th DCS "multi split" value
747         //
748
749
750         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
751         if (!aHolder) {
752                 AliError(Form("There isn't configuration for detector: %s",
753                         detector));
754                 return 0;
755         }
756
757         return aHolder->GetMultiSplit(iServ);
758 }
759
760 //______________________________________________________________________________________________
761 const TObjArray* AliShuttleConfig::GetDCSAliases(const char* detector, Int_t iServ) const
762 {
763         //
764         // returns collection of TObjString which represents the i-th set of aliases
765         // which used for data retrieval for particular detector
766         //
767
768         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
769         if (!aHolder) {
770                 AliError(Form("There isn't configuration for detector: %s",
771                         detector));
772                 return NULL;
773         }
774
775         return aHolder->GetDCSAliases(iServ);
776 }
777
778 //______________________________________________________________________________________________
779 const TObjArray* AliShuttleConfig::GetDCSDataPoints(const char* detector, Int_t iServ) const
780 {
781         //
782         // returns collection of TObjString which represents the set of aliases
783         // which used for data retrieval for particular detector
784         //
785
786         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
787         if (!aHolder) {
788                 AliError(Form("There isn't configuration for detector: %s",
789                         detector));
790                 return NULL;
791         }
792
793         return aHolder->GetDCSDataPoints(iServ);
794 }
795
796 //______________________________________________________________________________________________
797 const TObjArray* AliShuttleConfig::GetCompactDCSAliases(const char* detector, Int_t iServ) const
798 {
799         //
800         // returns collection of TObjString which represents the i-th set of aliases
801         // which used for data retrieval for particular detector (Compact style)
802         //
803
804         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
805         if (!aHolder) {
806                 AliError(Form("There isn't configuration for detector: %s",
807                         detector));
808                 return NULL;
809         }
810
811         return aHolder->GetCompactDCSAliases(iServ);
812 }
813
814 //______________________________________________________________________________________________
815 const TObjArray* AliShuttleConfig::GetCompactDCSDataPoints(const char* detector, Int_t iServ) const
816 {
817         //
818         // returns collection of TObjString which represents the set of aliases
819         // which used for data retrieval for particular detector (Compact style)
820         //
821
822         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
823         if (!aHolder) {
824                 AliError(Form("There isn't configuration for detector: %s",
825                         detector));
826                 return NULL;
827         }
828
829         return aHolder->GetCompactDCSDataPoints(iServ);
830 }
831
832 //______________________________________________________________________________________________
833 const TObjArray* AliShuttleConfig::GetResponsibles(const char* detector) const
834 {
835         //
836         // returns collection of TObjString which represents the list of mail addresses
837         // of the detector's responsible(s)
838         //
839
840         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
841         if (!aHolder) {
842                 AliError(Form("There isn't configuration for detector: %s",
843                         detector));
844                 return NULL;
845         }
846
847         return aHolder->GetResponsibles();
848 }
849
850 //______________________________________________________________________________________________
851 const TObjArray* AliShuttleConfig::GetAdmins(Int_t sys) const
852 {
853         //
854         // returns collection of TObjString which represents the list of mail addresses
855         // of the system's administrator(s) (DAQ, DCS, HLT, Global, Amanda)
856         //
857
858         if (sys < 0 || sys > 4) return 0;
859         return fAdmin[sys];
860 }
861
862 //______________________________________________________________________________________________
863 Bool_t AliShuttleConfig::HostProcessDetector(const char* detector) const
864 {
865         // return TRUE if detector is handled by host or if fProcessAll is TRUE
866
867         if(fProcessAll) return kTRUE;
868         TIter iter(&fProcessedDetectors);
869         TObjString* detName;
870         while((detName = (TObjString*) iter.Next())){
871                 if(detName->String() == detector) return kTRUE;
872         }
873         return kFALSE;
874 }
875
876 //______________________________________________________________________________________________
877 Bool_t AliShuttleConfig::StrictRunOrder(const char* detector) const
878 {
879         // return TRUE if detector wants strict run ordering of stored data
880
881         AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) fDetectorMap.GetValue(detector);
882         if (!aHolder)
883         {
884                 AliError(Form("There isn't configuration for detector: %s",
885                         detector));
886                 return kTRUE;
887         }
888
889         return aHolder->StrictRunOrder();
890 }
891
892 //______________________________________________________________________________________________
893 UInt_t AliShuttleConfig::SetGlobalConfig(TList* list)
894 {
895         // Set the global configuration (DAQ Logbook + preprocessor monitoring settings)
896
897         TLDAPEntry* anEntry = 0;
898         TLDAPAttribute* anAttribute = 0;
899         
900         if (list->GetEntries() == 0) 
901         {
902                 AliError("Global configuration not found!");
903                 return 1;
904         } 
905         else if (list->GetEntries() > 1)
906         {
907                 AliError("More than one global configuration found!");
908                 return 2;
909         }
910         
911         anEntry = dynamic_cast<TLDAPEntry*> (list->At(0));
912         
913         if (!anEntry)
914         {
915                 AliError("Unexpected! Global list does not contain a TLDAPEntry");
916                 return 3;
917         } 
918         
919         
920         anAttribute = anEntry->GetAttribute("daqLbHost");
921         if (!anAttribute) {
922                 AliError("Can't find daqLbHost attribute!");
923                 return 4;
924         }
925         fDAQlbHost = anAttribute->GetValue();
926
927         anAttribute = anEntry->GetAttribute("daqLbPort"); // MAY
928         if (anAttribute)
929         {
930                 fDAQlbPort = ((TString) anAttribute->GetValue()).Atoi();
931         } else {
932                 fDAQlbPort = 3306; // mysql
933         }
934
935         anAttribute = anEntry->GetAttribute("daqLbUser");
936         if (!anAttribute) {
937                 AliError("Can't find daqLbUser attribute!");
938                 return 4;
939         }
940         fDAQlbUser = anAttribute->GetValue();
941
942         anAttribute = anEntry->GetAttribute("daqLbPasswd");
943         if (!anAttribute) {
944                 AliError("Can't find daqLbPasswd attribute!");
945                 return 4;
946         }
947         fDAQlbPass = anAttribute->GetValue();
948
949         anAttribute = anEntry->GetAttribute("daqLbDB");
950         if (!anAttribute) {
951                 AliError("Can't find daqLbDB attribute!");
952                 return 4;
953         }
954         fDAQlbDB = anAttribute->GetValue();
955
956         anAttribute = anEntry->GetAttribute("daqLbTable");
957         if (!anAttribute) {
958                 AliError("Can't find daqLbTable attribute!");
959                 return 4;
960         }
961         fDAQlbTable = anAttribute->GetValue();
962
963         anAttribute = anEntry->GetAttribute("shuttleLbTable");
964         if (!anAttribute) {
965                 AliError("Can't find shuttleLbTable attribute!");
966                 return 4;
967         }
968         fShuttlelbTable = anAttribute->GetValue();
969
970         anAttribute = anEntry->GetAttribute("runTypeLbTable");
971         if (!anAttribute) {
972                 AliError("Can't find runTypeLbTable attribute!");
973                 return 4;
974         }
975         fRunTypelbTable = anAttribute->GetValue();
976
977         anAttribute = anEntry->GetAttribute("ppmaxRetries");
978         if (!anAttribute) {
979                 AliError("Can't find ppmaxRetries attribute!");
980                 return 4;
981         }
982         TString tmpStr = anAttribute->GetValue();
983         fMaxRetries = tmpStr.Atoi();
984
985         anAttribute = anEntry->GetAttribute("ppTimeOut");
986         if (!anAttribute) {
987                 AliError("Can't find ppTimeOut attribute!");
988                 return 4;
989         }
990         tmpStr = anAttribute->GetValue();
991         fPPTimeOut = tmpStr.Atoi();
992
993         anAttribute = anEntry->GetAttribute("ppMaxMem");
994         if (!anAttribute) {
995                 AliError("Can't find ppMaxMem attribute!");
996                 return 4;
997         }
998         tmpStr = anAttribute->GetValue();
999         fPPMaxMem = tmpStr.Atoi();
1000         
1001         anAttribute = anEntry->GetAttribute("monitorHost");
1002         if (!anAttribute) {
1003                 AliError("Can't find monitorHost attribute!");
1004                 return 4;
1005         }
1006         fMonitorHost = anAttribute->GetValue();
1007         
1008         anAttribute = anEntry->GetAttribute("monitorTable");
1009         if (!anAttribute) {
1010                 AliError("Can't find monitorTable attribute!");
1011                 return 4;
1012         }
1013         fMonitorTable = anAttribute->GetValue();
1014
1015         anAttribute = anEntry->GetAttribute("triggerWait"); // MAY
1016         if (!anAttribute) {
1017                 AliWarning(Form("triggerWait not set! default = ", fTriggerWait));
1018         }
1019         tmpStr = anAttribute->GetValue();
1020         fTriggerWait = tmpStr.Atoi();
1021         
1022         anAttribute = anEntry->GetAttribute("mode");
1023         if (!anAttribute) {
1024                 AliWarning("Run mode not set! Running in test mode.");
1025         } else {
1026           tmpStr = anAttribute->GetValue();
1027           if (tmpStr == "test")
1028           {
1029             fRunMode = kTest;
1030           } else if (tmpStr == "prod") {
1031             fRunMode = kProd;
1032           } else {
1033             AliWarning(Form("Not a valid run mode: %s", tmpStr.Data()));                
1034             AliWarning("Valid run modes are \"test\" and \"prod\". Running in test mode.");
1035           }
1036         }
1037
1038         anAttribute = anEntry->GetAttribute("keepDCSMap"); // MAY
1039         if (!anAttribute)
1040         {
1041                 AliWarning("keepDCSMap flag not set - default is FALSE");
1042         } else {
1043                 TString keepDCSMapStr = anAttribute->GetValue();
1044                 if (!(keepDCSMapStr == "0" || keepDCSMapStr == "1"))
1045                 {
1046                         AliError("keepDCSMap flag must be 0 or 1!");
1047                         return 4;
1048                 }
1049                 fKeepDCSMap = (Bool_t) keepDCSMapStr.Atoi();
1050         }
1051         
1052         anAttribute = anEntry->GetAttribute("keepTempFolder"); // MAY
1053         if (!anAttribute)
1054         {
1055                 AliWarning("keepTempFolder flag not set - default is FALSE");
1056         } else {
1057                 TString keepTempFolderStr = anAttribute->GetValue();
1058                 if (!(keepTempFolderStr == "0" || keepTempFolderStr == "1"))
1059                 {
1060                         AliError("keepTempFolder flag must be 0 or 1!");
1061                         return 4;
1062                 }
1063                 fKeepTempFolder = (Bool_t) keepTempFolderStr.Atoi();
1064         }
1065         
1066
1067         anAttribute = anEntry->GetAttribute("shuttleAdmin"); // MAY
1068         if (!anAttribute)
1069         {
1070                 AliDebug(2, "Warning! No \"shuttleAdmin\" attribute!");
1071         }
1072         else
1073         {
1074                 const char* anAdmin;
1075                 while ((anAdmin = anAttribute->GetValue()))
1076                 {
1077                         fAdmin[kGlobal]->AddLast(new TObjString(anAdmin));
1078                 }
1079         }
1080
1081         anAttribute = anEntry->GetAttribute("amandaAdmin"); // MAY
1082         if (!anAttribute)
1083         {
1084                 AliDebug(2, "Warning! No \"amandaAdmin\" attribute!");
1085         }
1086         else
1087         {
1088                 const char* anAdmin;
1089                 while ((anAdmin = anAttribute->GetValue()))
1090                 {
1091                         fAdmin[kAmanda]->AddLast(new TObjString(anAdmin));
1092                 }
1093         }
1094         
1095         anAttribute = anEntry->GetAttribute("sendMail"); // MAY
1096         if (!anAttribute)
1097         {
1098                 AliWarning("sendMail flag not set - default is FALSE");
1099         } else {
1100                 TString sendMailStr = anAttribute->GetValue();
1101                 if (!(sendMailStr == "0" || sendMailStr == "1"))
1102                 {
1103                         AliError("sendMail flag must be 0 or 1!");
1104                         return 4;
1105                 }
1106                 fSendMail = (Bool_t) sendMailStr.Atoi();
1107         }
1108                                                 
1109         return 0;
1110 }
1111
1112 //______________________________________________________________________________________________
1113 UInt_t AliShuttleConfig::SetSysConfig(TList* list)
1114 {
1115         // Set the online FXS configuration (DAQ + DCS + HLT)
1116         
1117         TLDAPEntry* anEntry = 0;
1118         TLDAPAttribute* anAttribute = 0;
1119         
1120         if (list->GetEntries() != 3) 
1121         {
1122                 AliError(Form("Wrong number of online systems found: %d !", list->GetEntries()));
1123                 return 1;
1124         } 
1125
1126         TIter iter(list);
1127         Int_t count = 0;
1128         SystemCode iSys=kDAQ;
1129         
1130         while ((anEntry = dynamic_cast<TLDAPEntry*> (iter.Next())))
1131         {
1132                 anAttribute = anEntry->GetAttribute("system");
1133                 TString sysName = anAttribute->GetValue();
1134                 
1135                 if (sysName == "DAQ") 
1136                 {
1137                         iSys = kDAQ;
1138                         count += 1;
1139                 }
1140                 else if (sysName == "DCS")
1141                 {
1142                         iSys = kDCS;
1143                         count += 10;
1144                 }
1145                 else if (sysName == "HLT")
1146                 {
1147                         iSys = kHLT;
1148                         count += 100;
1149                 }
1150                 
1151                 anAttribute = anEntry->GetAttribute("dbHost");
1152                 if (!anAttribute) {
1153                         AliError(Form ("Can't find dbHost attribute for %s!!",
1154                                                 AliShuttleInterface::GetSystemName(iSys)));
1155                         return 5;
1156                 }
1157                 fFXSdbHost[iSys] = anAttribute->GetValue();
1158
1159                 anAttribute = anEntry->GetAttribute("dbPort"); // MAY
1160                 if (anAttribute)
1161                 {
1162                         fFXSdbPort[iSys] = ((TString) anAttribute->GetValue()).Atoi();
1163                 } else {
1164                         fFXSdbPort[iSys] = 3306; // mysql
1165                 }
1166
1167                 anAttribute = anEntry->GetAttribute("dbUser");
1168                 if (!anAttribute) {
1169                         AliError(Form ("Can't find dbUser attribute for %s!!",
1170                                                 AliShuttleInterface::GetSystemName(iSys)));
1171                         return 5;
1172                 }
1173                 fFXSdbUser[iSys] = anAttribute->GetValue();
1174
1175                 anAttribute = anEntry->GetAttribute("dbPasswd");
1176                 if (!anAttribute) {
1177                         AliError(Form ("Can't find dbPasswd attribute for %s!!",
1178                                                 AliShuttleInterface::GetSystemName(iSys)));
1179                         return 5;
1180                 }
1181                 fFXSdbPass[iSys] = anAttribute->GetValue();
1182
1183                 anAttribute = anEntry->GetAttribute("dbName");
1184                 if (!anAttribute) {
1185                         AliError(Form ("Can't find dbName attribute for %s!!",
1186                                                 AliShuttleInterface::GetSystemName(iSys)));
1187                         return 5;
1188                 }
1189
1190                 fFXSdbName[iSys] = anAttribute->GetValue();
1191                 anAttribute = anEntry->GetAttribute("dbTable");
1192                 if (!anAttribute) {
1193                         AliError(Form ("Can't find dbTable attribute for %s!!",
1194                                                 AliShuttleInterface::GetSystemName(iSys)));
1195                         return 5;
1196                 }
1197                 fFXSdbTable[iSys] = anAttribute->GetValue();
1198
1199                 anAttribute = anEntry->GetAttribute("fxsHost");
1200                 if (!anAttribute) {
1201                         AliError(Form ("Can't find fxsHost attribute for %s!!",
1202                                                 AliShuttleInterface::GetSystemName(iSys)));
1203                         return 5;
1204                 }
1205                 fFXSHost[iSys] = anAttribute->GetValue();
1206
1207                 anAttribute = anEntry->GetAttribute("fxsPort"); // MAY
1208                 if (anAttribute)
1209                 {
1210                         fFXSPort[iSys] = ((TString) anAttribute->GetValue()).Atoi();
1211                 } else {
1212                         fFXSPort[iSys] = 22; // scp port number
1213                 }
1214
1215                 anAttribute = anEntry->GetAttribute("fxsUser");
1216                 if (!anAttribute) {
1217                         AliError(Form ("Can't find fxsUser attribute for %s!!",
1218                                                 AliShuttleInterface::GetSystemName(iSys)));
1219                         return 5;
1220                 }
1221                 fFXSUser[iSys] = anAttribute->GetValue();
1222
1223                 anAttribute = anEntry->GetAttribute("fxsPasswd");
1224                 if (anAttribute) fFXSPass[iSys] = anAttribute->GetValue();
1225         
1226                 anAttribute = anEntry->GetAttribute("fxsAdmin"); // MAY
1227                 if (!anAttribute)
1228                 {
1229                         AliDebug(2, "Warning! No \"fxsAdmin\" attribute!");
1230                 }
1231                 else
1232                 {
1233                         const char* anAdmin;
1234                         while ((anAdmin = anAttribute->GetValue()))
1235                         {
1236                                 fAdmin[iSys]->AddLast(new TObjString(anAdmin));
1237                         }
1238                 }
1239         
1240         }
1241         
1242         if(count != 111) {
1243                 AliError(Form("Wrong system configuration! (code = %d)", count));
1244                 return 6;
1245         }
1246         
1247         return 0;
1248 }
1249
1250 //______________________________________________________________________________________________
1251 UInt_t AliShuttleConfig::SetDetConfig(TList* detList, TList* dcsList)
1252 {
1253         // Set the detector configuration (general settings + DCS amanda server and alias/DP lists)
1254
1255         TLDAPEntry* anEntry = 0;
1256         
1257         TIter iter(detList);
1258         while ((anEntry = dynamic_cast<TLDAPEntry*> (iter.Next())))
1259         {
1260                 
1261                 AliShuttleDetConfigHolder* detHolder = new AliShuttleDetConfigHolder(anEntry);
1262
1263                 if (!detHolder->IsValid()) {
1264                         AliError("Detector configuration error!");
1265                         delete detHolder;
1266                         return 7;
1267                 }
1268
1269                 TObjString* detStr = new TObjString(detHolder->GetDetector());
1270                 
1271                 // Look for DCS Configuration
1272                 TIter dcsIter(dcsList);
1273                 TLDAPEntry *dcsEntry = 0;
1274                 while ((dcsEntry = dynamic_cast<TLDAPEntry*> (dcsIter.Next())))
1275                 {
1276                         TString dn = dcsEntry->GetDn();
1277                         if(dn.Contains(detStr->GetName())) {
1278                                 AliDebug(2, Form("Found DCS configuration: dn = %s",dn.Data()));
1279                                 AliShuttleDCSConfigHolder* dcsHolder = new AliShuttleDCSConfigHolder(dcsEntry);
1280                                 if (!dcsHolder->IsValid()) {
1281                                         AliError("DCS configuration error!");
1282                                         delete detHolder;
1283                                         delete dcsHolder;
1284                                         return 7;
1285                                 }
1286                                 detHolder->AddDCSConfig(dcsHolder);
1287                         }
1288                 }
1289                 
1290                 
1291                 fDetectorMap.Add(detStr, detHolder);
1292                 fDetectorList.AddLast(detStr);
1293         }
1294         
1295         return 0;
1296 }
1297
1298 //______________________________________________________________________________________________
1299 UInt_t AliShuttleConfig::SetHostConfig(TList* list)
1300 {
1301         // Set the Shuttle machines configuration (which detectors processes each machine)
1302         
1303         TLDAPEntry* anEntry = 0;
1304         TLDAPAttribute* anAttribute = 0;
1305         
1306         fShuttleInstanceHost = gSystem->HostName();
1307         
1308         TIter iter(list);
1309         while ((anEntry = dynamic_cast<TLDAPEntry*> (iter.Next())))
1310         {
1311         
1312                 TString dn(anEntry->GetDn());
1313                 if (!dn.Contains(Form("shuttleHost=%s", fShuttleInstanceHost.Data()))) continue;
1314                 
1315                 if (!fProcessAll)
1316                 {
1317                         anAttribute = anEntry->GetAttribute("detectors");
1318                         const char *detName;
1319                         while((detName = anAttribute->GetValue())){
1320                                 TObjString *objDet= new TObjString(detName);
1321                                 fProcessedDetectors.Add(objDet);
1322                         }
1323                 }
1324         }       
1325         
1326         return 0;
1327 }
1328
1329
1330 //______________________________________________________________________________________________
1331 void AliShuttleConfig::Print(Option_t* option) const
1332 {
1333 // print configuration
1334 // options : "": print configuration for all detectors, aliases and DPs in compacted format
1335 //           "uncompact": print configuration for all detectors, aliases and DPs in uncompacted format
1336 //           "DET": print configuration for DET, aliases and DPs in compacted format
1337 //           "DET, uncompact": print configuration for DET, aliases and DPs in uncompacted format
1338
1339         TString result;
1340         result += '\n';
1341         
1342         TString mode = "test";
1343         if (fRunMode == kProd) mode = "production";
1344
1345         result += "########################################################################\n";
1346         result += Form(" Shuttle configuration from %s - Run Mode: <%s> \n", 
1347                                         fConfigHost.Data(), mode.Data());
1348         result += "########################################################################\n";
1349         result += Form("\nShuttle running on %s \n", fShuttleInstanceHost.Data());
1350
1351         if(fProcessAll) {
1352                 result += Form("All detectors will be processed! \n");
1353         } else {
1354                 result += "Detectors processed by this host: ";
1355                 TIter it(&fProcessedDetectors);
1356                 TObjString* aDet;
1357                 while ((aDet = (TObjString*) it.Next())) {
1358                         result += Form("%s ", aDet->String().Data());
1359                 }
1360                 result += "\n";
1361         }
1362
1363         result += Form("PP time out = %d - max PP mem size = %d KB - max retries = %d "
1364                        "- DIM trigger waiting timeout = %d\n", 
1365                                 fPPTimeOut, fPPMaxMem, fMaxRetries, fTriggerWait);
1366         result += Form("FLAGS: keepDCSMap = %d - keepTempFolder = %d - SendMail = %d \n", 
1367                                 fKeepDCSMap, fKeepTempFolder, fSendMail);
1368         const TObjArray* shuttleAdmins = GetAdmins(kGlobal);
1369         if (shuttleAdmins->GetEntries() != 0)
1370         {
1371                 result += "SHUTTLE administrator(s): ";
1372                 TIter it(shuttleAdmins);
1373                 TObjString* anAdmin;
1374                 while ((anAdmin = (TObjString*) it.Next()))
1375                 {
1376                         result += Form("%s ", anAdmin->String().Data());
1377                 }
1378                 result += "\n";
1379         }
1380         const TObjArray* amandaAdmins = GetAdmins(kAmanda);
1381         if (amandaAdmins->GetEntries() != 0)
1382         {
1383                 result += "Amanda server administrator(s): ";
1384                 TIter it(amandaAdmins);
1385                 TObjString* anAdmin;
1386                 while ((anAdmin = (TObjString*) it.Next()))
1387                 {
1388                         result += Form("%s ", anAdmin->String().Data());
1389                 }
1390                 result += "\n\n";
1391         }
1392         result += "------------------------------------------------------\n";
1393
1394         result += Form("Logbook Configuration \n\n \tHost: %s:%d; \tUser: %s; ",
1395                 fDAQlbHost.Data(), fDAQlbPort, fDAQlbUser.Data());
1396
1397 //      result += "Password: ";
1398 //      result.Append('*', fDAQlbPass.Length());
1399         result += Form("\tDB: %s; \tTables: %s, %s, %s\n",
1400                 fDAQlbDB.Data(), fDAQlbTable.Data(), fShuttlelbTable.Data(), fRunTypelbTable.Data());
1401
1402         result += "\n\n";
1403         
1404         result += "------------------------------------------------------\n";
1405         result += "FXS configuration\n\n";
1406
1407         for(int iSys=0;iSys<3;iSys++){
1408                 result += Form("*** %s ***\n", AliShuttleInterface::GetSystemName(iSys));
1409                 result += Form("\tDB  host: %s:%d; \tUser: %s; \tName: %s; \tTable: %s\n",
1410                                                 fFXSdbHost[iSys].Data(), fFXSdbPort[iSys], fFXSdbUser[iSys].Data(),
1411                                                 fFXSdbName[iSys].Data(), fFXSdbTable[iSys].Data());
1412                 // result += Form("DB Password:",fFXSdbPass[iSys].Data());
1413                 result += Form("\tFXS host: %s:%d; \tUser: %s\n", fFXSHost[iSys].Data(), fFXSPort[iSys],
1414                                                 fFXSUser[iSys].Data());
1415                 // result += Form("FXS Password:",fFXSPass[iSys].Data());
1416                 const TObjArray* fxsAdmins = GetAdmins(iSys);
1417                 if (fxsAdmins->GetEntries() != 0)
1418                 {
1419                         result += "\tAdministrator(s): ";
1420                         TIter it(fxsAdmins);
1421                         TObjString* anAdmin;
1422                         while ((anAdmin = (TObjString*) it.Next()))
1423                         {
1424                                 result += Form("%s ", anAdmin->String().Data());
1425                         }
1426                         result += "\n\n";
1427                 }
1428         }
1429
1430         result += "------------------------------------------------------\n";
1431         result += "MonaLisa configuration\n\n";
1432         
1433         result += Form("\tHost: %s; \tTable name: %s",
1434                 fMonitorHost.Data(), fMonitorTable.Data());
1435                 
1436         result += "\n\n";
1437                 
1438         TString optStr(option);
1439
1440         result += "------------------------------------------------------\n";
1441         result += "Detector-specific configuration\n\n";
1442         
1443         TIter iter(fDetectorMap.GetTable());
1444         TPair* aPair = 0;
1445         
1446         while ((aPair = (TPair*) iter.Next())) {
1447                 AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) aPair->Value();
1448                 if (optStr != "" && !optStr.Contains(aHolder->GetDetector()) && 
1449                                 optStr.CompareTo("uncompact",TString::kIgnoreCase) != 0 )
1450                                 continue;
1451                 
1452                 result += Form("*** %s *** \n", aHolder->GetDetector());
1453
1454                 const TObjArray* responsibles = aHolder->GetResponsibles();
1455                 if (responsibles->GetEntries() != 0)
1456                 {
1457                         result += "\tDetector responsible(s): ";
1458                         TIter it(responsibles);
1459                         TObjString* aResponsible;
1460                         while ((aResponsible = (TObjString*) it.Next()))
1461                         {
1462                                 result += Form("%s ", aResponsible->String().Data());
1463                         }
1464                         result += "\n";
1465                 }
1466
1467                 result += Form("\tStrict run ordering: %s \n\n", aHolder->StrictRunOrder() ? "YES" : "NO");
1468                 
1469                 const TObjArray* dcsConfig = aHolder->GetDCSConfig();
1470                 
1471                 AliShuttleDCSConfigHolder* dcsHolder = 0;
1472                 TIter dcsIter(dcsConfig);
1473                 Int_t count=0;
1474                 while ((dcsHolder = dynamic_cast<AliShuttleDCSConfigHolder*> (dcsIter.Next())))
1475                 {
1476                         result += Form("\tAmanda server [%d]: %s:%d - MultiSplit = %d\n", count,
1477                                 dcsHolder->GetDCSHost(), dcsHolder->GetDCSPort(), dcsHolder->GetMultiSplit());
1478
1479                         const TObjArray* aliases = 0;
1480                         if (optStr.Contains("uncompact",TString::kIgnoreCase))
1481                         {
1482                                 aliases = dcsHolder->GetDCSAliases();
1483                         } else {
1484                                 aliases = dcsHolder->GetCompactDCSAliases();
1485                         }
1486
1487                         if (aliases->GetEntries() != 0)
1488                         {
1489                                 result += Form("\tDCS Aliases [%d]: ", count);
1490                                 TIter it(aliases);
1491                                 TObjString* anAlias;
1492                                 while ((anAlias = (TObjString*) it.Next()))
1493                                 {
1494                                         result += Form("%s ", anAlias->String().Data());
1495                                 }
1496                                 result += "\n";
1497                         }
1498
1499                         const TObjArray* dataPoints = 0;
1500                         if (optStr.Contains("uncompact",TString::kIgnoreCase))
1501                         {
1502                                 dataPoints = dcsHolder->GetDCSDataPoints();
1503                         } else {
1504                                 dataPoints = dcsHolder->GetCompactDCSDataPoints();
1505                         }
1506                         if (dataPoints->GetEntries() != 0)
1507                         {
1508                                 result += Form("\tDCS Data Points [%d]: ", count);
1509                                 TIter it(dataPoints);
1510                                 TObjString* aDataPoint;
1511                                 while ((aDataPoint = (TObjString*) it.Next())) {
1512                                         result += Form("%s ", aDataPoint->String().Data());
1513                                 }
1514                                 result += "\n";
1515                         }
1516                         count++;
1517                         result += "\n";
1518                 }
1519         }
1520         if(!fIsValid) result += "\n\n********** !!!!! Configuration is INVALID !!!!! **********\n";
1521
1522         AliInfo(result);
1523 }