X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliCDBManager.cxx;h=06b412fea9391e8260f4cf9348fcb1092f8c488b;hb=8f16115a61ede20ac71354ccf4a126d81c099942;hp=69782ad051a98a703a4c649a34b916ab3c12d6b4;hpb=fdf65bb545d3ae693c2713661993bc6bf1f3bfa0;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliCDBManager.cxx b/STEER/AliCDBManager.cxx index 69782ad051a..06b412fea93 100644 --- a/STEER/AliCDBManager.cxx +++ b/STEER/AliCDBManager.cxx @@ -24,24 +24,39 @@ #include "AliCDBDump.h" #include "AliCDBLocal.h" #include "AliCDBGrid.h" -//#include "AliCDBEntry.h" +#include "AliCDBEntry.h" +#include "AliCDBHandler.h" -//#include -#include +#include +#include +#include +#include +#include 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"); +TString AliCDBManager::fgkMCIdealStorage("alien://folder=/alice/simulation/2008/v4-15-Release/Ideal"); +TString AliCDBManager::fgkMCFullStorage("alien://folder=/alice/simulation/2008/v4-15-Release/Full"); +TString AliCDBManager::fgkMCResidualStorage("alien://folder=/alice/simulation/2008/v4-15-Release/Residual"); +TString AliCDBManager::fgkOCDBFolderXMLfile("alien:///alice/data/OCDBFoldervsRunRange.xml"); AliCDBManager* AliCDBManager::fgInstance = 0x0; //_____________________________________________________________________________ -AliCDBManager* AliCDBManager::Instance() { +AliCDBManager* AliCDBManager::Instance(TMap *entryCache, Int_t run) +{ // returns AliCDBManager instance (singleton) if (!fgInstance) { fgInstance = new AliCDBManager(); - fgInstance->Init(); + if (!entryCache) + fgInstance->Init(); + else + fgInstance->InitFromCache(entryCache,run); } return fgInstance; @@ -57,13 +72,37 @@ 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::InitFromCache(TMap *entryCache, Int_t run) { +// initialize manager from existing cache +// used on the slaves in case of parallel reconstruction + SetRun(run); + + TIter iter(entryCache->GetTable()); + TPair* pair = 0; + + while((pair = dynamic_cast (iter.Next()))){ + fEntryCache.Add(pair->Key(),pair->Value()); + } + // fEntry is the new owner of the cache + fEntryCache.SetOwnerKeyValue(kTRUE,kTRUE); + entryCache->SetOwnerKeyValue(kFALSE,kFALSE); + AliInfo(Form("%d cache entries have been loaded",fEntryCache.GetEntries())); } + //_____________________________________________________________________________ void AliCDBManager::Destroy() { // delete ALCDBManager instance and active storages if (fgInstance) { + //fgInstance->Delete(); delete fgInstance; fgInstance = 0x0; } @@ -71,24 +110,53 @@ void AliCDBManager::Destroy() { //_____________________________________________________________________________ AliCDBManager::AliCDBManager(): - fDefaultStorage(NULL), - fDrainStorage(NULL) + 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), + fRaw(kFALSE), + fStartRunLHCPeriod(-1), + fEndRunLHCPeriod(-1), + fLHCPeriod(""), + fKey(0) { // default constuctor - fFactories.SetOwner(); + fFactories.SetOwner(1); + fActiveStorages.SetOwner(1); + fSpecificStorages.SetOwner(1); + fEntryCache.SetName("CDBEntryCache"); + fEntryCache.SetOwnerKeyValue(kTRUE,kTRUE); + + fStorageMap = new TMap(); + fStorageMap->SetOwner(1); + fIds = new TList(); + fIds->SetOwner(1); } //_____________________________________________________________________________ AliCDBManager::~AliCDBManager() { // destructor + ClearCache(); DestroyActiveStorages(); -} - -//_____________________________________________________________________________ -AliCDBStorage* AliCDBManager::GetActiveStorage(const AliCDBParam* param) { -// get a storage object from the list of active storages - - return (AliCDBStorage*) fActiveStorages.GetValue(param); + fFactories.Delete(); + fDrainStorage = 0x0; + fDefaultStorage = 0x0; + delete fStorageMap; fStorageMap = 0; + delete fIds; fIds = 0; + delete fCondParam; + delete fRefParam; + delete fShortLived; fShortLived = 0x0; } //_____________________________________________________________________________ @@ -110,16 +178,16 @@ 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); - AliCDBStorageFactory* factory; + AliCDBStorageFactory* factory=0; while ((factory = (AliCDBStorageFactory*) iter.Next())) { if (factory->Validate(dbString)) { return kTRUE; - } + } } return kFALSE; @@ -131,13 +199,10 @@ AliCDBParam* AliCDBManager::CreateParameter(const char* dbString) const { TIter iter(&fFactories); - AliCDBStorageFactory* factory; + AliCDBStorageFactory* factory=0; while ((factory = (AliCDBStorageFactory*) iter.Next())) { - AliCDBParam* param = factory->CreateParameter(dbString); - if (param) { - return param; - } + if(param) return param; } return NULL; @@ -146,34 +211,42 @@ 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; - } + } AliCDBStorage* aStorage = GetStorage(param); delete param; - return aStorage; } //_____________________________________________________________________________ AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) { // get storage object from AliCDBParam object - - // if the list of active storages already contains + + // if the list of active storages already contains // the requested storage, return it AliCDBStorage* aStorage = GetActiveStorage(param); if (aStorage) { 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; - + AliCDBStorageFactory* factory=0; + // loop on the list of registered factories while ((factory = (AliCDBStorageFactory*) iter.Next())) { @@ -181,26 +254,40 @@ AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) { aStorage = factory->Create(param); if (aStorage) { PutActiveStorage(param->CloneParam(), aStorage); - // if default storage is not set, set to this storage - if(!fDefaultStorage){ - fDefaultStorage=aStorage; - AliInfo(Form("Default storage set to: %s",(param->GetURI()).Data())); + 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; } +//_____________________________________________________________________________ +AliCDBStorage* AliCDBManager::GetActiveStorage(const AliCDBParam* param) { +// get a storage object from the list of active storages + + return dynamic_cast (fActiveStorages.GetValue(param)); +} + //_____________________________________________________________________________ TList* AliCDBManager::GetActiveStorages() { // return list of active storages +// user has responsibility to delete returned object TList* result = new TList(); - TIter iter(fActiveStorages.GetTable()); - TPair* aPair; + TIter iter(fActiveStorages.GetTable()); + TPair* aPair=0; while ((aPair = (TPair*) iter.Next())) { result->Add(aPair->Value()); } @@ -218,7 +305,7 @@ void AliCDBManager::SetDrain(const char* dbString) { //_____________________________________________________________________________ void AliCDBManager::SetDrain(const AliCDBParam* param) { // set drain storage from AliCDBParam - + fDrainStorage = GetStorage(param); } @@ -233,46 +320,831 @@ 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::RemoveDrain() { -// remove drain storage - - fDrainStorage=0; -} - -//_____________________________________________________________________________ +//____________________________________________________________________________ void AliCDBManager::SetDefaultStorage(const char* dbString) { // sets default storage from URI string + + // checking whether we are in the raw case + TString dbStringTemp(dbString); + if (dbStringTemp == "raw://") + { + fRaw = kTRUE; + AliInfo("Setting the run-number will set the corresponding OCDB for raw data reconstruction."); + AliInfo("Connecting to the grid..."); + if(!gGrid) { + TGrid::Connect("alien://",""); + if(!gGrid) { + AliError("Connection to alien failed!"); + return; + } + } + return; + } - if(fDefaultStorage) fDefaultStorage = 0; - fDefaultStorage = GetStorage(dbString); + AliCDBStorage* bckStorage = fDefaultStorage; + + fDefaultStorage = GetStorage(dbString); + + if(!fDefaultStorage) return; + + 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 - if(fDefaultStorage) fDefaultStorage = 0; - fDrainStorage = GetStorage(param); + AliCDBStorage* bckStorage = fDefaultStorage; + + fDefaultStorage = GetStorage(param); + + if(!fDefaultStorage) return; + + 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(fDefaultStorage) fDefaultStorage = 0; + // 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::SetDefaultStorage(const char* mcString, const char* simType) { +// sets default storage for MC data +// mcString MUST be "MC", +// simType can be "Ideal","Residual","Full" + + TString strmcString(mcString); + TString strsimType(simType); + TString dbString; + if (strmcString != "MC"){ + AliFatal("Method requires first string to be MC!"); + } + else { + if (strsimType == "Ideal"){ + dbString = fgkMCIdealStorage; + } + else if (strsimType == "Full"){ + dbString = fgkMCFullStorage; + } + else if (strsimType == "Residual"){ + dbString = fgkMCResidualStorage; + } + else { + AliFatal("Error in setting the storage for MC data, second argument MUST be either \"Ideal\" or \"Full\" or \"Residual\"."); + } + + SetDefaultStorage(dbString.Data()); + if(!fDefaultStorage) AliFatal(Form("%s storage not there! Please check!",fLHCPeriod.Data())); + } +} +//_____________________________________________________________________________ +void AliCDBManager::SetDefaultStorageFromRun(Int_t run) { +// set default storage from the run number - to be used only with raw data + + // if lock is ON, cannot activate more storages! + if(fLock) { + if (fDefaultStorage) { + AliFatal("Lock is ON, and default storage is already set: " + "cannot activate default storage from run number"); + } + } + + // retrieve XML file from alien + if(!gGrid) { + TGrid::Connect("alien://",""); + if(!gGrid) { + AliError("Connection to alien failed!"); + return; + } + } + TUUID uuid; + TString rndname = "/tmp/"; + rndname += "OCDBFolderXML."; + rndname += uuid.AsString(); + rndname += ".xml"; + AliDebug(2, Form("file to be copied = %s", fgkOCDBFolderXMLfile.Data())); + if (!TFile::Cp(fgkOCDBFolderXMLfile.Data(), rndname.Data())) { + AliFatal(Form("Cannot make a local copy of OCDBFolder xml file in %s",rndname.Data())); + } + AliCDBHandler* saxcdb = new AliCDBHandler(); + saxcdb->SetRun(run); + TSAXParser *saxParser = new TSAXParser(); + saxParser->ConnectToHandler("AliCDBHandler", saxcdb); + saxParser->ParseFile(rndname.Data()); + AliInfo(Form(" LHC folder = %s", saxcdb->GetOCDBFolder().Data())); + AliInfo(Form(" LHC period start run = %d", saxcdb->GetStartRunRange())); + AliInfo(Form(" LHC period end run = %d", saxcdb->GetEndRunRange())); + fLHCPeriod = saxcdb->GetOCDBFolder(); + fStartRunLHCPeriod = saxcdb->GetStartRunRange(); + fEndRunLHCPeriod = saxcdb->GetEndRunRange(); + + SetDefaultStorage(fLHCPeriod.Data()); + if(!fDefaultStorage) AliFatal(Form("%s storage not there! Please check!",fLHCPeriod.Data())); + +} + +//_____________________________________________________________________________ +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(); + } + + fRun = fStartRunLHCPeriod = fEndRunLHCPeriod = -1; + fRaw = kFALSE; + + fDefaultStorage = 0x0; +} + +//_____________________________________________________________________________ +void AliCDBManager::SetSpecificStorage(const char* calibType, const char* dbString) { +// sets storage specific for detector or calibration type (works with AliCDBManager::Get(...)) + + AliCDBParam *aPar = CreateParameter(dbString); + if(!aPar) return; + SetSpecificStorage(calibType, aPar); + delete aPar; +} + +//_____________________________________________________________________________ +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("*/Align/*","local://DB_TPCAlign"); +// calibType must be a valid CDB path! (3 level folder structure) + + + if(!fDefaultStorage && !fRaw) { + AliError("Please activate a default storage first!"); + return; + } + + + AliCDBPath aPath(calibType); + if(!aPath.IsValid()){ + AliError(Form("Not a valid path: %s", calibType)); + return; + } + + TObjString *objCalibType = new TObjString(aPath.GetPath()); + if(fSpecificStorages.Contains(objCalibType)){ + AliWarning(Form("Storage \"%s\" already activated! It will be replaced by the new one", + calibType)); + AliCDBParam *checkPar = dynamic_cast (fSpecificStorages.GetValue(calibType)); + if(checkPar) delete checkPar; + delete fSpecificStorages.Remove(objCalibType); + } + AliCDBStorage *aStorage = GetStorage(param); + if(!aStorage) return; + + 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 + + AliCDBPath calibPath(calibType); + if(!calibPath.IsValid()) return NULL; + + AliCDBParam *checkPar = (AliCDBParam*) fSpecificStorages.GetValue(calibPath.GetPath()); + if(!checkPar){ + AliError(Form("%s storage not found!", calibType)); + return NULL; + } else { + return GetStorage(checkPar); + } + +} + +//_____________________________________________________________________________ +AliCDBParam* AliCDBManager::SelectSpecificStorage(const TString& path) { +// select storage valid for path from the list of specific storages + + AliCDBPath aPath(path); + 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); + tmpPath.SetPath(calibTypePath.GetPath()); + } + } + return aPar; +} + +//_____________________________________________________________________________ +AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber, + Int_t version, Int_t subVersion) { +// get an AliCDBEntry object from the database + + 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 Get(AliCDBId(path, runNumber, runNumber, version, subVersion)); +} + +//_____________________________________________________________________________ +AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, + const AliCDBRunRange& runRange, Int_t version, + Int_t subVersion) { +// get an AliCDBEntry object from the database! + + return Get(AliCDBId(path, runRange, version, subVersion)); +} + +//_____________________________________________________________________________ +AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) { +// get an AliCDBEntry object from the database + + // 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(fLock && !(fRun >= query.GetFirstRun() && fRun <= query.GetLastRun())) + AliFatal("Lock is ON: cannot use different run number than the internal one!"); + + if(fCache && !(fRun >= query.GetFirstRun() && fRun <= query.GetLastRun())) + 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 entry; + } + + if(!fDefaultStorage) { + AliError("No storage set!"); + return NULL; + } + // 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"); + } + + entry = aStorage->Get(query); + + if(entry && fCache && (query.GetFirstRun() == fRun)){ + CacheEntry(query.GetPath(), entry); + } + + if(entry && !fIds->Contains(&entry->GetId())){ + fIds->Add(entry->GetId().Clone()); + } + + + return entry; + +} + +//_____________________________________________________________________________ +const char* AliCDBManager::GetURI(const char* path) { +// return the URI of the storage where to look for path + + if(!IsDefaultStorageSet()) return 0; + + AliCDBParam *aPar=SelectSpecificStorage(path); + + if(aPar) { + return aPar->GetURI().Data(); + + } else { + return GetDefaultStorage()->GetURI().Data(); + } + + return 0; +} + +//_____________________________________________________________________________ +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); + } //_____________________________________________________________________________ -void AliCDBManager::RemoveDefaultStorage() { -// remove default storage +TList* AliCDBManager::GetAll(const AliCDBPath& path, Int_t runNumber, + Int_t version, Int_t subVersion) { +// get multiple AliCDBEntry objects from the database + + 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; + } - fDefaultStorage = 0; + return GetAll(AliCDBId(path, runNumber, runNumber, version, + subVersion)); +} + +//_____________________________________________________________________________ +TList* AliCDBManager::GetAll(const AliCDBPath& path, + const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) { +// get multiple AliCDBEntry objects from the database + + return GetAll(AliCDBId(path, runRange, version, subVersion)); +} + +//_____________________________________________________________________________ +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!"); + return NULL; + } + + if (!query.IsValid()) { + AliError(Form("Invalid query: %s", query.ToString().Data())); + return NULL; + } + + 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; + } + + if (query.IsAnyRange()) { + AliError(Form("Unspecified run or runrange: %s", + query.ToString().Data())); + return NULL; + } + + 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); + AliDebug(2,Form("Looking into storage: %s", aPar->GetURI().Data())); + + } else { + aStorage=GetDefaultStorage(); + 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); + } + } + + + return result; +} + +//_____________________________________________________________________________ +Bool_t AliCDBManager::Put(TObject* object, AliCDBId& id, AliCDBMetaData* metaData, const DataType type){ +// store an AliCDBEntry object into the database + + if (object==0x0) { + AliError("Null Entry! No storage will be done!"); + return kFALSE; + } + + AliCDBEntry anEntry(object, id, metaData); + return Put(&anEntry, type); + +} + + +//_____________________________________________________________________________ +Bool_t AliCDBManager::Put(AliCDBEntry* entry, DataType type){ +// store an AliCDBEntry object into the database + + if(type == kPrivate && !fDefaultStorage) { + AliError("No storage set!"); + return kFALSE; + } + + if (!entry){ + AliError("No entry!"); + return kFALSE; + } + + if (entry->GetObject()==0x0){ + AliError("No valid object in CDB entry!"); + return kFALSE; + } + + if (!entry->GetId().IsValid()) { + AliError(Form("Invalid entry ID: %s", + entry->GetId().ToString().Data())); + return kFALSE; + } + + if (!entry->GetId().IsSpecified()) { + AliError(Form("Unspecified entry ID: %s", + entry->GetId().ToString().Data())); + return kFALSE; + } + + AliCDBId id = entry->GetId(); + AliCDBParam *aPar = SelectSpecificStorage(id.GetPath()); + + AliCDBStorage *aStorage=0; + + if(aPar) { + aStorage=GetStorage(aPar); + } else { + switch(type){ + case kCondition: + aStorage = GetStorage(fCondParam); + break; + case kReference: + aStorage = GetStorage(fRefParam); + break; + case kPrivate: + aStorage = GetDefaultStorage(); + break; + } + } + + AliDebug(2,Form("Storing object into storage: %s", aStorage->GetURI().Data())); + + Bool_t result = aStorage->Put(entry, type); + + if(fRun >= 0) QueryCDB(); + + return result; + + +} + +//_____________________________________________________________________________ +void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry) +{ +// cache AliCDBEntry. Cache is valid until run number is changed. + + 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())); + +} + +//_____________________________________________________________________________ +void AliCDBManager::Print(Option_t* /*option*/) const +{ +// Print list of active storages and their URIs + + TString output=Form("Run number = %d; ",fRun); + output += "Cache is "; + if(!fCache) output += "NOT "; + output += Form("ACTIVE; Number of active storages: %d\n",fActiveStorages.GetEntries()); + + if(fDefaultStorage) { + output += Form("\t*** Default Storage URI: \"%s\"\n",fDefaultStorage->GetURI().Data()); +// AliInfo(output.Data()); + } + if(fSpecificStorages.GetEntries()>0) { + TIter iter(fSpecificStorages.GetTable()); + TPair *aPair=0; + Int_t i=1; + while((aPair = (TPair*) iter.Next())){ + output += Form("\t*** Specific storage %d: Path \"%s\" -> URI \"%s\"\n", + i++, ((TObjString*) aPair->Key())->GetName(), + ((AliCDBParam*) aPair->Value())->GetURI().Data()); + } + } + if(fDrainStorage) { + output += Form("*** Drain Storage URI: %s\n",fDrainStorage->GetURI().Data()); + } + AliInfo(output.Data()); +} + +//_____________________________________________________________________________ +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; + if(fRaw){ + // here the LHCPeriod xml file is parsed; the string containing the correct period is returned; the default storage is set + if (fStartRunLHCPeriod <= run && fEndRunLHCPeriod >= run){ + AliInfo("LHCPeriod alien folder for current run already in memory"); + }else{ + SetDefaultStorageFromRun(run); + if(fEntryCache.GetEntries()!=0) ClearCache(); + return; + } + } + ClearCache(); + QueryCDB(); +} + +//_____________________________________________________________________________ +void AliCDBManager::ClearCache(){ +// clear AliCDBEntry 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("After deleting - Cache entries: %d",fEntryCache.GetEntries())); +} + +//_____________________________________________________________________________ +void AliCDBManager::UnloadFromCache(const char* path){ +// unload cached object + + if(!fActiveStorages.GetEntries()) { + AliDebug(2, Form("No active storages. Object \"%s\" is not unloaded from cache", path)); + return; + } + + 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)){ + AliDebug(2, Form("Unloading object \"%s\" from cache", path)); + TObjString pathStr(path); + 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)) { + AliDebug(2, Form("Unloading object \"%s\" from cache", entryPath.GetPath().Data())); + TObjString pathStr(entryPath.GetPath().Data()); + delete fEntryCache.Remove(&pathStr); + } + } + AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries())); } //_____________________________________________________________________________ @@ -280,21 +1152,169 @@ void AliCDBManager::DestroyActiveStorages() { // delete list of active storages fActiveStorages.DeleteAll(); + fSpecificStorages.DeleteAll(); } //_____________________________________________________________________________ void AliCDBManager::DestroyActiveStorage(AliCDBStorage* /*storage*/) { -// destroys active storage (not implemented) +// destroys active storage + +/* + TIter iter(fActiveStorages.GetTable()); + TPair* aPair; + while ((aPair = (TPair*) iter.Next())) { + if(storage == (AliCDBStorage*) aPair->Value()) + delete fActiveStorages.Remove(aPair->Key()); + storage->Delete(); storage=0x0; + } +*/ } +//_____________________________________________________________________________ +void AliCDBManager::QueryCDB() { +// query default and specific storages for files valid for fRun. Every storage loads the Ids into its list. + + if (fRun < 0){ + AliError("Run number not yet set! Use AliCDBManager::SetRun."); + return; + } + 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; + AliCDBParam* aPar=0; + while((aCalibType = dynamic_cast (iter.Next()))){ + aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType); + if(aPar) { + 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); + +} + +//______________________________________________________________________________________________ +ULong_t AliCDBManager::SetLock(Bool_t lock, ULong_t key){ + // To lock/unlock user must provide the key. A new key is provided after + // each successful lock. User should always backup the returned key and + // use it on next access. + if (fLock == lock) return 0; // nothing to be done + if (lock) { + // User wants to lock - check his identity + if (fKey) { + // Lock has a user - check his key + if (fKey != key) { + AliFatal("Wrong key provided to lock CDB. Please remove CDB lock access from your code !"); + return 0; + } + } + // Provide new key + fKey = gSystem->Now(); + fLock = kTRUE; + return fKey; + } + // User wants to unlock - check the provided key + if (key != fKey) { + AliFatal("Lock is ON: wrong key provided"); + return 0; + } + fLock = kFALSE; + return key; +} + /////////////////////////////////////////////////////////// // AliCDBManager Parameter class // // interface to specific AliCDBParameter class // // (AliCDBGridParam, AliCDBLocalParam, AliCDBDumpParam) // /////////////////////////////////////////////////////////// -AliCDBParam::AliCDBParam() { +AliCDBParam::AliCDBParam(): + fType(), + fURI() +{ // constructor }