[u/mrichter/AliRoot.git] / STEER / AliCDBManager.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
//-------------------------------------------------------------------------
//   Implementation of AliCDBManager and AliCDBParam classe
//   Author: Alberto Colla 
//   e-mail: Alberto.Colla@cern.ch
//-------------------------------------------------------------------------

#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliLog.h"
#include "AliCDBDump.h"
#include "AliCDBLocal.h"
#include "AliCDBGrid.h"
#include "AliCDBEntry.h"
#include "AliCDBMetaData.h"

#include <TObjString.h>
#include <TSystem.h>

ClassImp(AliCDBParam)

ClassImp(AliCDBManager)

AliCDBManager* AliCDBManager::fgInstance = 0x0;

//_____________________________________________________________________________
AliCDBManager* AliCDBManager::Instance() {
// returns AliCDBManager instance (singleton)

	if (!fgInstance) {
		fgInstance = new AliCDBManager();
		fgInstance->Init();
	}

	return fgInstance;
}

//_____________________________________________________________________________
void AliCDBManager::Init() {
// factory registering

	RegisterFactory(new AliCDBDumpFactory());
	RegisterFactory(new AliCDBLocalFactory()); 
	// AliCDBGridFactory is registered only if AliEn libraries are enabled in Root
	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());
	}
}
//_____________________________________________________________________________
void AliCDBManager::Destroy() {
// delete ALCDBManager instance and active storages

	if (fgInstance) {
		//fgInstance->Delete();
		delete fgInstance;
		fgInstance = 0x0;
	}
}

//_____________________________________________________________________________
AliCDBManager::AliCDBManager():
	fDefaultStorage(NULL),
	fDrainStorage(NULL),
	fCache(kTRUE),
	fRun(0)
{
// default constuctor
	fFactories.SetOwner(1);
  	fEntryCache.SetOwner(1);
}

//_____________________________________________________________________________
AliCDBManager::~AliCDBManager() {
// destructor
	ClearCache();
	DestroyActiveStorages();
	fDrainStorage = 0x0;
	fDefaultStorage = 0x0;
}

//_____________________________________________________________________________
AliCDBStorage* AliCDBManager::GetActiveStorage(const AliCDBParam* param) {
// get a storage object from the list of active storages 

        return (AliCDBStorage*) fActiveStorages.GetValue(param);
}

//_____________________________________________________________________________
void AliCDBManager::PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage){
// put a storage object into the list of active storages

	fActiveStorages.Add(param, storage);
	AliDebug(1, Form("Active storages: %d", fActiveStorages.GetEntries()));
}

//_____________________________________________________________________________
void AliCDBManager::RegisterFactory(AliCDBStorageFactory* factory) {
// add a storage factory to the list of registerd factories
 
	if (!fFactories.Contains(factory)) {
		fFactories.Add(factory);
	}
}

//_____________________________________________________________________________
Bool_t AliCDBManager::HasStorage(const char* dbString) const {
// check if dbString is a URI valid for one of the registered factories 

	TIter iter(&fFactories);

	AliCDBStorageFactory* factory;
	while ((factory = (AliCDBStorageFactory*) iter.Next())) {

		if (factory->Validate(dbString)) {
			return kTRUE;
		}	
	}

	return kFALSE;
}

//_____________________________________________________________________________
AliCDBParam* AliCDBManager::CreateParameter(const char* dbString) const {
// create AliCDBParam object from URI string

	TIter iter(&fFactories);

        AliCDBStorageFactory* factory;
        while ((factory = (AliCDBStorageFactory*) iter.Next())) {

		AliCDBParam* param = factory->CreateParameter(dbString);
		if (param) {
			return param;
		}
        }

        return NULL;
}

//_____________________________________________________________________________
AliCDBStorage* AliCDBManager::GetStorage(const char* dbString) {
// get storage object from URI string
	
	AliCDBParam* param = CreateParameter(dbString);
	if (!param) {
		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 
	// the requested storage, return it
	AliCDBStorage* aStorage = GetActiveStorage(param);
	if (aStorage) {
		return aStorage;
	}

	TIter iter(&fFactories);

        AliCDBStorageFactory* factory;
        
	// loop on the list of registered factories
	while ((factory = (AliCDBStorageFactory*) iter.Next())) {

		// each factory tries to create its storage from the parameter
		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()));
			}
			return aStorage;
		}
        }

        return NULL;
}

