X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliCDBManager.cxx;h=be2397d155f8da143625b1ffd69e307340a70a2a;hb=d5efea33f7bdd4e2c60f3cf9d90899d4392044a6;hp=8abdccfbbcef883cbb4ae844a5dd6e06101c9a8a;hpb=620321242adc863f8edba964e55ab8ee5475abbd;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliCDBManager.cxx b/STEER/AliCDBManager.cxx index 8abdccfbbce..be2397d155f 100644 --- a/STEER/AliCDBManager.cxx +++ b/STEER/AliCDBManager.cxx @@ -34,10 +34,14 @@ ClassImp(AliCDBParam) ClassImp(AliCDBManager) +//TODO OCDB and Reference folder should not be fully hardcoded but built from run number (or year/LHC period) +TString AliCDBManager::fgkCondUri("alien://folder=/alice/cern.ch/user/a/aliprod/testCDB/CDB?user=aliprod"); +TString AliCDBManager::fgkRefUri("alien://folder=/alice/cern.ch/user/a/aliprod/testCDB/Reference?user=aliprod"); AliCDBManager* AliCDBManager::fgInstance = 0x0; //_____________________________________________________________________________ -AliCDBManager* AliCDBManager::Instance() { +AliCDBManager* AliCDBManager::Instance() +{ // returns AliCDBManager instance (singleton) if (!fgInstance) { @@ -58,7 +62,11 @@ void AliCDBManager::Init() { if(!gSystem->Exec("root-config --has-alien |grep yes 2>&1 > /dev/null")){ // returns 0 if yes AliInfo("AliEn classes enabled in Root. AliCDBGrid factory registered."); RegisterFactory(new AliCDBGridFactory()); + fCondParam = CreateParameter(fgkCondUri); + fRefParam = CreateParameter(fgkRefUri); } + + InitShortLived(); } //_____________________________________________________________________________ void AliCDBManager::Destroy() { @@ -73,16 +81,32 @@ void AliCDBManager::Destroy() { //_____________________________________________________________________________ AliCDBManager::AliCDBManager(): - fDefaultStorage(NULL), - fDrainStorage(NULL), - fCache(kTRUE), - fRun(-1) + TObject(), + fFactories(), + fActiveStorages(), + fSpecificStorages(), + fEntryCache(), + fIds(0), + fStorageMap(0), + fShortLived(0), + fDefaultStorage(NULL), + fDrainStorage(NULL), + fCondParam(0), + fRefParam(0), + fRun(-1), + fCache(kTRUE), + fLock(kFALSE) { // default constuctor fFactories.SetOwner(1); fActiveStorages.SetOwner(1); fSpecificStorages.SetOwner(1); fEntryCache.SetOwner(1); + + fStorageMap = new TMap(); + fStorageMap->SetOwner(1); + fIds = new TList(); + fIds->SetOwner(1); } //_____________________________________________________________________________ @@ -93,6 +117,11 @@ AliCDBManager::~AliCDBManager() { fFactories.Delete(); fDrainStorage = 0x0; fDefaultStorage = 0x0; + delete fStorageMap; fStorageMap = 0; + delete fIds; fIds = 0; + delete fCondParam; + delete fRefParam; + delete fShortLived; fShortLived = 0x0; } //_____________________________________________________________________________ @@ -114,7 +143,7 @@ void AliCDBManager::RegisterFactory(AliCDBStorageFactory* factory) { //_____________________________________________________________________________ Bool_t AliCDBManager::HasStorage(const char* dbString) const { -// check if dbString is a URI valid for one of the registered factories +// check if dbString is a URI valid for one of the registered factories TIter iter(&fFactories); @@ -123,7 +152,7 @@ Bool_t AliCDBManager::HasStorage(const char* dbString) const { if (factory->Validate(dbString)) { return kTRUE; - } + } } return kFALSE; @@ -147,9 +176,10 @@ AliCDBParam* AliCDBManager::CreateParameter(const char* dbString) const { //_____________________________________________________________________________ AliCDBStorage* AliCDBManager::GetStorage(const char* dbString) { // get storage object from URI string - + AliCDBParam* param = CreateParameter(dbString); if (!param) { + AliError(Form("Failed to activate requested storage! Check URI: %s", dbString)); return NULL; } @@ -162,7 +192,7 @@ AliCDBStorage* AliCDBManager::GetStorage(const char* dbString) { //_____________________________________________________________________________ AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) { // get storage object from AliCDBParam object - + // if the list of active storages already contains // the requested storage, return it AliCDBStorage* aStorage = GetActiveStorage(param); @@ -170,6 +200,14 @@ AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) { return aStorage; } + // if lock is ON, cannot activate more storages! + if(fLock) { + if (fDefaultStorage) { + AliFatal("Lock is ON, and default storage is already set: " + "cannot reset it or activate more storages!"); + } + } + TIter iter(&fFactories); AliCDBStorageFactory* factory=0; @@ -182,10 +220,20 @@ AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) { if (aStorage) { PutActiveStorage(param->CloneParam(), aStorage); aStorage->SetURI(param->GetURI()); + if(fRun >= 0) { + if(aStorage->GetType() == "alien"){ + aStorage->QueryCDB(fRun); + } else { + AliDebug(2, + "Skipping query for valid files, it is used only in grid..."); + } + } return aStorage; } } + AliError(Form("Failed to activate requested storage! Check URI: %s", param->GetURI().Data())); + return NULL; } @@ -222,7 +270,7 @@ void AliCDBManager::SetDrain(const char* dbString) { //_____________________________________________________________________________ void AliCDBManager::SetDrain(const AliCDBParam* param) { // set drain storage from AliCDBParam - + fDrainStorage = GetStorage(param); } @@ -237,30 +285,98 @@ void AliCDBManager::SetDrain(AliCDBStorage* storage) { Bool_t AliCDBManager::Drain(AliCDBEntry *entry) { // drain retrieved object to drain storage - AliInfo("Draining into drain storage..."); + AliDebug(2, "Draining into drain storage..."); return fDrainStorage->Put(entry); } //_____________________________________________________________________________ void AliCDBManager::SetDefaultStorage(const char* dbString) { // sets default storage from URI string - + AliInfo(Form("Setting Default storage to: %s",dbString)); + AliCDBStorage* bckStorage = fDefaultStorage; + fDefaultStorage = GetStorage(dbString); + + if(bckStorage && (fDefaultStorage != bckStorage)){ + AliWarning("Existing default storage replaced: clearing cache!"); + ClearCache(); + } + + if (fStorageMap->Contains("default")) { + delete fStorageMap->Remove(fStorageMap->GetValue("default")); + } + fStorageMap->Add(new TObjString("default"), new TObjString(fDefaultStorage->GetURI())); } //_____________________________________________________________________________ void AliCDBManager::SetDefaultStorage(const AliCDBParam* param) { // set default storage from AliCDBParam object - fDrainStorage = GetStorage(param); + AliCDBStorage* bckStorage = fDefaultStorage; + + fDefaultStorage = GetStorage(param); + + if(bckStorage && (fDefaultStorage != bckStorage)){ + AliWarning("Existing default storage replaced: clearing cache!"); + ClearCache(); + } + + if (fStorageMap->Contains("default")) { + delete fStorageMap->Remove(fStorageMap->GetValue("default")); + } + fStorageMap->Add(new TObjString("default"), new TObjString(fDefaultStorage->GetURI())); } //_____________________________________________________________________________ void AliCDBManager::SetDefaultStorage(AliCDBStorage* storage) { // set default storage from another active storage + // if lock is ON, cannot activate more storages! + if(fLock) { + if (fDefaultStorage) { + AliFatal("Lock is ON, and default storage is already set: " + "cannot reset it or activate more storages!"); + } + } + + if (!storage) { + UnsetDefaultStorage(); + return; + } + + AliCDBStorage* bckStorage = fDefaultStorage; + fDefaultStorage = storage; + + if(bckStorage && (fDefaultStorage != bckStorage)){ + AliWarning("Existing default storage replaced: clearing cache!"); + ClearCache(); + } + + if (fStorageMap->Contains("default")) { + delete fStorageMap->Remove(fStorageMap->GetValue("default")); + } + fStorageMap->Add(new TObjString("default"), new TObjString(fDefaultStorage->GetURI())); +} + +//_____________________________________________________________________________ +void AliCDBManager::UnsetDefaultStorage() { +// Unset default storage + + // if lock is ON, action is forbidden! + if(fLock) { + if (fDefaultStorage) { + AliFatal("Lock is ON: cannot unset default storage!"); + } + } + + if (fDefaultStorage) { + AliWarning("Clearing cache!"); + ClearCache(); + } + + fDefaultStorage = 0x0; } //_____________________________________________________________________________ @@ -278,14 +394,15 @@ void AliCDBManager::SetSpecificStorage(const char* calibType, AliCDBParam* param // sets storage specific for detector or calibration type (works with AliCDBManager::Get(...)) // Default storage should be defined prior to any specific storages, e.g.: // AliCDBManager::instance()->SetDefaultStorage("alien://"); -// AliCDBManager::instance()->SetSpecificStorage("TPC","local://DB_TPC"); -// AliCDBManager::instance()->SetSpecificStorage("RICH/Align","local://DB_TPCAlign"); +// AliCDBManager::instance()->SetSpecificStorage("TPC/*","local://DB_TPC"); +// AliCDBManager::instance()->SetSpecificStorage("*/Align/*","local://DB_TPCAlign"); +// calibType must be a valid CDB path! (3 level folder structure) if(!fDefaultStorage) { - AliError("Please activate a default storage first!"); + AliError("Please activate a default storage first!"); return; } - + AliCDBPath aPath(calibType); if(!aPath.IsValid()){ AliError(Form("Not a valid path: %s", calibType)); @@ -296,24 +413,36 @@ void AliCDBManager::SetSpecificStorage(const char* calibType, AliCDBParam* param if(fSpecificStorages.Contains(objCalibType)){ AliWarning(Form("Storage \"%s\" already activated! It will be replaced by the new one", calibType)); - fSpecificStorages.Remove(objCalibType); + AliCDBParam *checkPar = dynamic_cast (fSpecificStorages.GetValue(calibType)); + if(checkPar) delete checkPar; + delete fSpecificStorages.Remove(objCalibType); } GetStorage(param); - fSpecificStorages.Add(objCalibType, param->CloneParam()); + + fSpecificStorages.Add(objCalibType, param->CloneParam()); + + if(fStorageMap->Contains(objCalibType)){ + delete fStorageMap->Remove(objCalibType); + } + fStorageMap->Add(objCalibType->Clone(), new TObjString(param->GetURI())); + } //_____________________________________________________________________________ AliCDBStorage* AliCDBManager::GetSpecificStorage(const char* calibType) { // get storage specific for detector or calibration type - AliCDBParam *checkPar = (AliCDBParam*) fSpecificStorages.GetValue(calibType); + AliCDBPath calibPath(calibType); + if(!calibPath.IsValid()) return NULL; + + AliCDBParam *checkPar = (AliCDBParam*) fSpecificStorages.GetValue(calibPath.GetPath()); if(!checkPar){ - AliError(Form("%s storage not found!",calibType)); + AliError(Form("%s storage not found!", calibType)); return NULL; } else { return GetStorage(checkPar); } - + } //_____________________________________________________________________________ @@ -321,26 +450,25 @@ AliCDBParam* AliCDBManager::SelectSpecificStorage(const TString& path) { // select storage valid for path from the list of specific storages AliCDBPath aPath(path); - if(!aPath.IsValid()){ - AliError(Form("Not a valid path: %s", path.Data())); - return NULL; - } + if(!aPath.IsValid()) return NULL; TIter iter(&fSpecificStorages); TObjString *aCalibType=0; + AliCDBPath tmpPath("null/null/null"); AliCDBParam* aPar=0; while((aCalibType = (TObjString*) iter.Next())){ AliCDBPath calibTypePath(aCalibType->GetName()); if(calibTypePath.Comprises(aPath)) { + if(calibTypePath.Comprises(tmpPath)) continue; aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType); - break; + tmpPath.SetPath(calibTypePath.GetPath()); } } return aPar; } //_____________________________________________________________________________ -AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber, +AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber, Int_t version, Int_t subVersion) { // get an AliCDBEntry object from the database @@ -357,7 +485,7 @@ AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber, } //_____________________________________________________________________________ -AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, +AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) { // get an AliCDBEntry object from the database! @@ -366,7 +494,7 @@ AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, } //_____________________________________________________________________________ -AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) { +AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) { // get an AliCDBEntry object from the database if(!fDefaultStorage) { @@ -383,50 +511,141 @@ AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) { // query is not specified if path contains wildcard or run range= [-1,-1] if (!query.IsSpecified()) { - AliError(Form("Unspecified query: %s", + AliError(Form("Unspecified query: %s", query.ToString().Data())); return NULL; } - if(fCache && query.GetFirstRun() != fRun) + if(fLock && query.GetFirstRun() != fRun) + AliFatal("Lock is ON: cannot use different run number than the internal one!"); + + if(fCache && query.GetFirstRun() != fRun) AliWarning("Run number explicitly set in query: CDB cache temporarily disabled!"); - AliCDBEntry *entry=0; - + // first look into map of cached objects if(fCache && query.GetFirstRun() == fRun) entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath()); if(entry) { - AliInfo(Form("Object %s retrieved from cache !!",query.GetPath().Data())); + AliDebug(2, Form("Object %s retrieved from cache !!",query.GetPath().Data())); return entry; } - - // Entry is not in cache -> retrieve it from CDB and cache it!! + + // Entry is not in cache -> retrieve it from CDB and cache it!! AliCDBStorage *aStorage=0; AliCDBParam *aPar=SelectSpecificStorage(query.GetPath()); +// Bool_t usedDefStorage=kTRUE; if(aPar) { aStorage=GetStorage(aPar); TString str = aPar->GetURI(); AliDebug(2,Form("Looking into storage: %s",str.Data())); - +// usedDefStorage=kFALSE; + } else { aStorage=GetDefaultStorage(); - AliDebug(2,"Looking into default storage"); + AliDebug(2,"Looking into default storage"); } - + entry = aStorage->Get(query); - if (!entry) return NULL; - if(fCache && (query.GetFirstRun() == fRun)){ - AliDebug(2,Form("Caching entry %s !",query.GetPath().Data())); + if(entry && fCache && (query.GetFirstRun() == fRun)){ CacheEntry(query.GetPath(), entry); } - + + if(entry && !fIds->Contains(&entry->GetId())){ + fIds->Add(entry->GetId().Clone()); + } + + return entry; + +} + +//_____________________________________________________________________________ +AliCDBId* AliCDBManager::GetId(const AliCDBPath& path, Int_t runNumber, + Int_t version, Int_t subVersion) { +// get the AliCDBId of the valid object from the database (does not retrieve the object) +// User must delete returned object! + + if(runNumber < 0){ + // RunNumber is not specified. Try with fRun + if (fRun < 0){ + AliError("Run number neither specified in query nor set in AliCDBManager! Use AliCDBManager::SetRun."); + return NULL; + } + runNumber = fRun; + } + + return GetId(AliCDBId(path, runNumber, runNumber, version, subVersion)); +} + +//_____________________________________________________________________________ +AliCDBId* AliCDBManager::GetId(const AliCDBPath& path, + const AliCDBRunRange& runRange, Int_t version, + Int_t subVersion) { +// get the AliCDBId of the valid object from the database (does not retrieve the object) +// User must delete returned object! + + return GetId(AliCDBId(path, runRange, version, subVersion)); +} + +//_____________________________________________________________________________ +AliCDBId* AliCDBManager::GetId(const AliCDBId& query) { +// get the AliCDBId of the valid object from the database (does not retrieve the object) +// User must delete returned object! + + if(!fDefaultStorage) { + AliError("No storage set!"); + return NULL; + } + + // check if query's path and runRange are valid + // query is invalid also if version is not specified and subversion is! + if (!query.IsValid()) { + AliError(Form("Invalid query: %s", query.ToString().Data())); + return NULL; + } + + // query is not specified if path contains wildcard or run range= [-1,-1] + if (!query.IsSpecified()) { + AliError(Form("Unspecified query: %s", + query.ToString().Data())); + return NULL; + } + + if(fCache && query.GetFirstRun() != fRun) + AliWarning("Run number explicitly set in query: CDB cache temporarily disabled!"); + + AliCDBEntry* entry = 0; + + // first look into map of cached objects + if(fCache && query.GetFirstRun() == fRun) + entry = (AliCDBEntry*) fEntryCache.GetValue(query.GetPath()); + + if(entry) { + AliDebug(2, Form("Object %s retrieved from cache !!",query.GetPath().Data())); + return dynamic_cast (entry->GetId().Clone()); + } + + // Entry is not in cache -> retrieve it from CDB and cache it!! + AliCDBStorage *aStorage=0; + AliCDBParam *aPar=SelectSpecificStorage(query.GetPath()); + + if(aPar) { + aStorage=GetStorage(aPar); + TString str = aPar->GetURI(); + AliDebug(2,Form("Looking into storage: %s",str.Data())); + } else { + aStorage=GetDefaultStorage(); + AliDebug(2,"Looking into default storage"); + } + + return aStorage->GetId(query); + } //_____________________________________________________________________________ @@ -448,7 +667,7 @@ TList* AliCDBManager::GetAll(const AliCDBPath& path, Int_t runNumber, } //_____________________________________________________________________________ -TList* AliCDBManager::GetAll(const AliCDBPath& path, +TList* AliCDBManager::GetAll(const AliCDBPath& path, const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) { // get multiple AliCDBEntry objects from the database @@ -460,6 +679,8 @@ TList* AliCDBManager::GetAll(const AliCDBId& query) { // get multiple AliCDBEntry objects from the database // Warning: this method works correctly only for queries of the type "Detector/*" // and not for more specific queries e.g. "Detector/Calib/*" ! +// Warning #2: Entries are cached, but GetAll will keep on retrieving objects from OCDB! +// To get an object from cache use Get() function if(!fDefaultStorage) { AliError("No storage set!"); @@ -474,49 +695,103 @@ TList* AliCDBManager::GetAll(const AliCDBId& query) { if((fSpecificStorages.GetEntries()>0) && query.GetPath().BeginsWith('*')){ // if specific storages are active a query with "*" is ambiguous AliError("Query too generic in this context!"); - return NULL; + return NULL; } if (query.IsAnyRange()) { AliError(Form("Unspecified run or runrange: %s", - query.ToString().Data())); + query.ToString().Data())); return NULL; - } - - TObjString objStrLev0(query.GetLevel0()); - AliCDBParam *aPar = (AliCDBParam*) fSpecificStorages.GetValue(&objStrLev0); + } - AliCDBStorage *aStorage; + if(fLock && query.GetFirstRun() != fRun) + AliFatal("Lock is ON: cannot use different run number than the internal one!"); + + AliCDBParam *aPar=SelectSpecificStorage(query.GetPath()); + + AliCDBStorage *aStorage; if(aPar) { aStorage=GetStorage(aPar); - TString str = aPar->GetURI(); - AliDebug(2,Form("Looking into storage: %s",str.Data())); - + AliDebug(2,Form("Looking into storage: %s", aPar->GetURI().Data())); + } else { aStorage=GetDefaultStorage(); - AliDebug(2,"Looking into default storage"); + AliDebug(2,"Looking into default storage"); + } + + TList *result = 0; + if(aStorage) result = aStorage->GetAll(query); + if(!result) return 0; + + // loop on result to check whether entries should be re-queried with specific storages + if(fSpecificStorages.GetEntries()>0 && ! (fSpecificStorages.GetEntries() == 1 && aPar)) { + AliInfo("Now look into all other specific storages..."); + + TIter iter(result); + AliCDBEntry* chkEntry=0; + + while((chkEntry = dynamic_cast (iter.Next()))){ + AliCDBId& chkId = chkEntry->GetId(); + AliDebug(2, Form("Checking id %s ", chkId.GetPath().Data())); + AliCDBParam *chkPar=SelectSpecificStorage(chkId.GetPath()); + if (!chkPar || aPar == chkPar) continue; + AliCDBStorage *chkStorage = GetStorage(chkPar); + AliDebug(2, Form("Found specific storage! %s", chkPar->GetURI().Data())); + + AliCDBEntry *newEntry=0; + chkId.SetRunRange(query.GetFirstRun(), query.GetLastRun()); + chkId.SetVersion(query.GetVersion()); + chkId.SetSubVersion(query.GetSubVersion()); + + if(chkStorage) newEntry = chkStorage->Get(chkId); + if(!newEntry) continue; + + // object is found in specific storage: replace entry in the result list! + chkEntry->SetOwner(1); + delete result->Remove(chkEntry); + result->AddFirst(newEntry); + } + + Int_t nEntries = result->GetEntries(); + AliInfo("After look into other specific storages, result list is:"); + for(int i=0; iAt(i); + AliInfo(Form("%s",entry->GetId().ToString().Data())); + } + } + + // caching entries + TIter iter(result); + AliCDBEntry* entry=0; + while((entry = dynamic_cast (iter.Next()))){ + + if(!fIds->Contains(&entry->GetId())){ + fIds->Add(entry->GetId().Clone()); + } + if(fCache && (query.GetFirstRun() == fRun)){ + CacheEntry(entry->GetId().GetPath(), entry); + } } - TList *result = aStorage->GetAll(query); - return result; + return result; } //_____________________________________________________________________________ -Bool_t AliCDBManager::Put(TObject* object, AliCDBId& id, AliCDBMetaData* metaData){ +Bool_t AliCDBManager::Put(TObject* object, AliCDBId& id, AliCDBMetaData* metaData, DataType type){ // store an AliCDBEntry object into the database AliCDBEntry anEntry(object, id, metaData); - return Put(&anEntry); + return Put(&anEntry, type); } //_____________________________________________________________________________ -Bool_t AliCDBManager::Put(AliCDBEntry* entry){ +Bool_t AliCDBManager::Put(AliCDBEntry* entry, DataType type){ // store an AliCDBEntry object into the database - if(!fDefaultStorage) { + if(type == kPrivate && !fDefaultStorage) { AliError("No storage set!"); return kFALSE; } @@ -541,19 +816,31 @@ Bool_t AliCDBManager::Put(AliCDBEntry* entry){ AliCDBId id = entry->GetId(); AliCDBParam *aPar = SelectSpecificStorage(id.GetPath()); - AliCDBStorage *aStorage; + AliCDBStorage *aStorage=0; if(aPar) { aStorage=GetStorage(aPar); - TString str = aPar->GetURI(); - AliDebug(2,Form("Storing object into storage: %s",str.Data())); - } else { - aStorage=GetDefaultStorage(); - AliDebug(2,"Storing object into default storage"); + switch(type){ + case kCondition: + aStorage = GetStorage(fCondParam); + break; + case kReference: + aStorage = GetStorage(fRefParam); + break; + case kPrivate: + aStorage = GetDefaultStorage(); + break; + } } - return aStorage->Put(entry); + AliDebug(2,Form("Storing object into storage: %s", aStorage->GetURI().Data())); + + Bool_t result = aStorage->Put(entry, type); + + if(fRun >= 0) QueryCDB(); + + return result; } @@ -563,9 +850,17 @@ void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry) { // cache AliCDBEntry. Cache is valid until run number is changed. - AliDebug(2,Form("Filling cache with entry %s",path)); + AliCDBEntry *chkEntry = dynamic_cast (fEntryCache.GetValue(path)); + + if(chkEntry) { + AliDebug(2, Form("Object %s already in cache !!", path)); + return; + } else { + AliDebug(2,Form("Caching entry %s", path)); + } + fEntryCache.Add(new TObjString(path), entry); - AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries())); + AliDebug(2,Form("Cache entries: %d", fEntryCache.GetEntries())); } @@ -573,49 +868,45 @@ void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry) void AliCDBManager::Print(Option_t* /*option*/) const { // Print list of active storages and their URIs - AliInfo(Form("Run number: %d\n",fRun)); - TString output; - output = "Cache is "; + TString output=Form("Run number = %d; ",fRun); + output += "Cache is "; if(!fCache) output += "NOT "; - output += "ACTIVE\n"; - AliInfo(output.Data()); + output += Form("ACTIVE; Number of active storages: %d\n",fActiveStorages.GetEntries()); if(fDefaultStorage) { - AliInfo("*** Default Storage: ***"); - output = Form("%s\n",fDefaultStorage->GetURI().Data()); - AliInfo(output.Data()); + output += Form("\t*** Default Storage URI: \"%s\"\n",fDefaultStorage->GetURI().Data()); +// AliInfo(output.Data()); } if(fSpecificStorages.GetEntries()>0) { - AliInfo("*** Specific Storages: ***"); TIter iter(fSpecificStorages.GetTable()); TPair *aPair=0; + Int_t i=1; while((aPair = (TPair*) iter.Next())){ - output = Form("Key: %s - Storage: %s", - ((TObjString*) aPair->Key())->GetName(), + output += Form("\t*** Specific storage %d: Path \"%s\" -> URI \"%s\"\n", + i++, ((TObjString*) aPair->Key())->GetName(), ((AliCDBParam*) aPair->Value())->GetURI().Data()); - AliInfo(output.Data()); } - printf("\n"); } if(fDrainStorage) { - AliInfo("*** Drain Storage: ***"); - output = Form("%s\n",fDrainStorage->GetURI().Data()); - AliInfo(output.Data()); + output += Form("*** Drain Storage URI: %s\n",fDrainStorage->GetURI().Data()); } - AliInfo(Form("Total number of active storages: %d",fActiveStorages.GetEntries())); - + AliInfo(output.Data()); } //_____________________________________________________________________________ -void AliCDBManager::SetRun(Long64_t run) +void AliCDBManager::SetRun(Int_t run) { // Sets current run number. // When the run number changes the caching is cleared. - + if (fRun == run) return; + if(fLock && fRun >= 0) { + AliFatal("Lock is ON, cannot reset run number!"); + } + fRun = run; ClearCache(); QueryCDB(); @@ -625,10 +916,61 @@ void AliCDBManager::SetRun(Long64_t run) void AliCDBManager::ClearCache(){ // clear AliCDBEntry cache - AliDebug(2,Form("Clearing cache!")); + AliDebug(2, Form("Cache entries to be deleted: %d",fEntryCache.GetEntries())); + + /* + // To clean entries one by one + TIter iter(fEntryCache.GetTable()); + TPair* pair=0; + while((pair= dynamic_cast (iter.Next()))){ + + TObjString* key = dynamic_cast (pair->Key()); + AliCDBEntry* entry = dynamic_cast (pair->Value()); + AliDebug(2, Form("Deleting entry: %s", key->GetName())); + if (entry) delete entry; + delete fEntryCache.Remove(key); + } + */ fEntryCache.DeleteAll(); - AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries())); + AliDebug(2, Form("After deleting - Cache entries: %d",fEntryCache.GetEntries())); +} + +//_____________________________________________________________________________ +void AliCDBManager::UnloadFromCache(const char* path){ +// unload cached object + + AliCDBPath queryPath(path); + if(!queryPath.IsValid()) return; + + if(!queryPath.IsWildcard()) { // path is not wildcard, get it directly from the cache and unload it! + if(fEntryCache.Contains(path)){ + AliInfo(Form("Unloading object \"%s\" from cache", path)); + TObjString pathStr(path); + AliCDBEntry *entry = dynamic_cast (fEntryCache.GetValue(&pathStr)); + if(entry) delete entry; + delete fEntryCache.Remove(&pathStr); + } else { + AliError(Form("Cache does not contain object \"%s\"!", path)) + } + AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries())); + return; + } + // path is wildcard: loop on the cache and unload all comprised objects! + TIter iter(fEntryCache.GetTable()); + TPair* pair = 0; + + while((pair = dynamic_cast (iter.Next()))){ + AliCDBPath entryPath = pair->Key()->GetName(); + if(queryPath.Comprises(entryPath)) { + AliInfo(Form("Unloading object \"%s\" from cache", entryPath.GetPath().Data())); + TObjString pathStr(entryPath.GetPath().Data()); + AliCDBEntry *entry = dynamic_cast (fEntryCache.GetValue(&pathStr)); + if(entry) delete entry; + delete fEntryCache.Remove(&pathStr); + } + } + AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries())); } //_____________________________________________________________________________ @@ -651,7 +993,7 @@ void AliCDBManager::DestroyActiveStorage(AliCDBStorage* /*storage*/) { delete fActiveStorages.Remove(aPair->Key()); storage->Delete(); storage=0x0; } -*/ +*/ } @@ -663,9 +1005,15 @@ void AliCDBManager::QueryCDB() { AliError("Run number not yet set! Use AliCDBManager::SetRun."); return; } - - AliInfo(Form("Querying default and specific storages for files valid for run %ld", (long) fRun)); - fDefaultStorage->QueryCDB(fRun); + if (!fDefaultStorage){ + AliError("Default storage is not set! Use AliCDBManager::SetDefaultStorage"); + return; + } + if(fDefaultStorage->GetType() == "alien"){ + fDefaultStorage->QueryCDB(fRun); + } else { + AliDebug(2,"Skipping query for valid files, it used only in grid..."); + } TIter iter(&fSpecificStorages); TObjString *aCalibType=0; @@ -673,14 +1021,96 @@ void AliCDBManager::QueryCDB() { while((aCalibType = dynamic_cast (iter.Next()))){ aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType); if(aPar) { - AliDebug(2,Form("Qerying specific storage %s",aCalibType->GetName())); - GetStorage(aPar)->QueryCDB(fRun,aCalibType->GetName()); - + AliDebug(2,Form("Querying specific storage %s",aCalibType->GetName())); + AliCDBStorage *aStorage = GetStorage(aPar); + if(aStorage->GetType() == "alien"){ + aStorage->QueryCDB(fRun,aCalibType->GetName()); + } else { + AliDebug(2, + "Skipping query for valid files, it is used only in grid..."); + } } } +} + +//______________________________________________________________________________________________ +const char* AliCDBManager::GetDataTypeName(DataType type) +{ + // returns the name (string) of the data type + + switch (type){ + case kCondition: return "Conditions"; + case kReference: return "Reference"; + case kPrivate: return "Private"; + } + return 0; + +} + +//______________________________________________________________________________________________ +void AliCDBManager::InitShortLived() +{ + // Init the list of short-lived objects + // currently disabled + + fShortLived=0x0; + +// fShortLived = new TList(); +// fShortLived->SetOwner(1); +// +// fShortLived->Add(new TObjString("EMCAL/Calib/Data")); +// +// fShortLived->Add(new TObjString("HMPID/Calib/Nmean")); +// fShortLived->Add(new TObjString("HMPID/Calib/Qthre")); +// +// fShortLived->Add(new TObjString("ITS/Calib/CalibSPD")); +// +// fShortLived->Add(new TObjString("MUON/Calib/Gains")); +// fShortLived->Add(new TObjString("MUON/Calib/HV")); +// fShortLived->Add(new TObjString("MUON/Calib/Pedestals")); +// +// fShortLived->Add(new TObjString("PHOS/Calib/CpvGainPedestals")); +// fShortLived->Add(new TObjString("PHOS/Calib/EmcGainPedestals")); +// +// fShortLived->Add(new TObjString("PMD/Calib/Data")); +// +// fShortLived->Add(new TObjString("TRD/Calib/ChamberGainFactor")); +// fShortLived->Add(new TObjString("TRD/Calib/LocalGainFactor")); +// fShortLived->Add(new TObjString("TRD/Calib/ChamberT0")); +// fShortLived->Add(new TObjString("TRD/Calib/LocalT0")); +// fShortLived->Add(new TObjString("TRD/Calib/ChamberVdrift")); +// fShortLived->Add(new TObjString("TRD/Calib/LocalVdrift")); +// +// fShortLived->Add(new TObjString("ZDC/Calib/Data")); + +} + +//______________________________________________________________________________________________ +Bool_t AliCDBManager::IsShortLived(const char* path) +{ + // returns the name (string) of the data type + + if(!fShortLived) return kFALSE; + + AliCDBPath aPath(path); + if(!aPath.IsValid()){ + AliError(Form("Not a valid path: %s", path)); + return kFALSE; + } + + return fShortLived->Contains(path); } +//______________________________________________________________________________________________ +void AliCDBManager::SetLock(Bool_t lock){ + + if(fLock == kTRUE && lock == kFALSE) { + AliFatal("Lock is ON: cannot reset it!"); + } + + fLock=lock; +} /////////////////////////////////////////////////////////// // AliCDBManager Parameter class // @@ -689,7 +1119,8 @@ void AliCDBManager::QueryCDB() { /////////////////////////////////////////////////////////// AliCDBParam::AliCDBParam(): -fType(), fURI() + fType(), + fURI() { // constructor