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 //_____________________________________________________________________________
  70 void AliCDBManager::Destroy() {
  71 // delete ALCDBManager instance and active storages
  72
  73         if (fgInstance) {
  74                 //fgInstance->Delete();
  75                 delete fgInstance;
  76                 fgInstance = 0x0;
  77         }
  78 }
  79
  80 //_____________________________________________________________________________
  81 AliCDBManager::AliCDBManager():
  82   TObject(),
  83   fCondParam(0),
  84   fRefParam(0),
  85   fFactories(),
  86   fActiveStorages(),
  87   fSpecificStorages(),
  88   fDefaultStorage(NULL),
  89   fDrainStorage(NULL),
  90   fEntryCache(),
  91   fCache(kTRUE),
  92   fRun(-1)
  93 {
  94 // default constuctor
  95         fFactories.SetOwner(1);
  96         fActiveStorages.SetOwner(1);
  97         fSpecificStorages.SetOwner(1);
  98         fEntryCache.SetOwner(1);
  99 }
 100
 101 //_____________________________________________________________________________
 102 AliCDBManager::~AliCDBManager() {
 103 // destructor
 104         ClearCache();
 105         DestroyActiveStorages();
 106         fFactories.Delete();
 107         fDrainStorage = 0x0;
 108         fDefaultStorage = 0x0;
 109         delete fCondParam;
 110         delete fRefParam;
 111 }
 112
 113 //_____________________________________________________________________________
 114 void AliCDBManager::PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage){
 115 // put a storage object into the list of active storages
 116
 117         fActiveStorages.Add(param, storage);
 118         AliDebug(1, Form("Active storages: %d", fActiveStorages.GetEntries()));
 119 }
 120
 121 //_____________________________________________________________________________
 122 void AliCDBManager::RegisterFactory(AliCDBStorageFactory* factory) {
 123 // add a storage factory to the list of registerd factories
 124
 125         if (!fFactories.Contains(factory)) {
 126                 fFactories.Add(factory);
 127         }
 128 }
 129
 130 //_____________________________________________________________________________
 131 Bool_t AliCDBManager::HasStorage(const char* dbString) const {
 132 // check if dbString is a URI valid for one of the registered factories
 133
 134         TIter iter(&fFactories);
 135
 136         AliCDBStorageFactory* factory=0;
 137         while ((factory = (AliCDBStorageFactory*) iter.Next())) {
 138
 139                 if (factory->Validate(dbString)) {
 140                         return kTRUE;
 141                 }
 142         }
 143
 144         return kFALSE;
 145 }
 146
 147 //_____________________________________________________________________________
 148 AliCDBParam* AliCDBManager::CreateParameter(const char* dbString) const {
 149 // create AliCDBParam object from URI string
 150
 151         TIter iter(&fFactories);
 152
 153         AliCDBStorageFactory* factory=0;
 154         while ((factory = (AliCDBStorageFactory*) iter.Next())) {
 155                 AliCDBParam* param = factory->CreateParameter(dbString);
 156                 if(param) return param;
 157         }
 158
 159         return NULL;
 160 }
 161
 162 //_____________________________________________________________________________
 163 AliCDBStorage* AliCDBManager::GetStorage(const char* dbString) {
 164 // get storage object from URI string
 165
 166         AliCDBParam* param = CreateParameter(dbString);
 167         if (!param) {
 168                 AliError(Form("Failed to activate requested storage! Check URI: %s", dbString));
 169                 return NULL;
 170         }
 171
 172         AliCDBStorage* aStorage = GetStorage(param);
 173
 174         delete param;
 175         return aStorage;
 176 }
 177
 178 //_____________________________________________________________________________
 179 AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) {
 180 // get storage object from AliCDBParam object
 181
 182         // if the list of active storages already contains
 183         // the requested storage, return it
 184         AliCDBStorage* aStorage = GetActiveStorage(param);
 185         if (aStorage) {
 186                 return aStorage;
 187         }
 188
 189         TIter iter(&fFactories);
 190
 191         AliCDBStorageFactory* factory=0;
 192
 193         // loop on the list of registered factories
 194         while ((factory = (AliCDBStorageFactory*) iter.Next())) {
 195
 196                 // each factory tries to create its storage from the parameter
 197                 aStorage = factory->Create(param);
 198                 if (aStorage) {
 199                         PutActiveStorage(param->CloneParam(), aStorage);
 200                         aStorage->SetURI(param->GetURI());
 201                         if(fRun >= 0) {
 202                                 aStorage->QueryCDB(fRun);
 203                         }
 204                         return aStorage;
 205                 }
 206         }
 207
 208         AliError(Form("Failed to activate requested storage! Check URI: %s", param->GetURI().Data()));
 209
 210         return NULL;
 211 }
 212
 213 //_____________________________________________________________________________
 214 AliCDBStorage* AliCDBManager::GetActiveStorage(const AliCDBParam* param) {
 215 // get a storage object from the list of active storages
 216
 217         return dynamic_cast<AliCDBStorage*> (fActiveStorages.GetValue(param));
 218 }
 219
 220 //_____________________________________________________________________________
 221 TList* AliCDBManager::GetActiveStorages() {
 222 // return list of active storages
 223 // user has responsibility to delete returned object
 224
 225         TList* result = new TList();
 226
 227         TIter iter(fActiveStorages.GetTable());
 228         TPair* aPair=0;
 229         while ((aPair = (TPair*) iter.Next())) {
 230                 result->Add(aPair->Value());
 231         }
 232
 233         return result;
 234 }
 235
 236 //_____________________________________________________________________________
 237 void AliCDBManager::SetDrain(const char* dbString) {
 238 // set drain storage from URI string
 239
 240         fDrainStorage = GetStorage(dbString);
 241 }
 242
 243 //_____________________________________________________________________________
 244 void AliCDBManager::SetDrain(const AliCDBParam* param) {
 245 // set drain storage from AliCDBParam
 246
 247         fDrainStorage = GetStorage(param);
 248 }
 249
 250 //_____________________________________________________________________________
 251 void AliCDBManager::SetDrain(AliCDBStorage* storage) {
 252 // set drain storage from another active storage
 253
 254         fDrainStorage = storage;
 255 }
 256
 257 //_____________________________________________________________________________
 258 Bool_t AliCDBManager::Drain(AliCDBEntry *entry) {
 259 // drain retrieved object to drain storage
 260
 261         AliDebug(2, "Draining into drain storage...");
 262         return fDrainStorage->Put(entry);
 263 }
 264
 265 //_____________________________________________________________________________
 266 void AliCDBManager::SetDefaultStorage(const char* dbString) {
 267 // sets default storage from URI string
 268
 269         AliInfo(Form("Setting Default storage to: %s",dbString));
 270         fDefaultStorage = GetStorage(dbString);
 271 }
 272
 273 //_____________________________________________________________________________
 274 void AliCDBManager::SetDefaultStorage(const AliCDBParam* param) {
 275 // set default storage from AliCDBParam object
 276
 277         fDefaultStorage = GetStorage(param);
 278 }
 279
 280 //_____________________________________________________________________________
 281 void AliCDBManager::SetDefaultStorage(AliCDBStorage* storage) {
 282 // set default storage from another active storage
 283
 284         fDefaultStorage = storage;
 285 }
 286
 287 //_____________________________________________________________________________
 288 void AliCDBManager::SetSpecificStorage(const char* calibType, const char* dbString) {
 289 // sets storage specific for detector or calibration type (works with AliCDBManager::Get(...))
 290
 291         AliCDBParam *aPar = CreateParameter(dbString);
 292         if(!aPar) return;
 293         SetSpecificStorage(calibType, aPar);
 294         delete aPar;
 295 }
 296
 297 //_____________________________________________________________________________
 298 void AliCDBManager::SetSpecificStorage(const char* calibType, AliCDBParam* param) {
 299 // sets storage specific for detector or calibration type (works with AliCDBManager::Get(...))
 300 // Default storage should be defined prior to any specific storages, e.g.:
 301 // AliCDBManager::instance()->SetDefaultStorage("alien://");
 302 // AliCDBManager::instance()->SetSpecificStorage("TPC/*","local://DB_TPC");
 303 // AliCDBManager::instance()->SetSpecificStorage("*/Align/*","local://DB_TPCAlign");
 304 // calibType must be a valid CDB path! (3 level folder structure)
 305
 306         if(!fDefaultStorage) {
 307                 AliError("Please activate a default storage first!");
 308                 return;
 309         }
 310
 311         AliCDBPath aPath(calibType);
 312         if(!aPath.IsValid()){
 313                 AliError(Form("Not a valid path: %s", calibType));
 314                 return;
 315         }
 316
 317         TObjString *objCalibType = new TObjString(aPath.GetPath());
 318         if(fSpecificStorages.Contains(objCalibType)){
 319                 AliWarning(Form("Storage \"%s\" already activated! It will be replaced by the new one",
 320                                         calibType));
 321                 delete fSpecificStorages.Remove(objCalibType);
 322         }
 323         GetStorage(param);
 324         fSpecificStorages.Add(objCalibType, param->CloneParam());
 325 }
 326
 327 //_____________________________________________________________________________
 328 AliCDBStorage* AliCDBManager::GetSpecificStorage(const char* calibType) {
 329 // get storage specific for detector or calibration type
 330
 331         AliCDBParam *checkPar = (AliCDBParam*) fSpecificStorages.GetValue(calibType);
 332         if(!checkPar){
 333                 AliError(Form("%s storage not found!", calibType));
 334                 return NULL;
 335         } else {
 336                 return GetStorage(checkPar);
 337         }
 338
 339 }
 340
 341 //_____________________________________________________________________________
 342 AliCDBParam* AliCDBManager::SelectSpecificStorage(const TString& path) {
 343 // select storage valid for path from the list of specific storages
 344
 345         AliCDBPath aPath(path);
 346         if(!aPath.IsValid()){
 347                 AliError(Form("Not a valid path: %s", path.Data()));
 348                 return NULL;
 349         }
 350
 351         TIter iter(&fSpecificStorages);
 352         TObjString *aCalibType=0;
 353         AliCDBParam* aPar=0;
 354         while((aCalibType = (TObjString*) iter.Next())){
 355                 AliCDBPath calibTypePath(aCalibType->GetName());
 356                 if(calibTypePath.Comprises(aPath)) {
 357                         aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType);
 358                         break;
 359                 }
 360         }
 361         return aPar;
 362 }
 363
 364 //_____________________________________________________________________________
 365 AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber,
 366         Int_t version, Int_t subVersion) {
 367 // get an AliCDBEntry object from the database
 368
 369         if(runNumber < 0){
 370                 // RunNumber is not specified. Try with fRun
 371                 if (fRun < 0){
 372                         AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
 373                         return NULL;
 374                 }
 375                 runNumber = fRun;
 376         }
 377
 378         return Get(AliCDBId(path, runNumber, runNumber, version, subVersion));
 379 }
 380
 381 //_____________________________________________________________________________
 382 AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path,
 383         const AliCDBRunRange& runRange, Int_t version,
 384         Int_t subVersion) {
 385 // get an AliCDBEntry object from the database!
 386
 387         return Get(AliCDBId(path, runRange, version, subVersion));
 388 }
 389
 390 //_____________________________________________________________________________
 391 AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) {
 392 // get an AliCDBEntry object from the database
 393
 394         if(!fDefaultStorage) {
 395                 AliError("No storage set!");
 396                 return NULL;
 397         }
 398
 399         // check if query's path and runRange are valid
 400         // query is invalid also if version is not specified and subversion is!
 401         if (!query.IsValid()) {
 402                 AliError(Form("Invalid query: %s", query.ToString().Data()));
 403                 return NULL;
 404         }
 405
 406         // query is not specified if path contains wildcard or run range= [-1,-1]
 407         if (!query.IsSpecified()) {
 408                 AliError(Form("Unspecified query: %s",
 409                                 query.ToString().Data()));
 410                 return NULL;
 411         }
 412
 413         if(fCache && query.GetFirstRun() != fRun)
 414                 AliWarning("Run number explicitly set in query: CDB cache temporarily disabled!");
 415
 416
 417         AliCDBEntry *entry=0;
 418
 419         // first look into map of cached objects
 420         if(fCache && query.GetFirstRun() == fRun)
 421                 entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath());
 422
 423         if(entry) {
 424                 AliDebug(2, Form("Object %s retrieved from cache !!",query.GetPath().Data()));
 425                 return entry;
 426         }
 427
 428         // Entry is not in cache -> retrieve it from CDB and cache it!!
 429         AliCDBStorage *aStorage=0;
 430         AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
 431
 432         if(aPar) {
 433                 aStorage=GetStorage(aPar);
 434                 TString str = aPar->GetURI();
 435                 AliDebug(2,Form("Looking into storage: %s",str.Data()));
 436
 437         } else {
 438                 aStorage=GetDefaultStorage();
 439                 AliDebug(2,"Looking into default storage");
 440         }
 441
 442         entry = aStorage->Get(query);
 443         if (!entry) return NULL;
 444
 445         if(fCache && (query.GetFirstRun() == fRun)){
 446                 AliDebug(2,Form("Caching entry %s !",query.GetPath().Data()));
 447                 CacheEntry(query.GetPath(), entry);
 448         }
 449
 450         return entry;
 451
 452 }
 453
 454 //_____________________________________________________________________________
 455 TList* AliCDBManager::GetAll(const AliCDBPath& path, Int_t runNumber,
 456         Int_t version, Int_t subVersion) {
 457 // get multiple AliCDBEntry objects from the database
 458
 459         if(runNumber < 0){
 460                 // RunNumber is not specified. Try with fRun
 461                 if (fRun < 0){
 462                         AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
 463                         return NULL;
 464                 }
 465                 runNumber = fRun;
 466         }
 467
 468         return GetAll(AliCDBId(path, runNumber, runNumber, version,
 469                         subVersion));
 470 }
 471
 472 //_____________________________________________________________________________
 473 TList* AliCDBManager::GetAll(const AliCDBPath& path,
 474         const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) {
 475 // get multiple AliCDBEntry objects from the database
 476
 477         return GetAll(AliCDBId(path, runRange, version, subVersion));
 478 }
 479
 480 //_____________________________________________________________________________
 481 TList* AliCDBManager::GetAll(const AliCDBId& query) {
 482 // get multiple AliCDBEntry objects from the database
 483 // Warning: this method works correctly only for queries of the type "Detector/*"
 484 //              and not for more specific queries e.g. "Detector/Calib/*" !
 485 // Warning #2: Entries are cached, but GetAll will keep on retrieving objects from OCDB!
 486 //              To get an object from cache use Get() function
 487
 488         if(!fDefaultStorage) {
 489                 AliError("No storage set!");
 490                 return NULL;
 491         }
 492
 493         if (!query.IsValid()) {
 494                 AliError(Form("Invalid query: %s", query.ToString().Data()));
 495                 return NULL;
 496         }
 497
 498         if((fSpecificStorages.GetEntries()>0) && query.GetPath().BeginsWith('*')){
 499                 // if specific storages are active a query with "*" is ambiguous
 500                 AliError("Query too generic in this context!");
 501                 return NULL;
 502         }
 503
 504         if (query.IsAnyRange()) {
 505                 AliError(Form("Unspecified run or runrange: %s",
 506                                 query.ToString().Data()));
 507                 return NULL;
 508         }
 509
 510         TObjString objStrLev0(query.GetLevel0());
 511         //AliCDBParam *aPar = (AliCDBParam*) fSpecificStorages.GetValue(&objStrLev0);
 512         AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
 513
 514         AliCDBStorage *aStorage;
 515         if(aPar) {
 516                 aStorage=GetStorage(aPar);
 517                 TString str = aPar->GetURI();
 518                 AliDebug(2,Form("Looking into storage: %s",str.Data()));
 519
 520         } else {
 521                 aStorage=GetDefaultStorage();
 522                 AliDebug(2,"Looking into default storage");
 523         }
 524
 525         TList *result = aStorage->GetAll(query);
 526         if(!result) return 0;
 527
 528         // caching entries
 529         if(fCache && (query.GetFirstRun() == fRun)){
 530
 531                 TIter iter(result);
 532                 AliCDBEntry* entry=0;
 533                 while((entry = dynamic_cast<AliCDBEntry*> (iter.Next()))){
 534                         const AliCDBId& anId = entry->GetId();
 535                         AliDebug(2,Form("Caching entry %s !", anId.GetPath().Data()));
 536                         CacheEntry(anId.GetPath(), entry);
 537                 }
 538         }
 539
 540         return result;
 541 }
 542
 543 //_____________________________________________________________________________
 544 Bool_t AliCDBManager::Put(TObject* object, AliCDBId& id,  AliCDBMetaData* metaData, DataType type){
 545 // store an AliCDBEntry object into the database
 546
 547         AliCDBEntry anEntry(object, id, metaData);
 548         return Put(&anEntry, type);
 549
 550 }
 551
 552
 553 //_____________________________________________________________________________
 554 Bool_t AliCDBManager::Put(AliCDBEntry* entry, DataType type){
 555 // store an AliCDBEntry object into the database
 556
 557         if(type == kPrivate && !fDefaultStorage) {
 558                 AliError("No storage set!");
 559                 return kFALSE;
 560         }
 561
 562         if (!entry){
 563                 AliError("No entry!");
 564                 return kFALSE;
 565         }
 566
 567         if (!entry->GetId().IsValid()) {
 568                 AliError(Form("Invalid entry ID: %s",
 569                         entry->GetId().ToString().Data()));
 570                 return kFALSE;
 571         }
 572
 573         if (!entry->GetId().IsSpecified()) {
 574                 AliError(Form("Unspecified entry ID: %s",
 575                         entry->GetId().ToString().Data()));
 576                 return kFALSE;
 577         }
 578
 579         AliCDBId id = entry->GetId();
 580         AliCDBParam *aPar = SelectSpecificStorage(id.GetPath());
 581
 582         AliCDBStorage *aStorage;
 583
 584         if(aPar) {
 585                 aStorage=GetStorage(aPar);
 586         } else {
 587                 switch(type){
 588                         case kCondition:
 589                                 aStorage = GetStorage(fCondParam);
 590                                 break;
 591                         case kReference:
 592                                 aStorage = GetStorage(fRefParam);
 593                                 break;
 594                         case kPrivate:
 595                                 aStorage = GetDefaultStorage();
 596                                 break;
 597                 }
 598         }
 599
 600         AliDebug(2,Form("Storing object into storage: %s", aStorage->GetURI().Data()));
 601
 602         return aStorage->Put(entry, type);
 603
 604
 605 }
 606
 607 //_____________________________________________________________________________
 608 void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry)
 609 {
 610 // cache AliCDBEntry. Cache is valid until run number is changed.
 611
 612         AliDebug(2,Form("Filling cache with entry %s",path));
 613         fEntryCache.Add(new TObjString(path), entry);
 614         AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
 615
 616 }
 617
 618 //_____________________________________________________________________________
 619 void AliCDBManager::Print(Option_t* /*option*/) const
 620 {
 621 // Print list of active storages and their URIs
 622
 623         TString output=Form("Run number = %d; ",fRun);
 624         output += "Cache is ";
 625         if(!fCache) output += "NOT ";
 626         output += Form("ACTIVE; Number of active storages: %d\n",fActiveStorages.GetEntries());
 627
 628         if(fDefaultStorage) {
 629                 output += Form("\t*** Default Storage URI: \"%s\"\n",fDefaultStorage->GetURI().Data());
 630 //              AliInfo(output.Data());
 631         }
 632         if(fSpecificStorages.GetEntries()>0) {
 633                 TIter iter(fSpecificStorages.GetTable());
 634                 TPair *aPair=0;
 635                 Int_t i=1;
 636                 while((aPair = (TPair*) iter.Next())){
 637                         output += Form("\t*** Specific storage %d: Path \"%s\" -> URI \"%s\"\n",
 638                                 i++, ((TObjString*) aPair->Key())->GetName(),
 639                                 ((AliCDBParam*) aPair->Value())->GetURI().Data());
 640                 }
 641         }
 642         if(fDrainStorage) {
 643                 output += Form("*** Drain Storage URI: %s\n",fDrainStorage->GetURI().Data());
 644         }
 645         AliInfo(output.Data());
 646 }
 647
 648 //_____________________________________________________________________________
 649 void AliCDBManager::SetRun(Int_t run)
 650 {
 651 // Sets current run number.
 652 // When the run number changes the caching is cleared.
 653
 654         if (fRun == run)
 655                 return;
 656
 657         fRun = run;
 658         ClearCache();
 659         QueryCDB();
 660 }
 661
 662 //_____________________________________________________________________________
 663 void AliCDBManager::ClearCache(){
 664 // clear AliCDBEntry cache
 665
 666         AliDebug(2,Form("Clearing cache!"));
 667         fEntryCache.DeleteAll();
 668         AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
 669
 670 }
 671
 672 //_____________________________________________________________________________
 673 void AliCDBManager::DestroyActiveStorages() {
 674 // delete list of active storages
 675
 676         fActiveStorages.DeleteAll();
 677         fSpecificStorages.DeleteAll();
 678 }
 679
 680 //_____________________________________________________________________________
 681 void AliCDBManager::DestroyActiveStorage(AliCDBStorage* /*storage*/) {
 682 // destroys active storage
 683
 684 /*
 685         TIter iter(fActiveStorages.GetTable());
 686         TPair* aPair;
 687         while ((aPair = (TPair*) iter.Next())) {
 688                 if(storage == (AliCDBStorage*) aPair->Value())
 689                         delete fActiveStorages.Remove(aPair->Key());
 690                         storage->Delete(); storage=0x0;
 691         }
 692 */
 693
 694 }
 695
 696 //_____________________________________________________________________________
 697 void AliCDBManager::QueryCDB() {
 698 // query default and specific storages for files valid for fRun. Every storage loads the Ids into its list.
 699
 700         if (fRun < 0){
 701                 AliError("Run number not yet set! Use AliCDBManager::SetRun.");
 702         return;
 703         }
 704         if (!fDefaultStorage){
 705                 AliError("Default storage is not set! Use AliCDBManager::SetDefaultStorage");
 706         return;
 707         }
 708         if(fDefaultStorage->GetType() == "alien"){
 709                 fDefaultStorage->QueryCDB(fRun);
 710         } else {
 711                 AliDebug(2,"Skipping query for valid files, it used only in grid...");
 712         }
 713
 714         TIter iter(&fSpecificStorages);
 715         TObjString *aCalibType=0;
 716         AliCDBParam* aPar=0;
 717         while((aCalibType = dynamic_cast<TObjString*> (iter.Next()))){
 718                 aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType);
 719                 if(aPar) {
 720                         AliDebug(2,Form("Querying specific storage %s",aCalibType->GetName()));
 721                         AliCDBStorage *aStorage = GetStorage(aPar);
 722                         if(aStorage->GetType() == "alien"){
 723                                 aStorage->QueryCDB(fRun,aCalibType->GetName());
 724                         } else {
 725                                 AliDebug(2,
 726                                         "Skipping query for valid files, it is used only in grid...");
 727                         }
 728                 }
 729         }
 730 }
 731
 732 //______________________________________________________________________________________________
 733 const char* AliCDBManager::GetDataTypeName(DataType type)
 734 {
 735   // returns the name (string) of the data type
 736
 737       switch (type){
 738             case kCondition: return "Conditions";
 739             case kReference: return "Reference";
 740             case kPrivate: return "Private";
 741      }
 742      return 0;
 743
 744 }
 745
 746 ///////////////////////////////////////////////////////////
 747 // AliCDBManager Parameter class                         //
 748 // interface to specific AliCDBParameter class           //
 749 // (AliCDBGridParam, AliCDBLocalParam, AliCDBDumpParam)  //
 750 ///////////////////////////////////////////////////////////
 751
 752 AliCDBParam::AliCDBParam():
 753   fType(),
 754   fURI()
 755 {
 756 // constructor
 757
 758 }
 759
 760 //_____________________________________________________________________________
 761 AliCDBParam::~AliCDBParam() {
 762 // destructor
 763
 764 }
 765