Fix for bug #78633 (Diego)
[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 #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<5; 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)
864         //
865
866         if (sys < 0 || sys > 4) 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)
1189
1190
1191         TLDAPEntry* anEntry = 0;
1192         TLDAPAttribute* anAttribute = 0;
1193         
1194         if (list->GetEntries() != 3) 
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                 
1225                 anAttribute = anEntry->GetAttribute("dbHost");
1226                 if (!anAttribute) {
1227                         AliError(Form ("Can't find dbHost attribute for %s!!",
1228                                                 AliShuttleInterface::GetSystemName(iSys)));
1229                         return 5;
1230                 }
1231                 fFXSdbHost[iSys] = anAttribute->GetValue();
1232
1233                 anAttribute = anEntry->GetAttribute("dbPort"); // MAY
1234                 if (anAttribute)
1235                 {
1236                         fFXSdbPort[iSys] = ((TString) anAttribute->GetValue()).Atoi();
1237                 } else {
1238                         fFXSdbPort[iSys] = 3306; // mysql
1239                 }
1240
1241                 anAttribute = anEntry->GetAttribute("dbUser");
1242                 if (!anAttribute) {
1243                         AliError(Form ("Can't find dbUser attribute for %s!!",
1244                                                 AliShuttleInterface::GetSystemName(iSys)));
1245                         return 5;
1246                 }
1247                 fFXSdbUser[iSys] = anAttribute->GetValue();
1248
1249                 anAttribute = anEntry->GetAttribute("dbName");
1250                 if (!anAttribute) {
1251                         AliError(Form ("Can't find dbName attribute for %s!!",
1252                                                 AliShuttleInterface::GetSystemName(iSys)));
1253                         return 5;
1254                 }
1255
1256                 fFXSdbName[iSys] = anAttribute->GetValue();
1257                 anAttribute = anEntry->GetAttribute("dbTable");
1258                 if (!anAttribute) {
1259                         AliError(Form ("Can't find dbTable attribute for %s!!",
1260                                                 AliShuttleInterface::GetSystemName(iSys)));
1261                         return 5;
1262                 }
1263                 fFXSdbTable[iSys] = anAttribute->GetValue();
1264
1265                 anAttribute = anEntry->GetAttribute("fxsHost");
1266                 if (!anAttribute) {
1267                         AliError(Form ("Can't find fxsHost attribute for %s!!",
1268                                                 AliShuttleInterface::GetSystemName(iSys)));
1269                         return 5;
1270                 }
1271                 fFXSHost[iSys] = anAttribute->GetValue();
1272
1273                 anAttribute = anEntry->GetAttribute("fxsPort"); // MAY
1274                 if (anAttribute)
1275                 {
1276                         fFXSPort[iSys] = ((TString) anAttribute->GetValue()).Atoi();
1277                 } else {
1278                         fFXSPort[iSys] = 22; // scp port number
1279                 }
1280
1281                 anAttribute = anEntry->GetAttribute("fxsUser");
1282                 if (!anAttribute) {
1283                         AliError(Form ("Can't find fxsUser attribute for %s!!",
1284                                                 AliShuttleInterface::GetSystemName(iSys)));
1285                         return 5;
1286                 }
1287                 fFXSUser[iSys] = anAttribute->GetValue();
1288
1289                 anAttribute = anEntry->GetAttribute("fxsPasswd");
1290                 if (anAttribute) fFXSPass[iSys] = anAttribute->GetValue();
1291
1292                 anAttribute = anEntry->GetAttribute("fxsBaseFolder");
1293                 if (anAttribute) fFXSBaseFolder[iSys] = anAttribute->GetValue();
1294         
1295                 anAttribute = anEntry->GetAttribute("fxsAdmin"); // MAY
1296                 if (!anAttribute)
1297                 {
1298                         AliDebug(2, "Warning! No \"fxsAdmin\" attribute!");
1299                 }
1300                 else
1301                 {
1302                         const char* anAdmin;
1303                         while ((anAdmin = anAttribute->GetValue()))
1304                         {
1305                                 fAdmin[iSys]->AddLast(new TObjString(anAdmin));
1306                         }
1307                 }
1308         
1309         }
1310         
1311         if(count != 111) {
1312                 AliError(Form("Wrong system configuration! (code = %d)", count));
1313                 return 6;
1314         }
1315         
1316         return 0;
1317 }
1318
1319 //______________________________________________________________________________________________
1320 UInt_t AliShuttleConfig::SetPasswords(){
1321         
1322         AliInfo("Setting Passwords");
1323
1324         // Retrieving Passwords for DAQ lb, DAQ/DCS/HLT FXS
1325
1326         ifstream *inputfile = new ifstream(fPasswdFilePath.Data());
1327         if (!*inputfile) {
1328                 AliError(Form("Error opening file %s !", fPasswdFilePath.Data()));
1329                 inputfile->close();
1330                 delete inputfile;
1331                 return 1;
1332         }
1333
1334         TString line;
1335         Int_t nPwd=0;
1336         Int_t nPwdFake=0;
1337         while (line.ReadLine(*inputfile)) {
1338                 TObjArray *tokens = line.Tokenize(" \t");
1339                 TString system = ((TObjString *)tokens->At(0))->String(); 
1340                 TString password = ((TObjString *)tokens->At(1))->String();
1341                 if (system.Contains("DAQ_LB")){
1342                         fDAQlbPass=password;
1343                         nPwd++;
1344                         AliDebug(3,Form("DAQ_LB: Password %s for %s found", password.Data(), system.Data()));
1345                 }
1346                 else if (system.Contains("DAQ_DB")){
1347                         fFXSdbPass[0]=password;
1348                         nPwd++;
1349                         AliDebug(3,Form("DAQ_DB: Password %s for %s found", password.Data(), system.Data()));
1350                 }
1351                 else if (system.Contains("DCS_DB")){
1352                         fFXSdbPass[1]=password;
1353                         nPwd++;
1354                         AliDebug(3,Form("DCS_DB: Password %s for %s found", password.Data(), system.Data()));
1355                 }
1356                 else if (system.Contains("HLT_DB")){
1357                         fFXSdbPass[2]=password;
1358                         nPwd++;
1359                         AliDebug(3,Form("HLT_DB: Password %s for %s found", password.Data(), system.Data()));
1360                 }
1361                 else {
1362                         nPwdFake++;
1363                         AliDebug(3,Form("%i fake line(s) found in file %s", nPwdFake, fPasswdFilePath.Data()));
1364                         continue;
1365                 }
1366                 delete tokens;
1367         }
1368
1369         inputfile->close();
1370         delete inputfile;
1371
1372         if (nPwd!=4){
1373                 AliError(Form("Wrong file for DAQ Logbook password found %s (some passwors missing), please Check!", fPasswdFilePath.Data()));
1374                 return 2;
1375         }
1376
1377         return 0;
1378
1379 }
1380 //______________________________________________________________________________________________
1381 UInt_t AliShuttleConfig::SetDetConfig(TList* detList, TList* dcsList)
1382 {
1383         // Set the detector configuration (general settings + DCS amanda server and alias/DP lists)
1384
1385         TLDAPEntry* anEntry = 0;
1386         
1387         TIter iter(detList);
1388         while ((anEntry = dynamic_cast<TLDAPEntry*> (iter.Next())))
1389         {
1390                 
1391                 AliShuttleDetConfigHolder* detHolder = new AliShuttleDetConfigHolder(anEntry);
1392
1393                 if (!detHolder->IsValid()) {
1394                         AliError("Detector configuration error!");
1395                         delete detHolder;
1396                         return 7;
1397                 }
1398
1399                 TObjString* detStr = new TObjString(detHolder->GetDetector());
1400                 
1401                 // Look for DCS Configuration
1402                 TIter dcsIter(dcsList);
1403                 TLDAPEntry *dcsEntry = 0;
1404                 while ((dcsEntry = dynamic_cast<TLDAPEntry*> (dcsIter.Next())))
1405                 {
1406                         TString dn = dcsEntry->GetDn();
1407                         if(dn.Contains(detStr->GetName())) {
1408                                 AliDebug(2, Form("Found DCS configuration: dn = %s",dn.Data()));
1409                                 AliShuttleDCSConfigHolder* dcsHolder = new AliShuttleDCSConfigHolder(dcsEntry);
1410                                 if (!dcsHolder->IsValid()) {
1411                                         AliError("DCS configuration error!");
1412                                         delete detHolder;
1413                                         delete dcsHolder;
1414                                         return 7;
1415                                 }
1416                                 detHolder->AddDCSConfig(dcsHolder);
1417                         }
1418                 }
1419                 
1420                 
1421                 fDetectorMap.Add(detStr, detHolder);
1422                 fDetectorList.AddLast(detStr);
1423         }
1424         
1425         return 0;
1426 }
1427
1428 //______________________________________________________________________________________________
1429 UInt_t AliShuttleConfig::SetHostConfig(TList* list)
1430 {
1431         // Set the Shuttle machines configuration (which detectors processes each machine)
1432         
1433         TLDAPEntry* anEntry = 0;
1434         TLDAPAttribute* anAttribute = 0;
1435         
1436         fShuttleInstanceHost = gSystem->HostName();
1437         
1438         TIter iter(list);
1439         while ((anEntry = dynamic_cast<TLDAPEntry*> (iter.Next())))
1440         {
1441         
1442                 TString dn(anEntry->GetDn());
1443                 if (!dn.Contains(Form("shuttleHost=%s", fShuttleInstanceHost.Data()))) continue;
1444                 
1445                 if (!fProcessAll)
1446                 {
1447                         anAttribute = anEntry->GetAttribute("detectors");
1448                         const char *detName;
1449                         while((detName = anAttribute->GetValue())){
1450                                 TObjString *objDet= new TObjString(detName);
1451                                 fProcessedDetectors.Add(objDet);
1452                         }
1453                 }
1454         }       
1455         
1456         return 0;
1457 }
1458
1459
1460 //______________________________________________________________________________________________
1461 void AliShuttleConfig::Print(Option_t* option) const
1462 {
1463 // print configuration
1464 // options : "": print configuration for all detectors, aliases and DPs in compacted format
1465 //           "uncompact": print configuration for all detectors, aliases and DPs in uncompacted format
1466 //           "DET": print configuration for DET, aliases and DPs in compacted format
1467 //           "DET, uncompact": print configuration for DET, aliases and DPs in uncompacted format
1468
1469         TString result;
1470         result += '\n';
1471         
1472         TString mode = "test";
1473         if (fRunMode == kProd) mode = "production";
1474
1475         result += "########################################################################\n";
1476         result += Form(" Shuttle configuration from %s - Run Mode: <%s> \n", 
1477                                         fConfigHost.Data(), mode.Data());
1478         result += "########################################################################\n";
1479         result += Form("\nShuttle running on %s \n", fShuttleInstanceHost.Data());
1480
1481         if(fProcessAll) {
1482                 result += Form("All detectors will be processed! \n");
1483         } else {
1484                 result += "Detectors processed by this host: ";
1485                 TIter it(&fProcessedDetectors);
1486                 TObjString* aDet;
1487                 while ((aDet = (TObjString*) it.Next())) {
1488                         result += Form("%s ", aDet->String().Data());
1489                 }
1490                 result += "\n";
1491         }
1492
1493         result += Form("PP time out = %d - DCS time out = %d - max PP mem size = %d KB - max retries = %d "
1494                        "- DIM trigger waiting timeout = %d\n", 
1495                                 fPPTimeOut, fDCSTimeOut, fPPMaxMem, fMaxRetries, fTriggerWait);
1496         result += Form("FLAGS: keepDCSMap = %d - keepTempFolder = %d - SendMail = %d \n", 
1497                                 fKeepDCSMap, fKeepTempFolder, fSendMail);
1498         const TObjArray* shuttleAdmins = GetAdmins(kGlobal);
1499         if (shuttleAdmins->GetEntries() != 0)
1500         {
1501                 result += "SHUTTLE administrator(s): ";
1502                 TIter it(shuttleAdmins);
1503                 TObjString* anAdmin;
1504                 while ((anAdmin = (TObjString*) it.Next()))
1505                 {
1506                         result += Form("%s ", anAdmin->String().Data());
1507                 }
1508                 result += "\n";
1509         }
1510         const TObjArray* amandaAdmins = GetAdmins(kAmanda);
1511         if (amandaAdmins->GetEntries() != 0)
1512         {
1513                 result += "Amanda server administrator(s): ";
1514                 TIter it(amandaAdmins);
1515                 TObjString* anAdmin;
1516                 while ((anAdmin = (TObjString*) it.Next()))
1517                 {
1518                         result += Form("%s ", anAdmin->String().Data());
1519                 }
1520                 result += "\n\n";
1521         }
1522         result += "------------------------------------------------------\n";
1523
1524         result += Form("Logbook Configuration \n\n \tHost: %s:%d; \tUser: %s; ",
1525                 fDAQlbHost.Data(), fDAQlbPort, fDAQlbUser.Data());
1526
1527         result += Form("\tDB: %s; \tTables: %s, %s, %s\n",
1528                 fDAQlbDB.Data(), fDAQlbTable.Data(), fShuttlelbTable.Data(), fRunTypelbTable.Data());
1529
1530         result += Form("Terminate file path: %s\n", fTerminateFilePath.Data());
1531
1532         result += "\n\n";
1533         
1534         result += "------------------------------------------------------\n";
1535         result += "FXS configuration\n\n";
1536
1537         for(int iSys=0;iSys<3;iSys++){
1538                 result += Form("*** %s ***\n", AliShuttleInterface::GetSystemName(iSys));
1539                 result += Form("\tDB  host: %s:%d; \tUser: %s; \tName: %s; \tTable: %s\n",
1540                                                 fFXSdbHost[iSys].Data(), fFXSdbPort[iSys], fFXSdbUser[iSys].Data(),
1541                                                 fFXSdbName[iSys].Data(), fFXSdbTable[iSys].Data());
1542                 result += Form("\tFXS host: %s:%d; \tUser: %s\n", fFXSHost[iSys].Data(), fFXSPort[iSys],
1543                                                 fFXSUser[iSys].Data());
1544                 const TObjArray* fxsAdmins = GetAdmins(iSys);
1545                 if (fxsAdmins->GetEntries() != 0)
1546                 {
1547                         result += "\tAdministrator(s): ";
1548                         TIter it(fxsAdmins);
1549                         TObjString* anAdmin;
1550                         while ((anAdmin = (TObjString*) it.Next()))
1551                         {
1552                                 result += Form("%s ", anAdmin->String().Data());
1553                         }
1554                         result += "\n\n";
1555                 }
1556         }
1557
1558         result += "------------------------------------------------------\n";
1559         result += "MonaLisa configuration\n\n";
1560         
1561         result += Form("\tHost: %s; \tTable name: %s",
1562                 fMonitorHost.Data(), fMonitorTable.Data());
1563                 
1564         result += "\n\n";
1565                 
1566         TString optStr(option);
1567
1568         result += "------------------------------------------------------\n";
1569         result += "Detector-specific configuration\n\n";
1570         
1571         TIter iter(fDetectorMap.GetTable());
1572         TPair* aPair = 0;
1573         
1574         while ((aPair = (TPair*) iter.Next())) {
1575                 AliShuttleDetConfigHolder* aHolder = (AliShuttleDetConfigHolder*) aPair->Value();
1576                 if (optStr != "" && !optStr.Contains(aHolder->GetDetector()) && 
1577                                 optStr.CompareTo("uncompact",TString::kIgnoreCase) != 0 )
1578                                 continue;
1579                 
1580                 result += Form("*** %s *** \n", aHolder->GetDetector());
1581
1582                 const TObjArray* responsibles = aHolder->GetResponsibles();
1583                 if (responsibles->GetEntries() != 0)
1584                 {
1585                         result += "\tDetector responsible(s): ";
1586                         TIter it(responsibles);
1587                         TObjString* aResponsible;
1588                         while ((aResponsible = (TObjString*) it.Next()))
1589                         {
1590                                 result += Form("%s ", aResponsible->String().Data());
1591                         }
1592                         result += "\n";
1593                 }
1594
1595                 result += Form("\tStrict run ordering: %s \n\n", aHolder->StrictRunOrder() ? "YES" : "NO");
1596                 
1597                 const TObjArray* dcsConfig = aHolder->GetDCSConfig();
1598                 
1599                 AliShuttleDCSConfigHolder* dcsHolder = 0;
1600                 TIter dcsIter(dcsConfig);
1601                 Int_t count=0;
1602                 while ((dcsHolder = dynamic_cast<AliShuttleDCSConfigHolder*> (dcsIter.Next())))
1603                 {
1604                         result += Form("\tAmanda server [%d]: %s:%d - MultiSplit = %d\n", count,
1605                                 dcsHolder->GetDCSHost(), dcsHolder->GetDCSPort(), dcsHolder->GetMultiSplit());
1606
1607                         const TObjArray* aliases = 0;
1608                         if (optStr.Contains("uncompact",TString::kIgnoreCase))
1609                         {
1610                                 aliases = dcsHolder->GetDCSAliases();
1611                         } else {
1612                                 aliases = dcsHolder->GetCompactDCSAliases();
1613                         }
1614
1615                         if (aliases->GetEntries() != 0)
1616                         {
1617                                 result += Form("\tDCS Aliases [%d]: ", count);
1618                                 TIter it(aliases);
1619                                 TObjString* anAlias;
1620                                 while ((anAlias = (TObjString*) it.Next()))
1621                                 {
1622                                         result += Form("%s ", anAlias->String().Data());
1623                                 }
1624                                 result += "\n";
1625                         }
1626
1627                         const TObjArray* dataPoints = 0;
1628                         if (optStr.Contains("uncompact",TString::kIgnoreCase))
1629                         {
1630                                 dataPoints = dcsHolder->GetDCSDataPoints();
1631                         } else {
1632                                 dataPoints = dcsHolder->GetCompactDCSDataPoints();
1633                         }
1634                         if (dataPoints->GetEntries() != 0)
1635                         {
1636                                 result += Form("\tDCS Data Points [%d]: ", count);
1637                                 TIter it(dataPoints);
1638                                 TObjString* aDataPoint;
1639                                 while ((aDataPoint = (TObjString*) it.Next())) {
1640                                         result += Form("%s ", aDataPoint->String().Data());
1641                                 }
1642                                 result += "\n";
1643                         }
1644                         count++;
1645                         result += "\n";
1646                 }
1647         }
1648         if(!fIsValid) result += "\n\n********** !!!!! Configuration is INVALID !!!!! **********\n";
1649
1650         AliInfo(result);
1651 }