//_____________________________________________________________________________
TList* AliCDBManager::GetActiveStorages() {
// return list of active storages

	TList* result = new TList();

	TIter iter(fActiveStorages.GetTable());	
	TPair* aPair;
	while ((aPair = (TPair*) iter.Next())) {
		result->Add(aPair->Value());
	}

	return result;
}

//_____________________________________________________________________________
void AliCDBManager::SetDrain(const char* dbString) {
// set drain storage from URI string

	fDrainStorage = GetStorage(dbString);	
}

//_____________________________________________________________________________
void AliCDBManager::SetDrain(const AliCDBParam* param) {
// set drain storage from AliCDBParam
	
	fDrainStorage = GetStorage(param);
}

//_____________________________________________________________________________
void AliCDBManager::SetDrain(AliCDBStorage* storage) {
// set drain storage from another active storage
	
	fDrainStorage = storage;
}

//_____________________________________________________________________________
Bool_t AliCDBManager::Drain(AliCDBEntry *entry) {
// drain retrieved object to drain storage

	AliInfo("Draining into drain storage...");
	return fDrainStorage->Put(entry);
}

//_____________________________________________________________________________
void AliCDBManager::SetDefaultStorage(const char* dbString) {
// sets default storage from URI string

	fDefaultStorage = GetStorage(dbString);	
}

//_____________________________________________________________________________
void AliCDBManager::SetDefaultStorage(const AliCDBParam* param) {
// set default storage from AliCDBParam object
	
	fDrainStorage = GetStorage(param);
}

//_____________________________________________________________________________
void AliCDBManager::SetDefaultStorage(AliCDBStorage* storage) {
// set default storage from another active storage
	
	fDefaultStorage = storage;
}

//_____________________________________________________________________________
void AliCDBManager::SetSpecificStorage(const char* detName, const char* dbString) {
// sets storage specific for detector (works with AliCDBManager::Get(...))

	AliCDBParam *aPar = CreateParameter(dbString);
	if(!aPar) return;
	SetSpecificStorage(detName, aPar);
	delete aPar;
}

//_____________________________________________________________________________
void AliCDBManager::SetSpecificStorage(const char* detName, AliCDBParam* param) {
// sets storage specific for detector (works with AliCDBManager::Get(...))

	if(!fDefaultStorage) {
		AliError("Please activate a default storage first!");	
		return;
	}
	
	TObjString *objDetName = new TObjString(detName);
	AliCDBParam *checkPar = (AliCDBParam*) fSpecificStorages.GetValue(objDetName);
	if(checkPar){
		AliWarning(Form("%s storage already activated! It will be replaced by the new one",objDetName->String().Data()));
		fSpecificStorages.Remove(objDetName);	
		delete checkPar;
	}
	GetStorage(param);
	fSpecificStorages.Add(objDetName, param->CloneParam());
}

//_____________________________________________________________________________
AliCDBStorage* AliCDBManager::GetSpecificStorage(const char* detName) {
// get storage specific for detector 

	AliCDBParam *checkPar = (AliCDBParam*) fSpecificStorages.GetValue(detName);
	if(!checkPar){
		AliError(Form("%s storage not found!",detName));
		return NULL;
	} else {
		return GetStorage(checkPar);
	}
	
}

//_____________________________________________________________________________
AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber, 
	Int_t version, Int_t subVersion) {
// get an AliCDBEntry object from the database

	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
	
	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 runrange = [-1,-1] 
	if (!query.IsSpecified()) {
		AliError(Form("Unspecified query: %s", 
				query.ToString().Data()));
                return NULL;
	}

	TObjString objStrLev0(query.GetLevel0());
	AliCDBParam *aPar = (AliCDBParam*) fSpecificStorages.GetValue(&objStrLev0);
	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");	
	}
			
	return aStorage->Get(query);
}

