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