[u/mrichter/AliRoot.git] / STEER / AliCDBStorage.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.                  *
 **************************************************************************/

#include <TKey.h>
#include <TH1.h>
#include "AliCDBStorage.h"
#include "AliCDBGrid.h"

#include "AliCDBEntry.h"
#include "AliLog.h"

ClassImp(AliCDBStorage)

//_____________________________________________________________________________
AliCDBStorage::AliCDBStorage():
fValidFileIds(),
fRun(-1),
fPathFilter(),
fVersion(-1),
fMetaDataFilter(0),
fSelections(),
fURI(),
fType(),
fBaseFolder()
{
// constructor

	fValidFileIds.SetOwner(1);
	fSelections.SetOwner(1);
}

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

	RemoveAllSelections();
	fValidFileIds.Clear();
	delete fMetaDataFilter;

}

//_____________________________________________________________________________
void AliCDBStorage::GetSelection(/*const*/ AliCDBId* id) {
// return required version and subversion from the list of selection criteria
	
	TIter iter(&fSelections);
	AliCDBId* aSelection;
        
	// loop on the list of selection criteria
	while ((aSelection = (AliCDBId*) iter.Next())) {
		// check if selection element contains id's path and run (range) 
		if (aSelection->Comprises(*id)) {
			AliDebug(2,Form("Using selection criterion: %s ", aSelection->ToString().Data()));
			// return required version and subversion
			
			id->SetVersion(aSelection->GetVersion());
			id->SetSubVersion(aSelection->GetSubVersion());
			return;  
		}
	}
	
	// no valid element is found in the list of selection criteria -> return
	AliDebug(2,"Looking for objects with most recent version");
	return;
}

//_____________________________________________________________________________
void AliCDBStorage::ReadSelectionFromFile(const char *fileName){
// read selection criteria list from file
	
	RemoveAllSelections();
	
	TList *list = GetIdListFromFile(fileName);
	if(!list) return;
	
	list->SetOwner();	
	Int_t nId = list->GetEntries();
	AliCDBId *id;
	TKey *key;
	
	for(int i=nId-1;i>=0;i--){
		key = (TKey*) list->At(i);
		id = (AliCDBId*) key->ReadObj();
		if(id) AddSelection(*id);
	}
	delete list;
	AliInfo(Form("Selection criteria list filled with %d entries",fSelections.GetEntries()));
	PrintSelectionList();
	
}

//_____________________________________________________________________________
void AliCDBStorage::AddSelection(const AliCDBId& selection) {
// add a selection criterion

	AliCDBPath path = selection.GetPath();
	if(!path.IsValid()) return;
	
	TIter iter(&fSelections);
	const AliCDBId *anId;
	while((anId = (AliCDBId*) iter.Next())){
		if(selection.Comprises(*anId)){
			AliWarning("This selection is more general than a previous one and will hide it!");
			AliWarning(Form("%s", (anId->ToString()).Data()));
			fSelections.AddBefore(anId, new AliCDBId(selection));
			return;
		}
	
	}
	fSelections.AddFirst(new AliCDBId(selection));
}

//_____________________________________________________________________________
void AliCDBStorage::AddSelection(const AliCDBPath& path,
	const AliCDBRunRange& runRange, Int_t version, Int_t subVersion){
// add a selection criterion

	AddSelection(AliCDBId(path, runRange, version, subVersion));
}

//_____________________________________________________________________________
void AliCDBStorage::AddSelection(const AliCDBPath& path,
	Int_t firstRun, Int_t lastRun, Int_t version, Int_t subVersion){
// add a selection criterion
	
	AddSelection(AliCDBId(path, firstRun, lastRun, version, subVersion));
}

//_____________________________________________________________________________
void AliCDBStorage::RemoveSelection(const AliCDBId& selection) {
// remove a selection criterion

	TIter iter(&fSelections);
	AliCDBId* aSelection;

	while ((aSelection = (AliCDBId*) iter.Next())) {
		if (selection.Comprises(*aSelection)) {
			fSelections.Remove(aSelection);
		}
	}
}