//_____________________________________________________________________________
TList* AliCDBManager::GetAll(const AliCDBPath& path, Int_t runNumber, 
	Int_t version, Int_t subVersion) {
// get multiple AliCDBEntry objects from the database

	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

	if(!fDefaultStorage) {
		AliError("No storage set!");
		return NULL;
	}

	if (!query.IsValid()) {
                AliError(Form("Invalid query: %s", query.ToString().Data()));
                return NULL;
        }

	if(query.GetPath().BeginsWith('*')){
                AliError("Query too generic in this context!");
                return NULL;		
	}

	if (query.IsAnyRange()) {
		AliError(Form("Unspecified run or runrange: %s",
				query.ToString().Data())); 	
		return NULL;
	}	
        
	TObjString objStrLev0(query.GetLevel0());
	AliCDBParam *aPar = (AliCDBParam*) fSpecificStorages.GetValue(&objStrLev0);
	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");	
	}

	TList *result = aStorage->GetAll(query);

        return result;
}

//_____________________________________________________________________________
Bool_t AliCDBManager::Put(TObject* object, AliCDBId& id,  AliCDBMetaData* metaData){
// store an AliCDBEntry object into the database

	AliCDBEntry anEntry(object, id, metaData);
	return Put(&anEntry);

}


//_____________________________________________________________________________
Bool_t AliCDBManager::Put(AliCDBEntry* entry){
// store an AliCDBEntry object into the database

	if(!fDefaultStorage) {
		AliError("No storage set!");
		return kFALSE;
	}

	if (!entry){
		AliError("No 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();
	TObjString objStrLev0(id.GetLevel0());
	AliCDBParam *aPar = (AliCDBParam*) fSpecificStorages.GetValue(&objStrLev0);
	AliCDBStorage *aStorage;
	
	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");	
	}

	return aStorage->Put(entry);


}

//_____________________________________________________________________________
AliCDBEntry* AliCDBManager::Get(const char* path)
{
// get an AliCDBEntry object from the database, using fRun as run number
    
  	if (fRun < 0)
  	{
   	 	AliError("Run number not set! Use AliCDBManager::SetRun.");
    		return 0;
  	}
	
  	AliCDBEntry *entry;
  
  	// first look into map of cached objects
  	entry = (AliCDBEntry*) fEntryCache.GetValue(path);
  	if(entry) return entry;

  	// Entry is not in cache -> retrieve it from CDB and cache it!!
  	entry = Get(path, fRun); 
  	if (!entry) return 0;
   
 	if(fCache) CacheEntry(path, entry);
  
  	return entry;

}

//_____________________________________________________________________________
void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry)
{
// cache AliCDBEntry. Cache is valid until run number is changed.

	AliDebug(2,Form("Filling cache with entry %s",path));
	fEntryCache.Add(new TObjString(path), entry);
	AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));

}

//_____________________________________________________________________________
void AliCDBManager::SetRun(Long64_t run)
{
//
// Sets current run number.  
// When the run number changes the caching is cleared.
//
  
	if (fRun == run)
		return;
  
	fRun = run;
	ClearCache();
}

//_____________________________________________________________________________
void AliCDBManager::ClearCache(){
// clear AliCDBEntry cache

	AliDebug(2,Form("Clearing cache!"));
	fEntryCache.DeleteAll();
	AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));

}

//_____________________________________________________________________________
void AliCDBManager::DestroyActiveStorages() {
// delete list of active storages

	fActiveStorages.DeleteAll();
	fSpecificStorages.DeleteAll();
}

//_____________________________________________________________________________
void AliCDBManager::DestroyActiveStorage(AliCDBStorage* /*storage*/) {
// 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;
	}
*/	

}

///////////////////////////////////////////////////////////
// AliCDBManager Parameter class                         //
// interface to specific AliCDBParameter class           //
// (AliCDBGridParam, AliCDBLocalParam, AliCDBDumpParam)  //
///////////////////////////////////////////////////////////

AliCDBParam::AliCDBParam() {
// constructor

}

//_____________________________________________________________________________
AliCDBParam::~AliCDBParam() {
// destructor

}
Commit	Line	Data
9e1ceb13	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
fdf65bb5	15	//-------------------------------------------------------------------------
	16	// Implementation of AliCDBManager and AliCDBParam classe
	17	// Author: Alberto Colla
	18	// e-mail: Alberto.Colla@cern.ch
	19	//-------------------------------------------------------------------------
9e1ceb13	20
	21	#include "AliCDBManager.h"
	22	#include "AliCDBStorage.h"
	23	#include "AliLog.h"
	24	#include "AliCDBDump.h"
	25	#include "AliCDBLocal.h"
	26	#include "AliCDBGrid.h"
02c4845e	27	#include "AliCDBEntry.h"
02c4845e	28	#include "AliCDBMetaData.h"
9e1ceb13	29
02c4845e	30	#include <TObjString.h>
9e1ceb13	31	#include <TSystem.h>
	32
	33	ClassImp(AliCDBParam)
	34
	35	ClassImp(AliCDBManager)
	36
	37	AliCDBManager* AliCDBManager::fgInstance = 0x0;
	38
	39	//_____________________________________________________________________________
	40	AliCDBManager* AliCDBManager::Instance() {
	41	// returns AliCDBManager instance (singleton)
	42
	43	if (!fgInstance) {
	44	fgInstance = new AliCDBManager();
	45	fgInstance->Init();
	46	}
	47
	48	return fgInstance;
	49	}
	50
	51	//_____________________________________________________________________________
	52	void AliCDBManager::Init() {
	53	// factory registering
	54
	55	RegisterFactory(new AliCDBDumpFactory());
	56	RegisterFactory(new AliCDBLocalFactory());
	57	// AliCDBGridFactory is registered only if AliEn libraries are enabled in Root
	58	if(!gSystem->Exec("root-config --has-alien \|grep yes 2>&1 > /dev/null")){ // returns 0 if yes
	59	AliInfo("AliEn classes enabled in Root. AliCDBGrid factory registered.");
	60	RegisterFactory(new AliCDBGridFactory());
	61	}
	62	}
	63	//_____________________________________________________________________________
	64	void AliCDBManager::Destroy() {
	65	// delete ALCDBManager instance and active storages
	66
	67	if (fgInstance) {
4b5e0dce	68	//fgInstance->Delete();
9e1ceb13	69	delete fgInstance;
	70	fgInstance = 0x0;
	71	}
	72	}
	73
	74	//_____________________________________________________________________________
	75	AliCDBManager::AliCDBManager():
	76	fDefaultStorage(NULL),
4b5e0dce	77	fDrainStorage(NULL),
	78	fCache(kTRUE),
	79	fRun(0)
9e1ceb13	80	{
9e1ceb13	81	// default constuctor
4b5e0dce	82	fFactories.SetOwner(1);
4b5e0dce	83	fEntryCache.SetOwner(1);
9e1ceb13	84	}
	85
	86	//_____________________________________________________________________________
	87	AliCDBManager::~AliCDBManager() {
	88	// destructor
4b5e0dce	89	ClearCache();
9e1ceb13	90	DestroyActiveStorages();
b05400be	91	fDrainStorage = 0x0;
b05400be	92	fDefaultStorage = 0x0;
9e1ceb13	93	}
	94
	95	//_____________________________________________________________________________
	96	AliCDBStorage* AliCDBManager::GetActiveStorage(const AliCDBParam* param) {
	97	// get a storage object from the list of active storages
	98
	99	return (AliCDBStorage*) fActiveStorages.GetValue(param);
	100	}
	101
	102	//_____________________________________________________________________________
	103	void AliCDBManager::PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage){
	104	// put a storage object into the list of active storages
	105
	106	fActiveStorages.Add(param, storage);
	107	AliDebug(1, Form("Active storages: %d", fActiveStorages.GetEntries()));
	108	}
	109
	110	//_____________________________________________________________________________
	111	void AliCDBManager::RegisterFactory(AliCDBStorageFactory* factory) {
	112	// add a storage factory to the list of registerd factories
	113
	114	if (!fFactories.Contains(factory)) {
	115	fFactories.Add(factory);
	116	}
	117	}
	118
	119	//_____________________________________________________________________________
