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