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(-1)
  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         // first look into map of cached objects
 388         if(query.GetFirstRun() == fRun)
 389                 entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath());
 390
 391         if(entry) {
 392                 AliDebug(2,Form("Object %s retrieved from cache !!",query.GetPath().Data()));
 393                 return entry;
 394         }
 395
 396         // Entry is not in cache -> retrieve it from CDB and cache it!!
 397         AliCDBStorage *aStorage=0;
 398         AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
 399
 400         if(aPar) {
 401                 aStorage=GetStorage(aPar);
 402                 TString str = aPar->GetURI();
 403                 AliDebug(2,Form("Looking into storage: %s",str.Data()));
 404
 405         } else {
 406                 aStorage=GetDefaultStorage();
 407                 AliDebug(2,"Looking into default storage");
 408         }
 409
 410         entry = aStorage->Get(query);
 411         if (!entry) return NULL;
 412
 413         if(fCache && (query.GetFirstRun() == fRun)){
 414                 AliDebug(2,Form("Caching entry %s !",query.GetPath().Data()));
 415                 CacheEntry(query.GetPath(), entry);
 416         }
 417
 418         return entry;
 419
 420 }
 421
 422 //_____________________________________________________________________________
 423 TList* AliCDBManager::GetAll(const AliCDBPath& path, Int_t runNumber,
 424         Int_t version, Int_t subVersion) {
 425 // get multiple AliCDBEntry objects from the database
 426
 427         if(runNumber < 0){
 428                 // RunNumber is not specified. Try with fRun
 429                 if (fRun < 0){
 430                         AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
 431                         return NULL;
 432                 }
 433                 runNumber = fRun;
 434         }
 435
 436         return GetAll(AliCDBId(path, runNumber, runNumber, version,
 437                         subVersion));
 438 }
 439
 440 //_____________________________________________________________________________
 441 TList* AliCDBManager::GetAll(const AliCDBPath& path,
 442         const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) {
 443 // get multiple AliCDBEntry objects from the database
 444
 445         return GetAll(AliCDBId(path, runRange, version, subVersion));
 446 }
 447
 448 //_____________________________________________________________________________
 449 TList* AliCDBManager::GetAll(const AliCDBId& query) {
 450 // get multiple AliCDBEntry objects from the database
 451 // Warning: this method works correctly only for queries of the type "Detector/*"
 452 //              and not for more specific queries e.g. "Detector/Calib/*" !
 453
 454         if(!fDefaultStorage) {
 455                 AliError("No storage set!");
 456                 return NULL;
 457         }
 458
 459         if (!query.IsValid()) {
 460                 AliError(Form("Invalid query: %s", query.ToString().Data()));
 461                 return NULL;
 462         }
 463
 464         if((fSpecificStorages.GetEntries()>0) && query.GetPath().BeginsWith('*')){
 465                 // if specific storages are active a query with "*" is ambiguous
 466                 AliError("Query too generic in this context!");
 467                 return NULL;
 468         }
 469
 470         if (query.IsAnyRange()) {
 471                 AliError(Form("Unspecified run or runrange: %s",
 472                                 query.ToString().Data()));
 473                 return NULL;
 474         }
 475
 476         TObjString objStrLev0(query.GetLevel0());
 477         AliCDBParam *aPar = (AliCDBParam*) fSpecificStorages.GetValue(&objStrLev0);
 478
 479         AliCDBStorage *aStorage;
 480         if(aPar) {
 481                 aStorage=GetStorage(aPar);
 482                 TString str = aPar->GetURI();
 483                 AliDebug(2,Form("Looking into storage: %s",str.Data()));
 484
 485         } else {
 486                 aStorage=GetDefaultStorage();
 487                 AliDebug(2,"Looking into default storage");
 488         }
 489
 490         TList *result = aStorage->GetAll(query);
 491
 492         return result;
 493 }
 494
 495 //_____________________________________________________________________________
 496 Bool_t AliCDBManager::Put(TObject* object, AliCDBId& id,  AliCDBMetaData* metaData){
 497 // store an AliCDBEntry object into the database
 498
 499         AliCDBEntry anEntry(object, id, metaData);
 500         return Put(&anEntry);
 501
 502 }
 503
 504
 505 //_____________________________________________________________________________
 506 Bool_t AliCDBManager::Put(AliCDBEntry* entry){
 507 // store an AliCDBEntry object into the database
 508
 509         if(!fDefaultStorage) {
 510                 AliError("No storage set!");
 511                 return kFALSE;
 512         }
 513
 514         if (!entry){
 515                 AliError("No entry!");
 516                 return kFALSE;
 517         }
 518
 519         if (!entry->GetId().IsValid()) {
 520                 AliError(Form("Invalid entry ID: %s",
 521                         entry->GetId().ToString().Data()));
 522                 return kFALSE;
 523         }
 524
 525         if (!entry->GetId().IsSpecified()) {
 526                 AliError(Form("Unspecified entry ID: %s",
 527                         entry->GetId().ToString().Data()));
 528                 return kFALSE;
 529         }
 530
 531         AliCDBId id = entry->GetId();
 532         AliCDBParam *aPar = SelectSpecificStorage(id.GetPath());
 533
 534         AliCDBStorage *aStorage;
 535
 536         if(aPar) {
 537                 aStorage=GetStorage(aPar);
 538                 TString str = aPar->GetURI();
 539                 AliDebug(2,Form("Storing object into storage: %s",str.Data()));
 540
 541         } else {
 542                 aStorage=GetDefaultStorage();
 543                 AliDebug(2,"Storing object into default storage");
 544         }
 545
 546         return aStorage->Put(entry);
 547
 548
 549 }
 550
 551 //_____________________________________________________________________________
 552 void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry)
 553 {
 554 // cache AliCDBEntry. Cache is valid until run number is changed.
 555
 556         AliDebug(2,Form("Filling cache with entry %s",path));
 557         fEntryCache.Add(new TObjString(path), entry);
 558         AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
 559
 560 }
 561
 562 //_____________________________________________________________________________
 563 void AliCDBManager::SetRun(Long64_t run)
 564 {
 565 // Sets current run number.
 566 // When the run number changes the caching is cleared.
 567
 568         if (fRun == run)
 569                 return;
 570
 571         fRun = run;
 572         ClearCache();
 573 }
 574
 575 //_____________________________________________________________________________
 576 void AliCDBManager::ClearCache(){
 577 // clear AliCDBEntry cache
 578
 579         AliDebug(2,Form("Clearing cache!"));
 580         fEntryCache.DeleteAll();
 581         AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
 582
 583 }
 584
 585 //_____________________________________________________________________________
 586 void AliCDBManager::DestroyActiveStorages() {
 587 // delete list of active storages
 588
 589         fActiveStorages.DeleteAll();
 590         fSpecificStorages.DeleteAll();
 591 }
 592
 593 //_____________________________________________________________________________
 594 void AliCDBManager::DestroyActiveStorage(AliCDBStorage* /*storage*/) {
 595 // destroys active storage
 596
 597 /*
 598         TIter iter(fActiveStorages.GetTable());
 599         TPair* aPair;
 600         while ((aPair = (TPair*) iter.Next())) {
 601                 if(storage == (AliCDBStorage*) aPair->Value())
 602                         delete fActiveStorages.Remove(aPair->Key());
 603                         storage->Delete(); storage=0x0;
 604         }
 605 */
 606
 607 }
 608
 609 ///////////////////////////////////////////////////////////
 610 // AliCDBManager Parameter class                         //
 611 // interface to specific AliCDBParameter class           //
 612 // (AliCDBGridParam, AliCDBLocalParam, AliCDBDumpParam)  //
 613 ///////////////////////////////////////////////////////////
 614
 615 AliCDBParam::AliCDBParam() {
 616 // constructor
 617
 618 }
 619
 620 //_____________________________________________________________________________
 621 AliCDBParam::~AliCDBParam() {
 622 // destructor
 623
 624 }
 625