coding conventions (Alberto)
[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.3  2006/06/06 14:26:40  jgrosseo
19 o) removed files that were moved to STEER
20 o) shuttle updated to follow the new interface (Alberto)
21
22 Revision 1.7  2006/05/12 09:07:16  colla
23 12/05/06
24 New configuration complete
25
26 Revision 1.2  2006/03/07 07:52:34  hristov
27 New version (B.Yordanov)
28
29 Revision 1.4  2005/11/19 14:20:31  byordano
30 logbook config added to AliShuttleConfig
31
32 Revision 1.3  2005/11/17 19:24:25  byordano
33 TList changed to TObjArray in AliShuttleConfig
34
35 Revision 1.2  2005/11/17 14:43:23  byordano
36 import to local CVS
37
38 Revision 1.1.1.1  2005/10/28 07:33:58  hristov
39 Initial import as subdirectory in AliRoot
40
41 Revision 1.1.1.1  2005/09/12 22:11:40  byordano
42 SHUTTLE package
43
44 Revision 1.3  2005/08/30 09:13:02  byordano
45 some docs added
46
47 */
48
49
50 //
51 // This class keeps the AliShuttle configuration.
52 // It reads the configuration for LDAP server.
53 // For every child entry in basedn which has schema type 'shuttleConfig'
54 // it creates a detector configuration. This configuration includes:
55 // DCS server host and port and the set of aliases for which data from
56 // will be retrieved (used by AliShuttle).
57 //
58
59
60 #include "AliShuttleConfig.h"
61
62 #include "AliLog.h"
63
64 #include <TSystem.h>
65 #include <TObjString.h>
66 #include <TLDAPResult.h>
67 #include <TLDAPEntry.h>
68 #include <TLDAPAttribute.h>
69
70 AliShuttleConfig::AliShuttleConfigHolder::AliShuttleConfigHolder(const TLDAPEntry* entry):
71         fIsValid(kFALSE)
72 {
73 // constructor of the shuttle configuration holder
74
75         TLDAPAttribute* anAttribute;
76         
77         anAttribute = entry->GetAttribute("det");
78         if (!anAttribute) {
79                 AliError("Invalid configuration! Can't get detector name.");
80                 return;
81         }
82         fDetector = anAttribute->GetValue();
83         if (!fDetector.Length()) {
84                 AliError("Detector name can't be an empty string!")
85                 return;
86         }
87
88         anAttribute = entry->GetAttribute("DCSHost");
89         if (!anAttribute) {
90                 AliError("Invalid configuration! Can't get DCSHost.");
91                 return;
92         }
93         fDCSHost = anAttribute->GetValue();
94         if (!fDCSHost.Length()) {
95                 AliError("Host can't be an empty string!")
96                 return;
97         }
98
99         anAttribute = entry->GetAttribute("DCSPort");
100         if (!anAttribute) {
101                 AliError("Invalid configuration! Can't get DCSPort.");
102                 return;
103         }
104         TString portStr = anAttribute->GetValue();
105         if (!portStr.Length()) {
106                 AliError("port can't be an empty string!")
107                 return;
108         }
109         fDCSPort = portStr.Atoi();
110
111         anAttribute = entry->GetAttribute("DCSAlias");
112         if (!anAttribute) {
113                 AliError("Invalid configuration! Can't get alias attribute.");
114                 return;
115         }
116         const char* anAlias;
117         while ((anAlias = anAttribute->GetValue())) {
118                 fDCSAliases.AddLast(new TObjString(anAlias));
119         }
120
121         anAttribute = entry->GetAttribute("DAQFileIDs");
122         if (!anAttribute) {
123                 AliError("Invalid configuration! Can't get DAQFileIDs attribute.");
124                 return;
125         }
126         const char* aFileID;
127         while ((aFileID = anAttribute->GetValue())) {
128                 fDAQFileIDs.AddLast(new TObjString(aFileID));
129         }
130                 
131         fIsValid = kTRUE;
132 }
133
134 AliShuttleConfig::AliShuttleConfigHolder::~AliShuttleConfigHolder() 
135 {
136 // destructor of the shuttle configuration holder
137
138         fDCSAliases.Delete();
139 }
140
141 ClassImp(AliShuttleConfig)
142
143 AliShuttleConfig::AliShuttleConfig(const char* host, Int_t port, 
144         const char* binddn, const char* password, const char* basedn):
145         fIsValid(kFALSE),
146         fProcessAll(kFALSE)
147 {
148         //
149         // host: ldap server host
150         // port: ldap server port
151         // binddn: binddn used for ldap binding (simple bind is used!).
152         // password: password for binddn
153         // basedn: this is basedn whose childeren entries which have
154         // (objectClass=shuttleConfig) will be used as detector configurations.
155         //
156
157         TLDAPServer aServer(host, port, binddn, password, 3);
158         
159         if (!aServer.IsConnected()) {
160                 AliError(Form("Can't connect to ldap server %s:%d", 
161                                 host, port));
162                 return;
163         }
164
165         // reads configuration for the shuttle running on this machine
166         
167         fShuttleInstanceHost = gSystem->HostName();
168         TString queryFilter = "(ShuttleHost=";
169         queryFilter += fShuttleInstanceHost;
170         queryFilter += ")";     
171         
172         TLDAPResult* aResult = aServer.Search(basedn, LDAP_SCOPE_ONELEVEL,
173                         queryFilter.Data());
174
175         if (!aResult) {
176                 AliError(Form("Can't find configuration with base DN: %s",
177                                 basedn));
178                 return;
179         }
180
181         if (aResult->GetCount() == 0) {
182                 AliError(Form("No Shuttle instance for host = %s!",fShuttleInstanceHost.Data()));
183                 AliError(Form("All detectors will be processed."));
184                 fProcessAll=kTRUE;
185         }
186
187         if (aResult->GetCount() > 1) {
188                 AliError(Form("More than one Shuttle instance for host %s!",fShuttleInstanceHost.Data()));
189                 return;
190         }
191         
192         TLDAPEntry* anEntry;
193         TLDAPAttribute* anAttribute;
194
195         if(!fProcessAll){
196                 anEntry = aResult->GetNext();
197                 anAttribute = anEntry->GetAttribute("detectors");
198                 const char *detName;
199                 while((detName = anAttribute->GetValue())){
200                         TObjString *objDet= new TObjString(detName);
201                         fProcessedDetectors.Add(objDet);
202                 }
203         }
204
205         aResult = aServer.Search(basedn, LDAP_SCOPE_ONELEVEL,
206                         "(objectClass=AliShuttleDetector)");
207         if (!aResult) {
208                 AliError(Form("Can't find configuration with base DN: %s",
209                                 basedn));
210                 return;
211         }
212
213         while ((anEntry = aResult->GetNext())) {
214                 AliShuttleConfigHolder* aHolder = new AliShuttleConfigHolder(anEntry);
215                 delete anEntry;
216
217                 if (!aHolder->IsValid()) {
218                         AliError("This entry is going to be skipped!");
219                         delete aHolder;
220
221                         continue;
222                 }
223
224                 TObjString* detStr = new TObjString(aHolder->GetDetector());
225                 fDetectorMap.Add(detStr, aHolder);
226                 fDetectorList.AddLast(detStr);
227         }       
228         
229         delete aResult;
230
231
232         aResult = aServer.Search(basedn, LDAP_SCOPE_ONELEVEL,
233                         "(objectClass=AliShuttleGlobalConfig)");
234         if (!aResult) {
235                 AliError(Form("Can't find configuration with base DN: %s",
236                                 basedn));
237                 return;
238         }
239
240         if (aResult->GetCount() == 0) {
241                 AliError("Can't find DAQ logbook configuration!");
242                 return;
243         }
244
245         if (aResult->GetCount() > 1) {
246                 AliError("More than one DAQ logbook configuration found!");
247                 return;
248         }
249
250         anEntry = aResult->GetNext();
251         
252         anAttribute = anEntry->GetAttribute("DAQLogbookHost");
253         if (!anAttribute) {
254                 AliError("Can't find DAQLogbookHost attribute!");
255                 return;
256         }
257         fDAQLogBookHost = anAttribute->GetValue();
258
259         anAttribute = anEntry->GetAttribute("DAQLogbookUser");
260         if (!anAttribute) {
261                 AliError("Can't find DAQLogbookUser attribute!");
262                 return;
263         }
264         fDAQLogBookUser = anAttribute->GetValue();
265         
266         anAttribute = anEntry->GetAttribute("DAQLogbookPassword");
267         if (!anAttribute) {
268                 AliError("Can't find DAQLogbookPassword attribute!");
269                 return;
270         }
271         fDAQLogBookPassword = anAttribute->GetValue();
272
273         anAttribute = anEntry->GetAttribute("DAQFileSystemHost");
274         if (!anAttribute) {
275                 AliError("Can't find DAQFileSystemHost attribute!");
276                 return;
277         }
278         fDAQFSHost = anAttribute->GetValue();
279
280         delete anEntry;
281         delete aResult;
282         
283         fIsValid = kTRUE;
284 }
285
286 AliShuttleConfig::~AliShuttleConfig() 
287 {
288 // destructor
289
290         fDetectorMap.DeleteAll();
291 }
292
293 const TObjArray* AliShuttleConfig::GetDetectors() const 
294 {
295         //
296         // returns collection of TObjString which contains the name
297         // of every detector which is in the configuration.
298         //
299
300         return &fDetectorList;
301 }
302
303 Bool_t AliShuttleConfig::HasDetector(const char* detector) const 
304 {
305         //
306         // checks for paricular detector in the configuration.
307         //
308         return fDetectorMap.GetValue(detector) != NULL;
309 }
310
311 const char* AliShuttleConfig::GetDCSHost(const char* detector) const 
312 {
313         //
314         // returns DCS server host used by particular detector
315         //
316         
317         AliShuttleConfigHolder* aHolder = (AliShuttleConfigHolder*) fDetectorMap.GetValue(detector);
318         if (!aHolder) {
319                 AliError(Form("There isn't configuration for detector: %s",
320                         detector));
321                 return NULL;
322         }
323
324         return aHolder->GetDCSHost();
325 }
326
327 Int_t AliShuttleConfig::GetDCSPort(const char* detector) const 
328 {
329         //
330         // returns DCS server port used by particular detector
331         //
332
333
334         AliShuttleConfigHolder* aHolder = (AliShuttleConfigHolder*) fDetectorMap.GetValue(detector);
335         if (!aHolder) {
336                 AliError(Form("There isn't configuration for detector: %s",
337                         detector));
338                 return 0;
339         }
340
341         return aHolder->GetDCSPort();
342 }
343
344 const TObjArray* AliShuttleConfig::GetDCSAliases(const char* detector) const 
345 {
346         //
347         // returns collection of TObjString which represents the set of aliases
348         // which used for data retrieval for particular detector
349         //
350
351         AliShuttleConfigHolder* aHolder = (AliShuttleConfigHolder*) fDetectorMap.GetValue(detector);
352         if (!aHolder) {
353                 AliError(Form("There isn't configuration for detector: %s",
354                         detector));
355                 return NULL;
356         }
357
358         return aHolder->GetDCSAliases();
359 }
360
361 const TObjArray* AliShuttleConfig::GetDAQFileIDs(const char* detector) const 
362 {
363         //
364         // returns collection of TObjString which represents the set of DAQ file IDs
365         // which used for data retrieval for particular detector
366         //
367
368         AliShuttleConfigHolder* aHolder = (AliShuttleConfigHolder*) fDetectorMap.GetValue(detector);
369         if (!aHolder) {
370                 AliError(Form("There isn't configuration for detector: %s",
371                         detector));
372                 return NULL;
373         }
374
375         return aHolder->GetDAQFileIDs();
376 }
377
378 Bool_t AliShuttleConfig::HostProcessDetector(const char* detector) const 
379 {
380         // return TRUE if detector is handled by host or if fProcessAll is TRUE
381
382         if(fProcessAll) return kTRUE;
383         TIter iter(&fProcessedDetectors);
384         TObjString* detName;
385         while((detName = (TObjString*) iter.Next())){
386                 if(detName->String() == detector) return kTRUE;
387         }
388         return kFALSE;
389 }
390
391 void AliShuttleConfig::Print(Option_t* /*option*/) const 
392 {
393 // print configuration
394         
395         TString result;
396         result += '\n';
397
398         result += "Shuttle running on host: ";
399         result += fShuttleInstanceHost;
400         result += '\n';
401         result += "Detectors handled by this host: ";
402         TIter it(&fProcessedDetectors);
403         TObjString* aDet;
404         while ((aDet = (TObjString*) it.Next())) {
405                 result += aDet->String();
406                 result += ' ';
407         }
408         result += '\n';
409         if(fProcessAll) result += "ProcessAll is ON";
410
411         result += '\n';
412         result += '\n';
413
414         result += "DAQ LogBook Host: ";
415         result += fDAQLogBookHost;
416         result += '\n';
417         result += "DAQ LogBook User: ";
418         result += fDAQLogBookUser;
419         result += '\n';
420         result += "DAQ LogBook Password: ";
421         result.Append('*', fDAQLogBookPassword.Length());
422         result += '\n';
423         result += '\n';
424         result += "DAQ File System Host: ";
425         result += fDAQFSHost;
426         result += '\n';
427
428         TIter iter(fDetectorMap.GetTable());
429         TPair* aPair;
430         while ((aPair = (TPair*) iter.Next())) {
431                 AliShuttleConfigHolder* aHolder = (AliShuttleConfigHolder*) aPair->Value();
432                 result += '\n';
433                 result += " Detector: ";
434                 result += aHolder->GetDetector();
435                 result += '\n'; 
436                 result += " DCS Host: ";
437                 result += aHolder->GetDCSHost();
438                 result += '\n';
439                 result += " DCS Port: ";
440                 result += aHolder->GetDCSPort();
441                 result += '\n';
442
443                 result += " DCS Aliases: ";
444                 const TObjArray* aliases = aHolder->GetDCSAliases();    
445                 TIter it(aliases);
446                 TObjString* anAlias;    
447                 while ((anAlias = (TObjString*) it.Next())) {
448                         result += anAlias->String();
449                         result += ' ';
450                 }       
451                 
452                 result += '\n';
453
454                 result += " DAQ File IDs: ";
455                 const TObjArray* fileIDs = aHolder->GetDAQFileIDs();    
456                 TIter it2(fileIDs);             
457                 TObjString* aFileID;    
458                 while ((aFileID = (TObjString*) it2.Next())) {
459                         result += aFileID->String();
460                         result += ' ';
461                 }       
462                 result += '\n';
463         }
464
465         AliInfo(result);
466 }