STEER/CDB/AliCDBStorage.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 #include <TKey.h>
  17 #include <TH1.h>
  18 #include <TTree.h>
  19 #include <TNtuple.h>
  20 #include <TFile.h>
  21 #include "AliCDBStorage.h"
  22 #include "AliCDBGrid.h"
  23
  24 #include "AliCDBEntry.h"
  25 #include "AliLog.h"
  26
  27 ClassImp(AliCDBStorage)
  28
  29 //_____________________________________________________________________________
  30 AliCDBStorage::AliCDBStorage():
  31 fValidFileIds(),
  32 fRun(-1),
  33 fPathFilter(),
  34 fVersion(-1),
  35 fMetaDataFilter(0),
  36 fSelections(),
  37 fURI(),
  38 fType(),
  39 fBaseFolder(),
  40 fNretry(0),
  41 fInitRetrySeconds(0)
  42 {
  43 // constructor
  44
  45         fValidFileIds.SetOwner(1);
  46         fSelections.SetOwner(1);
  47 }
  48
  49 //_____________________________________________________________________________
  50 AliCDBStorage::~AliCDBStorage() {
  51 // destructor
  52
  53         RemoveAllSelections();
  54         fValidFileIds.Clear();
  55         delete fMetaDataFilter;
  56
  57 }
  58
  59 //_____________________________________________________________________________
  60 void AliCDBStorage::GetSelection(/*const*/ AliCDBId* id) {
  61 // return required version and subversion from the list of selection criteria
  62
  63         TIter iter(&fSelections);
  64         AliCDBId* aSelection;
  65
  66         // loop on the list of selection criteria
  67         while ((aSelection = (AliCDBId*) iter.Next())) {
  68                 // check if selection element contains id's path and run (range)
  69                 if (aSelection->Comprises(*id)) {
  70                         AliDebug(2,Form("Using selection criterion: %s ", aSelection->ToString().Data()));
  71                         // return required version and subversion
  72
  73                         id->SetVersion(aSelection->GetVersion());
  74                         id->SetSubVersion(aSelection->GetSubVersion());
  75                         return;
  76                 }
  77         }
  78
  79         // no valid element is found in the list of selection criteria -> return
  80         AliDebug(2,"Looking for objects with most recent version");
  81         return;
  82 }
  83
  84 //_____________________________________________________________________________
  85 void AliCDBStorage::ReadSelectionFromFile(const char *fileName){
  86 // read selection criteria list from file
  87
  88         RemoveAllSelections();
  89
  90         TList *list = GetIdListFromFile(fileName);
  91         if(!list) return;
  92
  93         list->SetOwner();
  94         Int_t nId = list->GetEntries();
  95         AliCDBId *id;
  96         TKey *key;
  97
  98         for(int i=nId-1;i>=0;i--){
  99                 key = (TKey*) list->At(i);
 100                 id = (AliCDBId*) key->ReadObj();
 101                 if(id) AddSelection(*id);
 102         }
 103         delete list;
 104         AliInfo(Form("Selection criteria list filled with %d entries",fSelections.GetEntries()));
 105         PrintSelectionList();
 106
 107 }
 108
 109 //_____________________________________________________________________________
 110 void AliCDBStorage::AddSelection(const AliCDBId& selection) {
 111 // add a selection criterion
 112
 113         AliCDBPath path = selection.GetPath();
 114         if(!path.IsValid()) return;
 115
 116         TIter iter(&fSelections);
 117         const AliCDBId *anId;
 118         while((anId = (AliCDBId*) iter.Next())){
 119                 if(selection.Comprises(*anId)){
 120                         AliWarning("This selection is more general than a previous one and will hide it!");
 121                         AliWarning(Form("%s", (anId->ToString()).Data()));
 122                         fSelections.AddBefore(anId, new AliCDBId(selection));
 123                         return;
 124                 }
 125
 126         }
 127         fSelections.AddFirst(new AliCDBId(selection));
 128 }
 129
 130 //_____________________________________________________________________________
 131 void AliCDBStorage::AddSelection(const AliCDBPath& path,
 132         const AliCDBRunRange& runRange, Int_t version, Int_t subVersion){
 133 // add a selection criterion
 134
 135         AddSelection(AliCDBId(path, runRange, version, subVersion));
 136 }
 137
 138 //_____________________________________________________________________________
 139 void AliCDBStorage::AddSelection(const AliCDBPath& path,
 140         Int_t firstRun, Int_t lastRun, Int_t version, Int_t subVersion){
 141 // add a selection criterion
 142
 143         AddSelection(AliCDBId(path, firstRun, lastRun, version, subVersion));
 144 }
 145
 146 //_____________________________________________________________________________
 147 void AliCDBStorage::RemoveSelection(const AliCDBId& selection) {
 148 // remove a selection criterion
 149
 150         TIter iter(&fSelections);
 151         AliCDBId* aSelection;
 152
 153         while ((aSelection = (AliCDBId*) iter.Next())) {
 154                 if (selection.Comprises(*aSelection)) {
 155                         fSelections.Remove(aSelection);
 156                 }
 157         }
 158 }
 159
 160 //_____________________________________________________________________________
 161 void AliCDBStorage::RemoveSelection(const AliCDBPath& path,
 162         const AliCDBRunRange& runRange){
 163 // remove a selection criterion
 164
 165         RemoveSelection(AliCDBId(path, runRange, -1, -1));
 166 }
 167
 168 //_____________________________________________________________________________
 169 void AliCDBStorage::RemoveSelection(const AliCDBPath& path,
 170         Int_t firstRun, Int_t lastRun){
 171 // remove a selection criterion
 172
 173         RemoveSelection(AliCDBId(path, firstRun, lastRun, -1, -1));
 174 }
 175
 176 //_____________________________________________________________________________
 177 void AliCDBStorage::RemoveSelection(int position){
 178 // remove a selection criterion from its position in the list
 179
 180         delete fSelections.RemoveAt(position);
 181 }
 182
 183 //_____________________________________________________________________________
 184 void AliCDBStorage::RemoveAllSelections(){
 185 // remove all selection criteria
 186
 187         fSelections.Clear();
 188 }
 189
 190 //_____________________________________________________________________________
 191 void AliCDBStorage::PrintSelectionList(){
 192 // prints the list of selection criteria
 193
 194         TIter iter(&fSelections);
 195         AliCDBId* aSelection;
 196
 197         // loop on the list of selection criteria
 198         int index=0;
 199         while ((aSelection = (AliCDBId*) iter.Next())) {
 200                 AliInfo(Form("index %d -> selection: %s",index++, aSelection->ToString().Data()));
 201         }
 202
 203 }
 204
 205 //_____________________________________________________________________________
 206 AliCDBEntry* AliCDBStorage::Get(const AliCDBId& query) {
 207 // get an AliCDBEntry object from the database
 208
 209         // check if query's path and runRange are valid
 210         // query is invalid also if version is not specified and subversion is!
 211         if (!query.IsValid()) {
 212                 AliError(Form("Invalid query: %s", query.ToString().Data()));
 213                 return NULL;
 214         }
 215
 216         // query is not specified if path contains wildcard or runrange = [-1,-1]
 217         if (!query.IsSpecified()) {
 218                 AliError(Form("Unspecified query: %s",
 219                                 query.ToString().Data()));
 220                 return NULL;
 221         }
 222
 223         // This is needed otherwise TH1  objects (histos, TTree's) are lost when file is closed!
 224         Bool_t oldStatus = TH1::AddDirectoryStatus();
 225         TH1::AddDirectory(kFALSE);
 226
 227         AliCDBEntry* entry = GetEntry(query);
 228
 229         if (oldStatus != kFALSE)
 230                 TH1::AddDirectory(kTRUE);
 231
 232         if (entry) {
 233                 // this is to make the SHUTTLE output lighter
 234                 if(!(query.GetPath().Contains("SHUTTLE/STATUS")))
 235                         AliDebug(2, Form("CDB object retrieved: %s", entry->GetId().ToString().Data()));
 236         } else {
 237                 // this is to make the SHUTTLE output lighter
 238                 if(!(query.GetPath().Contains("SHUTTLE/STATUS"))){
 239
 240                         if(!(query.GetPath().Contains("SHUTTLE"))){
 241                                 AliFatal(Form("No valid CDB object found! request was: %s", query.ToString().Data()));
 242                         }
 243                         else {
 244                                 AliInfo(Form("No valid CDB object found! request was: %s", query.ToString().Data()));
 245                         }
 246                 }
 247         }
 248
 249         // if drain storage is set, drain entry into drain storage
 250         if(entry && (AliCDBManager::Instance())->IsDrainSet())
 251                 AliCDBManager::Instance()->Drain(entry);
 252
 253         return entry;
 254 }
 255
 256 //_____________________________________________________________________________
 257 AliCDBEntry* AliCDBStorage::Get(const AliCDBPath& path, Int_t runNumber,
 258         Int_t version, Int_t subVersion) {
 259 // get an AliCDBEntry object from the database
 260
 261         return Get(AliCDBId(path, runNumber, runNumber, version, subVersion));
 262 }
 263
 264 //_____________________________________________________________________________
 265 AliCDBEntry* AliCDBStorage::Get(const AliCDBPath& path,
 266         const AliCDBRunRange& runRange, Int_t version,
 267         Int_t subVersion) {
 268 // get an AliCDBEntry object from the database
 269
 270         return Get(AliCDBId(path, runRange, version, subVersion));
 271 }
 272
 273 //_____________________________________________________________________________
 274 TList* AliCDBStorage::GetAll(const AliCDBId& query) {
 275 // get multiple AliCDBEntry objects from the database
 276
 277
 278         if (!query.IsValid()) {
 279                 AliError(Form("Invalid query: %s", query.ToString().Data()));
 280                 return NULL;
 281         }
 282
 283         if (query.IsAnyRange()) {
 284                 AliError(Form("Unspecified run or runrange: %s",
 285                                 query.ToString().Data()));
 286                 return NULL;
 287         }
 288
 289         // This is needed otherwise TH1  objects (histos, TTree's) are lost when file is closed!
 290         Bool_t oldStatus = TH1::AddDirectoryStatus();
 291         TH1::AddDirectory(kFALSE);
 292
 293         TList *result = GetEntries(query);
 294
 295         if (oldStatus != kFALSE)
 296                 TH1::AddDirectory(kTRUE);
 297
 298         Int_t nEntries = result->GetEntries();
 299
 300         AliInfo(Form("%d objects retrieved. Request was: %s",
 301                         nEntries, query.ToString().Data()));
 302         for(int i=0; i<nEntries;i++){
 303                 AliCDBEntry *entry = (AliCDBEntry*) result->At(i);
 304                 AliInfo(Form("%s",entry->GetId().ToString().Data()));
 305         }
 306
 307
 308         // if drain storage is set, drain entries into drain storage
 309         if((AliCDBManager::Instance())->IsDrainSet()){
 310                 for(int i = 0; i<result->GetEntries(); i++){
 311                         AliCDBEntry* entry = (AliCDBEntry*) result->At(i);
 312                         AliCDBManager::Instance()->Drain(entry);
 313                 }
 314         }
 315
 316
 317         return result;
 318 }
 319
 320 //_____________________________________________________________________________
 321 TList* AliCDBStorage::GetAll(const AliCDBPath& path, Int_t runNumber,
 322         Int_t version, Int_t subVersion) {
 323 // get multiple AliCDBEntry objects from the database
 324
 325         return GetAll(AliCDBId(path, runNumber, runNumber, version,
 326                         subVersion));
 327 }
 328
 329 //_____________________________________________________________________________
 330 TList* AliCDBStorage::GetAll(const AliCDBPath& path,
 331         const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) {
 332 // get multiple AliCDBEntry objects from the database
 333
 334         return GetAll(AliCDBId(path, runRange, version, subVersion));
 335 }
 336
 337 //_____________________________________________________________________________
 338 AliCDBId* AliCDBStorage::GetId(const AliCDBId& query) {
 339 // get the Id of the valid object from the database (does not open the file)
 340
 341         // check if query's path and runRange are valid
 342         // query is invalid also if version is not specified and subversion is!
 343         if (!query.IsValid()) {
 344                 AliError(Form("Invalid query: %s", query.ToString().Data()));
 345                 return NULL;
 346         }
 347
 348         // query is not specified if path contains wildcard or runrange = [-1,-1]
 349         if (!query.IsSpecified()) {
 350                 AliError(Form("Unspecified query: %s",
 351                                 query.ToString().Data()));
 352                 return NULL;
 353         }
 354
 355         AliCDBId* id = GetEntryId(query);
 356
 357         return id;
 358 }
 359
 360 //_____________________________________________________________________________
 361 AliCDBId* AliCDBStorage::GetId(const AliCDBPath& path, Int_t runNumber,
 362         Int_t version, Int_t subVersion) {
 363 // get the Id of the valid object from the database (does not open the file)
 364
 365         return GetId(AliCDBId(path, runNumber, runNumber, version, subVersion));
 366 }
 367
 368 //_____________________________________________________________________________
 369 AliCDBId* AliCDBStorage::GetId(const AliCDBPath& path,
 370         const AliCDBRunRange& runRange, Int_t version,
 371         Int_t subVersion) {
 372 // get the Id of the valid object from the database (does not open the file)
 373
 374         return GetId(AliCDBId(path, runRange, version, subVersion));
 375 }
 376
 377 //_____________________________________________________________________________
 378 Bool_t AliCDBStorage::Put(TObject* object, AliCDBId& id, AliCDBMetaData* metaData, const char* mirrors, AliCDBManager::DataType type) {
 379 // store an AliCDBEntry object into the database
 380
 381         if (object==0x0) {
 382                 AliError("Null Entry! No storage will be done!");
 383                 return kFALSE;
 384         }
 385
 386         AliCDBEntry anEntry(object, id, metaData);
 387
 388         return Put(&anEntry, mirrors, type);
 389 }
 390
 391 //_____________________________________________________________________________
 392 Bool_t AliCDBStorage::Put(AliCDBEntry* entry, const char* mirrors, AliCDBManager::DataType type) {
 393 // store an AliCDBEntry object into the database
 394
 395         if (!entry){
 396                 AliError("No entry!");
 397                 return kFALSE;
 398         }
 399
 400         if (entry->GetObject()==0x0){
 401                 AliError("No valid object in CDB entry!");
 402                 return kFALSE;
 403         }
 404
 405         if (!entry->GetId().IsValid()) {
 406                 AliError(Form("Invalid entry ID: %s",
 407                         entry->GetId().ToString().Data()));
 408                 return kFALSE;
 409         }
 410
 411         if (!entry->GetId().IsSpecified()) {
 412                 AliError(Form("Unspecified entry ID: %s",
 413                         entry->GetId().ToString().Data()));
 414                 return kFALSE;
 415         }
 416
 417         AliCDBManager::DataType expectedType = GetDataType();
 418
 419         if(expectedType != AliCDBManager::kPrivate && type != expectedType) {
 420                 AliError(Form("It is forbidden to store %s data into a folder of type %s!",
 421                         AliCDBManager::GetDataTypeName(type),
 422                         AliCDBManager::GetDataTypeName(expectedType)));
 423                         return 0;
 424         }
 425
 426
 427         TString strMirrors(mirrors);
 428         if(!strMirrors.IsNull() && !strMirrors.IsWhitespace())
 429             return PutEntry(entry, mirrors);
 430         else
 431             return PutEntry(entry);
 432 }
 433
 434 //_____________________________________________________________________________
 435 void AliCDBStorage::QueryCDB(Int_t run, const char* pathFilter,
 436                                 Int_t version, AliCDBMetaData* md){
 437 // query CDB for files valid for given run, and fill list fValidFileIds
 438 // Actual query is done in virtual function QueryValidFiles()
 439
 440         fRun = run;
 441
 442         fPathFilter = pathFilter;
 443         if(!fPathFilter.IsValid()) {
 444                 AliError(Form("Filter not valid: %s", pathFilter));
 445                 fPathFilter = "*";
 446                 return;
 447         }
 448
 449         fVersion = version;
 450
 451         AliInfo(Form("Querying files valid for run %d and path \"%s\" into CDB storage  \"%s://%s\"",
 452                                 fRun, pathFilter, fType.Data(), fBaseFolder.Data()));
 453
 454         // Clear fValidFileIds list (it cannot be filled twice!
 455         AliDebug(2, "Clearing list of CDB Id's previously loaded");
 456         fValidFileIds.Clear();
 457
 458         if(fMetaDataFilter) {delete fMetaDataFilter; fMetaDataFilter=0;}
 459         if(md) fMetaDataFilter = dynamic_cast<AliCDBMetaData*> (md->Clone());
 460
 461         QueryValidFiles();
 462
 463         AliInfo(Form("%d valid files found!", fValidFileIds.GetEntriesFast()));
 464
 465 }
 466
 467 //_____________________________________________________________________________
 468 void AliCDBStorage::PrintQueryCDB(){
 469 // print parameters used to load list of CDB Id's (fRun, fPathFilter, fVersion)
 470
 471         AliCDBId paramId(fPathFilter, fRun, fRun, fVersion);
 472         AliInfo(Form("**** QueryCDB Parameters **** \n\t<%s>\n",
 473                                 paramId.ToString().Data()));
 474
 475         if(fMetaDataFilter) fMetaDataFilter->PrintMetaData();
 476
 477
 478         TString message = "**** Id's of valid objects found *****\n";
 479         TIter iter(&fValidFileIds);
 480         AliCDBId* anId=0;
 481
 482         // loop on the list of selection criteria
 483         while ((anId = dynamic_cast<AliCDBId*>(iter.Next()))) {
 484                 message += Form("\t%s\n", anId->ToString().Data());
 485         }
 486         message += Form("\n\tTotal: %d objects found\n", fValidFileIds.GetEntriesFast());
 487         AliInfo(Form("%s", message.Data()));
 488 }
 489
 490 //_____________________________________________________________________________
 491 AliCDBManager::DataType AliCDBStorage::GetDataType() const {
 492 // returns the type of the data that should be stored into this storage:
 493 // kConditions: conditions data; kReference: reference data; kPrivate: private (user-defined) data type
 494
 495         if(GetType() != "alien") return AliCDBManager::kPrivate;
 496
 497         TString condFolder = ((AliCDBGridParam*) AliCDBManager::Instance()->GetCondParam())->GetDBFolder();
 498         TString refFolder = ((AliCDBGridParam*) AliCDBManager::Instance()->GetRefParam())->GetDBFolder();
 499
 500         if(GetBaseFolder().Contains(condFolder)) return AliCDBManager::kCondition;
 501         if(GetBaseFolder().Contains(refFolder)) return AliCDBManager::kReference;
 502
 503         return AliCDBManager::kPrivate;
 504 }
 505
 506 //_____________________________________________________________________________
 507 void AliCDBStorage::SetMirrorSEs(const char* mirrors) {
 508 // if the current storage is not of "alien" type, just issue a warning
 509 // AliCDBGrid implements its own SetMirrorSEs method, classes for other storage types do not
 510
 511         TString storageType = GetType();
 512         if(storageType != "alien"){
 513             AliWarning(Form("The current storage is of type \"%s\". Setting of SEs to \"%s\" skipped!",storageType.Data(),mirrors));
 514             return;
 515         }
 516         AliError("We should never get here!! AliCDBGrid must have masked this virtual method!");
 517         return;
 518 }
 519
 520 //_____________________________________________________________________________
 521 const char* AliCDBStorage::GetMirrorSEs() const {
 522 // if the current storage is not of "alien" type, just issue a warning
 523 // AliCDBGrid implements its own GetMirrorSEs method, classes for other storage types do not
 524
 525         TString storageType = GetType();
 526         if(storageType != "alien"){
 527             AliWarning(Form("The current storage is of type \"%s\" and cannot handle SEs. Returning empty string!",storageType.Data()));
 528             return "";
 529         }
 530         AliError("We should never get here!! AliCDBGrid must have masked this virtual method!");
 531         return "";
 532 }
 533
 534 //_____________________________________________________________________________
 535 void AliCDBStorage::LoadTreeFromFile(AliCDBEntry *entry) const {
 536 // Checks whether entry contains a TTree and in case loads it into memory
 537
 538         TObject *obj = (TObject*) entry->GetObject();
 539         if (!obj) {
 540           AliError("Cannot retrieve the object:");
 541           entry->PrintMetaData();
 542           return;
 543         }
 544
 545         if (!strcmp(obj->ClassName(),TTree::Class_Name())) {
 546
 547                 AliWarning("Entry contains a TTree! Loading baskets...");
 548
 549                 TTree* tree = dynamic_cast<TTree*> (obj);
 550
 551                 if(!tree) return;
 552
 553                 tree->LoadBaskets();
 554                 tree->SetDirectory(0);
 555         }
 556         else if (!strcmp(obj->ClassName(),TNtuple::Class_Name())){
 557
 558                 AliWarning("Entry contains a TNtuple! Loading baskets...");
 559
 560                 TNtuple* ntu = dynamic_cast<TNtuple*> (obj);
 561
 562                 if(!ntu) return;
 563
 564                 ntu->LoadBaskets();
 565                 ntu->SetDirectory(0);
 566         }
 567
 568         return;
 569 }
 570
 571 // //_____________________________________________________________________________
 572 // void AliCDBStorage::SetTreeToFile(AliCDBEntry *entry, TFile* file) const {
 573 // // Checks whether entry contains a TTree and in case assigns it to memory
 574 //
 575 //      AliCDBMetaData *md = dynamic_cast<AliCDBMetaData*> (entry->GetMetaData());
 576 //      if(!md) return;
 577 //      TString objStr = md->GetObjectClassName();
 578 //      if(objStr != "TTree") return;
 579 //      AliWarning("Entry contains a TTree! Setting file...");
 580 //
 581 //      TTree* tree = dynamic_cast<TTree*> (entry->GetObject());
 582 //
 583 //      if(!tree) return;
 584 //
 585 // //   tree->SetDirectory(file);
 586 //      tree->SetDirectory(0);
 587 //
 588 //      return;
 589 // }