// //
/////////////////////////////////////////////////////////////////////////////////////////////////
-
+#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()
+ if (!gGrid || fGridUrl != gGrid->GridUrl()
|| (( fUser != "" ) && ( fUser != gGrid->GetUser() )) ) {
// connection to the Grid
AliInfo("Connection to the Grid...");
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()));
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);
}
// 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);
TString filename;
}
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);
if(validFileIds.GetEntriesFast() < 1) {
return NULL;
} else if (validFileIds.GetEntriesFast() == 1) {
- return dynamic_cast<AliCDBId*> (validFileIds.At(0));
+ return dynamic_cast<AliCDBId*> (validFileIds.At(0)->Clone());
}
TIter iter(&validFileIds);
if (!query.HasVersion()){ // look for highest version
if(result && result->GetVersion() > anIdPtr->GetVersion()) continue;
if(result && result->GetVersion() == anIdPtr->GetVersion()) {
- AliDebug(2,Form("More than one object valid for run %d, version %d!",
+ AliError(Form("More than one object valid for run %d, version %d!",
query.GetFirstRun(), anIdPtr->GetVersion()));
return NULL;
}
} else { // look for specified version
if(query.GetVersion() != anIdPtr->GetVersion()) continue;
if(result && result->GetVersion() == anIdPtr->GetVersion()){
- AliDebug(2,Form("More than one object valid for run %d, version %d!",
+ AliError(Form("More than one object valid for run %d, version %d!",
query.GetFirstRun(), anIdPtr->GetVersion()));
return NULL;
}
}
}
+
+ if (!result) return NULL;
-
- return result;
+ 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=0;
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;
+ 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);
}
+ 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, filename)) {
AliDebug(2,Form("Bad data ID encountered! Subnormal error!"));
+ delete dataId;
return NULL;
}
AliCDBEntry* anEntry = GetEntryFromFile(filename, dataId);
+ delete dataId;
return anEntry;
}
AliDebug(2,Form("Opening file: %s",filename.Data()));
filename.Prepend("/alien");
- TFile *file = TFile::Open(filename);
+
+ // if option="CACHEREAD" TFile will use the local caching facility!
+ TString option="READ";
+ if(fCacheFolder != ""){
+
+ // 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) {
AliDebug(2,Form("Can't open file <%s>!", filename.Data()));
return NULL;
} else {
dataId = GetId(validFileIds, thisId);
}
- if(dataId) selectedIds.Add(dataId->Clone());
+ if(dataId) selectedIds.Add(dataId);
}
delete iter; iter=0;
fDBFolder.Data(),
id.GetPath().Data());
- // add CDB and CDB_MD tag to folder
- // TODO how to check that folder has already tags?
- AddTag(folderToTag,"CDB");
- AddTag(folderToTag,"CDB_MD");
-
TDirectory* saveDir = gDirectory;
TString fullFilename = Form("/alien%s", filename.Data());
file->Close(); delete file; file=0;
if(result) {
- AliInfo(Form("CDB object stored into file %s", filename.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()))
TagFileMetaData(filename, entry->GetMetaData());
}
+ AliInfo(Form("CDB object stored into file %s", filename.Data()));
+ AliInfo(Form("Storage Element: %s", fSE.Data()));
return result;
}
//_____________________________________________________________________________
id->GetLastRun(),
id->GetVersion());
TString addTagValue3 = Form("path_level_0=\"%s\" path_level_1=\"%s\" path_level_2=\"%s\"",
- id->GetLevel0().Data(),
- id->GetLevel1().Data(),
- id->GetLevel2().Data());
+ id->GetPathLevel(0).Data(),
+ id->GetPathLevel(1).Data(),
+ id->GetPathLevel(2).Data());
TString addTagValue = Form("%s%s%s",
addTagValue1.Data(),
addTagValue2.Data(),
filename.Data()));
result = kFALSE;
} else {
- AliInfo("Object successfully tagged.");
+ 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;
filename.Data()));
result = kFALSE;
} else {
- AliInfo("Object successfully tagged.");
+ AliDebug(2,"Object successfully tagged.");
result = kTRUE;
}
return result;
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");
Int_t AliCDBGrid::GetLatestVersion(const char* path, Int_t run){
// get last version found in the database valid for run and path
- TObjArray validFileIds;
- validFileIds.SetOwner(1);
-
AliCDBPath aCDBPath(path);
if(!aCDBPath.IsValid() || aCDBPath.IsWildcard()) {
AliError(Form("Invalid path in request: %s", path));
run, path));
dataId = GetId(fValidFileIds, query);
if (!dataId) return -1;
- return dataId->GetVersion();
+ 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);
dataId = GetId(validFileIds, query);
if (!dataId) return -1;
- return dataId->GetVersion();
+ Int_t version = dataId->GetVersion();
+ delete dataId;
+ return version;
}
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);
+ Bool_t rawFlag = kFALSE; // flag to say whether we are in the "raw://" case
TString gridUrl = "alien://";
TString user = "";
- TString dbFolder = "DBGrid";
+ 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 = 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;
-
- 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()));
- return new AliCDBGridParam(gridUrl.Data(), user.Data(), dbFolder.Data(), se.Data());
+ 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);
}
//_____________________________________________________________________________
grid = new AliCDBGrid(gridParam->GridUrl().Data(),
gridParam->GetUser().Data(),
gridParam->GetDBFolder().Data(),
- gridParam->GetSE().Data());
+ gridParam->GetSE().Data(),
+ gridParam->GetCacheFolder().Data(),
+ gridParam->GetOperateDisconnected(),
+ gridParam->GetCacheSize(),
+ gridParam->GetCleanupInterval());
}
/////////////////////////////////////////////////////////////////////////////////////////////////
// //
-// AliCDBGrid Parameter class // //
+// AliCDBGrid Parameter class // //
// //
/////////////////////////////////////////////////////////////////////////////////////////////////
fGridUrl(),
fUser(),
fDBFolder(),
- fSE()
+ 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 = Form("%s?User=%s?DBFolder=%s?SE=%s",
+ 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());
+ fDBFolder.Data(), fSE.Data(), fCacheFolder.Data(),
+ fOperateDisconnected, fCacheSize, fCleanupInterval);
+ AliDebug(2,Form("uri = %s", uri.Data()));
SetURI(uri.Data());
}
// clone parameter
return new AliCDBGridParam(fGridUrl.Data(), fUser.Data(),
- fDBFolder.Data(), fSE.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