//_____________________________________________________________________________
void AliCDBStorage::RemoveSelection(const AliCDBPath& path, 
	const AliCDBRunRange& runRange){
// remove a selection criterion

	RemoveSelection(AliCDBId(path, runRange, -1, -1));
}

//_____________________________________________________________________________
void AliCDBStorage::RemoveSelection(const AliCDBPath& path,
	Int_t firstRun, Int_t lastRun){
// remove a selection criterion

	RemoveSelection(AliCDBId(path, firstRun, lastRun, -1, -1));
}

//_____________________________________________________________________________
void AliCDBStorage::RemoveSelection(int position){
// remove a selection criterion from its position in the list

	delete fSelections.RemoveAt(position);
}

//_____________________________________________________________________________
void AliCDBStorage::RemoveAllSelections(){
// remove all selection criteria

	fSelections.Clear();
}

//_____________________________________________________________________________
void AliCDBStorage::PrintSelectionList(){
// prints the list of selection criteria

	TIter iter(&fSelections);
	AliCDBId* aSelection;

	// loop on the list of selection criteria
	int index=0;
	while ((aSelection = (AliCDBId*) iter.Next())) {
		AliInfo(Form("index %d -> selection: %s",index++, aSelection->ToString().Data()));
	}

}

//_____________________________________________________________________________
AliCDBEntry* AliCDBStorage::Get(const AliCDBId& query) {
// get an AliCDBEntry object from the database
	
	// check if query's path and runRange are valid
	// query is invalid also if version is not specified and subversion is!
	if (!query.IsValid()) {
		AliError(Form("Invalid query: %s", query.ToString().Data()));
		return NULL;
	}

	// query is not specified if path contains wildcard or runrange = [-1,-1] 
	if (!query.IsSpecified()) {
		AliError(Form("Unspecified query: %s", 
				query.ToString().Data()));
                return NULL;
	}

	// This is needed otherwise TH1  objects (histos, TTree's) are lost when file is closed!
	Bool_t oldStatus = TH1::AddDirectoryStatus();
	TH1::AddDirectory(kFALSE);

	AliCDBEntry* entry = GetEntry(query);

	if (oldStatus != kFALSE)
  		TH1::AddDirectory(kTRUE);

  	if (entry) {
		// this is to make the SHUTTLE output lighter
		if(!(query.GetPath().Contains("SHUTTLE/STATUS")))
    			AliDebug(2, Form("CDB object retrieved: %s", entry->GetId().ToString().Data()));
  	} else {
		// this is to make the SHUTTLE output lighter
		if(!(query.GetPath().Contains("SHUTTLE/STATUS")))
    			AliInfo(Form("No valid CDB object found! request was: %s", query.ToString().Data()));
  	}

	// if drain storage is set, drain entry into drain storage
	if(entry && (AliCDBManager::Instance())->IsDrainSet())
		AliCDBManager::Instance()->Drain(entry);

	return entry;
}

//_____________________________________________________________________________
AliCDBEntry* AliCDBStorage::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* AliCDBStorage::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));
}

//_____________________________________________________________________________
TList* AliCDBStorage::GetAll(const AliCDBId& query) {
// get multiple AliCDBEntry objects from the database


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

	if (query.IsAnyRange()) {
		AliError(Form("Unspecified run or runrange: %s",
				query.ToString().Data())); 	
		return NULL;
	}	
        
	// This is needed otherwise TH1  objects (histos, TTree's) are lost when file is closed!
	Bool_t oldStatus = TH1::AddDirectoryStatus();
	TH1::AddDirectory(kFALSE);

	TList *result = GetEntries(query);

	if (oldStatus != kFALSE)
  		TH1::AddDirectory(kTRUE);

 	Int_t nEntries = result->GetEntries();

 	AliInfo(Form("%d objects retrieved. Request was: %s",
		 	nEntries, query.ToString().Data()));
	for(int i=0; i<nEntries;i++){
		AliCDBEntry *entry = (AliCDBEntry*) result->At(i);
		AliInfo(Form("%s",entry->GetId().ToString().Data()));
	}


	// if drain storage is set, drain entries into drain storage
	if((AliCDBManager::Instance())->IsDrainSet()){
		for(int i = 0; i<result->GetEntries(); i++){
			AliCDBEntry* entry = (AliCDBEntry*) result->At(i);
			AliCDBManager::Instance()->Drain(entry);
		}
	}
	

        return result;
}

//_____________________________________________________________________________
TList* AliCDBStorage::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* AliCDBStorage::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));
}


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

	return Put(&anEntry, type);
}

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

	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;
	}

	AliCDBManager::DataType expectedType = GetDataType();

	if(expectedType != AliCDBManager::kPrivate && type != expectedType) {
		AliError(Form("It is forbidden to store %s data into a folder of type %s!",
			AliCDBManager::GetDataTypeName(type),
			AliCDBManager::GetDataTypeName(expectedType)));
			return 0;
	}

	// set object's class name into metaData!
	entry->GetMetaData()->SetObjectClassName(entry->GetObject()->ClassName());

	return PutEntry(entry);
}

//_____________________________________________________________________________
void AliCDBStorage::QueryCDB(Int_t run, const char* pathFilter,
				Int_t version, AliCDBMetaData* md){
// query CDB for files valid for given run, and fill list fValidFileIds
// Actual query is done in virtual function QueryValidFiles()

	fRun = run;

	fPathFilter = pathFilter;
	if(!fPathFilter.IsValid()) {
		AliError(Form("Filter not valid: %s", pathFilter));
		fPathFilter = "*";
		return;
	}

	fVersion = version;

	AliInfo(Form("Querying files valid for run %d and path \"%s\" into CDB storage  \"%s://%s\"",
				fRun, pathFilter, fType.Data(), fBaseFolder.Data()));

	// Clear fValidFileIds list (it cannot be filled twice!
	AliDebug(2, "Clearing list of CDB Id's previously loaded");
	fValidFileIds.Clear();

	if(fMetaDataFilter) {delete fMetaDataFilter; fMetaDataFilter=0;}
	if(md) fMetaDataFilter = dynamic_cast<AliCDBMetaData*> (md->Clone());

	QueryValidFiles();
	AliCDBId queryId(pathFilter,run,run,version);

	AliInfo(Form("%d valid files found!", fValidFileIds.GetEntriesFast()));

}

//_____________________________________________________________________________
void AliCDBStorage::PrintQueryCDB(){
// print parameters used to load list of CDB Id's (fRun, fPathFilter, fVersion)

	AliCDBId paramId(fPathFilter, fRun, fRun, fVersion);
	AliInfo(Form("**** QueryCDB Parameters **** \n\t<%s>\n",
				paramId.ToString().Data()));

	if(fMetaDataFilter) fMetaDataFilter->PrintMetaData();


	TString message = "**** Id's of valid objects found *****\n";
	TIter iter(&fValidFileIds);
	AliCDBId* anId=0;

	// loop on the list of selection criteria
	while ((anId = dynamic_cast<AliCDBId*>(iter.Next()))) {
		message += Form("\t%s\n", anId->ToString().Data());
	}
	message += Form("\n\tTotal: %d objects found\n", fValidFileIds.GetEntriesFast());
	AliInfo(Form("%s", message.Data()));
}

//_____________________________________________________________________________
AliCDBManager::DataType AliCDBStorage::GetDataType() const {
// returns the type of the data that should be stored into this storage:
// kConditions: conditions data; kReference: reference data; kPrivate: private (user-defined) data type

	if(GetType() != "alien") return AliCDBManager::kPrivate;

	TString condFolder = ((AliCDBGridParam*) AliCDBManager::Instance()->GetCondParam())->GetDBFolder();
	TString refFolder = ((AliCDBGridParam*) AliCDBManager::Instance()->GetRefParam())->GetDBFolder();

	if(GetBaseFolder().Contains(condFolder)) return AliCDBManager::kCondition;
	if(GetBaseFolder().Contains(refFolder)) return AliCDBManager::kReference;

	return AliCDBManager::kPrivate;
}
Commit	Line	Data
2c8628dd	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	**************************************************************************/
	15
b05400be	16	#include <TKey.h>
02c4845e	17	#include <TH1.h>
fe913d8f	18	#include "AliCDBStorage.h"
b8ec52f6	19	#include "AliCDBGrid.h"
2c8628dd	20
9e1ceb13	21	#include "AliCDBEntry.h"
9e1ceb13	22	#include "AliLog.h"
2c8628dd	23
fe913d8f	24	ClassImp(AliCDBStorage)
2c8628dd	25
9e1ceb13	26	//_____________________________________________________________________________
62032124	27	AliCDBStorage::AliCDBStorage():
	28	fValidFileIds(),
	29	fRun(-1),
	30	fPathFilter(),
	31	fVersion(-1),
	32	fMetaDataFilter(0),
	33	fSelections(),
	34	fURI(),
	35	fType(),
	36	fBaseFolder()
	37	{
9e1ceb13	38	// constructor
9e1ceb13	39
62032124	40	fValidFileIds.SetOwner(1);
9e1ceb13	41	fSelections.SetOwner(1);
9e1ceb13	42	}
2c8628dd	43
9e1ceb13	44	//_____________________________________________________________________________
	45	AliCDBStorage::~AliCDBStorage() {
	46	// destructor
2c8628dd	47
62032124	48	RemoveAllSelections();
	49	fValidFileIds.Clear();
	50	delete fMetaDataFilter;
	51
9e1ceb13	52	}
2c8628dd	53
2c8628dd	54	//_____________________________________________________________________________
4b5e0dce	55	void AliCDBStorage::GetSelection(/const/ AliCDBId* id) {
0f678e35	56	// return required version and subversion from the list of selection criteria
9e1ceb13	57
	58	TIter iter(&fSelections);
	59	AliCDBId* aSelection;
	60
	61	// loop on the list of selection criteria
	62	while ((aSelection = (AliCDBId*) iter.Next())) {
	63	// check if selection element contains id's path and run (range)
4b5e0dce	64	if (aSelection->Comprises(*id)) {
b05400be	65	AliDebug(2,Form("Using selection criterion: %s ", aSelection->ToString().Data()));
9e1ceb13	66	// return required version and subversion
4b5e0dce	67
	68	id->SetVersion(aSelection->GetVersion());
	69	id->SetSubVersion(aSelection->GetSubVersion());
	70	return;
9e1ceb13	71	}
	72	}
	73
	74	// no valid element is found in the list of selection criteria -> return
b05400be	75	AliDebug(2,"Looking for objects with most recent version");
4b5e0dce	76	return;
2c8628dd	77	}
2c8628dd	78
b05400be	79	//_____________________________________________________________________________
	80	void AliCDBStorage::ReadSelectionFromFile(const char *fileName){
	81	// read selection criteria list from file
	82
	83	RemoveAllSelections();
	84
	85	TList *list = GetIdListFromFile(fileName);
	86	if(!list) return;
	87
	88	list->SetOwner();
	89	Int_t nId = list->GetEntries();
	90	AliCDBId *id;
	91	TKey *key;
	92
	93	for(int i=nId-1;i>=0;i--){
	94	key = (TKey*) list->At(i);
	95	id = (AliCDBId*) key->ReadObj();
	96	if(id) AddSelection(*id);
	97	}
	98	delete list;
	99	AliInfo(Form("Selection criteria list filled with %d entries",fSelections.GetEntries()));
	100	PrintSelectionList();
	101
	102	}
	103
2c8628dd	104	//_____________________________________________________________________________
9e1ceb13	105	void AliCDBStorage::AddSelection(const AliCDBId& selection) {
	106	// add a selection criterion
	107
	108	AliCDBPath path = selection.GetPath();
	109	if(!path.IsValid()) return;
	110
	111	TIter iter(&fSelections);
	112	const AliCDBId *anId;
	113	while((anId = (AliCDBId*) iter.Next())){
	114	if(selection.Comprises(*anId)){
	115	AliWarning("This selection is more general than a previous one and will hide it!");
	116	AliWarning(Form("%s", (anId->ToString()).Data()));
	117	fSelections.AddBefore(anId, new AliCDBId(selection));
	118	return;
	119	}
	120
	121	}
	122	fSelections.AddFirst(new AliCDBId(selection));
	123	}
2c8628dd	124
2c8628dd	125	//_____________________________________________________________________________
62032124	126	void AliCDBStorage::AddSelection(const AliCDBPath& path,
9e1ceb13	127	const AliCDBRunRange& runRange, Int_t version, Int_t subVersion){
9e1ceb13	128	// add a selection criterion
2c8628dd	129
9e1ceb13	130	AddSelection(AliCDBId(path, runRange, version, subVersion));
2c8628dd	131	}
2c8628dd	132
9e1ceb13	133	//_____________________________________________________________________________
	134	void AliCDBStorage::AddSelection(const AliCDBPath& path,
	135	Int_t firstRun, Int_t lastRun, Int_t version, Int_t subVersion){
	136	// add a selection criterion
	137
	138	AddSelection(AliCDBId(path, firstRun, lastRun, version, subVersion));
	139	}
2c8628dd	140
9e1ceb13	141	//_____________________________________________________________________________
	142	void AliCDBStorage::RemoveSelection(const AliCDBId& selection) {
	143	// remove a selection criterion
2c8628dd	144
9e1ceb13	145	TIter iter(&fSelections);
9e1ceb13	146	AliCDBId* aSelection;
2c8628dd	147
9e1ceb13	148	while ((aSelection = (AliCDBId*) iter.Next())) {
	149	if (selection.Comprises(*aSelection)) {
	150	fSelections.Remove(aSelection);
	151	}
	152	}
	153	}
