// //
/////////////////////////////////////////////////////////////////////////////////////////////////
-
+#include <cstdlib>
#include <TGrid.h>
#include <TGridResult.h>
#include <TFile.h>
#include <TKey.h>
#include <TROOT.h>
-#include <TSystem.h>
+#include <TList.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TRegexp.h>
#include "AliLog.h"
#include "AliCDBEntry.h"
#include "AliCDBGrid.h"
+#include "AliCDBManager.h"
ClassImp(AliCDBGrid)
//_____________________________________________________________________________
-AliCDBGrid::AliCDBGrid(const char *gridUrl, const char *user, const char *dbFolder, const char *se) :
+AliCDBGrid::AliCDBGrid(const char *gridUrl, const char *user, const char *dbFolder,
+ const char *se, const char* cacheFolder, Bool_t operateDisconnected,
+ Long64_t cacheSize, Long_t cleanupInterval) :
AliCDBStorage(),
fGridUrl(gridUrl),
fUser(user),
fDBFolder(dbFolder),
-fSE(se)
+fSE(se),
+fCacheFolder(cacheFolder),
+fOperateDisconnected(operateDisconnected),
+fCacheSize(cacheSize),
+fCleanupInterval(cleanupInterval)
{
// constructor //
// if the same Grid is alreay active, skip connection
- if (!gGrid || fGridUrl != gGrid->GridUrl()
- || fUser != gGrid->GetUser()) {
+ if (!gGrid || fGridUrl != gGrid->GridUrl()
+ || (( fUser != "" ) && ( fUser != gGrid->GetUser() )) ) {
// connection to the Grid
+ AliInfo("Connection to the Grid...");
+ if(gGrid){
+ AliInfo(Form("gGrid = %x; fGridUrl = %s; gGrid->GridUrl() = %s",gGrid,fGridUrl.Data(), gGrid->GridUrl()));
+ AliInfo(Form("fUser = %s; gGrid->GetUser() = %s",fUser.Data(), gGrid->GetUser()));
+ }
+ AliDebug(2,Form("1. Grid Url = %s",fGridUrl.Data()));
+ if (fGridUrl == "raw://") fGridUrl = "alien://";
+ AliDebug(2,Form("2. Grid Url = %s (should be different from previous in cas eof raw)", fGridUrl.Data()));
TGrid::Connect(fGridUrl.Data(),fUser.Data());
}
// check DBFolder: trying to cd to DBFolder; if it does not exist, create it
if(!gGrid->Cd(fDBFolder.Data(),0)){
AliDebug(2,Form("Creating new folder <%s> ...",fDBFolder.Data()));
- if(!gGrid->Mkdir(fDBFolder.Data(),"",0)){
- AliError(Form("Cannot create folder <%s> !",fDBFolder.Data()));
+ TGridResult* res = gGrid->Command(Form("mkdir -p %s",fDBFolder.Data()));
+ TString result = res->GetKey(0,"__result__");
+ if(result == "0"){
+ AliFatal(Form("Cannot create folder <%s> !",fDBFolder.Data()));
+ return;
}
} else {
AliDebug(2,Form("Folder <%s> found",fDBFolder.Data()));
while(fDBFolder.EndsWith("/")) fDBFolder.Remove(fDBFolder.Last('/'));
fDBFolder+="/";
+ fType="alien";
+ fBaseFolder = fDBFolder;
+
+ // Setting the cache
+
+ // Check if local cache folder is already defined
+ TString origCache(TFile::GetCacheFileDir());
+ if(fCacheFolder.Length() > 0) {
+ if(origCache.Length() == 0) {
+ AliInfo(Form("Setting local cache to: %s", fCacheFolder.Data()));
+ } else if(fCacheFolder != origCache) {
+ AliWarning(Form("Local cache folder was already defined, changing it to: %s",
+ fCacheFolder.Data()));
+ }
+
+ // default settings are: operateDisconnected=kTRUE, forceCacheread = kFALSE
+ if(!TFile::SetCacheFileDir(fCacheFolder.Data(), fOperateDisconnected)) {
+ AliError(Form("Could not set cache folder %s !", fCacheFolder.Data()));
+ fCacheFolder = "";
+ } else {
+ // reset fCacheFolder because the function may have
+ // slightly changed the folder name (e.g. '/' added)
+ fCacheFolder = TFile::GetCacheFileDir();
+ }
+
+ // default settings are: cacheSize=1GB, cleanupInterval = 0
+ if(!TFile::ShrinkCacheFileDir(fCacheSize, fCleanupInterval)) {
+ AliError(Form("Could not set following values "
+ "to ShrinkCacheFileDir: cacheSize = %d, cleanupInterval = %d !",
+ fCacheSize, fCleanupInterval));
+ }
+ }
+
// return to the initial directory
gGrid->Cd(initDir.Data(),0);
}
AliCDBGrid::~AliCDBGrid()
{
// destructor
+ delete gGrid; gGrid=0;
}
//_____________________________________________________________________________
-Bool_t AliCDBGrid::FilenameToId(const char* filename, AliCDBRunRange& runRange,
- Int_t& gridVersion) {
-// build AliCDBId from filename numbers
+Bool_t AliCDBGrid::FilenameToId(TString& filename, AliCDBId& id) {
+// build AliCDBId from full path filename (fDBFolder/path/Run#x_#y_v#z_s0.root)
+
+ if(filename.Contains(fDBFolder)){
+ filename = filename(fDBFolder.Length(),filename.Length()-fDBFolder.Length());
+ }
+
+ TString idPath = filename(0,filename.Last('/'));
+ id.SetPath(idPath);
+ if(!id.IsValid()) return kFALSE;
+
+ filename=filename(idPath.Length()+1,filename.Length()-idPath.Length());
Ssiz_t mSize;
-
- // valid filename: Run#firstRun_#lastRun_v#version.root
- TRegexp keyPattern("^Run[0-9]+_[0-9]+_v[0-9]+.root$");
+ // valid filename: Run#firstRun_#lastRun_v#version_s0.root
+ TRegexp keyPattern("^Run[0-9]+_[0-9]+_v[0-9]+_s0.root$");
keyPattern.Index(filename, &mSize);
if (!mSize) {
- AliDebug(2,Form("Bad filename <%s>.", filename));
- return kFALSE;
- }
- TString idString(filename);
- idString.Resize(idString.Length() - sizeof(".root") + 1);
+ // TODO backward compatibility ... maybe remove later!
+ Ssiz_t oldmSize;
+ TRegexp oldKeyPattern("^Run[0-9]+_[0-9]+_v[0-9]+.root$");
+ oldKeyPattern.Index(filename, &oldmSize);
+ if(!oldmSize) {
+ AliDebug(2,Form("Bad filename <%s>.", filename.Data()));
+ return kFALSE;
+ } else {
+ AliDebug(2,Form("Old filename format <%s>.", filename.Data()));
+ id.SetSubVersion(-11); // TODO trick to ensure backward compatibility
+ }
+
+ } else {
+ id.SetSubVersion(-1); // TODO trick to ensure backward compatibility
+ }
+
+ filename.Resize(filename.Length() - sizeof(".root") + 1);
- TObjArray* strArray = (TObjArray*) idString.Tokenize("_");
+ TObjArray* strArray = (TObjArray*) filename.Tokenize("_");
TString firstRunString(((TObjString*) strArray->At(0))->GetString());
- runRange.SetFirstRun(atoi(firstRunString.Data() + 3));
- runRange.SetLastRun(atoi(((TObjString*) strArray->At(1))->GetString()));
-
+ id.SetFirstRun(atoi(firstRunString.Data() + 3));
+ id.SetLastRun(atoi(((TObjString*) strArray->At(1))->GetString()));
+
TString verString(((TObjString*) strArray->At(2))->GetString());
- gridVersion = atoi(verString.Data() + 1);
+ id.SetVersion(atoi(verString.Data() + 1));
delete strArray;
}
//_____________________________________________________________________________
-Bool_t AliCDBGrid::IdToFilename(const AliCDBRunRange& runRange, Int_t gridVersion,
- TString& filename) {
-// build file name from AliCDBId data (run range, version)
+Bool_t AliCDBGrid::IdToFilename(const AliCDBId& id, TString& filename) const {
+// build file name from AliCDBId (path, run range, version) and fDBFolder
- if (!runRange.IsValid()) {
- AliDebug(2,Form("Invalid run range <%d, %d>.",
- runRange.GetFirstRun(), runRange.GetLastRun()));
+ if (!id.GetAliCDBRunRange().IsValid()) {
+ AliDebug(2,Form("Invalid run range <%d, %d>.",
+ id.GetFirstRun(), id.GetLastRun()));
return kFALSE;
}
- if (gridVersion < 0) {
- AliDebug(2,Form("Invalid version <%d>.", gridVersion));
+ if (id.GetVersion() < 0) {
+ AliDebug(2,Form("Invalid version <%d>.", id.GetVersion()));
return kFALSE;
}
-
- filename += "Run";
- filename += runRange.GetFirstRun();
- filename += "_";
- filename += runRange.GetLastRun();
- filename += "_v";
- filename += gridVersion;
+
+ filename = Form("Run%d_%d_v%d",
+ id.GetFirstRun(),
+ id.GetLastRun(),
+ id.GetVersion());
+
+ if (id.GetSubVersion() != -11) filename += "_s0"; // TODO to ensure backward compatibility
filename += ".root";
+ filename.Prepend(fDBFolder + id.GetPath() + '/');
+
return kTRUE;
}
// prepare id (version) of the object that will be stored (called by PutEntry)
TString initDir(gGrid->Pwd(0));
- TString pathName= id.GetPath();
TString dirName(fDBFolder);
Bool_t dirExist=kFALSE;
-
+
+
+
// go to the path; if directory does not exist, create it
- TObjArray *arrName=pathName.Tokenize("/");
- for(int i=0;i<arrName->GetEntries();i++){
- TString buffer((arrName->At(i))->GetName());
- dirName+=buffer; dirName+="/";
+ for(int i=0;i<3;i++){
+ dirName+=Form("%s/",id.GetPathLevel(i).Data());
dirExist=gGrid->Cd(dirName,0);
if (!dirExist) {
AliDebug(2,Form("Creating new folder <%s> ...",dirName.Data()));
gGrid->Cd(initDir.Data());
return kFALSE;
}
+
+ // if folders are new add tags to them
+ if(i == 1) {
+ // TODO Currently disabled
+ // add short lived tag!
+ // AliInfo("Tagging level 1 folder with \"ShortLived\" tag");
+ // if(!AddTag(dirName,"ShortLived_try")){
+ // AliError(Form("Could not tag folder %s !", dirName.Data()));
+ // if(!gGrid->Rmdir(dirName.Data())){
+ // AliError(Form("Unexpected: could not remove %s directory!", dirName.Data()));
+ // }
+ // return 0;
+ //}
+
+ } else if(i == 2) {
+ AliDebug(2,"Tagging level 2 folder with \"CDB\" and \"CDB_MD\" tag");
+ if(!AddTag(dirName,"CDB")){
+ AliError(Form("Could not tag folder %s !", dirName.Data()));
+ if(!gGrid->Rmdir(dirName.Data())){
+ AliError(Form("Unexpected: could not remove %s directory!", dirName.Data()));
+ }
+ return 0;
+ }
+ if(!AddTag(dirName,"CDB_MD")){
+ AliError(Form("Could not tag folder %s !", dirName.Data()));
+ if(!gGrid->Rmdir(dirName.Data())){
+ AliError(Form("Unexpected: could not remove %s directory!", dirName.Data()));
+ }
+ return 0;
+ }
+
+ // TODO Currently disabled
+ // add short lived tag!
+ // TString path=id.GetPath();
+ // if(AliCDBManager::Instance()->IsShortLived(path.Data())) {
+ // AliInfo(Form("Tagging %s as short lived", dirName.Data()));
+ // if(!TagShortLived(dirName, kTRUE)){
+ // AliError(Form("Could not tag folder %s !", dirName.Data()));
+ // if(!gGrid->Rmdir(dirName.Data())){
+ // AliError(Form("Unexpected: could not remove %s directory!", dirName.Data()));
+ // }
+ // return 0;
+ // }
+ // } else {
+ // AliInfo(Form("Tagging %s as long lived", dirName.Data()));
+ // if(!TagShortLived(dirName, kFALSE)){
+ // AliError(Form("Could not tag folder %s !", dirName.Data()));
+ // if(!gGrid->Rmdir(dirName.Data())){
+ // AliError(Form("Unexpected: could not remove %s directory!", dirName.Data()));
+ // }
+ // return 0;
+ // }
+ // }
+ }
}
}
- delete arrName;
gGrid->Cd(initDir,0);
- const char* filename;
- AliCDBRunRange aRunRange; // the runRange got from filename
+ TString filename;
+ AliCDBId anId; // the id got from filename
AliCDBRunRange lastRunRange(-1,-1); // highest runRange found
- Int_t aVersion; // the version got from filename
Int_t lastVersion=0; // highest version found
TGridResult *res = gGrid->Ls(dirName);
//loop on the files in the directory, look for highest version
for(int i=0; i < res->GetEntries(); i++){
- filename=res->GetFileName(i);
- if (!FilenameToId(filename, aRunRange, aVersion)) continue;
- if (aRunRange.Overlaps(id.GetAliCDBRunRange()) && aVersion > lastVersion) {
- lastVersion = aVersion;
- lastRunRange = aRunRange;
+ filename=res->GetFileNamePath(i);
+ if (!FilenameToId(filename, anId)) continue;
+ if (anId.GetAliCDBRunRange().Overlaps(id.GetAliCDBRunRange()) && anId.GetVersion() > lastVersion) {
+ lastVersion = anId.GetVersion();
+ lastRunRange = anId.GetAliCDBRunRange();
}
}
- delete res;
-
+ delete res;
+
+ // GRP entries with explicitly set version escape default incremental versioning
+ if(id.GetPath().Contains("GRP") && id.HasVersion() && lastVersion!=0)
+ {
+ AliDebug(5,Form("Entry %s won't be put in the destination OCDB", id.ToString().Data()));
+ return kFALSE;
+ }
+
id.SetVersion(lastVersion + 1);
+ id.SetSubVersion(0);
TString lastStorage = id.GetLastStorage();
if(lastStorage.Contains(TString("new"), TString::kIgnoreCase) && id.GetVersion() > 1 ){
- AliWarning(Form("A NEW object is being stored with version %d",
+ AliDebug(2, Form("A NEW object is being stored with version %d",
id.GetVersion()));
- AliWarning(Form("and it will hide previously stored object with version %d!",
+ AliDebug(2, Form("and it will hide previously stored object with version %d!",
id.GetVersion()-1));
}
- if(!lastRunRange.IsAnyRange() && !(lastRunRange.IsEqual(&id.GetAliCDBRunRange())))
+ if(!lastRunRange.IsAnyRange() && !(lastRunRange.IsEqual(&id.GetAliCDBRunRange())))
AliWarning(Form("Run range modified w.r.t. previous version (Run%d_%d_v%d)",
lastRunRange.GetFirstRun(), lastRunRange.GetLastRun(), id.GetVersion()));
-
+
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliCDBGrid::GetId(const AliCDBId& query, AliCDBId& result) {
-// look for filename matching query (called by GetEntry)
+AliCDBId* AliCDBGrid::GetId(const TObjArray& validFileIds, const AliCDBId& query) {
+// look for the Id that matches query's requests (highest or exact version)
- TString initDir(gGrid->Pwd(0));
+ if(validFileIds.GetEntriesFast() < 1) {
+ return NULL;
+ } else if (validFileIds.GetEntriesFast() == 1) {
+ return dynamic_cast<AliCDBId*> (validFileIds.At(0)->Clone());
+ }
- TString dirName(fDBFolder);
- dirName += query.GetPath(); // dirName = fDBFolder/idPath
+ TIter iter(&validFileIds);
- if (!gGrid->Cd(dirName,0)) {
- AliError(Form("Directory <%s> not found", (query.GetPath()).Data()));
- AliError(Form("in DB folder %s", fDBFolder.Data()));
- return kFALSE;
- }
-
- TGridResult *res = gGrid->Ls(dirName);
+ AliCDBId *anIdPtr=0;
+ AliCDBId* result=0;
- const char* filename;
- AliCDBRunRange aRunRange; // the runRange got from filename
- Int_t aVersion; // the version got from filename
-
- for(int i=0; i < res->GetEntries(); i++){
- filename=res->GetFileName(i);
- if (!FilenameToId(filename, aRunRange, aVersion)) continue;
- // aRunRange and aVersion filled from filename
-
- if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue;
- // aRunRange contains requested run!
+ while((anIdPtr = dynamic_cast<AliCDBId*> (iter.Next()))){
+ if(anIdPtr->GetPath() != query.GetPath()) continue;
+
+ //if(!CheckVersion(query, anIdPtr, result)) return NULL;
if (!query.HasVersion()){ // look for highest version
- if(result.GetVersion() > aVersion) continue;
- if(result.GetVersion() == aVersion) {
- AliError(Form("More than one object valid for run %d, version %d!",
- query.GetFirstRun(), aVersion));
- return kFALSE;
+ if(result && result->GetVersion() > anIdPtr->GetVersion()) continue;
+ if(result && result->GetVersion() == anIdPtr->GetVersion()) {
+ AliError(Form("More than one object valid for run %d, version %d!",
+ query.GetFirstRun(), anIdPtr->GetVersion()));
+ return NULL;
}
- result.SetVersion(aVersion);
- result.SetFirstRun(aRunRange.GetFirstRun());
- result.SetLastRun(aRunRange.GetLastRun());
-
+ result = anIdPtr;
} else { // look for specified version
- if(query.GetVersion() != aVersion) continue;
- if(result.GetVersion() == aVersion){
- AliError(Form("More than one object valid for run %d, version %d!",
- query.GetFirstRun(), aVersion));
- return kFALSE;
+ if(query.GetVersion() != anIdPtr->GetVersion()) continue;
+ if(result && result->GetVersion() == anIdPtr->GetVersion()){
+ AliError(Form("More than one object valid for run %d, version %d!",
+ query.GetFirstRun(), anIdPtr->GetVersion()));
+ return NULL;
}
- result.SetVersion(aVersion);
- result.SetFirstRun(aRunRange.GetFirstRun());
- result.SetLastRun(aRunRange.GetLastRun());
+ result = anIdPtr;
}
- } // end loop on filenames
- delete res;
+
+ }
- gGrid->Cd(initDir.Data(),0);
-
- return kTRUE;
+ if (!result) return NULL;
+
+ return dynamic_cast<AliCDBId*> (result->Clone());
}
//_____________________________________________________________________________
-AliCDBEntry* AliCDBGrid::GetEntry(const AliCDBId& queryId) {
-// get AliCDBEntry from the database
+AliCDBId* AliCDBGrid::GetEntryId(const AliCDBId& queryId) {
+// get AliCDBId from the database
+// User must delete returned object
- AliCDBId dataId(queryId.GetAliCDBPath(), -1, -1, -1, -1);
- Bool_t result;
-
- // look for a filename matching query requests (path, runRange, version, subVersion)
- if (!queryId.HasVersion()) {
+ AliCDBId* dataId=0;
+
+ AliCDBId selectedId(queryId);
+ if (!selectedId.HasVersion()) {
// if version is not specified, first check the selection criteria list
- AliCDBId selectedId(queryId);
GetSelection(&selectedId);
- result = GetId(selectedId,dataId);
+ }
+
+ TObjArray validFileIds;
+ validFileIds.SetOwner(1);
+
+ // look for file matching query requests (path, runRange, version)
+ if(selectedId.GetFirstRun() == fRun &&
+ fPathFilter.Comprises(selectedId.GetAliCDBPath()) && fVersion < 0 && !fMetaDataFilter){
+ // look into list of valid files previously loaded with AliCDBStorage::FillValidFileIds()
+ AliDebug(2, Form("List of files valid for run %d and for path %s was loaded. Looking there!",
+ selectedId.GetFirstRun(), selectedId.GetPath().Data()));
+ dataId = GetId(fValidFileIds, selectedId);
+
} else {
- result = GetId(queryId,dataId);
+ // List of files valid for reqested run was not loaded. Looking directly into CDB
+ AliDebug(2, Form("List of files valid for run %d and for path %s was not loaded. Looking directly into CDB!",
+ selectedId.GetFirstRun(), selectedId.GetPath().Data()));
+
+ TString filter;
+ MakeQueryFilter(selectedId.GetFirstRun(), selectedId.GetLastRun(), 0, filter);
+
+ TString pattern = Form("%s/Run*", selectedId.GetPath().Data());
+ if(selectedId.GetVersion() >= 0) pattern += Form("_v%d*",selectedId.GetVersion());
+ pattern += ".root";
+ AliDebug(2,Form("pattern: %s", pattern.Data()));
+
+ TGridResult *res = gGrid->Query(fDBFolder, pattern, filter, "");
+ if (res) {
+ AliCDBId validFileId;
+ for(int i=0; i<res->GetEntries(); i++){
+ TString filename = res->GetKey(i, "lfn");
+ if(filename == "") continue;
+ if(FilenameToId(filename, validFileId))
+ validFileIds.AddLast(validFileId.Clone());
+ }
+ delete res;
+ }
+ dataId = GetId(validFileIds, selectedId);
}
- if (!result || !dataId.IsSpecified()) return NULL;
+ return dataId;
+}
+
+//_____________________________________________________________________________
+AliCDBEntry* AliCDBGrid::GetEntry(const AliCDBId& queryId) {
+// get AliCDBEntry from the database
+
+ AliCDBId* dataId = GetEntryId(queryId);
+
+ if (!dataId) return NULL;
TString filename;
- if (!IdToFilename(dataId.GetAliCDBRunRange(), dataId.GetVersion(),filename)) {
- AliError("Bad data ID encountered! Subnormal error!");
+ if (!IdToFilename(*dataId, filename)) {
+ AliDebug(2,Form("Bad data ID encountered! Subnormal error!"));
+ delete dataId;
return NULL;
}
- filename.Prepend("/alien" + fDBFolder + queryId.GetPath() + '/');
- filename += "?se="; filename += fSE.Data();
+ AliCDBEntry* anEntry = GetEntryFromFile(filename, dataId);
+
+ delete dataId;
+ return anEntry;
+}
+
+//_____________________________________________________________________________
+AliCDBEntry* AliCDBGrid::GetEntryFromFile(TString& filename, AliCDBId* dataId){
+// Get AliCBEntry object from file "filename"
+
+ AliDebug(2,Form("Opening file: %s",filename.Data()));
+
+ filename.Prepend("/alien");
+
+ // if option="CACHEREAD" TFile will use the local caching facility!
+ TString option="READ";
+ if(fCacheFolder != ""){
- AliInfo(Form("Opening file: %s",filename.Data()));
- TFile *file = TFile::Open(filename);
+ // Check if local cache folder was changed in the meanwhile
+ TString origCache(TFile::GetCacheFileDir());
+ if(fCacheFolder != origCache) {
+ AliWarning(Form("Local cache folder has been overwritten!! fCacheFolder = %s origCache = %s",
+ fCacheFolder.Data(), origCache.Data()));
+ TFile::SetCacheFileDir(fCacheFolder.Data(), fOperateDisconnected);
+ TFile::ShrinkCacheFileDir(fCacheSize, fCleanupInterval);
+ }
+
+ option.Prepend("CACHE");
+ }
+
+ AliDebug(2, Form("Option: %s", option.Data()));
+
+ TFile *file = TFile::Open(filename, option);
if (!file) {
- AliError(Form("Can't open file <%s>!", filename.Data()));
+ AliDebug(2,Form("Can't open file <%s>!", filename.Data()));
return NULL;
}
// get the only AliCDBEntry object from the file
// the object in the file is an AliCDBEntry entry named "AliCDBEntry"
- TObject* anObject = file->Get("AliCDBEntry");
-
- if (!anObject) {
- AliError("Bad storage data: NULL entry object!");
- return NULL;
- }
+ AliCDBEntry* anEntry = dynamic_cast<AliCDBEntry*> (file->Get("AliCDBEntry"));
- if (AliCDBEntry::Class() != anObject->IsA()) {
- AliError("Bad storage data: Invalid entry object!");
+ if (!anEntry) {
+ AliDebug(2,Form("Bad storage data: file does not contain an AliCDBEntry object!"));
+ file->Close();
return NULL;
}
- AliCDBId entryId = ((AliCDBEntry* ) anObject)->GetId();
-
// The object's Id is not reset during storage
// If object's Id runRange or version do not match with filename,
// it means that someone renamed file by hand. In this case a warning msg is issued.
-
- ((AliCDBEntry*) anObject)->SetLastStorage("grid");
-
- if(!((entryId.GetAliCDBRunRange()).IsEqual(&dataId.GetAliCDBRunRange())) ||
- entryId.GetVersion() != dataId.GetVersion()){
- AliWarning(Form("Either RunRange or gridVersion in the object's metadata do noth match with fileName numbers:"));
- AliWarning(Form("someone renamed file by hand!"));
+
+ if(anEntry){
+ AliCDBId entryId = anEntry->GetId();
+ Int_t tmpSubVersion = dataId->GetSubVersion();
+ dataId->SetSubVersion(entryId.GetSubVersion()); // otherwise filename and id may mismatch
+ if(!entryId.IsEqual(dataId)){
+ AliWarning(Form("Mismatch between file name and object's Id!"));
+ AliWarning(Form("File name: %s", dataId->ToString().Data()));
+ AliWarning(Form("Object's Id: %s", entryId.ToString().Data()));
+ }
+ dataId->SetSubVersion(tmpSubVersion);
}
+ anEntry->SetLastStorage("grid");
+
+ // Check whether entry contains a TTree. In case load the tree in memory!
+ LoadTreeFromFile(anEntry);
+
// close file, return retieved entry
file->Close(); delete file; file=0;
- return (AliCDBEntry*) anObject;
+
+ return anEntry;
}
//_____________________________________________________________________________
-void AliCDBGrid::GetEntriesForLevel0(const char* level0,
- const AliCDBId& queryId, TList* result) {
+TList* AliCDBGrid::GetEntries(const AliCDBId& queryId) {
// multiple request (AliCDBStorage::GetAll)
- TString level0Dir=fDBFolder;
- level0Dir += level0;
+ TList* result = new TList();
+ result->SetOwner();
+
+ TObjArray validFileIds;
+ validFileIds.SetOwner(1);
- if (!gGrid->Cd(level0Dir,0)) {
- AliError(Form("Level0 directory <%s> not found", level0Dir.Data()));
- return;
- }
+ Bool_t alreadyLoaded = kFALSE;
- TGridResult *res = gGrid->Ls(level0Dir);
- TString level1;
- for(int i=0; i < res->GetEntries(); i++){
- level1=res->GetFileName(i);
- if (queryId.GetAliCDBPath().Level1Comprises(level1))
- GetEntriesForLevel1(level0, level1, queryId, result);
- }
- delete res;
-}
+ // look for file matching query requests (path, runRange)
+ if(queryId.GetFirstRun() == fRun &&
+ fPathFilter.Comprises(queryId.GetAliCDBPath()) && fVersion < 0 && !fMetaDataFilter){
+ // look into list of valid files previously loaded with AliCDBStorage::FillValidFileIds()
+ AliDebug(2,Form("List of files valid for run %d and for path %s was loaded. Looking there!",
+ queryId.GetFirstRun(), queryId.GetPath().Data()));
-//_____________________________________________________________________________
-void AliCDBGrid::GetEntriesForLevel1(const char* level0, const char* level1,
- const AliCDBId& queryId, TList* result) {
-// multiple request (AliCDBStorage::GetAll)
+ alreadyLoaded = kTRUE;
- TString level1Dir=fDBFolder;
- level1Dir += level0;
- level1Dir += '/';
- level1Dir += level1;
+ } else {
+ // List of files valid for reqested run was not loaded. Looking directly into CDB
+ AliDebug(2,Form("List of files valid for run %d and for path %s was not loaded. Looking directly into CDB!",
+ queryId.GetFirstRun(), queryId.GetPath().Data()));
- if (!gGrid->Cd(level1Dir,0)) {
- AliError(Form("Level1 directory <%s> not found", level1Dir.Data()));
- return;
- }
+ TString filter;
+ MakeQueryFilter(queryId.GetFirstRun(), queryId.GetLastRun(), 0, filter);
- TGridResult *res = gGrid->Ls(level1Dir);
- TString level2;
- for(int i=0; i < res->GetEntries(); i++){
- level2=res->GetFileName(i);
- if (queryId.GetAliCDBPath().Level2Comprises(level2)){
- AliCDBPath entryPath(level0, level1, level2);
- AliCDBId entryId(entryPath,
- queryId.GetAliCDBRunRange(),
- queryId.GetVersion(),
- queryId.GetSubVersion());
+ TString pattern = Form("%s/Run*.root", queryId.GetPath().Data());
+ AliDebug(2,Form("pattern: %s", pattern.Data()));
- AliCDBEntry* anEntry = GetEntry(entryId);
- if (anEntry) result->Add(anEntry);
+ TGridResult *res = gGrid->Query(fDBFolder, pattern, filter, "");
+ AliCDBId validFileId;
+ for(int i=0; i<res->GetEntries(); i++){
+ TString filename = res->GetKey(i, "lfn");
+ if(filename == "") continue;
+ if(FilenameToId(filename, validFileId))
+ validFileIds.AddLast(validFileId.Clone());
}
+ delete res;
}
- delete res;
-}
-//_____________________________________________________________________________
-TList* AliCDBGrid::GetEntries(const AliCDBId& queryId) {
-// multiple request (AliCDBStorage::GetAll)
+ TIter *iter=0;
+ if(alreadyLoaded){
+ iter = new TIter(&fValidFileIds);
+ } else {
+ iter = new TIter(&validFileIds);
+ }
- TList* result = new TList();
- result->SetOwner();
+ TObjArray selectedIds;
+ selectedIds.SetOwner(1);
+
+ // loop on list of valid Ids to select the right version to get.
+ // According to query and to the selection criteria list, version can be the highest or exact
+ AliCDBPath pathCopy;
+ AliCDBId* anIdPtr=0;
+ AliCDBId* dataId=0;
+ AliCDBPath queryPath = queryId.GetAliCDBPath();
+ while((anIdPtr = dynamic_cast<AliCDBId*> (iter->Next()))){
+ AliCDBPath thisCDBPath = anIdPtr->GetAliCDBPath();
+ if(!(queryPath.Comprises(thisCDBPath)) || pathCopy.GetPath() == thisCDBPath.GetPath()) continue;
+ pathCopy = thisCDBPath;
+
+ // check the selection criteria list for this query
+ AliCDBId thisId(*anIdPtr);
+ thisId.SetVersion(queryId.GetVersion());
+ if(!thisId.HasVersion()) GetSelection(&thisId);
+
+ if(alreadyLoaded){
+ dataId = GetId(fValidFileIds, thisId);
+ } else {
+ dataId = GetId(validFileIds, thisId);
+ }
+ if(dataId) selectedIds.Add(dataId);
+ }
- TString initDir(gGrid->Pwd(0));
+ delete iter; iter=0;
- TGridResult *res = gGrid->Ls(fDBFolder);
- TString level0;
+ // selectedIds contains the Ids of the files matching all requests of query!
+ // All the objects are now ready to be retrieved
+ iter = new TIter(&selectedIds);
+ while((anIdPtr = dynamic_cast<AliCDBId*> (iter->Next()))){
+ TString filename;
+ if (!IdToFilename(*anIdPtr, filename)) {
+ AliDebug(2,Form("Bad data ID encountered! Subnormal error!"));
+ continue;
+ }
- for(int i=0; i < res->GetEntries(); i++){
- level0=res->GetFileName(i);
- if (queryId.GetAliCDBPath().Level0Comprises(level0))
- GetEntriesForLevel0(level0, queryId, result);
- }
- delete res;
-
- gGrid->Cd(initDir.Data(),0);
- return result;
+ AliCDBEntry* anEntry = GetEntryFromFile(filename, anIdPtr);
+
+ if(anEntry) result->Add(anEntry);
+
+ }
+ delete iter; iter=0;
+
+ return result;
}
//_____________________________________________________________________________
Bool_t AliCDBGrid::PutEntry(AliCDBEntry* entry) {
// put an AliCDBEntry object into the database
-
+
AliCDBId& id = entry->GetId();
// set version for the entry to be stored
- if (!PrepareId(id)) return kFALSE;
+ if (!PrepareId(id)) return kFALSE;
// build filename from entry's id
TString filename;
- if (!IdToFilename(id.GetAliCDBRunRange(), id.GetVersion(), filename)) {
+ if (!IdToFilename(id, filename)) {
AliError("Bad ID encountered! Subnormal error!");
return kFALSE;
- }
+ }
+
+ TString folderToTag = Form("%s%s",
+ fDBFolder.Data(),
+ id.GetPath().Data());
- filename.Prepend("/alien" + fDBFolder + id.GetPath() + '/');
- TString filenameCopy(filename);
- filename += "?se="; filename += fSE.Data();
-
TDirectory* saveDir = gDirectory;
+ TString fullFilename = Form("/alien%s", filename.Data());
+ // specify SE to filename
+ if (fSE != "default") fullFilename += Form("?se=%s",fSE.Data());
+
// open file
- TFile *file = TFile::Open(filename,"CREATE");
- if(!file || !file->IsWritable()){
- AliError(Form("Can't open file <%s>!", filename.Data()));
- if(file && !file->IsWritable()) file->Close(); delete file; file=0;
- return kFALSE;
- }
-
- file->cd();
+ TFile *file = TFile::Open(fullFilename,"CREATE");
+ if(!file || !file->IsWritable()){
+ AliError(Form("Can't open file <%s>!", filename.Data()));
+ if(file && !file->IsWritable()) file->Close(); delete file; file=0;
+ return kFALSE;
+ }
+
+ file->cd();
+
+ //SetTreeToFile(entry, file);
entry->SetVersion(id.GetVersion());
// write object (key name: "AliCDBEntry")
- Bool_t result = (entry->Write("AliCDBEntry") != 0);
- if (!result) AliError(Form("Can't write entry to file <%s>!",filename.Data()));
+ Bool_t result = (file->WriteTObject(entry, "AliCDBEntry") != 0);
+ if (!result) AliError(Form("Can't write entry to file <%s>!", filename.Data()));
if (saveDir) saveDir->cd(); else gROOT->cd();
file->Close(); delete file; file=0;
+
if(result) {
- AliInfo(Form("CDB object stored into file %s",filenameCopy.Data()));
- AliInfo(Form("using S.E. %s", fSE.Data()));
+
+ if(!TagFileId(filename, &id)){
+ AliInfo(Form("CDB tagging failed. Deleting file %s!",filename.Data()));
+ if(!gGrid->Rm(filename.Data()))
+ AliError("Can't delete file!");
+ return kFALSE;
+ }
+
+ TagFileMetaData(filename, entry->GetMetaData());
+ }
+
+ AliInfo(Form("CDB object stored into file %s", filename.Data()));
+ AliInfo(Form("Storage Element: %s", fSE.Data()));
+ return result;
+}
+//_____________________________________________________________________________
+Bool_t AliCDBGrid::AddTag(TString& folderToTag, const char* tagname){
+// add "tagname" tag (CDB or CDB_MD) to folder where object will be stored
+
+ Bool_t result = kTRUE;
+ AliDebug(2, Form("adding %s tag to folder %s", tagname, folderToTag.Data()));
+ TString addTag = Form("addTag %s %s", folderToTag.Data(), tagname);
+ TGridResult *gridres = gGrid->Command(addTag.Data());
+ const char* resCode = gridres->GetKey(0,"__result__"); // '1' if success
+ if(resCode[0] != '1') {
+ AliError(Form("Couldn't add %s tags to folder %s !",
+ tagname, folderToTag.Data()));
+ result = kFALSE;
+ }
+ delete gridres;
+ return result;
+}
+
+//_____________________________________________________________________________
+Bool_t AliCDBGrid::TagFileId(TString& filename, const AliCDBId* id){
+// tag stored object in CDB table using object Id's parameters
+
+ TString addTagValue1 = Form("addTagValue %s CDB ", filename.Data());
+ TString addTagValue2 = Form("first_run=%d last_run=%d version=%d ",
+ id->GetFirstRun(),
+ id->GetLastRun(),
+ id->GetVersion());
+ TString addTagValue3 = Form("path_level_0=\"%s\" path_level_1=\"%s\" path_level_2=\"%s\"",
+ id->GetPathLevel(0).Data(),
+ id->GetPathLevel(1).Data(),
+ id->GetPathLevel(2).Data());
+ TString addTagValue = Form("%s%s%s",
+ addTagValue1.Data(),
+ addTagValue2.Data(),
+ addTagValue3.Data());
+
+ Bool_t result = kFALSE;
+ AliDebug(2, Form("Tagging file. Tag command: %s", addTagValue.Data()));
+ TGridResult* res = gGrid->Command(addTagValue.Data());
+ const char* resCode = res->GetKey(0,"__result__"); // '1' if success
+ if(resCode[0] != '1') {
+ AliError(Form("Couldn't add CDB tag value to file %s !",
+ filename.Data()));
+ result = kFALSE;
+ } else {
+ AliDebug(2, "Object successfully tagged.");
+ result = kTRUE;
+ }
+ delete res;
+ return result;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliCDBGrid::TagShortLived(TString& filename, Bool_t value){
+// tag folder with ShortLived tag
+
+ TString addTagValue = Form("addTagValue %s ShortLived_try value=%d", filename.Data(), value);
+
+ Bool_t result = kFALSE;
+ AliDebug(2, Form("Tagging file. Tag command: %s", addTagValue.Data()));
+ TGridResult* res = gGrid->Command(addTagValue.Data());
+ const char* resCode = res->GetKey(0,"__result__"); // '1' if success
+ if(resCode[0] != '1') {
+ AliError(Form("Couldn't add ShortLived tag value to file %s !", filename.Data()));
+ result = kFALSE;
+ } else {
+ AliDebug(2,"Object successfully tagged.");
+ result = kTRUE;
+ }
+ delete res;
+ return result;
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliCDBGrid::TagFileMetaData(TString& filename, const AliCDBMetaData* md){
+// tag stored object in CDB table using object Id's parameters
+
+ TString addTagValue1 = Form("addTagValue %s CDB_MD ", filename.Data());
+ TString addTagValue2 = Form("object_classname=\"%s\" responsible=\"%s\" beam_period=%d ",
+ md->GetObjectClassName(),
+ md->GetResponsible(),
+ md->GetBeamPeriod());
+ TString addTagValue3 = Form("aliroot_version=\"%s\" comment=\"%s\"",
+ md->GetAliRootVersion(),
+ md->GetComment());
+ TString addTagValue = Form("%s%s%s",
+ addTagValue1.Data(),
+ addTagValue2.Data(),
+ addTagValue3.Data());
+
+ Bool_t result = kFALSE;
+ AliDebug(2, Form("Tagging file. Tag command: %s", addTagValue.Data()));
+ TGridResult* res = gGrid->Command(addTagValue.Data());
+ const char* resCode = res->GetKey(0,"__result__"); // '1' if success
+ if(resCode[0] != '1') {
+ AliWarning(Form("Couldn't add CDB_MD tag value to file %s !",
+ filename.Data()));
+ result = kFALSE;
+ } else {
+ AliDebug(2,"Object successfully tagged.");
+ result = kTRUE;
}
-
return result;
}
TString turl(fileName);
turl.Prepend("/alien" + fDBFolder);
- turl += "?se="; turl += fSE.Data();
+ turl += "?se="; turl += fSE.Data();
TFile *file = TFile::Open(turl);
if (!file) {
AliError(Form("Can't open selection file <%s>!", turl.Data()));
list->SetOwner();
int i=0;
TString keycycle;
-
+
AliCDBId *id;
while(1){
i++;
return result;
}
+//_____________________________________________________________________________
+void AliCDBGrid::QueryValidFiles()
+{
+// Query the CDB for files valid for AliCDBStorage::fRun
+// fills list fValidFileIds with AliCDBId objects created from file name
+
+ TString filter;
+ MakeQueryFilter(fRun, fRun, fMetaDataFilter, filter);
+
+ TString pattern = Form("%s/Run*", fPathFilter.GetPath().Data());
+ if(fVersion >= 0) pattern += Form("_v%d*", fVersion);
+ pattern += ".root";
+ AliDebug(2,Form("pattern: %s", pattern.Data()));
+
+ TGridResult *res = gGrid->Query(fDBFolder, pattern, filter, "");
+
+ if (!res) {
+ AliError("Grid query failed");
+ return;
+ }
+
+ AliCDBId validFileId;
+ for(int i=0; i<res->GetEntries(); i++){
+ TString filename = res->GetKey(i, "lfn");
+ if(filename == "") continue;
+ AliDebug(2,Form("Found valid file: %s", filename.Data()));
+ Bool_t result = FilenameToId(filename, validFileId);
+ if(result) {
+ fValidFileIds.AddLast(validFileId.Clone());
+ }
+ }
+ delete res;
+
+}
+
+//_____________________________________________________________________________
+void AliCDBGrid::MakeQueryFilter(Int_t firstRun, Int_t lastRun,
+ const AliCDBMetaData* md, TString& result) const
+{
+// create filter for file query
+
+ result = Form("CDB:first_run<=%d and CDB:last_run>=%d", firstRun, lastRun);
+
+// if(version >= 0) {
+// result += Form(" and CDB:version=%d", version);
+// }
+// if(pathFilter.GetLevel0() != "*") {
+// result += Form(" and CDB:path_level_0=\"%s\"", pathFilter.GetLevel0().Data());
+// }
+// if(pathFilter.GetLevel1() != "*") {
+// result += Form(" and CDB:path_level_1=\"%s\"", pathFilter.GetLevel1().Data());
+// }
+// if(pathFilter.GetLevel2() != "*") {
+// result += Form(" and CDB:path_level_2=\"%s\"", pathFilter.GetLevel2().Data());
+// }
+
+ if(md){
+ if(md->GetObjectClassName()[0] != '\0') {
+ result += Form(" and CDB_MD:object_classname=\"%s\"", md->GetObjectClassName());
+ }
+ if(md->GetResponsible()[0] != '\0') {
+ result += Form(" and CDB_MD:responsible=\"%s\"", md->GetResponsible());
+ }
+ if(md->GetBeamPeriod() != 0) {
+ result += Form(" and CDB_MD:beam_period=%d", md->GetBeamPeriod());
+ }
+ if(md->GetAliRootVersion()[0] != '\0') {
+ result += Form(" and CDB_MD:aliroot_version=\"%s\"", md->GetAliRootVersion());
+ }
+ if(md->GetComment()[0] != '\0') {
+ result += Form(" and CDB_MD:comment=\"%s\"", md->GetComment());
+ }
+ }
+ AliDebug(2, Form("filter: %s",result.Data()));
+
+}
+
+//_____________________________________________________________________________
+Int_t AliCDBGrid::GetLatestVersion(const char* path, Int_t run){
+// get last version found in the database valid for run and path
+
+ AliCDBPath aCDBPath(path);
+ if(!aCDBPath.IsValid() || aCDBPath.IsWildcard()) {
+ AliError(Form("Invalid path in request: %s", path));
+ return -1;
+ }
+ AliCDBId query(path, run, run, -1, -1);
+ AliCDBId* dataId = 0;
+
+ // look for file matching query requests (path, runRange, version)
+ if(run == fRun && fPathFilter.Comprises(aCDBPath) && fVersion < 0){
+ // look into list of valid files previously loaded with AliCDBStorage::FillValidFileIds()
+ AliDebug(2, Form("List of files valid for run %d and for path %s was loaded. Looking there!",
+ run, path));
+ dataId = GetId(fValidFileIds, query);
+ if (!dataId) return -1;
+ Int_t version = dataId->GetVersion();
+ delete dataId;
+ return version;
+
+ }
+ // List of files valid for reqested run was not loaded. Looking directly into CDB
+ AliDebug(2, Form("List of files valid for run %d and for path %s was not loaded. Looking directly into CDB!",
+ run, path));
+
+ TObjArray validFileIds;
+ validFileIds.SetOwner(1);
+
+ TString filter;
+ MakeQueryFilter(run, run, 0, filter);
+
+ TString pattern = Form("%s/Run*.root", path);
+ AliDebug(2,Form("pattern: %s", pattern.Data()));
+
+ TGridResult *res = gGrid->Query(fDBFolder, pattern, filter, "");
+ AliCDBId validFileId;
+ for(int i=0; i<res->GetEntries(); i++){
+ TString filename = res->GetKey(i, "lfn");
+ if(filename == "") continue;
+ if(FilenameToId(filename, validFileId))
+ validFileIds.AddLast(validFileId.Clone());
+ }
+ delete res;
+
+ dataId = GetId(validFileIds, query);
+ if (!dataId) return -1;
+
+ Int_t version = dataId->GetVersion();
+ delete dataId;
+ return version;
+
+}
+
+//_____________________________________________________________________________
+Int_t AliCDBGrid::GetLatestSubVersion(const char* /*path*/, Int_t /*run*/, Int_t /*version*/){
+// get last subversion found in the database valid for run and path
+ AliError("Objects in GRID storage have no sub version!");
+ return -1;
+}
+
+
/////////////////////////////////////////////////////////////////////////////////////////////////
// //
// AliCDBGrid factory //
Bool_t AliCDBGridFactory::Validate(const char* gridString) {
// check if the string is valid Grid URI
- // pattern: alien://hostName:Port;user;dbPath;SE
- // example of a valid pattern:
- // "alien://aliendb4.cern.ch:9000;colla;DBTest;ALICE::CERN::Server"
-// TRegexp gridPattern("^alien://.+:[0-9]+;[a-zA-Z0-9_-.]+;.+;.+$");
TRegexp gridPattern("^alien://.+$");
+ TRegexp gridRawPattern("^raw://.+$");
- return TString(gridString).Contains(gridPattern);
+ return (TString(gridString).Contains(gridPattern)||TString(gridString).Contains(gridRawPattern));
}
//_____________________________________________________________________________
if (!Validate(gridString)) {
return NULL;
}
- //TString buffer(gridString + sizeof("alien://") - 1);
+
TString buffer(gridString);
-
- TString gridUrl = "alien://";
+ Bool_t rawFlag = kFALSE; // flag to say whether we are in the "raw://" case
+
+ TString gridUrl = "alien://";
TString user = "";
- TString dbFolder = "DBGrid";
- TString se = "ALICE::CERN::se01";
+ TString dbFolder = "";
+ TString se = "default";
+ TString cacheFolder = "";
+ Bool_t operateDisconnected = kTRUE;
+ Long64_t cacheSize = (UInt_t) 1024*1024*1024; // 1GB
+ Long_t cleanupInterval = 0;
TObjArray *arr = buffer.Tokenize('?');
TIter iter(arr);
- TObjString *str;
-
+ TObjString *str = 0;
+
while((str = (TObjString*) iter.Next())){
TString entry(str->String());
Int_t indeq = entry.Index('=');
if(entry.BeginsWith("alien://")) { // maybe it's a gridUrl!
gridUrl = entry;
continue;
+ } else if(entry.BeginsWith("raw://")) { // maybe it's a gridRawUrl!
+ gridUrl = entry;
+ rawFlag = kTRUE;
+ continue;
} else {
AliError(Form("Invalid entry! %s",entry.Data()));
continue;
if(key.Contains("grid",TString::kIgnoreCase)) {
gridUrl += value;
- }
+ }
else if (key.Contains("user",TString::kIgnoreCase)){
user = value;
}
+ else if (key.Contains("se",TString::kIgnoreCase)){
+ se = value;
+ }
+ else if (key.Contains("cacheF",TString::kIgnoreCase)){
+ cacheFolder = value;
+ if (!cacheFolder.EndsWith("/"))
+ cacheFolder += "/";
+ }
else if (key.Contains("folder",TString::kIgnoreCase)){
dbFolder = value;
}
- else if (key.Contains("se",TString::kIgnoreCase)){
- se = value;
+ else if (key.Contains("operateDisc",TString::kIgnoreCase)){
+ if(value == "kTRUE") {
+ operateDisconnected = kTRUE;
+ } else if (value == "kFALSE") {
+ operateDisconnected = kFALSE;
+ } else if (value == "0" || value == "1") {
+ operateDisconnected = (Bool_t) value.Atoi();
+ } else {
+ AliError(Form("Invalid entry! %s",entry.Data()));
+ return NULL;
+ }
+ }
+ else if (key.Contains("cacheS",TString::kIgnoreCase)){
+ if(value.IsDigit()) {
+ cacheSize = value.Atoi();
+ } else {
+ AliError(Form("Invalid entry! %s",entry.Data()));
+ return NULL;
+ }
+ }
+ else if (key.Contains("cleanupInt",TString::kIgnoreCase)){
+ if(value.IsDigit()) {
+ cleanupInterval = value.Atoi();
+ } else {
+ AliError(Form("Invalid entry! %s",entry.Data()));
+ return NULL;
+ }
}
else{
AliError(Form("Invalid entry! %s",entry.Data()));
+ return NULL;
}
}
delete arr; arr=0;
-
- AliInfo(Form("gridUrl: %s",gridUrl.Data()));
- AliInfo(Form("user: %s",user.Data()));
- AliInfo(Form("dbFolder: %s",dbFolder.Data()));
- AliInfo(Form("s.e.: %s",se.Data()));
- return new AliCDBGridParam(gridUrl, user, dbFolder, se);
+ AliDebug(2, Form("gridUrl: %s", gridUrl.Data()));
+ AliDebug(2, Form("user: %s", user.Data()));
+ AliDebug(2, Form("dbFolder: %s", dbFolder.Data()));
+ AliDebug(2, Form("s.e.: %s", se.Data()));
+ AliDebug(2, Form("local cache folder: %s", cacheFolder.Data()));
+ AliDebug(2, Form("local cache operate disconnected: %d", operateDisconnected));
+ AliDebug(2, Form("local cache size: %d", cacheSize));
+ AliDebug(2, Form("local cache cleanup interval: %d", cleanupInterval));
+
+ if(dbFolder == "" && !rawFlag){
+ AliError("Base folder must be specified!");
+ return NULL;
+ }
+
+ return new AliCDBGridParam(gridUrl.Data(), user.Data(),
+ dbFolder.Data(), se.Data(), cacheFolder.Data(),
+ operateDisconnected, cacheSize, cleanupInterval);
}
//_____________________________________________________________________________
AliCDBStorage* AliCDBGridFactory::Create(const AliCDBParam* param) {
// create AliCDBGrid storage instance from parameters
+ AliCDBGrid *grid = 0;
if (AliCDBGridParam::Class() == param->IsA()) {
-
+
const AliCDBGridParam* gridParam = (const AliCDBGridParam*) param;
- AliCDBGrid *grid = new AliCDBGrid(gridParam->GridUrl(),
- gridParam->GetUser(), gridParam->GetDBFolder(),
- gridParam->GetSE());
+ grid = new AliCDBGrid(gridParam->GridUrl().Data(),
+ gridParam->GetUser().Data(),
+ gridParam->GetDBFolder().Data(),
+ gridParam->GetSE().Data(),
+ gridParam->GetCacheFolder().Data(),
+ gridParam->GetOperateDisconnected(),
+ gridParam->GetCacheSize(),
+ gridParam->GetCleanupInterval());
+
+ }
- if(gGrid) return grid;
+ if(!gGrid && grid) {
+ delete grid; grid=0;
}
- return NULL;
+ return grid;
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// //
-// AliCDBGrid Parameter class // //
+// AliCDBGrid Parameter class // //
// //
/////////////////////////////////////////////////////////////////////////////////////////////////
ClassImp(AliCDBGridParam)
//_____________________________________________________________________________
-AliCDBGridParam::AliCDBGridParam() {
+AliCDBGridParam::AliCDBGridParam():
+ AliCDBParam(),
+ fGridUrl(),
+ fUser(),
+ fDBFolder(),
+ fSE(),
+ fCacheFolder(),
+ fOperateDisconnected(),
+ fCacheSize(),
+ fCleanupInterval()
+
+ {
// default constructor
}
//_____________________________________________________________________________
-AliCDBGridParam::AliCDBGridParam(const char* gridUrl,
- const char* user,
- const char* dbFolder,
- const char* se):
+AliCDBGridParam::AliCDBGridParam(const char* gridUrl, const char* user, const char* dbFolder,
+ const char* se, const char* cacheFolder, Bool_t operateDisconnected,
+ Long64_t cacheSize, Long_t cleanupInterval):
+ AliCDBParam(),
fGridUrl(gridUrl),
fUser(user),
fDBFolder(dbFolder),
- fSE(se)
+ fSE(se),
+ fCacheFolder(cacheFolder),
+ fOperateDisconnected(operateDisconnected),
+ fCacheSize(cacheSize),
+ fCleanupInterval(cleanupInterval)
{
// constructor
-
+
SetType("alien");
- TString uri;
- uri+=fGridUrl; uri+="?";
- uri+="User="; uri+=fUser; uri+="?";
- uri+="DBFolder="; uri+=fDBFolder; uri+="?";
- uri+="SE="; uri+=fSE;
-
- SetURI(uri);
+ TString uri = Form("%s?User=%s?DBFolder=%s?SE=%s?CacheFolder=%s"
+ "?OperateDisconnected=%d?CacheSize=%d?CleanupInterval=%d",
+ fGridUrl.Data(), fUser.Data(),
+ fDBFolder.Data(), fSE.Data(), fCacheFolder.Data(),
+ fOperateDisconnected, fCacheSize, fCleanupInterval);
+
+ AliDebug(2,Form("uri = %s", uri.Data()));
+ SetURI(uri.Data());
}
//_____________________________________________________________________________
AliCDBParam* AliCDBGridParam::CloneParam() const {
// clone parameter
- return new AliCDBGridParam(fGridUrl, fUser, fDBFolder, fSE);
+ return new AliCDBGridParam(fGridUrl.Data(), fUser.Data(),
+ fDBFolder.Data(), fSE.Data(), fCacheFolder.Data(),
+ fOperateDisconnected, fCacheSize, fCleanupInterval);
}
//_____________________________________________________________________________
ULong_t AliCDBGridParam::Hash() const {
// return Hash function
- return fGridUrl.Hash()+fUser.Hash()+fDBFolder.Hash()+fSE.Hash();
+ return fGridUrl.Hash()+fUser.Hash()+fDBFolder.Hash()+fSE.Hash()+fCacheFolder.Hash();
}
//_____________________________________________________________________________
if(fUser != other->fUser) return kFALSE;
if(fDBFolder != other->fDBFolder) return kFALSE;
if(fSE != other->fSE) return kFALSE;
+ if(fCacheFolder != other->fCacheFolder) return kFALSE;
+ if(fOperateDisconnected != other->fOperateDisconnected) return kFALSE;
+ if(fCacheSize != other->fCacheSize) return kFALSE;
+ if(fCleanupInterval != other->fCleanupInterval) return kFALSE;
return kTRUE;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff