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