2c8628dd	154
9e1ceb13	155	//_____________________________________________________________________________
	156	void AliCDBStorage::RemoveSelection(const AliCDBPath& path,
	157	const AliCDBRunRange& runRange){
	158	// remove a selection criterion
2c8628dd	159
9e1ceb13	160	RemoveSelection(AliCDBId(path, runRange, -1, -1));
9e1ceb13	161	}
f05209ee	162
9e1ceb13	163	//_____________________________________________________________________________
	164	void AliCDBStorage::RemoveSelection(const AliCDBPath& path,
	165	Int_t firstRun, Int_t lastRun){
	166	// remove a selection criterion
f05209ee	167
9e1ceb13	168	RemoveSelection(AliCDBId(path, firstRun, lastRun, -1, -1));
9e1ceb13	169	}
f05209ee	170
9e1ceb13	171	//_____________________________________________________________________________
eb0b1051	172	void AliCDBStorage::RemoveSelection(int position){
9e1ceb13	173	// remove a selection criterion from its position in the list
2c8628dd	174
62032124	175	delete fSelections.RemoveAt(position);
2c8628dd	176	}
2c8628dd	177
2c8628dd	178	//_____________________________________________________________________________
9e1ceb13	179	void AliCDBStorage::RemoveAllSelections(){
9e1ceb13	180	// remove all selection criteria
2c8628dd	181
62032124	182	fSelections.Clear();
9e1ceb13	183	}
fe913d8f	184
9e1ceb13	185	//_____________________________________________________________________________
	186	void AliCDBStorage::PrintSelectionList(){
	187	// prints the list of selection criteria
	188
	189	TIter iter(&fSelections);
	190	AliCDBId* aSelection;
62032124	191
9e1ceb13	192	// loop on the list of selection criteria
	193	int index=0;
	194	while ((aSelection = (AliCDBId*) iter.Next())) {
	195	AliInfo(Form("index %d -> selection: %s",index++, aSelection->ToString().Data()));
	196	}
fe913d8f	197
9e1ceb13	198	}
fe913d8f	199
9e1ceb13	200	//_____________________________________________________________________________
0f678e35	201	AliCDBEntry* AliCDBStorage::Get(const AliCDBId& query) {
9e1ceb13	202	// get an AliCDBEntry object from the database
	203
	204	// check if query's path and runRange are valid
	205	// query is invalid also if version is not specified and subversion is!
	206	if (!query.IsValid()) {
	207	AliError(Form("Invalid query: %s", query.ToString().Data()));
	208	return NULL;
	209	}
	210
	211	// query is not specified if path contains wildcard or runrange = [-1,-1]
	212	if (!query.IsSpecified()) {
	213	AliError(Form("Unspecified query: %s",
	214	query.ToString().Data()));
	215	return NULL;
	216	}
62032124	217
02c4845e	218	// This is needed otherwise TH1 objects (histos, TTree's) are lost when file is closed!
	219	Bool_t oldStatus = TH1::AddDirectoryStatus();
	220	TH1::AddDirectory(kFALSE);
9e1ceb13	221
9e1ceb13	222	AliCDBEntry* entry = GetEntry(query);
02c4845e	223
	224	if (oldStatus != kFALSE)
	225	TH1::AddDirectory(kTRUE);
0f678e35	226
9e1ceb13	227	if (entry) {
62032124	228	// this is to make the SHUTTLE output lighter
62032124	229	if(!(query.GetPath().Contains("SHUTTLE/STATUS")))
b8ec52f6	230	AliDebug(2, Form("CDB object retrieved: %s", entry->GetId().ToString().Data()));
9e1ceb13	231	} else {
62032124	232	// this is to make the SHUTTLE output lighter
0f678e35	233	if(!(query.GetPath().Contains("SHUTTLE/STATUS")))
c3a7b59a	234	AliInfo(Form("No valid CDB object found! request was: %s", query.ToString().Data()));
9e1ceb13	235	}
0f678e35	236
9e1ceb13	237	// if drain storage is set, drain entry into drain storage
	238	if(entry && (AliCDBManager::Instance())->IsDrainSet())
	239	AliCDBManager::Instance()->Drain(entry);
0f678e35	240
9e1ceb13	241	return entry;
2c8628dd	242	}
	243
	244	//_____________________________________________________________________________
9e1ceb13	245	AliCDBEntry* AliCDBStorage::Get(const AliCDBPath& path, Int_t runNumber,
	246	Int_t version, Int_t subVersion) {
	247	// get an AliCDBEntry object from the database
2c8628dd	248
9e1ceb13	249	return Get(AliCDBId(path, runNumber, runNumber, version, subVersion));
2c8628dd	250	}
2c8628dd	251
2c8628dd	252	//_____________________________________________________________________________
9e1ceb13	253	AliCDBEntry* AliCDBStorage::Get(const AliCDBPath& path,
	254	const AliCDBRunRange& runRange, Int_t version,
	255	Int_t subVersion) {
	256	// get an AliCDBEntry object from the database
2c8628dd	257
9e1ceb13	258	return Get(AliCDBId(path, runRange, version, subVersion));
2c8628dd	259	}
2c8628dd	260
2c8628dd	261	//_____________________________________________________________________________
9e1ceb13	262	TList* AliCDBStorage::GetAll(const AliCDBId& query) {
	263	// get multiple AliCDBEntry objects from the database
	264
	265
	266	if (!query.IsValid()) {
	267	AliError(Form("Invalid query: %s", query.ToString().Data()));
	268	return NULL;
	269	}
	270
	271	if (query.IsAnyRange()) {
	272	AliError(Form("Unspecified run or runrange: %s",
	273	query.ToString().Data()));
	274	return NULL;
	275	}
	276
02c4845e	277	// This is needed otherwise TH1 objects (histos, TTree's) are lost when file is closed!
	278	Bool_t oldStatus = TH1::AddDirectoryStatus();
	279	TH1::AddDirectory(kFALSE);
	280
9e1ceb13	281	TList *result = GetEntries(query);
9e1ceb13	282
02c4845e	283	if (oldStatus != kFALSE)
	284	TH1::AddDirectory(kTRUE);
	285
9e1ceb13	286	Int_t nEntries = result->GetEntries();
b8ec52f6	287
	288	AliInfo(Form("%d objects retrieved. Request was: %s",
	289	nEntries, query.ToString().Data()));
	290	for(int i=0; i<nEntries;i++){
	291	AliCDBEntry entry = (AliCDBEntry) result->At(i);
	292	AliInfo(Form("%s",entry->GetId().ToString().Data()));
9e1ceb13	293	}
9e1ceb13	294
b8ec52f6	295
9e1ceb13	296	// if drain storage is set, drain entries into drain storage
	297	if((AliCDBManager::Instance())->IsDrainSet()){
	298	for(int i = 0; i<result->GetEntries(); i++){
	299	AliCDBEntry* entry = (AliCDBEntry*) result->At(i);
	300	AliCDBManager::Instance()->Drain(entry);
	301	}
	302	}
	303
	304
	305	return result;
	306	}
