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) {
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);
}
}
//_____________________________________________________________________________
//_____________________________________________________________________________
AliCDBManager::AliCDBManager():
TObject(),
+ fCondParam(0),
+ fRefParam(0),
fFactories(),
fActiveStorages(),
fSpecificStorages(),
fFactories.Delete();
fDrainStorage = 0x0;
fDefaultStorage = 0x0;
+ delete fCondParam;
+ delete fRefParam;
}
//_____________________________________________________________________________
if (factory->Validate(dbString)) {
return kTRUE;
- }
+ }
}
return kFALSE;
if (aStorage) {
PutActiveStorage(param->CloneParam(), aStorage);
aStorage->SetURI(param->GetURI());
- if(fRun > 0) {
+ if(fRun >= 0) {
aStorage->QueryCDB(fRun);
}
return aStorage;
//_____________________________________________________________________________
void AliCDBManager::SetDrain(const AliCDBParam* param) {
// set drain storage from AliCDBParam
-
+
fDrainStorage = GetStorage(param);
}
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 AliCDBParam* param) {
// set default storage from AliCDBParam object
- fDrainStorage = GetStorage(param);
+ fDefaultStorage = GetStorage(param);
}
//_____________________________________________________________________________
AliError("Please activate a default storage first!");
return;
}
-
+
AliCDBPath aPath(calibType);
if(!aPath.IsValid()){
AliError(Form("Not a valid path: %s", calibType));
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<AliCDBParam*> (fSpecificStorages.GetValue(calibType));
+ if(checkPar) delete checkPar;
+ delete fSpecificStorages.Remove(objCalibType);
}
GetStorage(param);
fSpecificStorages.Add(objCalibType, param->CloneParam());
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);
// 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;
return NULL;
}
- if(fCache && query.GetFirstRun() != fRun)
+ 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;
}
AliDebug(2,Form("Caching entry %s !",query.GetPath().Data()));
CacheEntry(query.GetPath(), entry);
}
-
+
return entry;
}
}
//_____________________________________________________________________________
-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
// 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!");
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);
+ //AliCDBParam *aPar = (AliCDBParam*) fSpecificStorages.GetValue(&objStrLev0);
+ AliCDBParam *aPar=SelectSpecificStorage(query.GetPath());
- AliCDBStorage *aStorage;
+ AliCDBStorage *aStorage;
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");
+ AliDebug(2,"Looking into default storage");
}
TList *result = aStorage->GetAll(query);
+ if(!result) return 0;
- return result;
+ // caching entries
+ if(fCache && (query.GetFirstRun() == fRun)){
+
+ TIter iter(result);
+ AliCDBEntry* entry=0;
+ while((entry = dynamic_cast<AliCDBEntry*> (iter.Next()))){
+ const AliCDBId& anId = entry->GetId();
+ AliDebug(2,Form("Caching entry %s !", anId.GetPath().Data()));
+ CacheEntry(anId.GetPath(), entry);
+ }
+ }
+
+ 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;
}
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;
}
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::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<AliCDBEntry*> (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<TPair*> (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<AliCDBEntry*> (fEntryCache.GetValue(&pathStr));
+ if(entry) delete entry;
+ delete fEntryCache.Remove(&pathStr);
+ }
+ }
+ AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
+}
+
//_____________________________________________________________________________
void AliCDBManager::DestroyActiveStorages() {
// delete list of active storages
delete fActiveStorages.Remove(aPair->Key());
storage->Delete(); storage=0x0;
}
-*/
+*/
}
AliError("Run number not yet set! Use AliCDBManager::SetRun.");
return;
}
-
- AliInfo(Form("Querying default and specific storages for files valid for run %d", 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;
aPar = (AliCDBParam*) fSpecificStorages.GetValue(aCalibType);
if(aPar) {
AliDebug(2,Form("Querying specific storage %s",aCalibType->GetName()));
- GetStorage(aPar)->QueryCDB(fRun,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;
+
+}
///////////////////////////////////////////////////////////
// AliCDBManager Parameter class //
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff