Update path for OCDB folders in cvmfs.
[u/mrichter/AliRoot.git] / STEER / CDB / AliCDBManager.cxx
CommitLineData
9e1ceb13 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 **************************************************************************/
fdf65bb5 15//-------------------------------------------------------------------------
16// Implementation of AliCDBManager and AliCDBParam classe
5078a13f 17// Author: Alberto Colla
fdf65bb5 18// e-mail: Alberto.Colla@cern.ch
19//-------------------------------------------------------------------------
9e1ceb13 20
c11cdcf2 21#include <stdlib.h>
5078a13f 22#include <fstream>
c11cdcf2 23
9e1ceb13 24#include "AliCDBManager.h"
25#include "AliCDBStorage.h"
26#include "AliLog.h"
27#include "AliCDBDump.h"
28#include "AliCDBLocal.h"
29#include "AliCDBGrid.h"
02c4845e 30#include "AliCDBEntry.h"
7de84b33 31#include "AliCDBHandler.h"
9e1ceb13 32
02c4845e 33#include <TObjString.h>
7de84b33 34#include <TSAXParser.h>
35#include <TFile.h>
647d2bb8 36#include <TKey.h>
7de84b33 37#include <TUUID.h>
27cac7e3 38#include <TGrid.h>
a37a1dfc 39#include "TMessage.h"
40#include "TObject.h"
5078a13f 41#include "TRegexp.h"
9e1ceb13 42
43ClassImp(AliCDBParam)
44
45ClassImp(AliCDBManager)
46
b8ec52f6 47//TODO OCDB and Reference folder should not be fully hardcoded but built from run number (or year/LHC period)
48TString AliCDBManager::fgkCondUri("alien://folder=/alice/cern.ch/user/a/aliprod/testCDB/CDB?user=aliprod");
49TString AliCDBManager::fgkRefUri("alien://folder=/alice/cern.ch/user/a/aliprod/testCDB/Reference?user=aliprod");
7de84b33 50TString AliCDBManager::fgkMCIdealStorage("alien://folder=/alice/simulation/2008/v4-15-Release/Ideal");
51TString AliCDBManager::fgkMCFullStorage("alien://folder=/alice/simulation/2008/v4-15-Release/Full");
52TString AliCDBManager::fgkMCResidualStorage("alien://folder=/alice/simulation/2008/v4-15-Release/Residual");
53TString AliCDBManager::fgkOCDBFolderXMLfile("alien:///alice/data/OCDBFoldervsRunRange.xml");
9e1ceb13 54AliCDBManager* AliCDBManager::fgInstance = 0x0;
55
56//_____________________________________________________________________________
5078a13f 57AliCDBManager* AliCDBManager::Instance(TMap *entryCache, Int_t run) {
9e1ceb13 58// returns AliCDBManager instance (singleton)
59
5078a13f 60 if (!fgInstance) {
61 fgInstance = new AliCDBManager();
62 if (!entryCache)
63 fgInstance->Init();
64 else
65 fgInstance->InitFromCache(entryCache,run);
66 }
9e1ceb13 67
5078a13f 68 return fgInstance;
9e1ceb13 69}
70
71//_____________________________________________________________________________
72void AliCDBManager::Init() {
73// factory registering
74
5078a13f 75 RegisterFactory(new AliCDBDumpFactory());
76 RegisterFactory(new AliCDBLocalFactory());
77 // AliCDBGridFactory is registered only if AliEn libraries are enabled in Root
78 if(!gSystem->Exec("root-config --has-alien 2>/dev/null |grep yes 2>&1 > /dev/null")){ // returns 0 if yes
79 AliInfo("AliEn classes enabled in Root. AliCDBGrid factory registered.");
80 RegisterFactory(new AliCDBGridFactory());
81 fCondParam = CreateParameter(fgkCondUri);
82 fRefParam = CreateParameter(fgkRefUri);
83 }
4667c116 84
5078a13f 85 InitShortLived();
9e1ceb13 86}
d1982b43 87
88//_____________________________________________________________________________
89void AliCDBManager::InitFromCache(TMap *entryCache, Int_t run) {
90// initialize manager from existing cache
91// used on the slaves in case of parallel reconstruction
92 SetRun(run);
93
94 TIter iter(entryCache->GetTable());
95 TPair* pair = 0;
96
97 while((pair = dynamic_cast<TPair*> (iter.Next()))){
98 fEntryCache.Add(pair->Key(),pair->Value());
99 }
100 // fEntry is the new owner of the cache
101 fEntryCache.SetOwnerKeyValue(kTRUE,kTRUE);
77d2efce 102 entryCache->SetOwnerKeyValue(kFALSE,kFALSE);
d1982b43 103 AliInfo(Form("%d cache entries have been loaded",fEntryCache.GetEntries()));
104}
105
9e1ceb13 106//_____________________________________________________________________________
c022b397 107void AliCDBManager::DumpToSnapshotFile(const char* snapshotFileName, Bool_t singleKeys){
5078a13f 108//
7ec0d3df 109// dump the entries map and the ids list to
110// the output file
111
5078a13f 112 // open the file
113 TFile *f = TFile::Open(snapshotFileName,"RECREATE");
114 if (!f || f->IsZombie()){
115 AliError(Form("Cannot open file %s",snapshotFileName));
116 return;
117 }
7ec0d3df 118
5078a13f 119 AliInfo(Form("Dumping entriesMap (entries'cache) with %d entries!\n", fEntryCache.GetEntries()));
120 AliInfo(Form("Dumping entriesList with %d entries!\n", fIds->GetEntries()));
121
122 f->cd();
123
124 if(singleKeys){
125 f->WriteObject(&fEntryCache,"CDBentriesMap");
126 f->WriteObject(fIds,"CDBidsList");
127 }else{
128 // We write the entries one by one named by their calibration path
129 /*
130 fEntryCache.Write("CDBentriesMap");
131 fIds->Write("CDBidsList");
132 */
133 TIter iter(fEntryCache.GetTable());
134 TPair* pair = 0;
135 while((pair = dynamic_cast<TPair*> (iter.Next()))){
136 TObjString *os = dynamic_cast<TObjString*>(pair->Key());
137 if (!os) continue;
138 TString path = os->GetString();
139 AliCDBEntry *entry = dynamic_cast<AliCDBEntry*>(pair->Value());
140 if (!entry) continue;
141 path.ReplaceAll("/","*");
142 entry->Write(path.Data());
c022b397 143 }
5078a13f 144 }
145 f->Close();
146 delete f;
7ec0d3df 147
5078a13f 148 exit(0);
7ec0d3df 149}
150
151//_____________________________________________________________________________
b0e8cda6 152Bool_t AliCDBManager::InitFromSnapshot(const char* snapshotFileName, Bool_t overwrite){
647d2bb8 153// initialize manager from a CDB snapshot, that is add the entries
154// to the entries map and the ids to the ids list taking them from
155// the map and the list found in the input file
156
5078a13f 157 // if the manager is locked it cannot initialize from a snapshot
158 if(fLock) {
159 AliError("Being locked I cannot initialize from the snapshot!");
160 return kFALSE;
161 }
162
163 // open the file
164 TString snapshotFile(snapshotFileName);
165 if(snapshotFile.BeginsWith("alien://")){
166 if(!gGrid) {
167 TGrid::Connect("alien://","");
168 if(!gGrid) {
169 AliError("Connection to alien failed!");
170 return kFALSE;
171 }
647d2bb8 172 }
5078a13f 173 }
647d2bb8 174
5078a13f 175 TFile *f = TFile::Open(snapshotFileName);
176 if (!f || f->IsZombie()){
177 AliError(Form("Cannot open file %s",snapshotFileName));
178 return kFALSE;
179 }
647d2bb8 180
5078a13f 181 // retrieve entries' map from snapshot file
182 TMap *entriesMap = 0;
183 TIter next(f->GetListOfKeys());
184 TKey *key;
185 while ((key = (TKey*)next())) {
186 if (strcmp(key->GetClassName(),"TMap") != 0) continue;
187 entriesMap = (TMap*)key->ReadObj();
188 break;
189 }
190 if (!entriesMap || entriesMap->GetEntries()==0){
191 AliError("Cannot get valid map of CDB entries from snapshot file");
192 return kFALSE;
193 }
194
195 // retrieve ids' list from snapshot file
196 TList *idsList = 0;
197 TIter nextKey(f->GetListOfKeys());
198 TKey *keyN;
199 while ((keyN = (TKey*)nextKey())) {
200 if (strcmp(keyN->GetClassName(),"TList") != 0) continue;
201 idsList = (TList*)keyN->ReadObj();
202 break;
203 }
204 if (!idsList || idsList->GetEntries()==0){
205 AliError("Cannot get valid list of CDB entries from snapshot file");
206 return kFALSE;
207 }
647d2bb8 208
5078a13f 209 // Add each (entry,id) from the snapshot to the memory: entry to the cache, id to the list of ids.
210 // If "overwrite" is false: add the entry to the cache and its id to the list of ids
211 // only if neither of them is already there.
212 // If "overwrite" is true: write the snapshot entry,id in any case. If something
213 // was already there for that calibration type, remove it and issue a warning
214 TIter iterObj(entriesMap->GetTable());
215 TPair* pair = 0;
216 Int_t nAdded=0;
217 while((pair = dynamic_cast<TPair*> (iterObj.Next()))){
218 TObjString* os = (TObjString*) pair->Key();
219 TString path = os->GetString();
220 TIter iterId(idsList);
221 AliCDBId* id=0;
222 AliCDBId* correspondingId=0;
223 while((id = dynamic_cast<AliCDBId*> (iterId.Next()))){
224 TString idpath(id->GetPath());
225 if(idpath==path){
226 correspondingId=id;
227 break;
228 }
647d2bb8 229 }
5078a13f 230 if(!correspondingId){
231 AliError(Form("id for \"%s\" not found in the snapshot (while entry was). This entry is skipped!",path.Data()));
232 break;
233 }
234 Bool_t cached = fEntryCache.Contains(path.Data());
235 Bool_t registeredId = kFALSE;
236 TIter iter(fIds);
237 AliCDBId *idT = 0;
238 while((idT = dynamic_cast<AliCDBId*> (iter.Next()))){
239 if(idT->GetPath()==path){
240 registeredId = kTRUE;
241 break;
242 }
647d2bb8 243 }
244
5078a13f 245 if(overwrite){
246 if(cached || registeredId){
247 AliWarning(Form("An entry was already cached for \"%s\". Removing it before caching from snapshot",path.Data()));
248 UnloadFromCache(path.Data());
249 }
250 fEntryCache.Add(pair->Key(),pair->Value());
251 fIds->Add(id);
252 nAdded++;
253 }else{
254 if(cached || registeredId){
255 AliWarning(Form("An entry was already cached for \"%s\". Not adding this object from snapshot",path.Data()));
256 }else{
257 fEntryCache.Add(pair->Key(),pair->Value());
258 fIds->Add(id);
259 nAdded++;
260 }
647d2bb8 261 }
5078a13f 262 }
b0e8cda6 263
5078a13f 264 // fEntry is the new owner of the cache
265 fEntryCache.SetOwnerKeyValue(kTRUE,kTRUE);
266 entriesMap->SetOwnerKeyValue(kFALSE,kFALSE);
267 fIds->SetOwner(kTRUE);
268 idsList->SetOwner(kFALSE);
269 AliInfo(Form("%d new (entry,id) cached. Total number %d",nAdded,fEntryCache.GetEntries()));
b0e8cda6 270
5078a13f 271 f->Close();
272 delete f;
647d2bb8 273
5078a13f 274 return kTRUE;
647d2bb8 275}
276
277//_____________________________________________________________________________
9e1ceb13 278void AliCDBManager::Destroy() {
279// delete ALCDBManager instance and active storages
280
5078a13f 281 if (fgInstance) {
282 //fgInstance->Delete();
283 delete fgInstance;
284 fgInstance = 0x0;
285 }
9e1ceb13 286}
287
288//_____________________________________________________________________________
289AliCDBManager::AliCDBManager():
fe12e09c 290 TObject(),
291 fFactories(),
292 fActiveStorages(),
293 fSpecificStorages(),
b21e3194 294 fEntryCache(),
295 fIds(0),
296 fStorageMap(0),
297 fShortLived(0),
fe12e09c 298 fDefaultStorage(NULL),
299 fDrainStorage(NULL),
b21e3194 300 fCondParam(0),
301 fRefParam(0),
4667c116 302 fRun(-1),
1f341624 303 fCache(kTRUE),
7de84b33 304 fLock(kFALSE),
c022b397 305 fSnapshotMode(kFALSE),
306 fSnapshotFile(0),
7de84b33 307 fRaw(kFALSE),
5078a13f 308 fCvmfsOcdb(""),
7de84b33 309 fStartRunLHCPeriod(-1),
310 fEndRunLHCPeriod(-1),
a6f59240 311 fLHCPeriod(""),
312 fKey(0)
9e1ceb13 313{
5078a13f 314 // default constuctor
315 fFactories.SetOwner(1);
316 fActiveStorages.SetOwner(1);
317 fSpecificStorages.SetOwner(1);
318 fEntryCache.SetName("CDBEntryCache");
319 fEntryCache.SetOwnerKeyValue(kTRUE,kTRUE);
b21e3194 320
5078a13f 321 fStorageMap = new TMap();
322 fStorageMap->SetOwner(1);
323 fIds = new TList();
324 fIds->SetOwner(1);
9e1ceb13 325}
326
327//_____________________________________________________________________________
328AliCDBManager::~AliCDBManager() {
329// destructor
5078a13f 330 ClearCache();
331 DestroyActiveStorages();
332 fFactories.Delete();
333 fDrainStorage = 0x0;
334 fDefaultStorage = 0x0;
335 delete fStorageMap; fStorageMap = 0;
336 delete fIds; fIds = 0;
337 delete fCondParam;
338 delete fRefParam;
339 delete fShortLived; fShortLived = 0x0;
340 //fSnapshotCache = 0;
341 //fSnapshotIdsList = 0;
342 if(fSnapshotMode){
343 fSnapshotFile->Close();
344 fSnapshotFile = 0;
345 }
9e1ceb13 346}
347
348//_____________________________________________________________________________
9e1ceb13 349void AliCDBManager::PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage){
350// put a storage object into the list of active storages
351
5078a13f 352 fActiveStorages.Add(param, storage);
353 AliDebug(1, Form("Active storages: %d", fActiveStorages.GetEntries()));
9e1ceb13 354}
355
356//_____________________________________________________________________________
357void AliCDBManager::RegisterFactory(AliCDBStorageFactory* factory) {
358// add a storage factory to the list of registerd factories
5078a13f 359
360 if (!fFactories.Contains(factory)) {
361 fFactories.Add(factory);
362 }
9e1ceb13 363}
364
365//_____________________________________________________________________________
fdf65bb5 366Bool_t AliCDBManager::HasStorage(const char* dbString) const {
b21e3194 367// check if dbString is a URI valid for one of the registered factories
9e1ceb13 368
5078a13f 369 TIter iter(&fFactories);
9e1ceb13 370
5078a13f 371 AliCDBStorageFactory* factory=0;
372 while ((factory = (AliCDBStorageFactory*) iter.Next())) {
9e1ceb13 373
5078a13f 374 if (factory->Validate(dbString)) {
375 return kTRUE;
376 }
377 }
9e1ceb13 378
5078a13f 379 return kFALSE;
9e1ceb13 380}
381
382//_____________________________________________________________________________
fdf65bb5 383AliCDBParam* AliCDBManager::CreateParameter(const char* dbString) const {
9e1ceb13 384// create AliCDBParam object from URI string
385
5078a13f 386 TString uriString(dbString);
387
388 if (! fCvmfsOcdb.IsNull()) {
389 AlienToCvmfsUri(uriString);
390 }
391
392 TIter iter(&fFactories);
7de84b33 393
5078a13f 394 AliCDBStorageFactory* factory=0;
395 while ((factory = (AliCDBStorageFactory*) iter.Next())) {
396 //AliCDBParam* param = factory->CreateParameter(dbString);
397 AliCDBParam* param = factory->CreateParameter(uriString);
398 if(param) return param;
399 }
400
401 return NULL;
402}
9e1ceb13 403
5078a13f 404//_____________________________________________________________________________
405void AliCDBManager::AlienToCvmfsUri(TString& uriString) const {
406// convert alien storage uri to local:///cvmfs storage uri (called when OCDB_PATH is set)
407
408 if (! uriString.BeginsWith("alien://") && !fCvmfsOcdb.IsNull())
409 AliFatal("Cannot set local://cvmfs storage for a non alien uri");
410
411 TObjArray *arr = uriString.Tokenize('?');
412 TIter iter(arr);
413 TObjString *str = 0;
414 TString entryKey = "";
415 TString entryValue = "";
416 TString newUriString = "";
417 while((str = (TObjString*) iter.Next())){
418 TString entry(str->String());
419 Int_t indeq = entry.Index('=');
420 entryKey = entry(0, indeq+1);
421 entryValue = entry(indeq+1, entry.Length()-indeq);
422
423 if ( entryKey.Contains("folder", TString::kIgnoreCase) )
424 {
425
426 TRegexp re_RawFolder("^/alice/data/20[0-9]+/OCDB");
427 TRegexp re_MCFolder("^/alice/simulation/2008/v4-15-Release");
428 TString rawFolder = entryValue(re_RawFolder);
429 TString mcFolder = entryValue(re_MCFolder);
430 if ( !rawFolder.IsNull() ){
37286873 431 entryValue.Replace(0, 6, "/cvmfs/alice-ocdb.cern.ch/calibration");
7ab8651a 432 //entryValue.Replace(entryValue.Length()-4, entryValue.Length(), "");
5078a13f 433 } else if ( !mcFolder.IsNull() ){
37286873 434 entryValue.Replace(0,36,"/cvmfs/alice-ocdb.cern.ch/calibration/MC");
5078a13f 435 } else {
436 AliFatal(Form("Environment variable for cvmfs OCDB folder set for an invalid OCDB storage:\n %s", entryValue.Data()));
437 }
438 } else {
439 newUriString += entryKey;
440 }
441 newUriString += entryValue;
442 newUriString += '?';
443 }
444 newUriString.Prepend("local://");
445 newUriString.Remove(TString::kTrailing, '?');
446 uriString = newUriString;
9e1ceb13 447}
448
449//_____________________________________________________________________________
450AliCDBStorage* AliCDBManager::GetStorage(const char* dbString) {
451// get storage object from URI string
9e1ceb13 452
5078a13f 453 // Check environment variable OCDB_PATH. It is set in case the user (job) expects
454 // to find in the local /cvmfs the required OCDB tag. The OCDB_PATH variable
455 // contains the path to the directory in /cvmfs/ which is an AliRoot tag based snapshot
456 // of the AliEn file catalogue. The directory has to contain:
457 // 1) catalogue/20??.list.gz gzipped text files listing the OCDB files (seen by that AliRoot tag)
458 // 2) bin/getOCDBperRun.sh (shell+awk) script extracting from 1) the list
459 // of valid files for the given run.
460
461 AliCDBParam* param = CreateParameter(dbString);
462 if (!param) {
463 AliError(Form("Failed to activate requested storage! Check URI: %s", dbString));
464 return NULL;
465 }
466
467 AliCDBStorage* aStorage = GetStorage(param);
9e1ceb13 468
5078a13f 469 delete param;
470 return aStorage;
9e1ceb13 471}
472
473//_____________________________________________________________________________
474AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) {
475// get storage object from AliCDBParam object
5078a13f 476
477 // if the list of active storages already contains
478 // the requested storage, return it
479 AliCDBStorage* aStorage = GetActiveStorage(param);
480 if (aStorage) {
481 return aStorage;
482 }
483
484 // if lock is ON, cannot activate more storages!
485 if(fLock) {
486 if (fDefaultStorage) {
487 AliFatal("Lock is ON, and default storage is already set: "
488 "cannot reset it or activate more storages!");
489 }
490 }
491
492 // loop on the list of registered factories
493 TIter iter(&fFactories);
494 AliCDBStorageFactory* factory=0;
495 while ((factory = (AliCDBStorageFactory*) iter.Next())) {
496
497 // each factory tries to create its storage from the parameter
498 aStorage = factory->Create(param);
499 if (aStorage) {
500 PutActiveStorage(param->CloneParam(), aStorage);
501 aStorage->SetURI(param->GetURI());
502 if(fRun >= 0) {
503 if( aStorage->GetType() == "alien" || aStorage->GetType() == "local" )
504 aStorage->QueryCDB(fRun);
7ab8651a 505 }
78f84046 506 return aStorage;
7ab8651a 507 }
5078a13f 508 }
5078a13f 509
7ab8651a 510 AliError(Form("Failed to activate requested storage! Check URI: %s", param->GetURI().Data()));
5078a13f 511
7ab8651a 512 return NULL;
9e1ceb13 513}
514
515//_____________________________________________________________________________
62032124 516AliCDBStorage* AliCDBManager::GetActiveStorage(const AliCDBParam* param) {
517// get a storage object from the list of active storages
518
5078a13f 519 return dynamic_cast<AliCDBStorage*> (fActiveStorages.GetValue(param));
62032124 520}
521
522//_____________________________________________________________________________
9e1ceb13 523TList* AliCDBManager::GetActiveStorages() {
524// return list of active storages
62032124 525// user has responsibility to delete returned object
9e1ceb13 526
5078a13f 527 TList* result = new TList();
9e1ceb13 528
5078a13f 529 TIter iter(fActiveStorages.GetTable());
530 TPair* aPair=0;
531 while ((aPair = (TPair*) iter.Next())) {
532 result->Add(aPair->Value());
533 }
9e1ceb13 534
5078a13f 535 return result;
9e1ceb13 536}
537
538//_____________________________________________________________________________
539void AliCDBManager::SetDrain(const char* dbString) {
540// set drain storage from URI string
541
5078a13f 542 fDrainStorage = GetStorage(dbString);
9e1ceb13 543}
544
545//_____________________________________________________________________________
546void AliCDBManager::SetDrain(const AliCDBParam* param) {
547// set drain storage from AliCDBParam
b8ec52f6 548
5078a13f 549 fDrainStorage = GetStorage(param);
9e1ceb13 550}
551
552//_____________________________________________________________________________
553void AliCDBManager::SetDrain(AliCDBStorage* storage) {
554// set drain storage from another active storage
5078a13f 555
556 fDrainStorage = storage;
9e1ceb13 557}
558
559//_____________________________________________________________________________
560Bool_t AliCDBManager::Drain(AliCDBEntry *entry) {
561// drain retrieved object to drain storage
562
5078a13f 563 AliDebug(2, "Draining into drain storage...");
564 return fDrainStorage->Put(entry);
9e1ceb13 565}
566
7de84b33 567//____________________________________________________________________________
5078a13f 568void AliCDBManager::SetDefaultStorage(const char* storageUri) {
9e1ceb13 569// sets default storage from URI string
5078a13f 570
571 // if in the cvmfs case (triggered by environment variable) check for path validity
572 // and modify Uri if it is "raw://"
573 TString cvmfsOcdb(gSystem->Getenv("OCDB_PATH"));
574 if (! cvmfsOcdb.IsNull()){
575 fCvmfsOcdb = cvmfsOcdb;
576 ValidateCvmfsCase();
577 }
578
579 // checking whether we are in the raw case
580 TString uriTemp(storageUri);
581 if (uriTemp == "raw://") {
582 fRaw = kTRUE; // read then by SetRun to check if the method has to be called again with expanded uri
583 AliInfo("Setting the run-number will set the corresponding OCDB for raw data reconstruction.");
584 return;
585 }
586
587 AliCDBStorage* bckStorage = fDefaultStorage;
588
589 fDefaultStorage = GetStorage(storageUri);
590
591 if(!fDefaultStorage) return;
592
593 if(bckStorage && (fDefaultStorage != bckStorage)){
594 AliWarning("Existing default storage replaced: clearing cache!");
595 ClearCache();
596 }
597
598 if (fStorageMap->Contains("default")) {
599 delete fStorageMap->Remove(((TPair*)fStorageMap->FindObject("default"))->Key());
600 }
601 fStorageMap->Add(new TObjString("default"), new TObjString(fDefaultStorage->GetURI()));
9e1ceb13 602}
5078a13f 603
9e1ceb13 604//_____________________________________________________________________________
605void AliCDBManager::SetDefaultStorage(const AliCDBParam* param) {
606// set default storage from AliCDBParam object
4954c5cd 607
5078a13f 608 AliCDBStorage* bckStorage = fDefaultStorage;
4954c5cd 609
5078a13f 610 fDefaultStorage = GetStorage(param);
95c0e132 611
5078a13f 612 if(!fDefaultStorage) return;
b21e3194 613
5078a13f 614 if(bckStorage && (fDefaultStorage != bckStorage)){
615 AliWarning("Existing default storage replaced: clearing cache!");
616 ClearCache();
617 }
618
619 if (fStorageMap->Contains("default")) {
620 delete fStorageMap->Remove(((TPair*)fStorageMap->FindObject("default"))->Key());
621 }
622 fStorageMap->Add(new TObjString("default"), new TObjString(fDefaultStorage->GetURI()));
9e1ceb13 623}
624
625//_____________________________________________________________________________
626void AliCDBManager::SetDefaultStorage(AliCDBStorage* storage) {
627// set default storage from another active storage
5078a13f 628
629 // if lock is ON, cannot activate more storages!
630 if(fLock) {
631 if (fDefaultStorage) {
632 AliFatal("Lock is ON, and default storage is already set: "
633 "cannot reset it or activate more storages!");
634 }
635 }
636
637 if (!storage) {
638 UnsetDefaultStorage();
639 return;
640 }
641
642 AliCDBStorage* bckStorage = fDefaultStorage;
643
644 fDefaultStorage = storage;
645
646 if(bckStorage && (fDefaultStorage != bckStorage)){
647 AliWarning("Existing default storage replaced: clearing cache!");
648 ClearCache();
649 }
650
651 if (fStorageMap->Contains("default")) {
652 delete fStorageMap->Remove(((TPair*)fStorageMap->FindObject("default"))->Key());
653 }
654 fStorageMap->Add(new TObjString("default"), new TObjString(fDefaultStorage->GetURI()));
9e1ceb13 655}
4667c116 656
657//_____________________________________________________________________________
7de84b33 658void AliCDBManager::SetDefaultStorage(const char* mcString, const char* simType) {
659// sets default storage for MC data
5078a13f 660// mcString MUST be "MC",
7de84b33 661// simType can be "Ideal","Residual","Full"
5078a13f 662
663 TString strmcString(mcString);
664 TString strsimType(simType);
665 TString dbString;
666 if (strmcString != "MC"){
667 AliFatal("Method requires first string to be MC!");
668 }
669 else {
670 if (strsimType == "Ideal"){
671 dbString = fgkMCIdealStorage;
672 }
673 else if (strsimType == "Full"){
674 dbString = fgkMCFullStorage;
675 }
676 else if (strsimType == "Residual"){
677 dbString = fgkMCResidualStorage;
678 }
679 else {
680 AliFatal("Error in setting the storage for MC data, second argument MUST be either \"Ideal\" or \"Full\" or \"Residual\".");
681 }
682
683 SetDefaultStorage(dbString.Data());
684 fStartRunLHCPeriod=0;
685 fEndRunLHCPeriod=AliCDBRunRange::Infinity();
686 if(!fDefaultStorage) AliFatal(Form("%s storage not there! Please check!",dbString.Data()));
687 }
688}
689
690//_____________________________________________________________________________
691void AliCDBManager::ValidateCvmfsCase() const {
692 if (! fCvmfsOcdb.BeginsWith("/cvmfs")) //!!!! to be commented out for testing
693 AliFatal(Form("OCDB_PATH set to an invalid path: %s", fCvmfsOcdb.Data()));
694
695 TString cvmfsUri(fCvmfsOcdb);
696 gSystem->ExpandPathName(cvmfsUri);
697 if (gSystem->AccessPathName(cvmfsUri))
698 AliFatal(Form("OCDB_PATH set to an invalid path: %s", cvmfsUri.Data()));
699
700 // check that we find the two scripts we need
701
702 AliDebug(3, "OCDB_PATH envvar is set. Changing OCDB storage from alien:// to local:///cvmfs type.");
703 cvmfsUri = cvmfsUri.Strip(TString::kTrailing, '/');
704 cvmfsUri.Append("/bin/getOCDBFilesPerRun.sh");
705 if (gSystem->AccessPathName(cvmfsUri))
706 AliFatal(Form("Cannot find valid script: %s", cvmfsUri.Data()));
7de84b33 707}
5078a13f 708
7de84b33 709//_____________________________________________________________________________
710void AliCDBManager::SetDefaultStorageFromRun(Int_t run) {
711// set default storage from the run number - to be used only with raw data
712
5078a13f 713 // if lock is ON, cannot activate more storages!
714 if(fLock) {
715 if (fDefaultStorage) {
716 AliFatal("Lock is ON, and default storage is already set: "
717 "cannot activate default storage from run number");
718 }
719 }
720
721 // fRaw and cvmfs case
722 if (! fCvmfsOcdb.IsNull()) {
723 // we don't want to connect to AliEn just to set the uri from the runnumber
724 // for that we use the script getUriFromYear.sh in the cvmfs AliRoot package
725 // check that we find the two scripts we need
726 TString getYearScript(fCvmfsOcdb);
727 getYearScript = getYearScript.Strip(TString::kTrailing, '/');
728 getYearScript.Append("/bin/getUriFromYear.sh");
729 if (gSystem->AccessPathName(getYearScript))
730 AliFatal(Form("Cannot find valid script: %s", getYearScript.Data()));
731 TString inoutFile(gSystem->WorkingDirectory());
732 inoutFile += "/uri_range_";
733 inoutFile += TString::Itoa(fRun,10);
734 TString command(getYearScript);
735 command += ' ';
736 command += TString::Itoa(fRun,10);
737 command += Form(" > %s", inoutFile.Data());
738 AliDebug(3, Form("Running command: \"%s\"",command.Data()));
739 Int_t result = gSystem->Exec(command.Data());
740 if(result != 0) {
741 AliFatal(Form("Was not able to execute \"%s\"", command.Data()));
742 }
743
744 // now read the file with the uri and first and last run
745 ifstream *file = new ifstream(inoutFile.Data());
746 if (!*file) {
747 AliFatal(Form("Error opening file \"%s\"!", inoutFile.Data()));
5078a13f 748 }
749 TString lhcPeriod;
750 TObjArray* oStringsArray = 0;
751 while (lhcPeriod.ReadLine(*file)){
752 oStringsArray = lhcPeriod.Tokenize(' ');
753 }
754 TObjString *oStrUri = dynamic_cast<TObjString*> (oStringsArray->At(0));
755 TObjString *oStrFirst = dynamic_cast<TObjString*> (oStringsArray->At(1));
756 TString firstRun = oStrFirst->GetString();
757 TObjString *oStrLast = dynamic_cast<TObjString*> (oStringsArray->At(2));
758 TString lastRun = oStrLast->GetString();
759
760 fLHCPeriod = oStrUri->GetString();
761 fStartRunLHCPeriod = firstRun.Atoi();
762 fEndRunLHCPeriod = lastRun.Atoi();
763
764 file->close();
765 delete file;
766
767 } else { // if not cvmfs case, "plain" AliEn case
768 // retrieve XML file from alien
769 if(!gGrid) {
770 TGrid::Connect("alien://","");
771 if(!gGrid) {
772 AliError("Connection to alien failed!");
773 return;
774 }
775 }
776 TUUID uuid;
777 TString rndname = "/tmp/";
778 rndname += "OCDBFolderXML.";
779 rndname += uuid.AsString();
780 rndname += ".xml";
781 AliDebug(2, Form("file to be copied = %s", fgkOCDBFolderXMLfile.Data()));
782 if (!TFile::Cp(fgkOCDBFolderXMLfile.Data(), rndname.Data())) {
783 AliFatal(Form("Cannot make a local copy of OCDBFolder xml file in %s",rndname.Data()));
784 }
785 AliCDBHandler* saxcdb = new AliCDBHandler();
786 saxcdb->SetRun(run);
787 TSAXParser *saxParser = new TSAXParser();
788 saxParser->ConnectToHandler("AliCDBHandler", saxcdb);
789 saxParser->ParseFile(rndname.Data());
790 AliInfo(Form(" LHC folder = %s", saxcdb->GetOCDBFolder().Data()));
791 AliInfo(Form(" LHC period start run = %d", saxcdb->GetStartRunRange()));
792 AliInfo(Form(" LHC period end run = %d", saxcdb->GetEndRunRange()));
793 fLHCPeriod = saxcdb->GetOCDBFolder();
794 fStartRunLHCPeriod = saxcdb->GetStartRunRange();
795 fEndRunLHCPeriod = saxcdb->GetEndRunRange();
796 }
797
798 SetDefaultStorage(fLHCPeriod.Data());
799 if(!fDefaultStorage) AliFatal(Form("%s storage not there! Please check!",fLHCPeriod.Data()));
7de84b33 800
801}
802
803//_____________________________________________________________________________
1f341624 804void AliCDBManager::UnsetDefaultStorage() {
805// Unset default storage
5078a13f 806
807 // if lock is ON, action is forbidden!
808 if(fLock) {
809 if (fDefaultStorage) {
810 AliFatal("Lock is ON: cannot unset default storage!");
811 }
812 }
813
814 if (fDefaultStorage) {
815 AliWarning("Clearing cache!");
816 ClearCache();
817 }
818
819 fRun = fStartRunLHCPeriod = fEndRunLHCPeriod = -1;
820 fRaw = kFALSE;
821
822 fDefaultStorage = 0x0;
4667c116 823}
9e1ceb13 824
02c4845e 825//_____________________________________________________________________________
024cf675 826void AliCDBManager::SetSpecificStorage(const char* calibType, const char* dbString) {
827// sets storage specific for detector or calibration type (works with AliCDBManager::Get(...))
02c4845e 828
5078a13f 829 AliCDBParam *aPar = CreateParameter(dbString);
830 if(!aPar) return;
831 SetSpecificStorage(calibType, aPar);
832 delete aPar;
02c4845e 833}
834
835//_____________________________________________________________________________
647d2bb8 836void AliCDBManager::SetSpecificStorage(const char* calibType, const AliCDBParam* param) {
024cf675 837// sets storage specific for detector or calibration type (works with AliCDBManager::Get(...))
838// Default storage should be defined prior to any specific storages, e.g.:
839// AliCDBManager::instance()->SetDefaultStorage("alien://");
c3a7b59a 840// AliCDBManager::instance()->SetSpecificStorage("TPC/*","local://DB_TPC");
841// AliCDBManager::instance()->SetSpecificStorage("*/Align/*","local://DB_TPCAlign");
842// calibType must be a valid CDB path! (3 level folder structure)
02c4845e 843
7de84b33 844
5078a13f 845 if(!fDefaultStorage && !fRaw) {
846 AliError("Please activate a default storage first!");
847 return;
848 }
4005d0b5 849
5078a13f 850 AliCDBPath aPath(calibType);
851 if(!aPath.IsValid()){
852 AliError(Form("Not a valid path: %s", calibType));
853 return;
854 }
62032124 855
5078a13f 856 TObjString *objCalibType = new TObjString(aPath.GetPath());
857 if(fSpecificStorages.Contains(objCalibType)){
858 AliWarning(Form("Storage \"%s\" already activated! It will be replaced by the new one",
859 calibType));
860 AliCDBParam *checkPar = dynamic_cast<AliCDBParam*> (fSpecificStorages.GetValue(calibType));
861 if(checkPar) delete checkPar;
862 delete fSpecificStorages.Remove(objCalibType);
863 }
864 AliCDBStorage *aStorage = GetStorage(param);
865 if(!aStorage) return;
96b7636d 866
5078a13f 867 fSpecificStorages.Add(objCalibType, param->CloneParam());
b21e3194 868
5078a13f 869 if(fStorageMap->Contains(objCalibType)){
870 delete fStorageMap->Remove(objCalibType);
871 }
872 fStorageMap->Add(objCalibType->Clone(), new TObjString(param->GetURI()));
b21e3194 873
02c4845e 874}
875
876//_____________________________________________________________________________
024cf675 877AliCDBStorage* AliCDBManager::GetSpecificStorage(const char* calibType) {
5078a13f 878// get storage specific for detector or calibration type
4b5e0dce 879
5078a13f 880 AliCDBPath calibPath(calibType);
881 if(!calibPath.IsValid()) return NULL;
96b7636d 882
5078a13f 883 AliCDBParam *checkPar = (AliCDBParam*) fSpecificStorages.GetValue(calibPath.GetPath());
884 if(!checkPar){
885 AliError(Form("%s storage not found!", calibType));
886 return NULL;
887 } else {
888 return GetStorage(checkPar);
889 }
96b7636d 890
02c4845e 891}
892
893//_____________________________________________________________________________
024cf675 894AliCDBParam* AliCDBManager::SelectSpecificStorage(const TString& path) {
82096dfc 895// select storage valid for path from the list of specific storages
024cf675 896
5078a13f 897 AliCDBPath aPath(path);
898 if(!aPath.IsValid()) return NULL;
899
900 TIter iter(&fSpecificStorages);
901 TObjString *aCalibType=0;
902 AliCDBPath tmpPath("null/null/null");
903 AliCDBParam* aPar=0;
904 while((aCalibType = (TObjString*) iter.Next())){
905 AliCDBPath calibTypePath(aCalibType->GetName());
906 if(calibTypePath.Comprises(aPath)) {
907 if(calibTypePath.Comprises(tmpPath)) continue;
908 aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType);
909 tmpPath.SetPath(calibTypePath.GetPath());
910 }
911 }
912 return aPar;
024cf675 913}
914
915//_____________________________________________________________________________
4667c116 916AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber,
5078a13f 917 Int_t version, Int_t subVersion) {
918 // get an AliCDBEntry object from the database
919
920 if(runNumber < 0){
921 // RunNumber is not specified. Try with fRun
922 if (fRun < 0){
923 AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
924 return NULL;
925 }
926 runNumber = fRun;
927 }
024cf675 928
5078a13f 929 return Get(AliCDBId(path, runNumber, runNumber, version, subVersion));
02c4845e 930}
931
932//_____________________________________________________________________________
4667c116 933AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path,
5078a13f 934 const AliCDBRunRange& runRange, Int_t version,
935 Int_t subVersion) {
936 // get an AliCDBEntry object from the database!
02c4845e 937
5078a13f 938 return Get(AliCDBId(path, runRange, version, subVersion));
02c4845e 939}
940
941//_____________________________________________________________________________
16fcd618 942AliCDBEntry* AliCDBManager::Get(const AliCDBId& query, Bool_t forceCaching) {
02c4845e 943// get an AliCDBEntry object from the database
5078a13f 944
945 // check if query's path and runRange are valid
946 // query is invalid also if version is not specified and subversion is!
947 if (!query.IsValid()) {
948 AliError(Form("Invalid query: %s", query.ToString().Data()));
949 return NULL;
950 }
951
952 // query is not specified if path contains wildcard or run range= [-1,-1]
953 if (!query.IsSpecified()) {
954 AliError(Form("Unspecified query: %s",
955 query.ToString().Data()));
956 return NULL;
957 }
958
959 if(fLock && !(fRun >= query.GetFirstRun() && fRun <= query.GetLastRun()))
960 AliFatal("Lock is ON: cannot use different run number than the internal one!");
961
962 if(fCache && !(fRun >= query.GetFirstRun() && fRun <= query.GetLastRun()))
963 AliWarning("Run number explicitly set in query: CDB cache temporarily disabled!");
964
965 AliCDBEntry *entry=0;
966
967 // first look into map of cached objects
968 if(fCache && query.GetFirstRun() == fRun)
969 entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath());
970 if(entry) {
971 AliDebug(2, Form("Object %s retrieved from cache !!",query.GetPath().Data()));
972 return entry;
973 }
974
975 // if snapshot flag is set, try getting from the snapshot
976 // but in the case a specific storage is specified for this path
977 AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
978 if(!aPar){
979 if(fSnapshotMode && query.GetFirstRun() == fRun)
980 {
981 entry = GetEntryFromSnapshot(query.GetPath());
982 if(entry) {
983 AliInfo(Form("Object \"%s\" retrieved from the snapshot.",query.GetPath().Data()));
984 if(query.GetFirstRun() == fRun) // no need to check fCache, fSnapshotMode not possible otherwise
985 CacheEntry(query.GetPath(), entry);
986
987 if(!fIds->Contains(&entry->GetId()))
988 fIds->Add(entry->GetId().Clone());
989
990 return entry;
991 }
992 }
993 }
994
995 // Entry is not in cache (and, in case we are in snapshot mode, not in the snapshot either)
996 // => retrieve it from the storage and cache it!!
997 if(!fDefaultStorage) {
998 AliError("No storage set!");
999 return NULL;
1000 }
1001
1002 AliCDBStorage *aStorage=0;
1003 if(aPar) {
1004 aStorage=GetStorage(aPar);
1005 TString str = aPar->GetURI();
1006 AliDebug(2,Form("Looking into storage: %s",str.Data()));
1007 } else {
1008 aStorage=GetDefaultStorage();
1009 AliDebug(2,"Looking into default storage");
1010 }
1011
1012 entry = aStorage->Get(query);
1013
1014 if(entry && fCache && (query.GetFirstRun()==fRun || forceCaching)){
1015 CacheEntry(query.GetPath(), entry);
1016 }
1017
1018 if(entry && !fIds->Contains(&entry->GetId())){
1019 fIds->Add(entry->GetId().Clone());
1020 }
1021
1022
1023 return entry;
4667c116 1024
1025}
1026
1027//_____________________________________________________________________________
c022b397 1028AliCDBEntry* AliCDBManager::GetEntryFromSnapshot(const char* path) {
5078a13f 1029// get the entry from the open snapshot file
c022b397 1030
5078a13f 1031 TString sPath(path);
1032 sPath.ReplaceAll("/","*");
1033 if(!fSnapshotFile){
1034 AliError("No snapshot file is open!");
1035 return 0;
1036 }
1037 AliCDBEntry *entry = dynamic_cast<AliCDBEntry*>(fSnapshotFile->Get(sPath.Data()));
1038 if(!entry){
1039 AliDebug(2,Form("Cannot get a CDB entry for \"%s\" from snapshot file",path));
1040 return 0;
1041 }
c022b397 1042
5078a13f 1043 return entry;
c022b397 1044}
1045
1046//_____________________________________________________________________________
1047Bool_t AliCDBManager::SetSnapshotMode(const char* snapshotFileName) {
1048// set the manager in snapshot mode
c022b397 1049
5078a13f 1050 if(!fCache){
1051 AliError("Cannot set the CDB manage in snapshot mode if the cache is not active!");
1052 return kFALSE;
1053 }
c022b397 1054
5078a13f 1055 //open snapshot file
1056 TString snapshotFile(snapshotFileName);
1057 if(snapshotFile.BeginsWith("alien://")){
1058 if(!gGrid) {
1059 TGrid::Connect("alien://","");
1060 if(!gGrid) {
1061 AliError("Connection to alien failed!");
1062 return kFALSE;
1063 }
c022b397 1064 }
5078a13f 1065 }
c022b397 1066
5078a13f 1067 fSnapshotFile = TFile::Open(snapshotFileName);
1068 if (!fSnapshotFile || fSnapshotFile->IsZombie()){
1069 AliError(Form("Cannot open file %s",snapshotFileName));
1070 return kFALSE;
1071 }
1072
1073 AliInfo("The CDB manager is set in snapshot mode!");
1074 fSnapshotMode = kTRUE;
1075 return kTRUE;
c022b397 1076
1077}
1078
1079//_____________________________________________________________________________
0f40a831 1080const char* AliCDBManager::GetURI(const char* path) {
1081// return the URI of the storage where to look for path
1082
5078a13f 1083 if(!IsDefaultStorageSet()) return 0;
1084
1085 AliCDBParam *aPar=SelectSpecificStorage(path);
0f40a831 1086
5078a13f 1087 if(aPar) {
1088 return aPar->GetURI().Data();
0f40a831 1089
5078a13f 1090 } else {
1091 return GetDefaultStorage()->GetURI().Data();
1092 }
1093
1094 return 0;
0f40a831 1095}
1096
1097//_____________________________________________________________________________
b7df0cc5 1098Int_t AliCDBManager::GetStartRunLHCPeriod(){
5078a13f 1099// get the first run of validity
1100// for the current period
1101// if set
1102 if(fStartRunLHCPeriod==-1)
1103 AliWarning("Run-range not yet set for the current LHC period.");
1104 return fStartRunLHCPeriod;
b7df0cc5 1105}
1106
1107//_____________________________________________________________________________
1108Int_t AliCDBManager::GetEndRunLHCPeriod(){
5078a13f 1109// get the last run of validity
1110// for the current period
1111// if set
1112 if(fEndRunLHCPeriod==-1)
1113 AliWarning("Run-range not yet set for the current LHC period.");
1114 return fEndRunLHCPeriod;
b7df0cc5 1115}
1116
1117//_____________________________________________________________________________
1118TString AliCDBManager::GetLHCPeriod(){
5078a13f 1119// get the current LHC period string
1120//
1121 if(fLHCPeriod.IsWhitespace() || fLHCPeriod.IsNull())
1122 AliWarning("LHC period (OCDB folder) not yet set");
1123 return fLHCPeriod;
b7df0cc5 1124}
1125
1126//_____________________________________________________________________________
4667c116 1127AliCDBId* AliCDBManager::GetId(const AliCDBPath& path, Int_t runNumber,
5078a13f 1128 Int_t version, Int_t subVersion) {
1129 // get the AliCDBId of the valid object from the database (does not retrieve the object)
1130 // User must delete returned object!
1131
1132 if(runNumber < 0){
1133 // RunNumber is not specified. Try with fRun
1134 if (fRun < 0){
1135 AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
1136 return NULL;
1137 }
1138 runNumber = fRun;
1139 }
4667c116 1140
5078a13f 1141 return GetId(AliCDBId(path, runNumber, runNumber, version, subVersion));
4667c116 1142}
1143
1144//_____________________________________________________________________________
1145AliCDBId* AliCDBManager::GetId(const AliCDBPath& path,
5078a13f 1146 const AliCDBRunRange& runRange, Int_t version,
1147 Int_t subVersion) {
1148 // get the AliCDBId of the valid object from the database (does not retrieve the object)
1149 // User must delete returned object!
4667c116 1150
5078a13f 1151 return GetId(AliCDBId(path, runRange, version, subVersion));
4667c116 1152}
1153
1154//_____________________________________________________________________________
1155AliCDBId* AliCDBManager::GetId(const AliCDBId& query) {
1156// get the AliCDBId of the valid object from the database (does not retrieve the object)
1157// User must delete returned object!
1158
5078a13f 1159 if(!fDefaultStorage) {
1160 AliError("No storage set!");
1161 return NULL;
1162 }
1163
1164 // check if query's path and runRange are valid
1165 // query is invalid also if version is not specified and subversion is!
1166 if (!query.IsValid()) {
1167 AliError(Form("Invalid query: %s", query.ToString().Data()));
1168 return NULL;
1169 }
1170
1171 // query is not specified if path contains wildcard or run range= [-1,-1]
1172 if (!query.IsSpecified()) {
1173 AliError(Form("Unspecified query: %s",
1174 query.ToString().Data()));
1175 return NULL;
1176 }
1177
1178 if(fCache && query.GetFirstRun() != fRun)
1179 AliWarning("Run number explicitly set in query: CDB cache temporarily disabled!");
1180
1181 AliCDBEntry* entry = 0;
1182
1183 // first look into map of cached objects
1184 if(fCache && query.GetFirstRun() == fRun)
1185 entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath());
1186
1187 if(entry) {
1188 AliDebug(2, Form("Object %s retrieved from cache !!",query.GetPath().Data()));
1189 return dynamic_cast<AliCDBId*> (entry->GetId().Clone());
1190 }
1191
1192 // Entry is not in cache -> retrieve it from CDB and cache it!!
1193 AliCDBStorage *aStorage=0;
1194 AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
1195
1196 if(aPar) {
1197 aStorage=GetStorage(aPar);
1198 TString str = aPar->GetURI();
1199 AliDebug(2,Form("Looking into storage: %s",str.Data()));
1200
1201 } else {
1202 aStorage=GetDefaultStorage();
1203 AliDebug(2,"Looking into default storage");
1204 }
1205
1206 return aStorage->GetId(query);
4667c116 1207
02c4845e 1208}
1209
1210//_____________________________________________________________________________
62032124 1211TList* AliCDBManager::GetAll(const AliCDBPath& path, Int_t runNumber,
5078a13f 1212 Int_t version, Int_t subVersion) {
1213 // get multiple AliCDBEntry objects from the database
1214
1215 if(runNumber < 0){
1216 // RunNumber is not specified. Try with fRun
1217 if (fRun < 0){
1218 AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun.");
1219 return NULL;
1220 }
1221 runNumber = fRun;
1222 }
afd8dbf4 1223
5078a13f 1224 return GetAll(AliCDBId(path, runNumber, runNumber, version,
1225 subVersion));
02c4845e 1226}
1227
1228//_____________________________________________________________________________
8e245d15 1229TList* AliCDBManager::GetAll(const AliCDBPath& path,
5078a13f 1230 const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) {
1231 // get multiple AliCDBEntry objects from the database
02c4845e 1232
5078a13f 1233 return GetAll(AliCDBId(path, runRange, version, subVersion));
02c4845e 1234}
1235
1236//_____________________________________________________________________________
1237TList* AliCDBManager::GetAll(const AliCDBId& query) {
1238// get multiple AliCDBEntry objects from the database
024cf675 1239// Warning: this method works correctly only for queries of the type "Detector/*"
1240// and not for more specific queries e.g. "Detector/Calib/*" !
8e245d15 1241// Warning #2: Entries are cached, but GetAll will keep on retrieving objects from OCDB!
1242// To get an object from cache use Get() function
02c4845e 1243
5078a13f 1244 if(!fDefaultStorage) {
1245 AliError("No storage set!");
1246 return NULL;
1247 }
1248
1249 if (!query.IsValid()) {
1250 AliError(Form("Invalid query: %s", query.ToString().Data()));
1251 return NULL;
1252 }
1253
1254 if((fSpecificStorages.GetEntries()>0) && query.GetPath().BeginsWith('*')){
1255 // if specific storages are active a query with "*" is ambiguous
1256 AliError("Query too generic in this context!");
1257 return NULL;
1258 }
1259
1260 if (query.IsAnyRange()) {
1261 AliError(Form("Unspecified run or runrange: %s",
1262 query.ToString().Data()));
1263 return NULL;
1264 }
1265
1266 if(fLock && query.GetFirstRun() != fRun)
1267 AliFatal("Lock is ON: cannot use different run number than the internal one!");
1268
1269 AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
1270
1271 AliCDBStorage *aStorage;
1272 if(aPar) {
1273 aStorage=GetStorage(aPar);
1274 AliDebug(2,Form("Looking into storage: %s", aPar->GetURI().Data()));
1275
1276 } else {
1277 aStorage=GetDefaultStorage();
1278 AliDebug(2,Form("Looking into default storage: %s", aStorage->GetURI().Data()));
1279 }
1280
1281 TList *result = 0;
1282 if(aStorage) result = aStorage->GetAll(query);
1283 if(!result) return 0;
1284
1285 // loop on result to check whether entries should be re-queried with specific storages
1286 if(fSpecificStorages.GetEntries()>0 && ! (fSpecificStorages.GetEntries() == 1 && aPar)) {
1287 AliInfo("Now look into all other specific storages...");
1288
1289 TIter iter(result);
1290 AliCDBEntry* chkEntry=0;
1291
1292 while((chkEntry = dynamic_cast<AliCDBEntry*> (iter.Next()))){
1293 AliCDBId& chkId = chkEntry->GetId();
1294 AliDebug(2, Form("Checking id %s ", chkId.GetPath().Data()));
1295 AliCDBParam *chkPar=SelectSpecificStorage(chkId.GetPath());
1296 if (!chkPar || aPar == chkPar) continue;
1297 AliCDBStorage *chkStorage = GetStorage(chkPar);
1298 AliDebug(2, Form("Found specific storage! %s", chkPar->GetURI().Data()));
1299
1300 AliCDBEntry *newEntry=0;
1301 chkId.SetRunRange(query.GetFirstRun(), query.GetLastRun());
1302 chkId.SetVersion(query.GetVersion());
1303 chkId.SetSubVersion(query.GetSubVersion());
1304
1305 if(chkStorage) newEntry = chkStorage->Get(chkId);
1306 if(!newEntry) continue;
1307
1308 // object is found in specific storage: replace entry in the result list!
1309 chkEntry->SetOwner(1);
1310 delete result->Remove(chkEntry);
1311 result->AddFirst(newEntry);
1312 }
1313
1314 Int_t nEntries = result->GetEntries();
1315 AliInfo("After look into other specific storages, result list is:");
1316 for(int i=0; i<nEntries;i++){
1317 AliCDBEntry *entry = (AliCDBEntry*) result->At(i);
1318 AliInfo(Form("%s",entry->GetId().ToString().Data()));
1319 }
1320 }
1321
1322 // caching entries
1323 TIter iter(result);
1324 AliCDBEntry* entry=0;
1325 while((entry = dynamic_cast<AliCDBEntry*> (iter.Next()))){
1326
1327 if(!fIds->Contains(&entry->GetId())){
1328 fIds->Add(entry->GetId().Clone());
1329 }
1330 if(fCache && (query.GetFirstRun() == fRun)){
1331 CacheEntry(entry->GetId().GetPath(), entry);
1332 }
1333 }
1334
1335
1336 return result;
02c4845e 1337}
1338
1339//_____________________________________________________________________________
b1bfa962 1340Bool_t AliCDBManager::Put(TObject* object, const AliCDBId& id, AliCDBMetaData* metaData, const char* mirrors, DataType type){
02c4845e 1341// store an AliCDBEntry object into the database
1342
5078a13f 1343 if (object==0x0) {
1344 AliError("Null Entry! No storage will be done!");
1345 return kFALSE;
1346 }
968cfa08 1347
5078a13f 1348 AliCDBEntry anEntry(object, id, metaData);
1349 return Put(&anEntry, mirrors, type);
02c4845e 1350
1351}
1352
1353
1354//_____________________________________________________________________________
06eeadea 1355Bool_t AliCDBManager::Put(AliCDBEntry* entry, const char* mirrors, DataType type){
02c4845e 1356// store an AliCDBEntry object into the database
1357
5078a13f 1358 if(type == kPrivate && !fDefaultStorage) {
1359 AliError("No storage set!");
1360 return kFALSE;
1361 }
1362
1363 if (!entry){
1364 AliError("No entry!");
1365 return kFALSE;
1366 }
1367
1368 if (entry->GetObject()==0x0){
1369 AliError("No valid object in CDB entry!");
1370 return kFALSE;
1371 }
1372
1373 if (!entry->GetId().IsValid()) {
1374 AliError(Form("Invalid entry ID: %s",
1375 entry->GetId().ToString().Data()));
1376 return kFALSE;
1377 }
1378
1379 if (!entry->GetId().IsSpecified()) {
1380 AliError(Form("Unspecified entry ID: %s",
1381 entry->GetId().ToString().Data()));
1382 return kFALSE;
1383 }
1384
1385 AliCDBId id = entry->GetId();
1386 AliCDBParam *aPar = SelectSpecificStorage(id.GetPath());
1387
1388 AliCDBStorage *aStorage=0;
1389
1390 if(aPar) {
1391 aStorage=GetStorage(aPar);
1392 } else {
1393 switch(type){
1394 case kCondition:
1395 aStorage = GetStorage(fCondParam);
1396 break;
1397 case kReference:
1398 aStorage = GetStorage(fRefParam);
1399 break;
1400 case kPrivate:
1401 aStorage = GetDefaultStorage();
1402 break;
1403 }
1404 }
1405
1406 AliDebug(2,Form("Storing object into storage: %s", aStorage->GetURI().Data()));
1407
1408 TString strMirrors(mirrors);
1409 Bool_t result = kFALSE;
1410 if(!strMirrors.IsNull() && !strMirrors.IsWhitespace())
1411 result = aStorage->Put(entry, mirrors, type);
1412 else
1413 result = aStorage->Put(entry, "", type);
1414
1415 if(fRun >= 0) QueryCDB();
1416
1417 return result;
02c4845e 1418
1419
1420}
9e1ceb13 1421
1422//_____________________________________________________________________________
5078a13f 1423void AliCDBManager::SetMirrorSEs(const char* mirrors) {
c5941d67 1424// set mirror Storage Elements for the default storage, if it is of type "alien"
5078a13f 1425 if(fDefaultStorage->GetType() != "alien"){
1426 AliInfo("The default storage is not of type \"alien\". Settings for Storage Elements are not taken into account!");
1427 return;
1428 }
1429 fDefaultStorage->SetMirrorSEs(mirrors);
c5941d67 1430}
1431
1432//_____________________________________________________________________________
1433const char* AliCDBManager::GetMirrorSEs() const {
1434// get mirror Storage Elements for the default storage, if it is of type "alien"
5078a13f 1435 if(fDefaultStorage->GetType() != "alien"){
1436 AliInfo("The default storage is not of type \"alien\". Settings for Storage Elements are not taken into account!");
1437 return "";
1438 }
1439 return fDefaultStorage->GetMirrorSEs();
c5941d67 1440}
1441
1442//_____________________________________________________________________________
5078a13f 1443void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry) {
4b5e0dce 1444// cache AliCDBEntry. Cache is valid until run number is changed.
1445
5078a13f 1446 AliCDBEntry *chkEntry = dynamic_cast<AliCDBEntry*> (fEntryCache.GetValue(path));
96b7636d 1447
5078a13f 1448 if(chkEntry) {
1449 AliDebug(2, Form("Object %s already in cache !!", path));
1450 return;
1451 } else {
1452 AliDebug(2,Form("Caching entry %s", path));
1453 }
96b7636d 1454
5078a13f 1455 fEntryCache.Add(new TObjString(path), entry);
1456 AliDebug(2,Form("Cache entries: %d", fEntryCache.GetEntries()));
4b5e0dce 1457
1458}
1459
1460//_____________________________________________________________________________
5078a13f 1461void AliCDBManager::Print(Option_t* /*option*/) const {
917a098b 1462// Print list of active storages and their URIs
917a098b 1463
5078a13f 1464 TString output=Form("Run number = %d; ",fRun);
1465 output += "Cache is ";
1466 if(!fCache) output += "NOT ";
1467 output += Form("ACTIVE; Number of active storages: %d\n",fActiveStorages.GetEntries());
1468
1469 if(fDefaultStorage) {
1470 output += Form("\t*** Default Storage URI: \"%s\"\n",fDefaultStorage->GetURI().Data());
1471 // AliInfo(output.Data());
1472 }
1473 if(fSpecificStorages.GetEntries()>0) {
1474 TIter iter(fSpecificStorages.GetTable());
1475 TPair *aPair=0;
1476 Int_t i=1;
1477 while((aPair = (TPair*) iter.Next())){
1478 output += Form("\t*** Specific storage %d: Path \"%s\" -> URI \"%s\"\n",
1479 i++, ((TObjString*) aPair->Key())->GetName(),
1480 ((AliCDBParam*) aPair->Value())->GetURI().Data());
1481 }
1482 }
1483 if(fDrainStorage) {
1484 output += Form("*** Drain Storage URI: %s\n",fDrainStorage->GetURI().Data());
1485 }
1486 AliInfo(output.Data());
917a098b 1487}
1488
1489//_____________________________________________________________________________
5078a13f 1490void AliCDBManager::SetRun(Int_t run) {
917a098b 1491// Sets current run number.
4b5e0dce 1492// When the run number changes the caching is cleared.
5078a13f 1493
1494 if(fRun == run)
1495 return;
1496
1497 if(fLock && fRun >= 0) {
1498 AliFatal("Lock is ON, cannot reset run number!");
1499 }
1500
1501 fRun = run;
1502
1503 if (fRaw) {
1504 // here the LHCPeriod xml file is parsed; the string containing the correct period is returned; the default storage is set
1505 if (fStartRunLHCPeriod <= run && fEndRunLHCPeriod >= run){
1506 AliInfo("LHCPeriod alien folder for current run already in memory");
1507 }else{
1508 SetDefaultStorageFromRun(run);
1509 if(fEntryCache.GetEntries()!=0) ClearCache();
1510 return;
1511 }
1512 }
1513 ClearCache();
1514 QueryCDB();
4b5e0dce 1515}
1516
1517//_____________________________________________________________________________
1518void AliCDBManager::ClearCache(){
1519// clear AliCDBEntry cache
1520
5078a13f 1521 AliDebug(2, Form("Cache entries to be deleted: %d",fEntryCache.GetEntries()));
1522
1523 /*
1524 // To clean entries one by one
1525 TIter iter(fEntryCache.GetTable());
1526 TPair* pair=0;
1527 while((pair= dynamic_cast<TPair*> (iter.Next()))){
1528
1529 TObjString* key = dynamic_cast<TObjString*> (pair->Key());
1530 AliCDBEntry* entry = dynamic_cast<AliCDBEntry*> (pair->Value());
1531 AliDebug(2, Form("Deleting entry: %s", key->GetName()));
1532 if (entry) delete entry;
1533 delete fEntryCache.Remove(key);
1534 }
1535 */
1536 fEntryCache.DeleteAll();
1537 AliDebug(2, Form("After deleting - Cache entries: %d",fEntryCache.GetEntries()));
4b5e0dce 1538}
1539
1540//_____________________________________________________________________________
4005d0b5 1541void AliCDBManager::UnloadFromCache(const char* path){
1542// unload cached object
b0e8cda6 1543// that is remove the entry from the cache and the id from the list of ids
1544//
5078a13f 1545 if(!fActiveStorages.GetEntries()) {
1546 AliDebug(2, Form("No active storages. Object \"%s\" is not unloaded from cache", path));
1547 return;
1548 }
1549
1550 AliCDBPath queryPath(path);
1551 if(!queryPath.IsValid()) return;
1552
1553 if(!queryPath.IsWildcard()) { // path is not wildcard, get it directly from the cache and unload it!
1554 if(fEntryCache.Contains(path)){
1555 AliDebug(2, Form("Unloading object \"%s\" from cache and from list of ids", path));
1556 TObjString pathStr(path);
1557 delete fEntryCache.Remove(&pathStr);
1558 // we do not remove from the list of Id's (it's not very coherent but we leave the
1559 // id for the benefit of the userinfo)
1560 /*
1561 TIter iter(fIds);
1562 AliCDBId *id = 0;
1563 while((id = dynamic_cast<AliCDBId*> (iter.Next()))){
1564 if(queryPath.Comprises(id->GetPath()))
1565 delete fIds->Remove(id);
1566 }*/
1567 } else {
1568 AliWarning(Form("Cache does not contain object \"%s\"!", path));
1569 }
1570 AliDebug(2, Form("Cache entries: %d",fEntryCache.GetEntries()));
1571 return;
1572 }
1573
1574 // path is wildcard: loop on the cache and unload all comprised objects!
1575 TIter iter(fEntryCache.GetTable());
1576 TPair* pair = 0;
1577 Int_t removed=0;
1578
1579 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1580 AliCDBPath entryPath = pair->Key()->GetName();
1581 if(queryPath.Comprises(entryPath)) {
1582 AliDebug(2, Form("Unloading object \"%s\" from cache and from list of ids", entryPath.GetPath().Data()));
1583 TObjString pathStr(entryPath.GetPath());
1584 delete fEntryCache.Remove(&pathStr);
1585 removed++;
1586
1587 // we do not remove from the list of Id's (it's not very coherent but we leave the
1588 // id for the benefit of the userinfo)
1589 /*
1590 TIter iterids(fIds);
1591 AliCDBId *anId = 0;
1592 while((anId = dynamic_cast<AliCDBId*> (iterids.Next()))){
1593 AliCDBPath aPath = anId->GetPath();
1594 TString aPathStr = aPath.GetPath();
1595 if(queryPath.Comprises(aPath)) {
1596 delete fIds->Remove(anId);
1597 }
1598 }*/
1599 }
1600 }
1601 AliDebug(2,Form("Cache entries and ids removed: %d Remaining: %d",removed,fEntryCache.GetEntries()));
4005d0b5 1602}
1603
1604//_____________________________________________________________________________
9e1ceb13 1605void AliCDBManager::DestroyActiveStorages() {
1606// delete list of active storages
1607
5078a13f 1608 fActiveStorages.DeleteAll();
1609 fSpecificStorages.DeleteAll();
9e1ceb13 1610}
1611
1612//_____________________________________________________________________________
1613void AliCDBManager::DestroyActiveStorage(AliCDBStorage* /*storage*/) {
b05400be 1614// destroys active storage
1615
5078a13f 1616 /*
1617 TIter iter(fActiveStorages.GetTable());
1618 TPair* aPair;
1619 while ((aPair = (TPair*) iter.Next())) {
1620 if(storage == (AliCDBStorage*) aPair->Value())
1621 delete fActiveStorages.Remove(aPair->Key());
1622 storage->Delete(); storage=0x0;
1623 }
1624 */
9e1ceb13 1625
1626}
1627
62032124 1628//_____________________________________________________________________________
1629void AliCDBManager::QueryCDB() {
1630// query default and specific storages for files valid for fRun. Every storage loads the Ids into its list.
1631
5078a13f 1632 if (fRun < 0){
1633 AliError("Run number not yet set! Use AliCDBManager::SetRun.");
1634 return;
1635 }
1636 if (!fDefaultStorage){
1637 AliError("Default storage is not set! Use AliCDBManager::SetDefaultStorage");
1638 return;
1639 }
1640 if(fDefaultStorage->GetType() == "alien" || fDefaultStorage->GetType() == "local"){
1641 fDefaultStorage->QueryCDB(fRun);
1642 //} else {
1643 // AliDebug(2,"Skipping query for valid files, it used only in grid...");
1644 }
1645
1646 TIter iter(&fSpecificStorages);
1647 TObjString *aCalibType=0;
1648 AliCDBParam* aPar=0;
1649 while((aCalibType = dynamic_cast<TObjString*> (iter.Next()))){
1650 aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType);
1651 if(aPar) {
1652 AliDebug(2,Form("Querying specific storage %s",aCalibType->GetName()));
1653 AliCDBStorage *aStorage = GetStorage(aPar);
7ab8651a 1654 if(aStorage->GetType() == "alien" || aStorage->GetType() == "local"){
003e9909 1655 aStorage->QueryCDB(fRun, aCalibType->GetName());
5078a13f 1656 } else {
1657 AliDebug(2,
1658 "Skipping query for valid files, it is used only in grid...");
1659 }
1660 }
1661 }
62032124 1662}
1663
b8ec52f6 1664//______________________________________________________________________________________________
5078a13f 1665const char* AliCDBManager::GetDataTypeName(DataType type) {
1666// returns the name (string) of the data type
b8ec52f6 1667
5078a13f 1668 switch (type){
1669 case kCondition: return "Conditions";
1670 case kReference: return "Reference";
1671 case kPrivate: return "Private";
1672 }
1673 return 0;
b8ec52f6 1674
1675}
62032124 1676
4667c116 1677//______________________________________________________________________________________________
5078a13f 1678Bool_t AliCDBManager::DiffObjects(const char *cdbFile1, const char *cdbFile2) const {
1679// Compare byte-by-byte the objects contained in the CDB entry in two different files,
1680// whose name is passed as input
1681// Return value:
1682// kTRUE - in case the content of the OCDB object (persistent part) is exactly the same
1683// kFALSE - otherwise
1684
1685 TString f1Str(cdbFile1);
1686 TString f2Str(cdbFile2);
1687 if (!gGrid && ( f1Str.BeginsWith("alien://") || f2Str.BeginsWith("alien://") ))
1688 TGrid::Connect("alien://");
1689
1690 TFile * f1 = TFile::Open(cdbFile1);
1691 if (!f1){
1692 Printf("Cannot open file \"%s\"",cdbFile1);
1693 return kFALSE;
1694 }
1695 TFile * f2 = TFile::Open(cdbFile2);
1696 if (!f2){
1697 Printf("Cannot open file \"%s\"",cdbFile2);
1698 return kFALSE;
1699 }
a37a1dfc 1700
5078a13f 1701 AliCDBEntry * entry1 = (AliCDBEntry*)f1->Get("AliCDBEntry");
1702 if (!entry1){
1703 Printf("Cannot get CDB entry from file \"%s\"",cdbFile1);
1704 return kFALSE;
1705 }
1706 AliCDBEntry * entry2 = (AliCDBEntry*)f2->Get("AliCDBEntry");
1707 if (!entry2){
1708 Printf("Cannot get CDB entry from file \"%s\"",cdbFile2);
1709 return kFALSE;
1710 }
a37a1dfc 1711
5078a13f 1712 // stream the two objects in the buffer of two TMessages
1713 TObject* object1 = entry1->GetObject();
1714 TObject* object2 = entry2->GetObject();
1715 TMessage * file1 = new TMessage(TBuffer::kWrite);
1716 file1->WriteObject(object1);
1717 Int_t size1 = file1->Length();
1718 TMessage * file2 = new TMessage(TBuffer::kWrite);
1719 file2->WriteObject(object2);
1720 Int_t size2 = file2->Length();
1721 if (size1!=size2){
1722 Printf("Problem 2: OCDB entry of different size (%d,%d)",size1,size2);
1723 return kFALSE;
1724 }
1725
1726 // if the two buffers have the same size, check that they are the same byte-by-byte
1727 Int_t countDiff=0;
1728 char* buf1 = file1->Buffer();
1729 char* buf2 = file2->Buffer();
1730 //for (Int_t i=0; i<size1; i++) if (file1->Buffer()[i]!=file2->Buffer()[i]) countDiff++;
1731 for(Int_t i=0; i<size1; i++)
1732 if (buf1[i]!=buf2[i]) countDiff++;
1733
1734 if (countDiff>0){
1735 Printf("The CDB objects differ by %d bytes.", countDiff);
1736 return kFALSE;
1737 }
a37a1dfc 1738
5078a13f 1739 Printf("The CDB objects are the same in the two files.");
1740 return kTRUE;
a37a1dfc 1741}
1742
1743//______________________________________________________________________________________________
5078a13f 1744void AliCDBManager::InitShortLived() {
1745// Init the list of short-lived objects
1746// currently disabled
1747
1748 fShortLived=0x0;
1749
1750 // fShortLived = new TList();
1751 // fShortLived->SetOwner(1);
1752 //
1753 // fShortLived->Add(new TObjString("EMCAL/Calib/Data"));
1754 //
1755 // fShortLived->Add(new TObjString("HMPID/Calib/Nmean"));
1756 // fShortLived->Add(new TObjString("HMPID/Calib/Qthre"));
1757 //
1758 // fShortLived->Add(new TObjString("ITS/Calib/CalibSPD"));
1759 //
1760 // fShortLived->Add(new TObjString("MUON/Calib/Gains"));
1761 // fShortLived->Add(new TObjString("MUON/Calib/HV"));
1762 // fShortLived->Add(new TObjString("MUON/Calib/Pedestals"));
1763 //
1764 // fShortLived->Add(new TObjString("PHOS/Calib/CpvGainPedestals"));
1765 // fShortLived->Add(new TObjString("PHOS/Calib/EmcGainPedestals"));
1766 //
1767 // fShortLived->Add(new TObjString("PMD/Calib/Data"));
1768 //
1769 // fShortLived->Add(new TObjString("TRD/Calib/ChamberGainFactor"));
1770 // fShortLived->Add(new TObjString("TRD/Calib/LocalGainFactor"));
1771 // fShortLived->Add(new TObjString("TRD/Calib/ChamberT0"));
1772 // fShortLived->Add(new TObjString("TRD/Calib/LocalT0"));
1773 // fShortLived->Add(new TObjString("TRD/Calib/ChamberVdrift"));
1774 // fShortLived->Add(new TObjString("TRD/Calib/LocalVdrift"));
1775 //
1776 // fShortLived->Add(new TObjString("ZDC/Calib/Data"));
4667c116 1777
1778}
1779
1780//______________________________________________________________________________________________
5078a13f 1781Bool_t AliCDBManager::IsShortLived(const char* path) {
1782// returns the name (string) of the data type
4667c116 1783
5078a13f 1784 if(!fShortLived) return kFALSE;
4667c116 1785
5078a13f 1786 AliCDBPath aPath(path);
1787 if(!aPath.IsValid()){
1788 AliError(Form("Not a valid path: %s", path));
1789 return kFALSE;
1790 }
4667c116 1791
5078a13f 1792 return fShortLived->Contains(path);
4667c116 1793
1794}
1795
1f341624 1796//______________________________________________________________________________________________
096d8e90 1797ULong64_t AliCDBManager::SetLock(Bool_t lock, ULong64_t key){
5078a13f 1798// To lock/unlock user must provide the key. A new key is provided after
1799// each successful lock. User should always backup the returned key and
1800// use it on next access.
a6f59240 1801 if (fLock == lock) return 0; // nothing to be done
1802 if (lock) {
1803 // User wants to lock - check his identity
1804 if (fKey) {
1805 // Lock has a user - check his key
1806 if (fKey != key) {
1807 AliFatal("Wrong key provided to lock CDB. Please remove CDB lock access from your code !");
1808 return 0;
5078a13f 1809 }
1810 }
1811 // Provide new key
a6f59240 1812 fKey = gSystem->Now();
1813 fLock = kTRUE;
1814 return fKey;
1815 }
1816 // User wants to unlock - check the provided key
1817 if (key != fKey) {
1818 AliFatal("Lock is ON: wrong key provided");
1819 return 0;
5078a13f 1820 }
a6f59240 1821 fLock = kFALSE;
5078a13f 1822 return key;
1f341624 1823}
1824
9e1ceb13 1825///////////////////////////////////////////////////////////
1826// AliCDBManager Parameter class //
1827// interface to specific AliCDBParameter class //
1828// (AliCDBGridParam, AliCDBLocalParam, AliCDBDumpParam) //
1829///////////////////////////////////////////////////////////
1830
62032124 1831AliCDBParam::AliCDBParam():
fe12e09c 1832 fType(),
1833 fURI()
62032124 1834{
5078a13f 1835 // constructor
9e1ceb13 1836
1837}
1838
1839//_____________________________________________________________________________
1840AliCDBParam::~AliCDBParam() {
5078a13f 1841 // destructor
9e1ceb13 1842
1843}
1844