fdf65bb5	120	Bool_t AliCDBManager::HasStorage(const char* dbString) const {
9e1ceb13	121	// check if dbString is a URI valid for one of the registered factories
	122
	123	TIter iter(&fFactories);
	124
	125	AliCDBStorageFactory* factory;
	126	while ((factory = (AliCDBStorageFactory*) iter.Next())) {
	127
	128	if (factory->Validate(dbString)) {
	129	return kTRUE;
	130	}
	131	}
	132
	133	return kFALSE;
	134	}
	135
	136	//_____________________________________________________________________________
fdf65bb5	137	AliCDBParam* AliCDBManager::CreateParameter(const char* dbString) const {
9e1ceb13	138	// create AliCDBParam object from URI string
	139
	140	TIter iter(&fFactories);
	141
	142	AliCDBStorageFactory* factory;
	143	while ((factory = (AliCDBStorageFactory*) iter.Next())) {
	144
	145	AliCDBParam* param = factory->CreateParameter(dbString);
	146	if (param) {
	147	return param;
	148	}
	149	}
	150
	151	return NULL;
	152	}
	153
	154	//_____________________________________________________________________________
	155	AliCDBStorage* AliCDBManager::GetStorage(const char* dbString) {
	156	// get storage object from URI string
	157
	158	AliCDBParam* param = CreateParameter(dbString);
	159	if (!param) {
	160	return NULL;
	161	}
	162
	163	AliCDBStorage* aStorage = GetStorage(param);
	164
	165	delete param;
	166
	167	return aStorage;
	168	}
	169
	170	//_____________________________________________________________________________
	171	AliCDBStorage* AliCDBManager::GetStorage(const AliCDBParam* param) {
	172	// get storage object from AliCDBParam object
	173
	174	// if the list of active storages already contains
	175	// the requested storage, return it
	176	AliCDBStorage* aStorage = GetActiveStorage(param);
	177	if (aStorage) {
	178	return aStorage;
	179	}
	180
	181	TIter iter(&fFactories);
	182
	183	AliCDBStorageFactory* factory;
	184
	185	// loop on the list of registered factories
	186	while ((factory = (AliCDBStorageFactory*) iter.Next())) {
	187
	188	// each factory tries to create its storage from the parameter
	189	aStorage = factory->Create(param);
	190	if (aStorage) {
	191	PutActiveStorage(param->CloneParam(), aStorage);
	192	// if default storage is not set, set to this storage
	193	if(!fDefaultStorage){
	194	fDefaultStorage=aStorage;
	195	AliInfo(Form("Default storage set to: %s",(param->GetURI()).Data()));
	196	}
	197	return aStorage;
	198	}
	199	}
	200
	201	return NULL;
202	}
203
204	//_____________________________________________________________________________
205	TList* AliCDBManager::GetActiveStorages() {
206	// return list of active storages
207
208	TList* result = new TList();
209
210	TIter iter(fActiveStorages.GetTable());
211	TPair* aPair;
212	while ((aPair = (TPair*) iter.Next())) {
213	result->Add(aPair->Value());
214	}
215
216	return result;
217	}
218
219	//_____________________________________________________________________________
220	void AliCDBManager::SetDrain(const char* dbString) {
221	// set drain storage from URI string
222
223	fDrainStorage = GetStorage(dbString);
224	}
225
226	//_____________________________________________________________________________
227	void AliCDBManager::SetDrain(const AliCDBParam* param) {
228	// set drain storage from AliCDBParam
229
230	fDrainStorage = GetStorage(param);
231	}
232
233	//_____________________________________________________________________________
234	void AliCDBManager::SetDrain(AliCDBStorage* storage) {
235	// set drain storage from another active storage
236
237	fDrainStorage = storage;
238	}
239
240	//_____________________________________________________________________________
241	Bool_t AliCDBManager::Drain(AliCDBEntry *entry) {
242	// drain retrieved object to drain storage
243
244	AliInfo("Draining into drain storage...");
245	return fDrainStorage->Put(entry);
246	}
247
9e1ceb13	248	//_____________________________________________________________________________
	249	void AliCDBManager::SetDefaultStorage(const char* dbString) {
	250	// sets default storage from URI string
	251
9e1ceb13	252	fDefaultStorage = GetStorage(dbString);
	253	}
	254
	255	//_____________________________________________________________________________
	256	void AliCDBManager::SetDefaultStorage(const AliCDBParam* param) {
	257	// set default storage from AliCDBParam object
	258
9e1ceb13	259	fDrainStorage = GetStorage(param);
	260	}
	261
	262	//_____________________________________________________________________________
	263	void AliCDBManager::SetDefaultStorage(AliCDBStorage* storage) {
	264	// set default storage from another active storage
	265
9e1ceb13	266	fDefaultStorage = storage;
	267	}
	268