2c8628dd	307
9e1ceb13	308	//_____________________________________________________________________________
	309	TList* AliCDBStorage::GetAll(const AliCDBPath& path, Int_t runNumber,
	310	Int_t version, Int_t subVersion) {
	311	// get multiple AliCDBEntry objects from the database
2c8628dd	312
9e1ceb13	313	return GetAll(AliCDBId(path, runNumber, runNumber, version,
9e1ceb13	314	subVersion));
2c8628dd	315	}
2c8628dd	316
2c8628dd	317	//_____________________________________________________________________________
9e1ceb13	318	TList* AliCDBStorage::GetAll(const AliCDBPath& path,
	319	const AliCDBRunRange& runRange, Int_t version, Int_t subVersion) {
	320	// get multiple AliCDBEntry objects from the database
2c8628dd	321
9e1ceb13	322	return GetAll(AliCDBId(path, runRange, version, subVersion));
2c8628dd	323	}
f05209ee	324
	325
	326	//_____________________________________________________________________________
b8ec52f6	327	Bool_t AliCDBStorage::Put(TObject* object, AliCDBId& id, AliCDBMetaData* metaData, AliCDBManager::DataType type) {
02c4845e	328	// store an AliCDBEntry object into the database
9e1ceb13	329
9e1ceb13	330	AliCDBEntry anEntry(object, id, metaData);
f05209ee	331
b8ec52f6	332	return Put(&anEntry, type);
b8ec52f6	333	}
f05209ee	334
9e1ceb13	335	//_____________________________________________________________________________
b8ec52f6	336	Bool_t AliCDBStorage::Put(AliCDBEntry* entry, AliCDBManager::DataType type) {
02c4845e	337	// store an AliCDBEntry object into the database
9e1ceb13	338
02c4845e	339	if (!entry){
	340	AliError("No entry!");
	341	return kFALSE;
	342	}
	343
9e1ceb13	344	if (!entry->GetId().IsValid()) {
62032124	345	AliError(Form("Invalid entry ID: %s",
9e1ceb13	346	entry->GetId().ToString().Data()));
	347	return kFALSE;
	348	}
	349
	350	if (!entry->GetId().IsSpecified()) {
62032124	351	AliError(Form("Unspecified entry ID: %s",
9e1ceb13	352	entry->GetId().ToString().Data()));
	353	return kFALSE;
	354	}
	355
b8ec52f6	356	AliCDBManager::DataType expectedType = GetDataType();
	357
	358	if(expectedType != AliCDBManager::kPrivate && type != expectedType) {
	359	AliError(Form("It is forbidden to store %s data into a folder of type %s!",
	360	AliCDBManager::GetDataTypeName(type),
	361	AliCDBManager::GetDataTypeName(expectedType)));
	362	return 0;
	363	}
	364
02c4845e	365	// set object's class name into metaData!
	366	entry->GetMetaData()->SetObjectClassName(entry->GetObject()->ClassName());
	367
9e1ceb13	368	return PutEntry(entry);
f05209ee	369	}
fe913d8f	370
62032124	371	//_____________________________________________________________________________
c3a7b59a	372	void AliCDBStorage::QueryCDB(Int_t run, const char* pathFilter,
62032124	373	Int_t version, AliCDBMetaData* md){
	374	// query CDB for files valid for given run, and fill list fValidFileIds
	375	// Actual query is done in virtual function QueryValidFiles()
	376
	377	fRun = run;
	378
	379	fPathFilter = pathFilter;
	380	if(!fPathFilter.IsValid()) {
	381	AliError(Form("Filter not valid: %s", pathFilter));
	382	fPathFilter = "*";
	383	return;
	384	}
	385
	386	fVersion = version;
	387
6dc56e97	388	AliInfo(Form("Querying files valid for run %d and path \"%s\" into CDB storage \"%s://%s\"",
	389	fRun, pathFilter, fType.Data(), fBaseFolder.Data()));
	390
62032124	391	// Clear fValidFileIds list (it cannot be filled twice!
	392	AliDebug(2, "Clearing list of CDB Id's previously loaded");
	393	fValidFileIds.Clear();
	394
	395	if(fMetaDataFilter) {delete fMetaDataFilter; fMetaDataFilter=0;}
	396	if(md) fMetaDataFilter = dynamic_cast<AliCDBMetaData*> (md->Clone());
	397
	398	QueryValidFiles();
c3a7b59a	399	AliCDBId queryId(pathFilter,run,run,version);
62032124	400
6dc56e97	401	AliInfo(Form("%d valid files found!", fValidFileIds.GetEntriesFast()));
62032124	402
	403	}
	404
	405	//_____________________________________________________________________________
	406	void AliCDBStorage::PrintQueryCDB(){
	407	// print parameters used to load list of CDB Id's (fRun, fPathFilter, fVersion)
	408
c3a7b59a	409	AliCDBId paramId(fPathFilter, fRun, fRun, fVersion);
	410	AliInfo(Form("** QueryCDB Parameters ** \n\t<%s>\n",
	411	paramId.ToString().Data()));
	412
	413	if(fMetaDataFilter) fMetaDataFilter->PrintMetaData();
62032124	414
62032124	415
c3a7b59a	416	TString message = "** Id's of valid objects found ***\n";
62032124	417	TIter iter(&fValidFileIds);
	418	AliCDBId* anId=0;
	419
	420	// loop on the list of selection criteria
	421	while ((anId = dynamic_cast<AliCDBId*>(iter.Next()))) {
c3a7b59a	422	message += Form("\t%s\n", anId->ToString().Data());
62032124	423	}
6dc56e97	424	message += Form("\n\tTotal: %d objects found\n", fValidFileIds.GetEntriesFast());
c3a7b59a	425	AliInfo(Form("%s", message.Data()));
62032124	426	}
62032124	427
b8ec52f6	428	//_____________________________________________________________________________
	429	AliCDBManager::DataType AliCDBStorage::GetDataType() const {
	430	// returns the type of the data that should be stored into this storage:
	431	// kConditions: conditions data; kReference: reference data; kPrivate: private (user-defined) data type
	432
	433	if(GetType() != "alien") return AliCDBManager::kPrivate;
	434
	435	TString condFolder = ((AliCDBGridParam*) AliCDBManager::Instance()->GetCondParam())->GetDBFolder();
	436	TString refFolder = ((AliCDBGridParam*) AliCDBManager::Instance()->GetRefParam())->GetDBFolder();
	437
	438	if(GetBaseFolder().Contains(condFolder)) return AliCDBManager::kCondition;
	439	if(GetBaseFolder().Contains(refFolder)) return AliCDBManager::kReference;
	440
	441	return AliCDBManager::kPrivate;
	442	}