[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 <TTree.h>
#include <TNtuple.h>
#include <TFile.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;
}

//_____________________________________________________________________________
void AliCDBStorage::LoadTreeFromFile(AliCDBEntry *entry) const {
// Checks whether entry contains a TTree and in case loads it into memory

	TObject *obj = (TObject*) entry->GetObject();

	if (!strcmp(obj->ClassName(),TTree::Class_Name())) {

		AliWarning("Entry contains a TTree! Loading baskets...");

		TTree* tree = dynamic_cast<TTree*> (obj);

		if(!tree) return;

		tree->LoadBaskets();
		tree->SetDirectory(0);
	}
	else if (!strcmp(obj->ClassName(),TNtuple::Class_Name())){

		AliWarning("Entry contains a TNtuple! Loading baskets...");

		TNtuple* ntu = dynamic_cast<TNtuple*> (obj);

		if(!ntu) return;

		ntu->LoadBaskets();
		ntu->SetDirectory(0);
	}

	return;
}

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