02c4845e	269	//_____________________________________________________________________________
	270	void AliCDBManager::SetSpecificStorage(const char* detName, const char* dbString) {
	271	// sets storage specific for detector (works with AliCDBManager::Get(...))
	272
	273	AliCDBParam *aPar = CreateParameter(dbString);
	274	if(!aPar) return;
	275	SetSpecificStorage(detName, aPar);
	276	delete aPar;
	277	}
	278
	279	//_____________________________________________________________________________
	280	void AliCDBManager::SetSpecificStorage(const char* detName, AliCDBParam* param) {
	281	// sets storage specific for detector (works with AliCDBManager::Get(...))
	282
	283	if(!fDefaultStorage) {
	284	AliError("Please activate a default storage first!");
	285	return;
	286	}
	287
	288	TObjString *objDetName = new TObjString(detName);
	289	AliCDBParam checkPar = (AliCDBParam) fSpecificStorages.GetValue(objDetName);
	290	if(checkPar){
	291	AliWarning(Form("%s storage already activated! It will be replaced by the new one",objDetName->String().Data()));
	292	fSpecificStorages.Remove(objDetName);
	293	delete checkPar;
	294	}
	295	GetStorage(param);
	296	fSpecificStorages.Add(objDetName, param->CloneParam());
	297	}
	298
	299	//_____________________________________________________________________________
	300	AliCDBStorage* AliCDBManager::GetSpecificStorage(const char* detName) {
	301	// get storage specific for detector
4b5e0dce	302
4b5e0dce	303	AliCDBParam checkPar = (AliCDBParam) fSpecificStorages.GetValue(detName);
02c4845e	304	if(!checkPar){
4b5e0dce	305	AliError(Form("%s storage not found!",detName));
02c4845e	306	return NULL;
	307	} else {
	308	return GetStorage(checkPar);
	309	}
	310
	311	}
	312
	313	//_____________________________________________________________________________
	314	AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path, Int_t runNumber,
	315	Int_t version, Int_t subVersion) {
	316	// get an AliCDBEntry object from the database
	317
	318	return Get(AliCDBId(path, runNumber, runNumber, version, subVersion));
	319	}
	320
	321	//_____________________________________________________________________________
	322	AliCDBEntry* AliCDBManager::Get(const AliCDBPath& path,
	323	const AliCDBRunRange& runRange, Int_t version,
	324	Int_t subVersion) {
	325	// get an AliCDBEntry object from the database!
	326
	327	return Get(AliCDBId(path, runRange, version, subVersion));
	328	}
	329
	330	//_____________________________________________________________________________
	331	AliCDBEntry* AliCDBManager::Get(const AliCDBId& query) {
	332	// get an AliCDBEntry object from the database
	333
	334	if(!fDefaultStorage) {
	335	AliError("No storage set!");
	336	return NULL;
	337	}
	338
	339	// check if query's path and runRange are valid
	340	// query is invalid also if version is not specified and subversion is!
	341	if (!query.IsValid()) {
	342	AliError(Form("Invalid query: %s", query.ToString().Data()));
	343	return NULL;
	344	}
	345
	346	// query is not specified if path contains wildcard or runrange = [-1,-1]
	347	if (!query.IsSpecified()) {
	348	AliError(Form("Unspecified query: %s",
	349	query.ToString().Data()));
	350	return NULL;
	351	}
	352
	353	TObjString objStrLev0(query.GetLevel0());
	354	AliCDBParam aPar = (AliCDBParam) fSpecificStorages.GetValue(&objStrLev0);
	355	AliCDBStorage *aStorage;
	356
	357	if(aPar) {
	358	aStorage=GetStorage(aPar);
	359	TString str = aPar->GetURI();
	360	AliDebug(2,Form("Looking into storage: %s",str.Data()));
	361
	362	} else {
	363	aStorage=GetDefaultStorage();
	364	AliDebug(2,"Looking into default storage");
	365	}
	366
	367	return aStorage->Get(query);
	368	}
	369
