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 //TODO OCDB and Reference folder should not be fully hardcoded but built from run number (or year/LHC period)
  38 TString AliCDBManager::fgkCondUri("alien://folder=/alice/cern.ch/user/a/aliprod/testCDB/CDB?user=aliprod");
  39 TString AliCDBManager::fgkRefUri("alien://folder=/alice/cern.ch/user/a/aliprod/testCDB/Reference?user=aliprod");
  40 AliCDBManager* AliCDBManager::fgInstance = 0x0;
  41
  42 //_____________________________________________________________________________
  43 AliCDBManager* AliCDBManager::Instance()
  44 {
  45 // returns AliCDBManager instance (singleton)
  46
  47         if (!fgInstance) {
  48                 fgInstance = new AliCDBManager();
  49                 fgInstance->Init();
  50         }
  51
  52         return fgInstance;
  53 }
  54
  55 //_____________________________________________________________________________
  56 void AliCDBManager::Init() {
  57 // factory registering
  58
  59         RegisterFactory(new AliCDBDumpFactory());
  60         RegisterFactory(new AliCDBLocalFactory());
  61         // AliCDBGridFactory is registered only if AliEn libraries are enabled in Root
  62         if(!gSystem->Exec("root-config --has-alien |grep yes 2>&1 > /dev/null")){ // returns 0 if yes
  63                 AliInfo("AliEn classes enabled in Root. AliCDBGrid factory registered.");
  64                 RegisterFactory(new AliCDBGridFactory());
  65                 fCondParam = CreateParameter(fgkCondUri);
  66                 fRefParam = CreateParameter(fgkRefUri);
  67         }
  68
  69         InitShortLived();
  70 }
  71 //_____________________________________________________________________________
  72 void AliCDBManager::Destroy() {
  73 // delete ALCDBManager instance and active storages
  74
  75         if (fgInstance) {
  76                 //fgInstance->Delete();
  77                 delete fgInstance;
  78                 fgInstance = 0x0;
  79         }
  80 }
  81
  82 //_____________________________________________________________________________
  83 AliCDBManager::AliCDBManager():
  84   TObject(),
  85   fFactories(),
  86   fActiveStorages(),
  87   fSpecificStorages(),
  88   fEntryCache(),
  89   fIds(0),
  90   fStorageMap(0),
  91   fShortLived(0),
  92   fDefaultStorage(NULL),
  93   fDrainStorage(NULL),
  94   fCondParam(0),
  95   fRefParam(0),
  96   fRun(-1),
  97   fCache(kTRUE),
  98   fLock(kFALSE)
  99 {
 100 // default constuctor
 101         fFactories.SetOwner(1);
 102         fActiveStorages.SetOwner(1);
 103         fSpecificStorages.SetOwner(1);
 104         fEntryCache.SetOwner(1);
 105
 106         fStorageMap = new TMap();
 107         fStorageMap->SetOwner(1);
 108         fIds = new TList();
 109         fIds->SetOwner(1);
 110 }
 111
 112 //_____________________________________________________________________________
 113 AliCDBManager::~AliCDBManager() {
 114 // destructor
 115         ClearCache();
 116         DestroyActiveStorages();
 117         fFactories.Delete();
 118         fDrainStorage = 0x0;
 119         fDefaultStorage = 0x0;
 120         delete fStorageMap; fStorageMap = 0;
 121         delete fIds; fIds = 0;
 122         delete fCondParam;
 123         delete fRefParam;
 124         delete fShortLived; fShortLived = 0x0;
 125 }
 126
 127 //_____________________________________________________________________________
 128 void AliCDBManager::PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage){
 129 // put a storage object into the list of active storages
 130
 131         fActiveStorages.Add(param, storage);
 132         AliDebug(1, Form("Active storages: %d", fActiveStorages.GetEntries()));
 133 }
 134
 135 //_____________________________________________________________________________
 136 void AliCDBManager::RegisterFactory(AliCDBStorageFactory* factory) {
 137 // add a storage factory to the list of registerd factories
 138
 139         if (!fFactories.Contains(factory)) {
 140                 fFactories.Add(factory);
 141         }
 142 }
 143
 144 //_____________________________________________________________________________
 145 Bool_t AliCDBManager::HasStorage(const char* dbString) const {
 146 // check if dbString is a URI valid for one of the registered factories
 147
 148         TIter iter(&fFactories);
 149
 150         AliCDBStorageFactory* factory=0;
 151         while ((factory = (AliCDBStorageFactory*) iter.Next())) {
 152
 153                 if (factory->Validate(dbString)) {
 154                         return kTRUE;
 155                 }
 156         }
 157
 158         return kFALSE;
 159 }
 160
 161 //_____________________________________________________________________________
 162 AliCDBParam* AliCDBManager::CreateParameter(const char* dbString) const {
 163 // create AliCDBParam object from URI string
 164
 165         TIter iter(&fFactories);
 166
 167         AliCDBStorageFactory* factory=0;
 168         while ((factory = (AliCDBStorageFactory*) iter.Next())) {
 169                 AliCDBParam* param = factory->CreateParameter(dbString);
 170                 if(param) return param;
 171         }
 172
 173         return NULL;
 174 }
 175
 176 //_____________________________________________________________________________
 177 AliCDBStorage* AliCDBManager::GetStorage(const char* dbString) {
 178 // get storage object from URI string
 179
 180         AliCDBParam* param = CreateParameter(dbString);
 181         if (!param) {
 182                 AliError(Form("Failed to activate requested storage! Check URI: %s", dbString));
 183                 return NULL;
 184         }
 185
 186         AliCDBStorage* aStorage = GetStorage(param);
 187
 188         delete param;
 189         return aStorage;
 190 }
 191
 192 //_____________________________________________________________________________
 193 AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) {
 194 // get storage object from AliCDBParam object
 195
 196         // if the list of active storages already contains
 197         // the requested storage, return it
 198         AliCDBStorage* aStorage = GetActiveStorage(param);
 199         if (aStorage) {
 200                 return aStorage;
 201         }
 202
 203         // if lock is ON, cannot activate more storages!
 204         if(fLock) {
 205                 if (fDefaultStorage) {
 206                         AliFatal("Lock is ON, and default storage is already set: "
 207                                 "cannot reset it or activate more storages!");
 208                 }
 209         }
 210
 211         TIter iter(&fFactories);
 212
 213         AliCDBStorageFactory* factory=0;
 214
 215         // loop on the list of registered factories
 216         while ((factory = (AliCDBStorageFactory*) iter.Next())) {
 217
 218                 // each factory tries to create its storage from the parameter
 219                 aStorage = factory->Create(param);
 220                 if (aStorage) {
 221                         PutActiveStorage(param->CloneParam(), aStorage);
 222                         aStorage->SetURI(param->GetURI());
 223                         if(fRun >= 0) {
 224                                 if(aStorage->GetType() == "alien"){
 225                                         aStorage->QueryCDB(fRun);
 226                                 } else {
 227                                         AliDebug(2,
 228                                                 "Skipping query for valid files, it is used only in grid...");
 229                                 }
 230                         }
 231                         return aStorage;
 232                 }
 233         }
 234
 235         AliError(Form("Failed to activate requested storage! Check URI: %s", param->GetURI().Data()));
 236
 237         return NULL;
 238 }
 239
 240 //_____________________________________________________________________________
 241 AliCDBStorage* AliCDBManager::GetActiveStorage(const AliCDBParam* param) {
 242 // get a storage object from the list of active storages
 243
 244         return dynamic_cast<AliCDBStorage*> (fActiveStorages.GetValue(param));
 245 }
 246
 247 //_____________________________________________________________________________
 248 TList* AliCDBManager::GetActiveStorages() {
 249 // return list of active storages
 250 // user has responsibility to delete returned object
 251
 252         TList* result = new TList();
 253
 254         TIter iter(fActiveStorages.GetTable());
 255         TPair* aPair=0;
 256         while ((aPair = (TPair*) iter.Next())) {
 257                 result->Add(aPair->Value());
 258         }
 259
 260         return result;
 261 }
 262
 263 //_____________________________________________________________________________
 264 void AliCDBManager::SetDrain(const char* dbString) {
 265 // set drain storage from URI string
 266
 267         fDrainStorage = GetStorage(dbString);
 268 }
 269
 270 //_____________________________________________________________________________
 271 void AliCDBManager::SetDrain(const AliCDBParam* param) {
 272 // set drain storage from AliCDBParam
 273
 274         fDrainStorage = GetStorage(param);
 275 }
 276
 277 //_____________________________________________________________________________
 278 void AliCDBManager::SetDrain(AliCDBStorage* storage) {
 279 // set drain storage from another active storage
 280
 281         fDrainStorage = storage;
 282 }
 283
 284 //_____________________________________________________________________________
 285 Bool_t AliCDBManager::Drain(AliCDBEntry *entry) {
 286 // drain retrieved object to drain storage
 287
 288         AliDebug(2, "Draining into drain storage...");
 289         return fDrainStorage->Put(entry);
 290 }
 291
 292 //_____________________________________________________________________________
 293 void AliCDBManager::SetDefaultStorage(const char* dbString) {
 294 // sets default storage from URI string
 295
 296         AliInfo(Form("Setting Default storage to: %s",dbString));
 297         AliCDBStorage* bckStorage = fDefaultStorage;
 298
 299         fDefaultStorage = GetStorage(dbString);
 300
 301         if(!fDefaultStorage) return;
 302
 303         if(bckStorage && (fDefaultStorage != bckStorage)){
 304                 AliWarning("Existing default storage replaced: clearing cache!");
 305                 ClearCache();
 306         }
 307
 308         if (fStorageMap->Contains("default")) {
 309                 delete fStorageMap->Remove(fStorageMap->GetValue("default"));
 310         }
 311         fStorageMap->Add(new TObjString("default"), new TObjString(fDefaultStorage->GetURI()));
 312 }
 313
 314 //_____________________________________________________________________________
 315 void AliCDBManager::SetDefaultStorage(const AliCDBParam* param) {
 316 // set default storage from AliCDBParam object
 317
 318         AliCDBStorage* bckStorage = fDefaultStorage;
 319
 320         fDefaultStorage = GetStorage(param);
 321
 322         if(!fDefaultStorage) return;
 323
 324         if(bckStorage && (fDefaultStorage != bckStorage)){
 325                 AliWarning("Existing default storage replaced: clearing cache!");
 326                 ClearCache();
 327         }
 328
 329         if (fStorageMap->Contains("default")) {
 330                 delete fStorageMap->Remove(fStorageMap->GetValue("default"));
 331         }
 332         fStorageMap->Add(new TObjString("default"), new TObjString(fDefaultStorage->GetURI()));
 333 }
 334
 335 //_____________________________________________________________________________
 336 void AliCDBManager::SetDefaultStorage(AliCDBStorage* storage) {
 337 // set default storage from another active storage
 338
 339         // if lock is ON, cannot activate more storages!
 340         if(fLock) {
 341                 if (fDefaultStorage) {
 342                         AliFatal("Lock is ON, and default storage is already set: "
 343                                 "cannot reset it or activate more storages!");
 344                 }
 345         }
 346
 347         if (!storage) {
 348                 UnsetDefaultStorage();
 349                 return;
 350         }
 351
 352         AliCDBStorage* bckStorage = fDefaultStorage;
 353
 354         fDefaultStorage = storage;
 355
 356         if(bckStorage && (fDefaultStorage != bckStorage)){
 357                 AliWarning("Existing default storage replaced: clearing cache!");
 358                 ClearCache();
 359         }
 360
 361         if (fStorageMap->Contains("default")) {
 362                 delete fStorageMap->Remove(fStorageMap->GetValue("default"));
 363         }
 364         fStorageMap->Add(new TObjString("default"), new TObjString(fDefaultStorage->GetURI()));
 365 }
 366
 367 //_____________________________________________________________________________
 368 void AliCDBManager::UnsetDefaultStorage() {
 369 // Unset default storage
 370
 371         // if lock is ON, action is forbidden!
 372         if(fLock) {
 373                 if (fDefaultStorage) {
 374                         AliFatal("Lock is ON: cannot unset default storage!");
 375                 }
 376         }
 377
 378         if (fDefaultStorage) {
 379                 AliWarning("Clearing cache!");
 380                 ClearCache();
 381         }
 382
 383         fDefaultStorage = 0x0;
 384 }
 385
 386 //_____________________________________________________________________________
 387 void AliCDBManager::SetSpecificStorage(const char* calibType, const char* dbString) {
 388 // sets storage specific for detector or calibration type (works with AliCDBManager::Get(...))
 389
 390         AliCDBParam *aPar = CreateParameter(dbString);
 391         if(!aPar) return;
 392         SetSpecificStorage(calibType, aPar);
 393         delete aPar;
 394 }
 395
 396 //_____________________________________________________________________________
 397 void AliCDBManager::SetSpecificStorage(const char* calibType, AliCDBParam* param) {
 398 // sets storage specific for detector or calibration type (works with AliCDBManager::Get(...))
 399 // Default storage should be defined prior to any specific storages, e.g.:
 400 // AliCDBManager::instance()->SetDefaultStorage("alien://");
 401 // AliCDBManager::instance()->SetSpecificStorage("TPC/*","local://DB_TPC");
 402 // AliCDBManager::instance()->SetSpecificStorage("*/Align/*","local://DB_TPCAlign");
 403 // calibType must be a valid CDB path! (3 level folder structure)
 404
 405         if(!fDefaultStorage) {
 406                 AliError("Please activate a default storage first!");
 407                 return;
 408         }
 409
 410         AliCDBPath aPath(calibType);
 411         if(!aPath.IsValid()){
 412                 AliError(Form("Not a valid path: %s", calibType));
 413                 return;
 414         }
 415
 416         TObjString *objCalibType = new TObjString(aPath.GetPath());
 417         if(fSpecificStorages.Contains(objCalibType)){
 418                 AliWarning(Form("Storage \"%s\" already activated! It will be replaced by the new one",
 419                                         calibType));
 420                 AliCDBParam *checkPar = dynamic_cast<AliCDBParam*> (fSpecificStorages.GetValue(calibType));
 421                 if(checkPar) delete checkPar;
 422                 delete fSpecificStorages.Remove(objCalibType);
 423         }
 424         AliCDBStorage *aStorage = GetStorage(param);
 425         if(!aStorage) return;
 426
 427         fSpecificStorages.Add(objCalibType, param->CloneParam());
 428
 429         if(fStorageMap->Contains(objCalibType)){
 430                 delete fStorageMap->Remove(objCalibType);
 431         }
 432         fStorageMap->Add(objCalibType->Clone(), new TObjString(param->GetURI()));
 433
 434 }
 435
 436 //_____________________________________________________________________________
 437 AliCDBStorage* AliCDBManager::GetSpecificStorage(const char* calibType) {
 438 // get storage specific for detector or calibration type
 439
 440         AliCDBPath calibPath(calibType);
 441         if(!calibPath.IsValid()) return NULL;
 442
 443         AliCDBParam *checkPar = (AliCDBParam*) fSpecificStorages.GetValue(calibPath.GetPath());
 444         if(!checkPar){
 445                 AliError(Form("%s storage not found!", calibType));
 446                 return NULL;
 447         } else {
 448                 return GetStorage(checkPar);
 449         }
 450
 451 }
 452
 453 //_____________________________________________________________________________
 454 AliCDBParam* AliCDBManager::SelectSpecificStorage(const TString& path) {
 455 // select storage valid for path from the list of specific storages
 456
 457         AliCDBPath aPath(path);
 458         if(!aPath.IsValid()) return NULL;
 459
 460         TIter iter(&fSpecificStorages);
 461         TObjString *aCalibType=0;
 462         AliCDBPath tmpPath("null/null/null");
 463         AliCDBParam* aPar=0;
 464         while((aCalibType = (TObjString*) iter.Next())){
 465                 AliCDBPath calibTypePath(aCalibType->GetName());
 466                 if(calibTypePath.Comprises(aPath)) {
 467                         if(calibTypePath.Comprises(tmpPath)) continue;
 468                         aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType);
 469                         tmpPath.SetPath(calibTypePath.GetPath());
 470                 }
 471         }
 472         return aPar;
 473 }
 474
 475 //_____________________________________________________________________________
 476 AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber,
 477         Int_t version, Int_t subVersion) {
 478 // get an AliCDBEntry object from the database
 479
 480         if(runNumber < 0){
 481                 // RunNumber is not specified. Try with fRun
 482                 if (fRun < 0){
 483                         AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
 484                         return NULL;
 485                 }
 486                 runNumber = fRun;
 487         }
 488
 489         return Get(AliCDBId(path, runNumber, runNumber, version, subVersion));
 490 }
 491
 492 //_____________________________________________________________________________
 493 AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path,
 494         const AliCDBRunRange& runRange, Int_t version,
 495         Int_t subVersion) {
 496 // get an AliCDBEntry object from the database!
 497
 498         return Get(AliCDBId(path, runRange, version, subVersion));
 499 }
 500
 501 //_____________________________________________________________________________
 502 AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) {
 503 // get an AliCDBEntry object from the database
 504
 505         if(!fDefaultStorage) {
 506                 AliError("No storage set!");
 507                 return NULL;
 508         }
 509
 510         // check if query's path and runRange are valid
 511         // query is invalid also if version is not specified and subversion is!
 512         if (!query.IsValid()) {
 513                 AliError(Form("Invalid query: %s", query.ToString().Data()));
 514                 return NULL;
 515         }
 516
 517         // query is not specified if path contains wildcard or run range= [-1,-1]
 518         if (!query.IsSpecified()) {
 519                 AliError(Form("Unspecified query: %s",
 520                                 query.ToString().Data()));
 521                 return NULL;
 522         }
 523
 524         if(fLock && query.GetFirstRun() != fRun)
 525                 AliFatal("Lock is ON: cannot use different run number than the internal one!");
 526
 527         if(fCache && query.GetFirstRun() != fRun)
 528                 AliWarning("Run number explicitly set in query: CDB cache temporarily disabled!");
 529
 530         AliCDBEntry *entry=0;
 531
 532         // first look into map of cached objects
 533         if(fCache && query.GetFirstRun() == fRun)
 534                 entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath());
 535
 536         if(entry) {
 537                 AliDebug(2, Form("Object %s retrieved from cache !!",query.GetPath().Data()));
 538                 return entry;
 539         }
 540
 541         // Entry is not in cache -> retrieve it from CDB and cache it!!
 542         AliCDBStorage *aStorage=0;
 543         AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
 544 //      Bool_t usedDefStorage=kTRUE;
 545
 546         if(aPar) {
 547                 aStorage=GetStorage(aPar);
 548                 TString str = aPar->GetURI();
 549                 AliDebug(2,Form("Looking into storage: %s",str.Data()));
 550 //              usedDefStorage=kFALSE;
 551
 552         } else {
 553                 aStorage=GetDefaultStorage();
 554                 AliDebug(2,"Looking into default storage");
 555         }
 556
 557         entry = aStorage->Get(query);
 558
 559         if(entry && fCache && (query.GetFirstRun() == fRun)){
 560                 CacheEntry(query.GetPath(), entry);
 561         }
 562
 563         if(entry && !fIds->Contains(&entry->GetId())){
 564                 fIds->Add(entry->GetId().Clone());
 565         }
 566
 567
 568         return entry;
 569
 570 }
 571
 572 //_____________________________________________________________________________
 573 const char* AliCDBManager::GetURI(const char* path) {
 574 // return the URI of the storage where to look for path
 575
 576         if(!IsDefaultStorageSet()) return 0;
 577
 578         AliCDBParam *aPar=SelectSpecificStorage(path);
 579
 580         if(aPar) {
 581                 return aPar->GetURI().Data();
 582
 583         } else {
 584                 return GetDefaultStorage()->GetURI().Data();
 585         }
 586
 587         return 0;
 588 }
 589
 590 //_____________________________________________________________________________
 591 AliCDBId* AliCDBManager::GetId(const AliCDBPath& path, Int_t runNumber,
 592         Int_t version, Int_t subVersion) {
 593 // get the AliCDBId of the valid object from the database (does not retrieve the object)
 594 // User must delete returned object!
 595
 596         if(runNumber < 0){
 597                 // RunNumber is not specified. Try with fRun
 598                 if (fRun < 0){
 599                         AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
 600                         return NULL;
 601                 }
 602                 runNumber = fRun;
 603         }
 604
 605         return GetId(AliCDBId(path, runNumber, runNumber, version, subVersion));
 606 }
 607
 608 //_____________________________________________________________________________
 609 AliCDBId* AliCDBManager::GetId(const AliCDBPath& path,
 610         const AliCDBRunRange& runRange, Int_t version,
 611         Int_t subVersion) {
 612 // get the AliCDBId of the valid object from the database (does not retrieve the object)
 613 // User must delete returned object!
 614
 615         return GetId(AliCDBId(path, runRange, version, subVersion));
 616 }
 617
 618 //_____________________________________________________________________________
 619 AliCDBId* AliCDBManager::GetId(const AliCDBId& query) {
 620 // get the AliCDBId of the valid object from the database (does not retrieve the object)
 621 // User must delete returned object!
 622
 623         if(!fDefaultStorage) {
 624                 AliError("No storage set!");
 625                 return NULL;
 626         }
 627
 628         // check if query's path and runRange are valid
 629         // query is invalid also if version is not specified and subversion is!
 630         if (!query.IsValid()) {
 631                 AliError(Form("Invalid query: %s", query.ToString().Data()));
 632                 return NULL;
 633         }
 634
 635         // query is not specified if path contains wildcard or run range= [-1,-1]
 636         if (!query.IsSpecified()) {
 637                 AliError(Form("Unspecified query: %s",
 638                                 query.ToString().Data()));
 639                 return NULL;
 640         }
 641
 642         if(fCache && query.GetFirstRun() != fRun)
 643                 AliWarning("Run number explicitly set in query: CDB cache temporarily disabled!");
 644
 645         AliCDBEntry* entry = 0;
 646
 647         // first look into map of cached objects
 648         if(fCache && query.GetFirstRun() == fRun)
 649                 entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath());
 650
 651         if(entry) {
 652                 AliDebug(2, Form("Object %s retrieved from cache !!",query.GetPath().Data()));
 653                 return dynamic_cast<AliCDBId*> (entry->GetId().Clone());
 654         }
 655
 656         // Entry is not in cache -> retrieve it from CDB and cache it!!
 657         AliCDBStorage *aStorage=0;
 658         AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
 659
 660         if(aPar) {
 661                 aStorage=GetStorage(aPar);
 662                 TString str = aPar->GetURI();
 663                 AliDebug(2,Form("Looking into storage: %s",str.Data()));
 664
 665         } else {
 666                 aStorage=GetDefaultStorage();
 667                 AliDebug(2,"Looking into default storage");
 668         }
 669
 670         return aStorage->GetId(query);
 671
 672 }
 673
 674 //_____________________________________________________________________________
 675 TList* AliCDBManager::GetAll(const AliCDBPath& path, Int_t runNumber,
 676         Int_t version, Int_t subVersion) {
 677 // get multiple AliCDBEntry objects from the database
 678
 679         if(runNumber < 0){
 680                 // RunNumber is not specified. Try with fRun
 681                 if (fRun < 0){
 682                         AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
 683                         return NULL;
 684                 }
 685                 runNumber = fRun;
 686         }
 687
 688         return GetAll(AliCDBId(path, runNumber, runNumber, version,
 689                         subVersion));
 690 }
 691
 692 //_____________________________________________________________________________
 693 TList* AliCDBManager::GetAll(const AliCDBPath& path,
 694         const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) {
 695 // get multiple AliCDBEntry objects from the database
 696
 697         return GetAll(AliCDBId(path, runRange, version, subVersion));
 698 }
 699
 700 //_____________________________________________________________________________
 701 TList* AliCDBManager::GetAll(const AliCDBId& query) {
 702 // get multiple AliCDBEntry objects from the database
 703 // Warning: this method works correctly only for queries of the type "Detector/*"
 704 //              and not for more specific queries e.g. "Detector/Calib/*" !
 705 // Warning #2: Entries are cached, but GetAll will keep on retrieving objects from OCDB!
 706 //              To get an object from cache use Get() function
 707
 708         if(!fDefaultStorage) {
 709                 AliError("No storage set!");
 710                 return NULL;
 711         }
 712
 713         if (!query.IsValid()) {
 714                 AliError(Form("Invalid query: %s", query.ToString().Data()));
 715                 return NULL;
 716         }
 717
 718         if((fSpecificStorages.GetEntries()>0) && query.GetPath().BeginsWith('*')){
 719                 // if specific storages are active a query with "*" is ambiguous
 720                 AliError("Query too generic in this context!");
 721                 return NULL;
 722         }
 723
 724         if (query.IsAnyRange()) {
 725                 AliError(Form("Unspecified run or runrange: %s",
 726                                 query.ToString().Data()));
 727                 return NULL;
 728         }
 729
 730         if(fLock && query.GetFirstRun() != fRun)
 731                 AliFatal("Lock is ON: cannot use different run number than the internal one!");
 732
 733         AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
 734
 735         AliCDBStorage *aStorage;
 736         if(aPar) {
 737                 aStorage=GetStorage(aPar);
 738                 AliDebug(2,Form("Looking into storage: %s", aPar->GetURI().Data()));
 739
 740         } else {
 741                 aStorage=GetDefaultStorage();
 742                 AliDebug(2,"Looking into default storage");
 743         }
 744
 745         TList *result = 0;
 746         if(aStorage) result = aStorage->GetAll(query);
 747         if(!result) return 0;
 748
 749        // loop on result to check whether entries should be re-queried with specific storages
 750         if(fSpecificStorages.GetEntries()>0 && ! (fSpecificStorages.GetEntries() == 1 && aPar)) {
 751                 AliInfo("Now look into all other specific storages...");
 752
 753                 TIter iter(result);
 754                 AliCDBEntry* chkEntry=0;
 755
 756                 while((chkEntry = dynamic_cast<AliCDBEntry*> (iter.Next()))){
 757                         AliCDBId& chkId = chkEntry->GetId();
 758                         AliDebug(2, Form("Checking id %s ", chkId.GetPath().Data()));
 759                         AliCDBParam *chkPar=SelectSpecificStorage(chkId.GetPath());
 760                         if (!chkPar || aPar == chkPar) continue;
 761                         AliCDBStorage *chkStorage = GetStorage(chkPar);
 762                         AliDebug(2, Form("Found specific storage! %s", chkPar->GetURI().Data()));
 763
 764                         AliCDBEntry *newEntry=0;
 765                         chkId.SetRunRange(query.GetFirstRun(), query.GetLastRun());
 766                         chkId.SetVersion(query.GetVersion());
 767                         chkId.SetSubVersion(query.GetSubVersion());
 768
 769                         if(chkStorage) newEntry = chkStorage->Get(chkId);
 770                         if(!newEntry) continue;
 771
 772                         // object is found in specific storage: replace entry in the result list!
 773                         chkEntry->SetOwner(1);
 774                         delete result->Remove(chkEntry);
 775                         result->AddFirst(newEntry);
 776                 }
 777
 778                 Int_t nEntries = result->GetEntries();
 779                 AliInfo("After look into other specific storages, result list is:");
 780                 for(int i=0; i<nEntries;i++){
 781                         AliCDBEntry *entry = (AliCDBEntry*) result->At(i);
 782                         AliInfo(Form("%s",entry->GetId().ToString().Data()));
 783                 }
 784         }
 785
 786         // caching entries
 787         TIter iter(result);
 788         AliCDBEntry* entry=0;
 789         while((entry = dynamic_cast<AliCDBEntry*> (iter.Next()))){
 790
 791                 if(!fIds->Contains(&entry->GetId())){
 792                         fIds->Add(entry->GetId().Clone());
 793                 }
 794                 if(fCache && (query.GetFirstRun() == fRun)){
 795                         CacheEntry(entry->GetId().GetPath(), entry);
 796                 }
 797         }
 798
 799
 800         return result;
 801 }
 802
 803 //_____________________________________________________________________________
 804 Bool_t AliCDBManager::Put(TObject* object, AliCDBId& id,  AliCDBMetaData* metaData, DataType type){
 805 // store an AliCDBEntry object into the database
 806
 807         if (object==0x0) {
 808                 AliError("Null Entry! No storage will be done!");
 809                 return kFALSE;
 810         }
 811
 812         AliCDBEntry anEntry(object, id, metaData);
 813         return Put(&anEntry, type);
 814
 815 }
 816
 817
 818 //_____________________________________________________________________________
 819 Bool_t AliCDBManager::Put(AliCDBEntry* entry, DataType type){
 820 // store an AliCDBEntry object into the database
 821
 822         if(type == kPrivate && !fDefaultStorage) {
 823                 AliError("No storage set!");
 824                 return kFALSE;
 825         }
 826
 827         if (entry->GetObject()==0x0){
 828                 AliError("No valid object in CDB entry!");
 829                 return kFALSE;
 830         }
 831
 832         if (!entry){
 833                 AliError("No entry!");
 834                 return kFALSE;
 835         }
 836
 837         if (!entry->GetId().IsValid()) {
 838                 AliError(Form("Invalid entry ID: %s",
 839                         entry->GetId().ToString().Data()));
 840                 return kFALSE;
 841         }
 842
 843         if (!entry->GetId().IsSpecified()) {
 844                 AliError(Form("Unspecified entry ID: %s",
 845                         entry->GetId().ToString().Data()));
 846                 return kFALSE;
 847         }
 848
 849         AliCDBId id = entry->GetId();
 850         AliCDBParam *aPar = SelectSpecificStorage(id.GetPath());
 851
 852         AliCDBStorage *aStorage=0;
 853
 854         if(aPar) {
 855                 aStorage=GetStorage(aPar);
 856         } else {
 857                 switch(type){
 858                         case kCondition:
 859                                 aStorage = GetStorage(fCondParam);
 860                                 break;
 861                         case kReference:
 862                                 aStorage = GetStorage(fRefParam);
 863                                 break;
 864                         case kPrivate:
 865                                 aStorage = GetDefaultStorage();
 866                                 break;
 867                 }
 868         }
 869
 870         AliDebug(2,Form("Storing object into storage: %s", aStorage->GetURI().Data()));
 871
 872         Bool_t result = aStorage->Put(entry, type);
 873
 874         if(fRun >= 0) QueryCDB();
 875
 876         return result;
 877
 878
 879 }
 880
 881 //_____________________________________________________________________________
 882 void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry)
 883 {
 884 // cache AliCDBEntry. Cache is valid until run number is changed.
 885
 886         AliCDBEntry *chkEntry = dynamic_cast<AliCDBEntry*> (fEntryCache.GetValue(path));
 887
 888         if(chkEntry) {
 889                 AliDebug(2, Form("Object %s already in cache !!", path));
 890                 return;
 891         } else {
 892                 AliDebug(2,Form("Caching entry %s", path));
 893         }
 894
 895         fEntryCache.Add(new TObjString(path), entry);
 896         AliDebug(2,Form("Cache entries: %d", fEntryCache.GetEntries()));
 897
 898 }
 899
 900 //_____________________________________________________________________________
 901 void AliCDBManager::Print(Option_t* /*option*/) const
 902 {
 903 // Print list of active storages and their URIs
 904
 905         TString output=Form("Run number = %d; ",fRun);
 906         output += "Cache is ";
 907         if(!fCache) output += "NOT ";
 908         output += Form("ACTIVE; Number of active storages: %d\n",fActiveStorages.GetEntries());
 909
 910         if(fDefaultStorage) {
 911                 output += Form("\t*** Default Storage URI: \"%s\"\n",fDefaultStorage->GetURI().Data());
 912 //              AliInfo(output.Data());
 913         }
 914         if(fSpecificStorages.GetEntries()>0) {
 915                 TIter iter(fSpecificStorages.GetTable());
 916                 TPair *aPair=0;
 917                 Int_t i=1;
 918                 while((aPair = (TPair*) iter.Next())){
 919                         output += Form("\t*** Specific storage %d: Path \"%s\" -> URI \"%s\"\n",
 920                                 i++, ((TObjString*) aPair->Key())->GetName(),
 921                                 ((AliCDBParam*) aPair->Value())->GetURI().Data());
 922                 }
 923         }
 924         if(fDrainStorage) {
 925                 output += Form("*** Drain Storage URI: %s\n",fDrainStorage->GetURI().Data());
 926         }
 927         AliInfo(output.Data());
 928 }
 929
 930 //_____________________________________________________________________________
 931 void AliCDBManager::SetRun(Int_t run)
 932 {
 933 // Sets current run number.
 934 // When the run number changes the caching is cleared.
 935
 936         if (fRun == run)
 937                 return;
 938
 939         if(fLock && fRun >= 0) {
 940                 AliFatal("Lock is ON, cannot reset run number!");
 941         }
 942
 943         fRun = run;
 944         ClearCache();
 945         QueryCDB();
 946 }
 947
 948 //_____________________________________________________________________________
 949 void AliCDBManager::ClearCache(){
 950 // clear AliCDBEntry cache
 951
 952         AliDebug(2, Form("Cache entries to be deleted: %d",fEntryCache.GetEntries()));
 953
 954         /*
 955         // To clean entries one by one
 956         TIter iter(fEntryCache.GetTable());
 957         TPair* pair=0;
 958         while((pair= dynamic_cast<TPair*> (iter.Next()))){
 959
 960                 TObjString* key = dynamic_cast<TObjString*> (pair->Key());
 961                 AliCDBEntry* entry = dynamic_cast<AliCDBEntry*> (pair->Value());
 962                 AliDebug(2, Form("Deleting entry: %s", key->GetName()));
 963                 if (entry) delete entry;
 964                 delete fEntryCache.Remove(key);
 965         }
 966         */
 967         fEntryCache.DeleteAll();
 968         AliDebug(2, Form("After deleting - Cache entries: %d",fEntryCache.GetEntries()));
 969 }
 970
 971 //_____________________________________________________________________________
 972 void AliCDBManager::UnloadFromCache(const char* path){
 973 // unload cached object
 974
 975         AliCDBPath queryPath(path);
 976         if(!queryPath.IsValid()) return;
 977
 978         if(!queryPath.IsWildcard()) { // path is not wildcard, get it directly from the cache and unload it!
 979                 if(fEntryCache.Contains(path)){
 980                         AliInfo(Form("Unloading object \"%s\" from cache", path));
 981                         TObjString pathStr(path);
 982                         AliCDBEntry *entry = dynamic_cast<AliCDBEntry*> (fEntryCache.GetValue(&pathStr));
 983                         if(entry) delete entry;
 984                         delete fEntryCache.Remove(&pathStr);
 985                 } else {
 986                         AliError(Form("Cache does not contain object \"%s\"!", path))
 987                 }
 988                 AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
 989                 return;
 990         }
 991
 992         // path is wildcard: loop on the cache and unload all comprised objects!
 993         TIter iter(fEntryCache.GetTable());
 994         TPair* pair = 0;
 995
 996         while((pair = dynamic_cast<TPair*> (iter.Next()))){
 997                 AliCDBPath entryPath = pair->Key()->GetName();
 998                 if(queryPath.Comprises(entryPath)) {
 999                         AliInfo(Form("Unloading object \"%s\" from cache", entryPath.GetPath().Data()));
1000                         TObjString pathStr(entryPath.GetPath().Data());
1001                         AliCDBEntry *entry = dynamic_cast<AliCDBEntry*> (fEntryCache.GetValue(&pathStr));
1002                         if(entry) delete entry;
1003                         delete fEntryCache.Remove(&pathStr);
1004                 }
1005         }
1006         AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
1007 }
1008
1009 //_____________________________________________________________________________
1010 void AliCDBManager::DestroyActiveStorages() {
1011 // delete list of active storages
1012
1013         fActiveStorages.DeleteAll();
1014         fSpecificStorages.DeleteAll();
1015 }
1016
1017 //_____________________________________________________________________________
1018 void AliCDBManager::DestroyActiveStorage(AliCDBStorage* /*storage*/) {
1019 // destroys active storage
1020
1021 /*
1022         TIter iter(fActiveStorages.GetTable());
1023         TPair* aPair;
1024         while ((aPair = (TPair*) iter.Next())) {
1025                 if(storage == (AliCDBStorage*) aPair->Value())
1026                         delete fActiveStorages.Remove(aPair->Key());
1027                         storage->Delete(); storage=0x0;
1028         }
1029 */
1030
1031 }
1032
1033 //_____________________________________________________________________________
1034 void AliCDBManager::QueryCDB() {
1035 // query default and specific storages for files valid for fRun. Every storage loads the Ids into its list.
1036
1037         if (fRun < 0){
1038                 AliError("Run number not yet set! Use AliCDBManager::SetRun.");
1039         return;
1040         }
1041         if (!fDefaultStorage){
1042                 AliError("Default storage is not set! Use AliCDBManager::SetDefaultStorage");
1043         return;
1044         }
1045         if(fDefaultStorage->GetType() == "alien"){
1046                 fDefaultStorage->QueryCDB(fRun);
1047         } else {
1048                 AliDebug(2,"Skipping query for valid files, it used only in grid...");
1049         }
1050
1051         TIter iter(&fSpecificStorages);
1052         TObjString *aCalibType=0;
1053         AliCDBParam* aPar=0;
1054         while((aCalibType = dynamic_cast<TObjString*> (iter.Next()))){
1055                 aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType);
1056                 if(aPar) {
1057                         AliDebug(2,Form("Querying specific storage %s",aCalibType->GetName()));
1058                         AliCDBStorage *aStorage = GetStorage(aPar);
1059                         if(aStorage->GetType() == "alien"){
1060                                 aStorage->QueryCDB(fRun,aCalibType->GetName());
1061                         } else {
1062                                 AliDebug(2,
1063                                         "Skipping query for valid files, it is used only in grid...");
1064                         }
1065                 }
1066         }
1067 }
1068
1069 //______________________________________________________________________________________________
1070 const char* AliCDBManager::GetDataTypeName(DataType type)
1071 {
1072   // returns the name (string) of the data type
1073
1074       switch (type){
1075             case kCondition: return "Conditions";
1076             case kReference: return "Reference";
1077             case kPrivate: return "Private";
1078      }
1079      return 0;
1080
1081 }
1082
1083 //______________________________________________________________________________________________
1084 void AliCDBManager::InitShortLived()
1085 {
1086   // Init the list of short-lived objects
1087   // currently disabled
1088
1089         fShortLived=0x0;
1090
1091 //      fShortLived = new TList();
1092 //      fShortLived->SetOwner(1);
1093 //
1094 //      fShortLived->Add(new TObjString("EMCAL/Calib/Data"));
1095 //
1096 //      fShortLived->Add(new TObjString("HMPID/Calib/Nmean"));
1097 //      fShortLived->Add(new TObjString("HMPID/Calib/Qthre"));
1098 //
1099 //      fShortLived->Add(new TObjString("ITS/Calib/CalibSPD"));
1100 //
1101 //      fShortLived->Add(new TObjString("MUON/Calib/Gains"));
1102 //      fShortLived->Add(new TObjString("MUON/Calib/HV"));
1103 //      fShortLived->Add(new TObjString("MUON/Calib/Pedestals"));
1104 //
1105 //      fShortLived->Add(new TObjString("PHOS/Calib/CpvGainPedestals"));
1106 //      fShortLived->Add(new TObjString("PHOS/Calib/EmcGainPedestals"));
1107 //
1108 //      fShortLived->Add(new TObjString("PMD/Calib/Data"));
1109 //
1110 //      fShortLived->Add(new TObjString("TRD/Calib/ChamberGainFactor"));
1111 //      fShortLived->Add(new TObjString("TRD/Calib/LocalGainFactor"));
1112 //      fShortLived->Add(new TObjString("TRD/Calib/ChamberT0"));
1113 //      fShortLived->Add(new TObjString("TRD/Calib/LocalT0"));
1114 //      fShortLived->Add(new TObjString("TRD/Calib/ChamberVdrift"));
1115 //      fShortLived->Add(new TObjString("TRD/Calib/LocalVdrift"));
1116 //
1117 //      fShortLived->Add(new TObjString("ZDC/Calib/Data"));
1118
1119 }
1120
1121 //______________________________________________________________________________________________
1122 Bool_t AliCDBManager::IsShortLived(const char* path)
1123 {
1124   // returns the name (string) of the data type
1125
1126         if(!fShortLived) return kFALSE;
1127
1128         AliCDBPath aPath(path);
1129         if(!aPath.IsValid()){
1130                 AliError(Form("Not a valid path: %s", path));
1131                 return kFALSE;
1132         }
1133
1134         return fShortLived->Contains(path);
1135
1136 }
1137
1138 //______________________________________________________________________________________________
1139 void AliCDBManager::SetLock(Bool_t lock){
1140
1141         if(fLock == kTRUE && lock == kFALSE) {
1142                 AliFatal("Lock is ON: cannot reset it!");
1143         }
1144
1145         fLock=lock;
1146 }
1147
1148 ///////////////////////////////////////////////////////////
1149 // AliCDBManager Parameter class                         //
1150 // interface to specific AliCDBParameter class           //
1151 // (AliCDBGridParam, AliCDBLocalParam, AliCDBDumpParam)  //
1152 ///////////////////////////////////////////////////////////
1153
1154 AliCDBParam::AliCDBParam():
1155   fType(),
1156   fURI()
1157 {
1158 // constructor
1159
1160 }
1161
1162 //_____________________________________________________________________________
1163 AliCDBParam::~AliCDBParam() {
1164 // destructor
1165
1166 }
1167