36f4d53b0589b98cfc0b1314ef8be0d917e43580
[u/mrichter/AliRoot.git] / STEER / CDB / AliCDBManager.h
1 #ifndef ALI_CDB_MANAGER_H
2 #define ALI_CDB_MANAGER_H
3
4 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  * See cxx source for full Copyright notice                               */
6
7 /////////////////////////////////////////////////////////////////////
8 //                                                                 //
9 //  class AliCDBManager                                            //
10 //                                                                 //
11 /////////////////////////////////////////////////////////////////////
12
13 #include <TObject.h>
14 #include <TList.h>
15 #include <TMap.h>
16 #include <TSystem.h>
17 #include <TFile.h>
18
19 class AliCDBEntry;
20 class AliCDBId;
21 class AliCDBPath;
22 class AliCDBRunRange;
23 class AliCDBMetaData;
24 class AliCDBStorage;
25 class AliCDBStorageFactory;
26 class AliCDBParam;
27
28 class AliCDBManager: public TObject {
29
30   public:
31     enum DataType {kCondition=0, kReference, kPrivate};
32
33     void RegisterFactory(AliCDBStorageFactory* factory);
34
35     Bool_t HasStorage(const char* dbString) const;
36
37     AliCDBParam* CreateParameter(const char* dbString) const;
38     AliCDBParam* GetCondParam() const {return fCondParam;}
39     AliCDBParam* GetRefParam() const {return fRefParam;}
40     static const char* GetDataTypeName(DataType type);
41
42     AliCDBStorage* GetStorage(const char* dbString);
43
44     TList* GetActiveStorages();
45
46     const TMap* GetStorageMap() const {return fStorageMap;}
47     const TList* GetRetrievedIds() const {return fIds;}
48
49     void SetDefaultStorage(const char* dbString);
50     void SetDefaultStorage(const AliCDBParam* param);
51     void SetDefaultStorage(AliCDBStorage *storage);
52     void SetDefaultStorage(const char* runType, const char* simType);
53     void SetDefaultStorageFromRun(Int_t run);
54
55     Bool_t IsDefaultStorageSet() const {return fDefaultStorage != 0;}
56     AliCDBStorage* GetDefaultStorage() const {return fDefaultStorage;}
57     void UnsetDefaultStorage();
58
59     void SetSpecificStorage(const char* calibType, const char* dbString);
60
61     AliCDBStorage* GetSpecificStorage(const char* calibType);
62
63     void SetDrain(const char* dbString);
64     void SetDrain(const AliCDBParam* param);
65     void SetDrain(AliCDBStorage *storage);
66
67     Bool_t IsDrainSet() const {return fDrainStorage != 0;}
68
69     Bool_t Drain(AliCDBEntry* entry);
70
71     void UnsetDrain(){fDrainStorage = 0x0;}
72
73     AliCDBEntry* Get(const AliCDBId& query, Bool_t forceCaching=kFALSE);
74     AliCDBEntry* Get(const AliCDBPath& path, Int_t runNumber=-1,
75         Int_t version = -1, Int_t subVersion = -1);
76     AliCDBEntry* Get(const AliCDBPath& path, const AliCDBRunRange& runRange,
77         Int_t version = -1, Int_t subVersion = -1);
78     AliCDBEntry* GetEntryFromSnapshot(const char* path);
79
80     const char* GetURI(const char* path);                                
81
82     TList* GetAll(const AliCDBId& query);
83     TList* GetAll(const AliCDBPath& path, Int_t runNumber=-1,
84         Int_t version = -1, Int_t subVersion = -1);
85     TList* GetAll(const AliCDBPath& path, const AliCDBRunRange& runRange,
86         Int_t version = -1, Int_t subVersion = -1); 
87
88     Bool_t Put(TObject* object, const AliCDBId& id, AliCDBMetaData* metaData,
89         const char* mirrors="", DataType type=kPrivate);
90     Bool_t Put(AliCDBEntry* entry, const char* mirrors="", DataType type=kPrivate);
91
92     void SetCacheFlag(Bool_t cacheFlag) {fCache=cacheFlag;}
93     Bool_t GetCacheFlag() const {return fCache;}
94
95     ULong64_t SetLock(Bool_t lockFlag=kTRUE, ULong64_t key=0);
96     Bool_t GetLock() const {return fLock;}
97
98     void SetRaw(Bool_t rawFlag){fRaw=rawFlag;}
99     Bool_t GetRaw() const {return fRaw;}
100
101     void SetRun(Int_t run);
102     Int_t GetRun() const {return fRun;}
103
104     void SetMirrorSEs(const char* mirrors);
105     const char* GetMirrorSEs() const;
106
107     void DestroyActiveStorages();
108     void DestroyActiveStorage(AliCDBStorage* storage);
109
110     void QueryCDB();
111
112     void Print(Option_t* option="") const;
113
114     static void Destroy();
115     ~AliCDBManager();
116
117     void ClearCache();
118     void UnloadFromCache(const char* path);
119     const TMap* GetEntryCache() const {return &fEntryCache;}
120
121     Bool_t IsShortLived(const char* path);
122
123     static AliCDBManager* Instance(TMap *entryCache = NULL, Int_t run = -1);
124
125     void Init();
126     void InitFromCache(TMap *entryCache, Int_t run);
127     Bool_t InitFromSnapshot(const char* snapshotFileName, Bool_t overwrite=kTRUE);
128     Bool_t SetSnapshotMode(const char* snapshotFileName="OCDB.root");
129     void UnsetSnapshotMode() {fSnapshotMode=kFALSE;}
130     void DumpToSnapshotFile(const char* snapshotFileName, Bool_t singleKeys);
131
132     Int_t GetStartRunLHCPeriod();
133     Int_t GetEndRunLHCPeriod();
134     TString GetLHCPeriod();
135     TString GetCvmfsOcdbTag() const {return fCvmfsOcdb;}
136
137     Bool_t DiffObjects(const char *cdbFile1, const char *cdbFile2) const;
138
139   protected:
140
141     static TString fgkCondUri;  // URI of the Conditions data base folder
142     static TString fgkRefUri;   // URI of the Reference data base folder
143     static TString fgkMCIdealStorage;   // URI of the MC-Ideal Conditions data base folder form MC data
144     static TString fgkMCFullStorage;    // URI of the MC-Full Conditions data base folder form MC data
145     static TString fgkMCResidualStorage;        // URI of the MC-Residual Conditions data base folder form MC data
146     static TString fgkOCDBFolderXMLfile;        // alien path of the XML file for OCDB folder <--> Run range correspondance
147
148     AliCDBManager() ; 
149     AliCDBManager(const AliCDBManager & source);
150     AliCDBManager & operator=(const AliCDBManager & source);
151
152     static AliCDBManager* fgInstance; // AliCDBManager instance
153
154     AliCDBStorage* GetStorage(const AliCDBParam* param);
155     AliCDBStorage* GetActiveStorage(const AliCDBParam* param);
156     void PutActiveStorage(AliCDBParam* param, AliCDBStorage* storage);
157     void SetSpecificStorage(const char* calibType, const AliCDBParam* param);
158     void AlienToCvmfsUri(TString& uriString) const;
159     void ValidateCvmfsCase() const;
160
161     void CacheEntry(const char* path, AliCDBEntry* entry);
162
163     AliCDBParam* SelectSpecificStorage(const TString& path);
164
165     AliCDBId* GetId(const AliCDBId& query);
166     AliCDBId* GetId(const AliCDBPath& path, Int_t runNumber=-1,
167         Int_t version = -1, Int_t subVersion = -1);
168     AliCDBId* GetId(const AliCDBPath& path, const AliCDBRunRange& runRange,
169         Int_t version = -1, Int_t subVersion = -1);
170
171
172     //  void Init();
173     void InitShortLived();
174     //  void InitFromCache(TMap *entryCache, Int_t run);
175
176
177     TList fFactories;           //! list of registered storage factories
178     TMap fActiveStorages;               //! list of active storages
179     TMap fSpecificStorages;         //! list of detector-specific storages
180     TMap fEntryCache;                   //! cache of the retrieved objects
181
182     TList* fIds;                //! List of the retrieved object Id's (to be streamed to file)
183     TMap* fStorageMap;      //! list of storages (to be streamed to file)
184     TList* fShortLived;         //! List of short lived objects
185
186     AliCDBStorage *fDefaultStorage;     //! pointer to default storage
187     AliCDBStorage *fDrainStorage;       //! pointer to drain storage
188
189     AliCDBParam* fCondParam;    // Conditions data storage parameters
190     AliCDBParam* fRefParam;             // Reference data storage parameters
191
192     Int_t fRun;                 //! The run number
193     Bool_t fCache;                      //! The cache flag
194     Bool_t fLock;       //! Lock flag, if ON default storage and run number cannot be reset
195
196     Bool_t fSnapshotMode;           //! flag saying if we are in snapshot mode
197     TFile *fSnapshotFile;
198
199     Bool_t fRaw;   // flag to say whether we are in the raw case
200     TString fCvmfsOcdb;       // set from $OCDB_PATH, points to a cvmfs AliRoot package
201     Int_t fStartRunLHCPeriod; // 1st run of the LHC period set
202     Int_t fEndRunLHCPeriod;   // last run of the LHC period set
203     TString fLHCPeriod;       // LHC period alien folder
204
205   private:
206     ULong64_t fKey;  //! Key for locking/unlocking
207
208
209     ClassDef(AliCDBManager, 0);
210 };
211
212
213 /////////////////////////////////////////////////////////////////////
214 //                                                                 //
215 //  class AliCDBStorageFactory                                     //
216 //                                                                 //
217 /////////////////////////////////////////////////////////////////////
218
219 class AliCDBParam;
220 class AliCDBStorageFactory: public TObject {
221   friend class AliCDBManager;
222
223   public:
224   virtual ~AliCDBStorageFactory(){}
225   virtual Bool_t Validate(const char* dbString) = 0;
226   virtual AliCDBParam* CreateParameter(const char* dbString) = 0;       
227
228   protected:
229   virtual AliCDBStorage* Create(const AliCDBParam* param) = 0;
230
231   ClassDef(AliCDBStorageFactory, 0);
232 };
233
234 /////////////////////////////////////////////////////////////////////
235 //                                                                 //
236 //  class AliCDBParam                                              //
237 //                                                                 //
238 /////////////////////////////////////////////////////////////////////
239
240 class AliCDBParam: public TObject {
241
242   public:
243
244     AliCDBParam();
245     virtual ~AliCDBParam();
246
247     const TString& GetType() const {return fType;};
248     const TString& GetURI() const {return fURI;};
249
250     virtual AliCDBParam* CloneParam() const = 0;
251
252   protected:
253
254     void SetType(const char* type) {fType = type;};
255     void SetURI(const char* uri) {fURI = uri;};
256
257   private:
258
259     TString fType; //! CDB type
260     TString fURI;  //! CDB URI
261
262     ClassDef(AliCDBParam, 0);
263 };
264
265 #endif