370	//_____________________________________________________________________________
371	TList* AliCDBManager::GetAll(const AliCDBPath& path, Int_t runNumber,
372	Int_t version, Int_t subVersion) {
373	// get multiple AliCDBEntry objects from the database
374
375	return GetAll(AliCDBId(path, runNumber, runNumber, version,
376	subVersion));
377	}
378
379	//_____________________________________________________________________________
380	TList* AliCDBManager::GetAll(const AliCDBPath& path,
381	const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) {
382	// get multiple AliCDBEntry objects from the database
383
384	return GetAll(AliCDBId(path, runRange, version, subVersion));
385	}
386
387	//_____________________________________________________________________________
388	TList* AliCDBManager::GetAll(const AliCDBId& query) {
389	// get multiple AliCDBEntry objects from the database
390
391	if(!fDefaultStorage) {
392	AliError("No storage set!");
393	return NULL;
394	}
395
396	if (!query.IsValid()) {
397	AliError(Form("Invalid query: %s", query.ToString().Data()));
398	return NULL;
399	}
400
401	if(query.GetPath().BeginsWith('*')){
402	AliError("Query too generic in this context!");
403	return NULL;
404	}
405
406	if (query.IsAnyRange()) {
407	AliError(Form("Unspecified run or runrange: %s",
408	query.ToString().Data()));
409	return NULL;
410	}
411
412	TObjString objStrLev0(query.GetLevel0());
413	AliCDBParam aPar = (AliCDBParam) fSpecificStorages.GetValue(&objStrLev0);
414	AliCDBStorage *aStorage;
415
416	if(aPar) {
417	aStorage=GetStorage(aPar);
418	TString str = aPar->GetURI();
419	AliDebug(2,Form("Looking into storage: %s",str.Data()));
420
421	} else {
422	aStorage=GetDefaultStorage();
423	AliDebug(2,"Looking into default storage");
424	}
425
426	TList *result = aStorage->GetAll(query);
427
428	return result;
429	}
430
431	//_____________________________________________________________________________
432	Bool_t AliCDBManager::Put(TObject* object, AliCDBId& id, AliCDBMetaData* metaData){
433	// store an AliCDBEntry object into the database
434
435	AliCDBEntry anEntry(object, id, metaData);
436	return Put(&anEntry);
437
438	}
439
440
441	//_____________________________________________________________________________
442	Bool_t AliCDBManager::Put(AliCDBEntry* entry){
443	// store an AliCDBEntry object into the database
444
445	if(!fDefaultStorage) {
446	AliError("No storage set!");
447	return kFALSE;
448	}
449
450	if (!entry){
451	AliError("No entry!");
452	return kFALSE;
453	}
454
455	if (!entry->GetId().IsValid()) {
456	AliError(Form("Invalid entry ID: %s",
457	entry->GetId().ToString().Data()));
458	return kFALSE;
459	}
460
461	if (!entry->GetId().IsSpecified()) {
462	AliError(Form("Unspecified entry ID: %s",
463	entry->GetId().ToString().Data()));
464	return kFALSE;
465	}
466
467	AliCDBId id = entry->GetId();
468	TObjString objStrLev0(id.GetLevel0());
469	AliCDBParam aPar = (AliCDBParam) fSpecificStorages.GetValue(&objStrLev0);
470	AliCDBStorage *aStorage;
471
472	if(aPar) {
473	aStorage=GetStorage(aPar);
474	TString str = aPar->GetURI();
475	AliDebug(2,Form("Storing object into storage: %s",str.Data()));
476
477	} else {
478	aStorage=GetDefaultStorage();
479	AliDebug(2,"Storing object into default storage");
480	}
481
482	return aStorage->Put(entry);
483
484
485	}
9e1ceb13	486
4b5e0dce	487	//_____________________________________________________________________________
	488	AliCDBEntry* AliCDBManager::Get(const char* path)
	489	{
	490	// get an AliCDBEntry object from the database, using fRun as run number
	491
	492	if (fRun < 0)
	493	{
	494	AliError("Run number not set! Use AliCDBManager::SetRun.");
	495	return 0;
	496	}
	497
	498	AliCDBEntry *entry;
	499
	500	// first look into map of cached objects
	501	entry = (AliCDBEntry*) fEntryCache.GetValue(path);
	502	if(entry) return entry;
	503
	504	// Entry is not in cache -> retrieve it from CDB and cache it!!
	505	entry = Get(path, fRun);
	506	if (!entry) return 0;
	507
	508	if(fCache) CacheEntry(path, entry);
	509
	510	return entry;
	511
	512	}
	513
	514	//_____________________________________________________________________________
	515	void AliCDBManager::CacheEntry(const char* path, AliCDBEntry* entry)
	516	{
	517	// cache AliCDBEntry. Cache is valid until run number is changed.
	518
	519	AliDebug(2,Form("Filling cache with entry %s",path));
	520	fEntryCache.Add(new TObjString(path), entry);
	521	AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
	522
	523	}
	524
	525	//_____________________________________________________________________________
	526	void AliCDBManager::SetRun(Long64_t run)
	527	{
	528	//
	529	// Sets current run number.
	530	// When the run number changes the caching is cleared.
	531	//
	532
	533	if (fRun == run)
	534	return;
	535
	536	fRun = run;
	537	ClearCache();
	538	}
	539
	540	//_____________________________________________________________________________
	541	void AliCDBManager::ClearCache(){
	542	// clear AliCDBEntry cache
	543
	544	AliDebug(2,Form("Clearing cache!"));
	545	fEntryCache.DeleteAll();
	546	AliDebug(2,Form("Cache entries: %d",fEntryCache.GetEntries()));
	547
	548	}
	549
