8bb84542fa46a8fccfbf3ac8920a2f6c1b6341d2
[u/mrichter/AliRoot.git] / STEER / AliCDBManager.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 //   Implementation of AliCDBManager and AliCDBParam classe
17 //   Author: Alberto Colla 
18 //   e-mail: Alberto.Colla@cern.ch
19 //-------------------------------------------------------------------------
20
21 #include "AliCDBManager.h"
22 #include "AliCDBStorage.h"
23 #include "AliLog.h"
24 #include "AliCDBDump.h"
25 #include "AliCDBLocal.h"
26 #include "AliCDBGrid.h"
27 #include "AliCDBEntry.h"
28 #include "AliCDBMetaData.h"
29
30 #include <TObjString.h>
31 #include <TSystem.h>
32
33 ClassImp(AliCDBParam)
34
35 ClassImp(AliCDBManager)
36
37 AliCDBManager* AliCDBManager::fgInstance = 0x0;
38
39 //_____________________________________________________________________________
40 AliCDBManager* AliCDBManager::Instance() {
41 // returns AliCDBManager instance (singleton)
42
43         if (!fgInstance) {
44                 fgInstance = new AliCDBManager();
45                 fgInstance->Init();
46         }
47
48         return fgInstance;
49 }
50
51 //_____________________________________________________________________________
52 void AliCDBManager::Init() {
53 // factory registering
54
55         RegisterFactory(new AliCDBDumpFactory());
56         RegisterFactory(new AliCDBLocalFactory()); 
57         // AliCDBGridFactory is registered only if AliEn libraries are enabled in Root
58         if(!gSystem->Exec("root-config --has-alien |grep yes 2>&1 > /dev/null")){ // returns 0 if yes
59                 AliInfo("AliEn classes enabled in Root. AliCDBGrid factory registered.");
60                 RegisterFactory(new AliCDBGridFactory());
61         }
62 }
63 //_____________________________________________________________________________
64 void AliCDBManager::Destroy() {
65 // delete ALCDBManager instance and active storages
66
67         if (fgInstance) {
68                 //fgInstance->Delete();
69                 delete fgInstance;
70                 fgInstance = 0x0;
71         }
72 }
73
74 //_____________________________________________________________________________
75 AliCDBManager::AliCDBManager():
76         fDefaultStorage(NULL),
77         fDrainStorage(NULL),
78         fCache(kTRUE),
79         fRun(0)
80 {
81 // default constuctor
82         fFactories.SetOwner(1);
83         fEntryCache.SetOwner(1);
84 }
85
86 //_____________________________________________________________________________
87 AliCDBManager::~AliCDBManager() {
88 // destructor
89         ClearCache();
90         DestroyActiveStorages();
91         fDrainStorage = 0x0;
92         fDefaultStorage = 0x0;
93 }
94
95 //_____________________________________________________________________________
96 AliCDBStorage* AliCDBManager::GetActiveStorage(const AliCDBParam* param) {
97 // get a storage object from the list of active storages 
98
99         return (AliCDBStorage*) fActiveStorages.GetValue(param);
100 }
101
102 //_____________________________________________________________________________
103 void AliCDBManager::PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage){
104 // put a storage object into the list of active storages
105
106         fActiveStorages.Add(param, storage);
107         AliDebug(1, Form("Active storages: %d", fActiveStorages.GetEntries()));
108 }
109
110 //_____________________________________________________________________________
111 void AliCDBManager::RegisterFactory(AliCDBStorageFactory* factory) {
112 // add a storage factory to the list of registerd factories
113  
114         if (!fFactories.Contains(factory)) {
115                 fFactories.Add(factory);
116         }
117 }
118
119 //_____________________________________________________________________________
120 Bool_t AliCDBManager::HasStorage(const char* dbString) const {
121 // check if dbString is a URI valid for one of the registered factories 
122
123         TIter iter(&fFactories);
124
125         AliCDBStorageFactory* factory;
126         while ((factory = (AliCDBStorageFactory*) iter.Next())) {
127
128                 if (factory->Validate(dbString)) {
129                         return kTRUE;
130                 }       
131         }
132
133         return kFALSE;
134 }
135
136 //_____________________________________________________________________________
137 AliCDBParam* AliCDBManager::CreateParameter(const char* dbString) const {
138 // create AliCDBParam object from URI string
139
140         TIter iter(&fFactories);
141
142         AliCDBStorageFactory* factory;
143         while ((factory = (AliCDBStorageFactory*) iter.Next())) {
144
145                 AliCDBParam* param = factory->CreateParameter(dbString);
146                 if (param) {
147                         return param;
148                 }
149         }
150
151         return NULL;
152 }
153
154 //_____________________________________________________________________________
155 AliCDBStorage* AliCDBManager::GetStorage(const char* dbString) {
156 // get storage object from URI string
157         
158         AliCDBParam* param = CreateParameter(dbString);
159         if (!param) {
160                 return NULL;
161         }       
162
163         AliCDBStorage* aStorage = GetStorage(param);
164
165         delete param;
166         
167         return aStorage;
168 }
169
170 //_____________________________________________________________________________
171 AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) {
172 // get storage object from AliCDBParam object
173
174         // if the list of active storages already contains 
175         // the requested storage, return it
176         AliCDBStorage* aStorage = GetActiveStorage(param);
177         if (aStorage) {
178                 return aStorage;
179         }
180
181         TIter iter(&fFactories);
182
183         AliCDBStorageFactory* factory;
184         
185         // loop on the list of registered factories
186         while ((factory = (AliCDBStorageFactory*) iter.Next())) {
187
188                 // each factory tries to create its storage from the parameter
189                 aStorage = factory->Create(param);
190                 if (aStorage) {
191                         PutActiveStorage(param->CloneParam(), aStorage);
192                         // if default storage is not set, set to this storage
193                         if(!fDefaultStorage){
194                                 fDefaultStorage=aStorage;
195                                 AliInfo(Form("Default storage set to: %s",(param->GetURI()).Data()));
196                         }
197                         return aStorage;
198                 }
199         }
200
201         return NULL;
202 }
203
204 //_____________________________________________________________________________
205 TList* AliCDBManager::GetActiveStorages() {
206 // return list of active storages
207
208         TList* result = new TList();
209
210         TIter iter(fActiveStorages.GetTable()); 
211         TPair* aPair;
212         while ((aPair = (TPair*) iter.Next())) {
213                 result->Add(aPair->Value());
214         }
215
216         return result;
217 }
218
219 //_____________________________________________________________________________
220 void AliCDBManager::SetDrain(const char* dbString) {
221 // set drain storage from URI string
222
223         fDrainStorage = GetStorage(dbString);   
224 }
225
226 //_____________________________________________________________________________
227 void AliCDBManager::SetDrain(const AliCDBParam* param) {
228 // set drain storage from AliCDBParam
229         
230         fDrainStorage = GetStorage(param);
231 }
232
233 //_____________________________________________________________________________
234 void AliCDBManager::SetDrain(AliCDBStorage* storage) {
235 // set drain storage from another active storage
236         
237         fDrainStorage = storage;
238 }
239
240 //_____________________________________________________________________________
241 Bool_t AliCDBManager::Drain(AliCDBEntry *entry) {
242 // drain retrieved object to drain storage
243
244         AliInfo("Draining into drain storage...");
245         return fDrainStorage->Put(entry);
246 }
247
248 //_____________________________________________________________________________
249 void AliCDBManager::SetDefaultStorage(const char* dbString) {
250 // sets default storage from URI string
251
252         fDefaultStorage = GetStorage(dbString); 
253 }
254
255 //_____________________________________________________________________________
256 void AliCDBManager::SetDefaultStorage(const AliCDBParam* param) {
257 // set default storage from AliCDBParam object
258         
259         fDrainStorage = GetStorage(param);
260 }
261
262 //_____________________________________________________________________________
263 void AliCDBManager::SetDefaultStorage(AliCDBStorage* storage) {
264 // set default storage from another active storage
265         
266         fDefaultStorage = storage;
267 }
268
269 //_____________________________________________________________________________
270 void AliCDBManager::SetSpecificStorage(const char* calibType, const char* dbString) {
271 // sets storage specific for detector or calibration type (works with AliCDBManager::Get(...))
272
273         AliCDBParam *aPar = CreateParameter(dbString);
274         if(!aPar) return;
275         SetSpecificStorage(calibType, aPar);
276         delete aPar;
277 }
278
279 //_____________________________________________________________________________
280 void AliCDBManager::SetSpecificStorage(const char* calibType, AliCDBParam* param) {
281 // sets storage specific for detector or calibration type (works with AliCDBManager::Get(...))
282 // Default storage should be defined prior to any specific storages, e.g.:
283 // AliCDBManager::instance()->SetDefaultStorage("alien://");
284 // AliCDBManager::instance()->SetSpecificStorage("TPC","local://DB_TPC");
285 // AliCDBManager::instance()->SetSpecificStorage("RICH/Align","local://DB_TPCAlign");
286
287         if(!fDefaultStorage) {
288                 AliError("Please activate a default storage first!");   
289                 return;
290         }
291         
292         TObjString *objCalibType = new TObjString(calibType);
293         if(fSpecificStorages.Contains(objCalibType)){
294                 AliWarning(Form("%s storage already activated! It will be replaced by the new one",
295                                         calibType));
296                 fSpecificStorages.Remove(objCalibType); 
297         }
298         GetStorage(param);
299         fSpecificStorages.Add(objCalibType, param->CloneParam());
300 }
301
302 //_____________________________________________________________________________
303 AliCDBStorage* AliCDBManager::GetSpecificStorage(const char* calibType) {
304 // get storage specific for detector or calibration type 
305
306         AliCDBParam *checkPar = (AliCDBParam*) fSpecificStorages.GetValue(calibType);
307         if(!checkPar){
308                 AliError(Form("%s storage not found!",calibType));
309                 return NULL;
310         } else {
311                 return GetStorage(checkPar);
312         }
313         
314 }
315
316 //_____________________________________________________________________________
317 AliCDBParam* AliCDBManager::SelectSpecificStorage(const TString& path) {
318 // select storage valid for path from the list of specific storages 
319
320         TIter iter(&fSpecificStorages);
321         TObjString *aCalibType;
322         AliCDBParam* aPar=0;
323         while((aCalibType = (TObjString*) iter.Next())){
324                 if(path.Contains(aCalibType->String(), TString::kIgnoreCase)) {
325                         aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType);
326                         break;
327                 }
328         }
329         return aPar;
330 }
331
332 //_____________________________________________________________________________
333 AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber, 
334         Int_t version, Int_t subVersion) {
335 // get an AliCDBEntry object from the database
336
337         if(runNumber < 0){
338                 // RunNumber is not specified. Try with fRun
339                 if (fRun < 0){
340                         AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
341                         return NULL;
342                 }
343                 runNumber = fRun;
344         }
345
346         return Get(AliCDBId(path, runNumber, runNumber, version, subVersion));
347 }
348
349 //_____________________________________________________________________________
350 AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, 
351         const AliCDBRunRange& runRange, Int_t version,
352         Int_t subVersion) {
353 // get an AliCDBEntry object from the database!
354
355         return Get(AliCDBId(path, runRange, version, subVersion));
356 }
357
358 //_____________________________________________________________________________
359 AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) {        
360 // get an AliCDBEntry object from the database
361         
362         if(!fDefaultStorage) {
363                 AliError("No storage set!");
364                 return NULL;
365         }
366
367         // check if query's path and runRange are valid
368         // query is invalid also if version is not specified and subversion is!
369         if (!query.IsValid()) {
370                 AliError(Form("Invalid query: %s", query.ToString().Data()));
371                 return NULL;
372         }
373         
374         // query is not specified if path contains wildcard or run range= [-1,-1]
375         if (!query.IsSpecified()) {
376                 AliError(Form("Unspecified query: %s", 
377                                 query.ToString().Data()));
378                 return NULL;
379         }
380
381         if(fCache && query.GetFirstRun() != fRun) 
382                 AliWarning("Run number explicitly set in query: CDB cache temporarily disabled!");
383
384         
385         AliCDBEntry *entry=0;
386         
387   
388         // first look into map of cached objects
389         if(query.GetFirstRun() == fRun) 
390                 entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath());
391
392         if(entry) {
393                 AliInfo(Form("Object %s retrieved from cache !!",query.GetPath().Data()));              
394                 return entry;
395         }
396         
397         // Entry is not in cache -> retrieve it from CDB and cache it!!   
398         AliCDBStorage *aStorage=0;
399         AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
400         
401         if(aPar) {
402                 aStorage=GetStorage(aPar);
403                 TString str = aPar->GetURI();
404                 AliDebug(2,Form("Looking into storage: %s",str.Data()));
405                 
406         } else {
407                 aStorage=GetDefaultStorage();
408                 AliDebug(2,"Looking into default storage");     
409         }
410                         
411         entry = aStorage->Get(query);
412         if (!entry) return NULL;
413
414         if(fCache && (query.GetFirstRun() == fRun)){
415                 AliInfo(Form("Caching entry %s !",query.GetPath().Data()));
416                 CacheEntry(query.GetPath(), entry);
417         }
418   
419         return entry;
420                 
421 }
422
423 //_____________________________________________________________________________
424 TList* AliCDBManager::GetAll(const AliCDBPath& path, Int_t runNumber, 
425         Int_t version, Int_t subVersion) {
426 // get multiple AliCDBEntry objects from the database
427
428         return GetAll(AliCDBId(path, runNumber, runNumber, version,     
429                         subVersion));
430 }
431
432 //_____________________________________________________________________________
433 TList* AliCDBManager::GetAll(const AliCDBPath& path, 
434         const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) {
435 // get multiple AliCDBEntry objects from the database
436
437         return GetAll(AliCDBId(path, runRange, version, subVersion));
438 }
439
440 //_____________________________________________________________________________
441 TList* AliCDBManager::GetAll(const AliCDBId& query) {
442 // get multiple AliCDBEntry objects from the database
443 // Warning: this method works correctly only for queries of the type "Detector/*"
444 //              and not for more specific queries e.g. "Detector/Calib/*" !
445
446         if(!fDefaultStorage) {
447                 AliError("No storage set!");
448                 return NULL;
449         }
450
451         if (!query.IsValid()) {
452                 AliError(Form("Invalid query: %s", query.ToString().Data()));
453                 return NULL;
454         }
455
456         if(query.GetPath().BeginsWith('*')){
457                 AliError("Query too generic in this context!");
458                 return NULL;            
459         }
460
461         if (query.IsAnyRange()) {
462                 AliError(Form("Unspecified run or runrange: %s",
463                                 query.ToString().Data()));      
464                 return NULL;
465         }       
466         
467         TObjString objStrLev0(query.GetLevel0());
468         AliCDBParam *aPar = (AliCDBParam*) fSpecificStorages.GetValue(&objStrLev0);
469
470         AliCDBStorage *aStorage;        
471         if(aPar) {
472                 aStorage=GetStorage(aPar);
473                 TString str = aPar->GetURI();
474                 AliDebug(2,Form("Looking into storage: %s",str.Data()));
475                 
476         } else {
477                 aStorage=GetDefaultStorage();
478                 AliDebug(2,"Looking into default storage");     
479         }
480
481         TList *result = aStorage->GetAll(query);
482
483         return result;
484 }
485
486 //_____________________________________________________________________________
487 Bool_t AliCDBManager::Put(TObject* object, AliCDBId& id,  AliCDBMetaData* metaData){
488 // store an AliCDBEntry object into the database
489
490         AliCDBEntry anEntry(object, id, metaData);
491         return Put(&anEntry);
492
493 }
494
495
496 //_____________________________________________________________________________
497 Bool_t AliCDBManager::Put(AliCDBEntry* entry){
498 // store an AliCDBEntry object into the database
499
500         if(!fDefaultStorage) {
501                 AliError("No storage set!");
502                 return kFALSE;
503         }
504
505         if (!entry){
506                 AliError("No entry!");
507                 return kFALSE;
508         }
509
510         if (!entry->GetId().IsValid()) {
511                 AliError(Form("Invalid entry ID: %s", 
512                         entry->GetId().ToString().Data()));
513                 return kFALSE;
514         }       
515
516         if (!entry->GetId().IsSpecified()) {
517                 AliError(Form("Unspecified entry ID: %s", 
518                         entry->GetId().ToString().Data()));
519                 return kFALSE;
520         }
521
522         AliCDBId id = entry->GetId();
523         AliCDBParam *aPar = SelectSpecificStorage(id.GetPath());
524
525         AliCDBStorage *aStorage;
526         
527         if(aPar) {
528                 aStorage=GetStorage(aPar);
529                 TString str = aPar->GetURI();
530                 AliDebug(2,Form("Storing object into storage: %s",str.Data()));
531                 
532         } else {
533                 aStorage=GetDefaultStorage();
534                 AliDebug(2,"Storing object into default storage");      
535         }
536
537         return aStorage->Put(entry);
538
539
540 }
541
542 //_____________________________________________________________________________
543 void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry)
544 {
545 // cache AliCDBEntry. Cache is valid until run number is changed.
546
547         AliDebug(2,Form("Filling cache with entry %s",path));
548         fEntryCache.Add(new TObjString(path), entry);
549         AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
550
551 }
552
553 //_____________________________________________________________________________
554 void AliCDBManager::SetRun(Long64_t run)
555 {
556 // Sets current run number.  
557 // When the run number changes the caching is cleared.
558   
559         if (fRun == run)
560                 return;
561   
562         fRun = run;
563         ClearCache();
564 }
565
566 //_____________________________________________________________________________
567 void AliCDBManager::ClearCache(){
568 // clear AliCDBEntry cache
569
570         AliDebug(2,Form("Clearing cache!"));
571         fEntryCache.DeleteAll();
572         AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
573
574 }
575
576 //_____________________________________________________________________________
577 void AliCDBManager::DestroyActiveStorages() {
578 // delete list of active storages
579
580         fActiveStorages.DeleteAll();
581         fSpecificStorages.DeleteAll();
582 }
583
584 //_____________________________________________________________________________
585 void AliCDBManager::DestroyActiveStorage(AliCDBStorage* /*storage*/) {
586 // destroys active storage
587
588 /*
589         TIter iter(fActiveStorages.GetTable()); 
590         TPair* aPair;
591         while ((aPair = (TPair*) iter.Next())) {
592                 if(storage == (AliCDBStorage*) aPair->Value())
593                         delete fActiveStorages.Remove(aPair->Key());
594                         storage->Delete(); storage=0x0;
595         }
596 */      
597
598 }
599
600 ///////////////////////////////////////////////////////////
601 // AliCDBManager Parameter class                         //
602 // interface to specific AliCDBParameter class           //
603 // (AliCDBGridParam, AliCDBLocalParam, AliCDBDumpParam)  //
604 ///////////////////////////////////////////////////////////
605
606 AliCDBParam::AliCDBParam() {
607 // constructor
608
609 }
610
611 //_____________________________________________________________________________
612 AliCDBParam::~AliCDBParam() {
613 // destructor
614
615 }
616