9e1ceb13	550	//_____________________________________________________________________________
	551	void AliCDBManager::DestroyActiveStorages() {
	552	// delete list of active storages
	553
	554	fActiveStorages.DeleteAll();
02c4845e	555	fSpecificStorages.DeleteAll();
9e1ceb13	556	}
	557
	558	//_____________________________________________________________________________
	559	void AliCDBManager::DestroyActiveStorage(AliCDBStorage* /storage/) {
b05400be	560	// destroys active storage
	561
	562	/*
	563	TIter iter(fActiveStorages.GetTable());
	564	TPair* aPair;
	565	while ((aPair = (TPair*) iter.Next())) {
	566	if(storage == (AliCDBStorage*) aPair->Value())
	567	delete fActiveStorages.Remove(aPair->Key());
	568	storage->Delete(); storage=0x0;
	569	}
	570	*/
9e1ceb13	571
	572	}
	573
	574	///////////////////////////////////////////////////////////
	575	// AliCDBManager Parameter class //
	576	// interface to specific AliCDBParameter class //
	577	// (AliCDBGridParam, AliCDBLocalParam, AliCDBDumpParam) //
	578	///////////////////////////////////////////////////////////
	579
	580	AliCDBParam::AliCDBParam() {
	581	// constructor
	582
	583	}
	584
	585	//_____________________________________________________________________________
	586	AliCDBParam::~AliCDBParam() {
	587	// destructor
	588
	589	}
	590