Completely Updated (Mario Sitta)
[u/mrichter/AliRoot.git] / STEER / AliCDBLocal.cxx
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
16 /////////////////////////////////////////////////////////////////////////////////////////////////
17 //                                                                                             //
18 // AliCDBLocal                                                                                 //
19 // access class to a DataBase in a local storage                                               //
20 //                                                                                             //
21 /////////////////////////////////////////////////////////////////////////////////////////////////
22
23 #include <TSystem.h>
24 #include <TObjString.h>
25 #include <TRegexp.h>
26 #include <TFile.h>
27 #include <TKey.h>
28
29 #include "AliCDBLocal.h"
30 #include "AliCDBEntry.h"
31 #include "AliLog.h"
32
33 ClassImp(AliCDBLocal)
34
35 //_____________________________________________________________________________
36 AliCDBLocal::AliCDBLocal(const char* baseDir):
37 fBaseDirectory(baseDir) 
38 {
39 // constructor
40
41         // check baseDire: trying to cd to baseDir; if it does not exist, create it
42         void* dir = gSystem->OpenDirectory(baseDir);
43         if (dir == NULL) {
44                 if (gSystem->mkdir(baseDir, kTRUE)) {
45                         AliError(Form("Can't open directory <%s>!", baseDir));
46                 }
47
48         } else {
49                 AliDebug(2,Form("Folder <%s> found",fBaseDirectory.Data()));
50                 gSystem->FreeDirectory(dir);
51         }
52         fType="local";
53         fBaseFolder = fBaseDirectory;
54 }
55
56 //_____________________________________________________________________________
57 AliCDBLocal::~AliCDBLocal() {
58 // destructor
59
60 }
61
62
63 //_____________________________________________________________________________
64 Bool_t AliCDBLocal::FilenameToId(const char* filename, AliCDBRunRange& runRange,
65         Int_t& version, Int_t& subVersion) {
66 // build AliCDBId from filename numbers
67
68
69         Ssiz_t mSize;
70
71         // valid filename: Run#firstRun_#lastRun_v#version_s#subVersion.root
72         TRegexp keyPattern("^Run[0-9]+_[0-9]+_v[0-9]+_s[0-9]+.root$");
73         keyPattern.Index(filename, &mSize);
74         if (!mSize) {
75                 AliDebug(2, Form("Bad filename <%s>.", filename));
76                 return kFALSE;
77         }
78
79         TString idString(filename);
80         idString.Resize(idString.Length() - sizeof(".root") + 1);
81
82         TObjArray* strArray = (TObjArray*) idString.Tokenize("_");
83
84         TString firstRunString(((TObjString*) strArray->At(0))->GetString());
85         runRange.SetFirstRun(atoi(firstRunString.Data() + 3));
86         runRange.SetLastRun(atoi(((TObjString*) strArray->At(1))->GetString()));
87         
88         TString verString(((TObjString*) strArray->At(2))->GetString());
89         version = atoi(verString.Data() + 1);
90
91         TString subVerString(((TObjString*) strArray->At(3))->GetString());
92         subVersion = atoi(subVerString.Data() + 1);
93
94         delete strArray;
95
96         return kTRUE;
97 }
98
99
100 //_____________________________________________________________________________
101 Bool_t AliCDBLocal::IdToFilename(const AliCDBId& id, TString& filename) const {
102 // build file name from AliCDBId data (run range, version, subVersion)
103
104         if (!id.GetAliCDBRunRange().IsValid()) {
105                 AliDebug(2,Form("Invalid run range <%d, %d>.", 
106                         id.GetFirstRun(), id.GetLastRun()));
107                 return kFALSE;
108         }
109
110         if (id.GetVersion() < 0) {
111                 AliDebug(2,Form("Invalid version <%d>.", id.GetVersion()));
112                 return kFALSE;
113         }
114
115         if (id.GetSubVersion() < 0) {
116                 AliDebug(2,Form("Invalid subversion <%s>.", id.GetSubVersion()));
117                 return kFALSE;
118         }
119  
120         filename = Form("Run%d_%d_v%d_s%d.root", id.GetFirstRun(), id.GetLastRun(),
121                                                  id.GetVersion(), id.GetSubVersion());
122
123         filename.Prepend(fBaseDirectory +'/' + id.GetPath() + '/');
124
125         return kTRUE;
126 }
127
128 //_____________________________________________________________________________
129 Bool_t AliCDBLocal::PrepareId(AliCDBId& id) {
130 // prepare id (version, subVersion) of the object that will be stored (called by PutEntry)
131
132         TString dirName = Form("%s/%s", fBaseDirectory.Data(), id.GetPath().Data());
133
134         // go to the path; if directory does not exist, create it
135         void* dirPtr = gSystem->OpenDirectory(dirName);
136         if (!dirPtr) {
137                 gSystem->mkdir(dirName, kTRUE);
138                 dirPtr = gSystem->OpenDirectory(dirName);
139
140                 if (!dirPtr) {
141                         AliError(Form("Can't create directory <%s>!", 
142                                         dirName.Data()));
143                         return kFALSE;
144                 }
145         }
146
147         const char* filename;
148         AliCDBRunRange aRunRange; // the runRange got from filename
149         AliCDBRunRange lastRunRange(-1,-1); // highest runRange found
150         Int_t aVersion, aSubVersion; // the version subVersion got from filename
151         Int_t lastVersion = 0, lastSubVersion = -1; // highest version and subVersion found
152
153         if (!id.HasVersion()) { // version not specified: look for highest version & subVersion
154                                 
155                 while ((filename = gSystem->GetDirEntry(dirPtr))) { // loop on the files
156
157                         TString aString(filename);
158                         if (aString == "." || aString == "..") continue;
159         
160                         if (!FilenameToId(filename, aRunRange, aVersion, 
161                                 aSubVersion)) {
162                                 AliDebug(2,Form(
163                                         "Bad filename <%s>! I'll skip it.", 
164                                         filename));
165                                 continue;
166                         }
167                         
168                         if (!aRunRange.Overlaps(id.GetAliCDBRunRange())) continue;
169                         if(aVersion < lastVersion) continue;
170                         if(aVersion > lastVersion) lastSubVersion = -1;
171                         if(aSubVersion < lastSubVersion) continue;
172                         lastVersion = aVersion;
173                         lastSubVersion = aSubVersion;
174                         lastRunRange = aRunRange;
175                 }
176
177                 id.SetVersion(lastVersion);
178                 id.SetSubVersion(lastSubVersion + 1);
179
180         } else { // version specified, look for highest subVersion only
181                 
182                 while ((filename = gSystem->GetDirEntry(dirPtr))) { // loop on the files
183                         
184                         TString aString(filename);
185                         if (aString == "." || aString == "..") {
186                                 continue;
187                         }
188
189                         if (!FilenameToId(filename, aRunRange, aVersion, 
190                                 aSubVersion)) {
191                                 AliDebug(2,Form(
192                                         "Bad filename <%s>!I'll skip it.",
193                                         filename));     
194                                 continue;
195                         }
196
197                         if (aRunRange.Overlaps(id.GetAliCDBRunRange()) 
198                                 && aVersion == id.GetVersion()
199                                 && aSubVersion > lastSubVersion) {
200                                 lastSubVersion = aSubVersion;
201                                 lastRunRange = aRunRange;
202                         }
203         
204                 }
205                 
206                 id.SetSubVersion(lastSubVersion + 1);
207         }
208
209         gSystem->FreeDirectory(dirPtr);
210
211         TString lastStorage = id.GetLastStorage();
212         if(lastStorage.Contains(TString("grid"), TString::kIgnoreCase) &&
213            id.GetSubVersion() > 0 ){
214                 AliError(Form("Grid to Local Storage error! local object with version v%d_s%d found:",id.GetVersion(), id.GetSubVersion()-1));
215                 AliError(Form("This object has been already transferred from Grid (check v%d_s0)!",id.GetVersion()));
216                 return kFALSE;
217         }
218
219         if(lastStorage.Contains(TString("new"), TString::kIgnoreCase) &&
220            id.GetSubVersion() > 0 ){
221                 AliDebug(2, Form("A NEW object is being stored with version v%d_s%d",
222                                         id.GetVersion(),id.GetSubVersion()));
223                 AliDebug(2, Form("and it will hide previously stored object with v%d_s%d!",
224                                         id.GetVersion(),id.GetSubVersion()-1));
225         }
226
227         if(!lastRunRange.IsAnyRange() && !(lastRunRange.IsEqual(& id.GetAliCDBRunRange()))) 
228                 AliWarning(Form("Run range modified w.r.t. previous version (Run%d_%d_v%d_s%d)",
229                         lastRunRange.GetFirstRun(), lastRunRange.GetLastRun(), 
230                         id.GetVersion(), id.GetSubVersion()-1));
231
232         return kTRUE;
233 }
234
235 // //_____________________________________________________________________________
236 // Bool_t AliCDBLocal::GetId(const AliCDBId& query, AliCDBId& result) {
237 // // look for filename matching query (called by GetEntry)
238 // 
239 //      TString dirName = Form("%s/%s", fBaseDirectory.Data(), query.GetPath().Data());
240 // 
241 //      void* dirPtr = gSystem->OpenDirectory(dirName);
242 //      if (!dirPtr) {
243 //              AliDebug(2,Form("Directory <%s> not found", (query.GetPath()).Data()));
244 //              AliDebug(2,Form("in DB folder %s", fBaseDirectory.Data()));
245 //              return kFALSE;
246 //      }
247 // 
248 //      const char* filename;
249 // 
250 //      AliCDBRunRange aRunRange; // the runRange got from filename
251 //      Int_t aVersion, aSubVersion; // the version and subVersion got from filename
252 // 
253 //      if (!query.HasVersion()) { // neither version and subversion specified -> look for highest version and subVersion
254 // 
255 //              while ((filename = gSystem->GetDirEntry(dirPtr))) { // loop on files
256 // 
257 //                      TString aString(filename);
258 //                      if (aString == "." || aString == "..") continue;
259 // 
260 //                      if (!FilenameToId(filename, aRunRange, aVersion, aSubVersion)) continue;
261 //                         // aRunRange, aVersion, aSubVersion filled from filename
262 // 
263 //                      if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue;
264 //                      // aRunRange contains requested run!
265 // 
266 //                      if (result.GetVersion() < aVersion) {
267 //                              result.SetVersion(aVersion);
268 //                              result.SetSubVersion(aSubVersion);
269 // 
270 //                              result.SetFirstRun(
271 //                                      aRunRange.GetFirstRun());
272 //                              result.SetLastRun(
273 //                                      aRunRange.GetLastRun());
274 // 
275 //                      } else if (result.GetVersion() == aVersion
276 //                              && result.GetSubVersion()
277 //                                      < aSubVersion) {
278 // 
279 //                              result.SetSubVersion(aSubVersion);
280 // 
281 //                              result.SetFirstRun(
282 //                                      aRunRange.GetFirstRun());
283 //                              result.SetLastRun(
284 //                                      aRunRange.GetLastRun());
285 //                      } else if (result.GetVersion() == aVersion
286 //                              && result.GetSubVersion() == aSubVersion){
287 //                                      AliDebug(2,Form("More than one object valid for run %d, version %d_%d!",
288 //                                      query.GetFirstRun(), aVersion, aSubVersion));
289 //                              gSystem->FreeDirectory(dirPtr);
290 //                              return kFALSE;
291 //                              }
292 //              }
293 // 
294 //      } else if (!query.HasSubVersion()) { // version specified but not subversion -> look for highest subVersion
295 // 
296 //              result.SetVersion(query.GetVersion());
297 // 
298 //              while ((filename = gSystem->GetDirEntry(dirPtr))) { // loop on files
299 // 
300 //                         TString aString(filename);
301 //                         if (aString == "." || aString == "..") continue;
302 // 
303 //                      if (!FilenameToId(filename, aRunRange, aVersion, aSubVersion)) continue;
304 //                         // aRunRange, aVersion, aSubVersion filled from filename
305 // 
306 //                         if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue; 
307 //                      // aRunRange contains requested run!
308 // 
309 //                      if(query.GetVersion() != aVersion) continue;
310 //                      // aVersion is requested version!
311 // 
312 //                      if(result.GetSubVersion() == aSubVersion){
313 //                                      AliDebug(2,Form("More than one object valid for run %d, version %d_%d!",
314 //                                      query.GetFirstRun(), aVersion, aSubVersion));
315 //                              gSystem->FreeDirectory(dirPtr);
316 //                              return kFALSE; 
317 //                      }
318 //                      if( result.GetSubVersion() < aSubVersion) {
319 // 
320 //                                 result.SetSubVersion(aSubVersion);
321 // 
322 //                                 result.SetFirstRun(
323 //                                      aRunRange.GetFirstRun());
324 //                                 result.SetLastRun(
325 //                                      aRunRange.GetLastRun());
326 //                      } 
327 //                 }
328 // 
329 //      } else { // both version and subversion specified
330 // 
331 //              while ((filename = gSystem->GetDirEntry(dirPtr))) { // loop on files
332 // 
333 //                         TString aString(filename);
334 //                         if (aString == "." || aString == "..") continue;
335 // 
336 //                         if (!FilenameToId(filename, aRunRange, aVersion, aSubVersion)) continue;
337 //                         // aRunRange, aVersion, aSubVersion filled from filename
338 // 
339 //                      if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue;
340 //                      // aRunRange contains requested run!
341 // 
342 //                      if(query.GetVersion() != aVersion || query.GetSubVersion() != aSubVersion) continue;
343 //                      // aVersion and aSubVersion are requested version and subVersion!
344 // 
345 //                      if(result.GetVersion() == aVersion && result.GetSubVersion() == aSubVersion){
346 //                                      AliDebug(2,Form("More than one object valid for run %d, version %d_%d!",
347 //                                      query.GetFirstRun(), aVersion, aSubVersion));
348 //                              gSystem->FreeDirectory(dirPtr);
349 //                              return kFALSE;
350 //                      }
351 //                      result.SetVersion(aVersion);
352 //                      result.SetSubVersion(aSubVersion);
353 //                      result.SetFirstRun(aRunRange.GetFirstRun());
354 //                      result.SetLastRun(aRunRange.GetLastRun());
355 // 
356 //              }
357 //      }
358 // 
359 //      gSystem->FreeDirectory(dirPtr);
360 // 
361 //      return kTRUE;
362 // }
363
364 //_____________________________________________________________________________
365 AliCDBId* AliCDBLocal::GetId(const AliCDBId& query) {
366 // look for filename matching query (called by GetEntryId)
367
368         TString dirName = Form("%s/%s", fBaseDirectory.Data(), query.GetPath().Data());
369
370         void* dirPtr = gSystem->OpenDirectory(dirName);
371         if (!dirPtr) {
372                 AliDebug(2,Form("Directory <%s> not found", (query.GetPath()).Data()));
373                 AliDebug(2,Form("in DB folder %s", fBaseDirectory.Data()));
374                 return NULL;
375         }
376
377         const char* filename;
378         AliCDBId *result = new AliCDBId();
379         result->SetPath(query.GetPath());
380
381         AliCDBRunRange aRunRange; // the runRange got from filename
382         Int_t aVersion, aSubVersion; // the version and subVersion got from filename
383
384         if (!query.HasVersion()) { // neither version and subversion specified -> look for highest version and subVersion
385
386                 while ((filename = gSystem->GetDirEntry(dirPtr))) { // loop on files
387
388                         TString aString(filename);
389                         if (aString == "." || aString == "..") continue;
390
391                         if (!FilenameToId(filename, aRunRange, aVersion, aSubVersion)) continue;
392                         // aRunRange, aVersion, aSubVersion filled from filename
393
394                         if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue;
395                         // aRunRange contains requested run!
396
397                         if (result->GetVersion() < aVersion) {
398                                 result->SetVersion(aVersion);
399                                 result->SetSubVersion(aSubVersion);
400
401                                 result->SetFirstRun(
402                                         aRunRange.GetFirstRun());
403                                 result->SetLastRun(
404                                         aRunRange.GetLastRun());
405
406                         } else if (result->GetVersion() == aVersion
407                                 && result->GetSubVersion()
408                                         < aSubVersion) {
409
410                                 result->SetSubVersion(aSubVersion);
411
412                                 result->SetFirstRun(
413                                         aRunRange.GetFirstRun());
414                                 result->SetLastRun(
415                                         aRunRange.GetLastRun());
416                         } else if (result->GetVersion() == aVersion
417                                 && result->GetSubVersion() == aSubVersion){
418                                 AliError(Form("More than one object valid for run %d, version %d_%d!",
419                                         query.GetFirstRun(), aVersion, aSubVersion));
420                                 gSystem->FreeDirectory(dirPtr);
421                                 delete result;
422                                 return NULL;
423                                 }
424                 }
425
426         } else if (!query.HasSubVersion()) { // version specified but not subversion -> look for highest subVersion
427
428                 result->SetVersion(query.GetVersion());
429
430                 while ((filename = gSystem->GetDirEntry(dirPtr))) { // loop on files
431
432                         TString aString(filename);
433                         if (aString == "." || aString == "..") continue;
434
435                         if (!FilenameToId(filename, aRunRange, aVersion, aSubVersion)) continue;
436                         // aRunRange, aVersion, aSubVersion filled from filename
437
438                         if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue; 
439                         // aRunRange contains requested run!
440
441                         if(query.GetVersion() != aVersion) continue;
442                         // aVersion is requested version!
443
444                         if(result->GetSubVersion() == aSubVersion){
445                                 AliError(Form("More than one object valid for run %d, version %d_%d!",
446                                         query.GetFirstRun(), aVersion, aSubVersion));
447                                 gSystem->FreeDirectory(dirPtr);
448                                 delete result;
449                                 return NULL;
450                         }
451                         if( result->GetSubVersion() < aSubVersion) {
452
453                                 result->SetSubVersion(aSubVersion);
454
455                                 result->SetFirstRun(
456                                         aRunRange.GetFirstRun());
457                                 result->SetLastRun(
458                                         aRunRange.GetLastRun());
459                         } 
460                 }
461
462         } else { // both version and subversion specified
463
464                 //AliCDBId dataId(queryId.GetAliCDBPath(), -1, -1, -1, -1);
465         //Bool_t result;
466         while ((filename = gSystem->GetDirEntry(dirPtr))) { // loop on files
467
468                         TString aString(filename);
469                         if (aString == "." || aString == "..") continue;
470
471                         if (!FilenameToId(filename, aRunRange, aVersion, aSubVersion)) continue;
472                         // aRunRange, aVersion, aSubVersion filled from filename
473
474                         if (!aRunRange.Comprises(query.GetAliCDBRunRange())) continue;
475                         // aRunRange contains requested run!
476
477                         if(query.GetVersion() != aVersion || query.GetSubVersion() != aSubVersion) continue;
478                         // aVersion and aSubVersion are requested version and subVersion!
479
480                         if(result->GetVersion() == aVersion && result->GetSubVersion() == aSubVersion){
481                                 AliError(Form("More than one object valid for run %d, version %d_%d!",
482                                         query.GetFirstRun(), aVersion, aSubVersion));
483                                 gSystem->FreeDirectory(dirPtr);
484                                 delete result;
485                                 return NULL;
486                         }
487                         result->SetVersion(aVersion);
488                         result->SetSubVersion(aSubVersion);
489                         result->SetFirstRun(aRunRange.GetFirstRun());
490                         result->SetLastRun(aRunRange.GetLastRun());
491                         
492                 }
493         }
494
495         gSystem->FreeDirectory(dirPtr);
496
497         return result;
498 }
499
500 //_____________________________________________________________________________
501 AliCDBEntry* AliCDBLocal::GetEntry(const AliCDBId& queryId) {
502 // get AliCDBEntry from the database
503
504         AliCDBId* dataId = GetEntryId(queryId);
505
506         if (!dataId || !dataId->IsSpecified()) return NULL;
507
508         TString filename;
509         if (!IdToFilename(*dataId, filename)) {
510
511                 AliDebug(2,Form("Bad data ID encountered! Subnormal error!"));
512                 delete dataId;
513                 return NULL;
514         }
515
516         TFile file(filename, "READ"); // open file
517         if (!file.IsOpen()) {
518                 AliDebug(2,Form("Can't open file <%s>!", filename.Data()));
519                 delete dataId;
520                 return NULL;
521         }
522
523         // get the only AliCDBEntry object from the file
524         // the object in the file is an AliCDBEntry entry named "AliCDBEntry"
525
526         AliCDBEntry* anEntry = dynamic_cast<AliCDBEntry*> (file.Get("AliCDBEntry"));
527         if (!anEntry) {
528                 AliDebug(2,Form("Bad storage data: No AliCDBEntry in file!"));
529                 file.Close();
530                 delete dataId;
531                 return NULL;
532         }
533
534         AliCDBId& entryId = anEntry->GetId();
535
536         // The object's Id are not reset during storage
537         // If object's Id runRange or version do not match with filename,
538         // it means that someone renamed file by hand. In this case a warning msg is issued.
539
540         anEntry-> SetLastStorage("local");
541
542         if(!entryId.IsEqual(dataId)){
543                 AliWarning(Form("Mismatch between file name and object's Id!"));
544                 AliWarning(Form("File name: %s", dataId->ToString().Data()));
545                 AliWarning(Form("Object's Id: %s", entryId.ToString().Data()));
546         }
547
548         // Check whether entry contains a TTree. In case load the tree in memory!
549         LoadTreeFromFile(anEntry);
550
551         // close file, return retieved entry
552         file.Close();
553         delete dataId;
554         return anEntry;
555 }
556
557 //_____________________________________________________________________________
558 AliCDBId* AliCDBLocal::GetEntryId(const AliCDBId& queryId) {
559 // get AliCDBId from the database
560
561         AliCDBId* dataId = 0;
562
563         // look for a filename matching query requests (path, runRange, version, subVersion)
564         if (!queryId.HasVersion()) {
565                 // if version is not specified, first check the selection criteria list
566                 AliCDBId selectedId(queryId);
567                 GetSelection(&selectedId);
568                 dataId = GetId(selectedId);
569         } else {
570                 dataId = GetId(queryId);
571         }
572
573         if (dataId && !dataId->IsSpecified()) {
574                 delete dataId;
575                 return NULL;
576         }
577
578         return dataId;
579 }
580
581 //_____________________________________________________________________________
582 void AliCDBLocal::GetEntriesForLevel0(const char* level0,
583         const AliCDBId& queryId, TList* result) {
584 // multiple request (AliCDBStorage::GetAll)
585
586         TString level0Dir = Form("%s/%s", fBaseDirectory.Data(), level0);
587
588         void* level0DirPtr = gSystem->OpenDirectory(level0Dir);
589         if (!level0DirPtr) {
590                 AliDebug(2,Form("Can't open level0 directory <%s>!",
591                         level0Dir.Data()));
592                 return;
593         }
594
595         const char* level1;
596         Long_t flag=0;
597         while ((level1 = gSystem->GetDirEntry(level0DirPtr))) {
598
599                 TString level1Str(level1);
600                 if (level1Str == "." || level1Str == "..") {
601                         continue;
602                 }
603                 
604                 TString fullPath = Form("%s/%s",level0Dir.Data(), level1); 
605
606                 Int_t res=gSystem->GetPathInfo(fullPath.Data(), 0, (Long64_t*) 0, &flag, 0);
607                 
608                 if(res){
609                         AliDebug(2, Form("Error reading entry %s !",level1Str.Data()));
610                         continue;
611                 }
612                 if(!(flag&2)) continue; // bit 1 of flag = directory!
613                 
614                 if (queryId.GetAliCDBPath().Level1Comprises(level1)) {
615                         GetEntriesForLevel1(level0, level1, queryId, result);
616                 }
617         }
618
619         gSystem->FreeDirectory(level0DirPtr);
620 }
621
622 //_____________________________________________________________________________
623 void AliCDBLocal::GetEntriesForLevel1(const char* level0, const char* level1,
624         const AliCDBId& queryId, TList* result) {
625 // multiple request (AliCDBStorage::GetAll)
626
627         TString level1Dir = Form("%s/%s/%s", fBaseDirectory.Data(), level0,level1);
628
629         void* level1DirPtr = gSystem->OpenDirectory(level1Dir);
630         if (!level1DirPtr) {
631                 AliDebug(2,Form("Can't open level1 directory <%s>!",
632                         level1Dir.Data()));
633                 return;
634         }
635
636         const char* level2;
637         Long_t flag=0;
638         while ((level2 = gSystem->GetDirEntry(level1DirPtr))) {
639
640                 TString level2Str(level2);
641                 if (level2Str == "." || level2Str == "..") {
642                         continue;
643                 }
644
645                 TString fullPath = Form("%s/%s",level1Dir.Data(), level2); 
646
647                 Int_t res=gSystem->GetPathInfo(fullPath.Data(), 0, (Long64_t*) 0, &flag, 0);
648                 
649                 if(res){
650                         AliDebug(2, Form("Error reading entry %s !",level2Str.Data()));
651                         continue;
652                 }
653                 if(!(flag&2)) continue; // bit 1 of flag = directory!
654                 
655                 if (queryId.GetAliCDBPath().Level2Comprises(level2)) {
656
657                         AliCDBPath entryPath(level0, level1, level2);
658                         AliCDBId entryId(entryPath, queryId.GetAliCDBRunRange(),
659                                 queryId.GetVersion(), queryId.GetSubVersion());
660
661                         AliCDBEntry* anEntry = GetEntry(entryId);
662                         if (anEntry) {
663                                 result->Add(anEntry);
664                         }
665                 }
666         }
667
668         gSystem->FreeDirectory(level1DirPtr);
669 }
670
671 //_____________________________________________________________________________
672 TList* AliCDBLocal::GetEntries(const AliCDBId& queryId) {
673 // multiple request (AliCDBStorage::GetAll)
674         
675         void* storageDirPtr = gSystem->OpenDirectory(fBaseDirectory);
676         if (!storageDirPtr) {
677                 AliDebug(2,Form("Can't open storage directory <%s>",
678                         fBaseDirectory.Data()));
679                 return NULL;
680         }
681
682         TList* result = new TList();
683         result->SetOwner();
684
685         const char* level0;
686         Long_t flag=0;
687         while ((level0 = gSystem->GetDirEntry(storageDirPtr))) {
688
689                 TString level0Str(level0);
690                 if (level0Str == "." || level0Str == "..") {
691                         continue;
692                 }
693                 
694                 TString fullPath = Form("%s/%s",fBaseDirectory.Data(), level0); 
695
696                 Int_t res=gSystem->GetPathInfo(fullPath.Data(), 0, (Long64_t*) 0, &flag, 0);
697                 
698                 if(res){
699                         AliDebug(2, Form("Error reading entry %s !",level0Str.Data()));
700                         continue;
701                 }
702                 
703                 if(!(flag&2)) continue; // bit 1 of flag = directory!                           
704
705                 if (queryId.GetAliCDBPath().Level0Comprises(level0)) {
706                         GetEntriesForLevel0(level0, queryId, result);
707                 }
708         }
709
710         gSystem->FreeDirectory(storageDirPtr);
711
712         return result;  
713 }
714
715 //_____________________________________________________________________________
716 Bool_t AliCDBLocal::PutEntry(AliCDBEntry* entry) {
717 // put an AliCDBEntry object into the database
718
719         AliCDBId& id = entry->GetId();
720
721         // set version and subVersion for the entry to be stored
722         if (!PrepareId(id)) return kFALSE;
723
724         
725         // build filename from entry's id
726         TString filename="";
727         if (!IdToFilename(id, filename)) {
728
729                 AliDebug(2,Form("Bad ID encountered! Subnormal error!"));
730                 return kFALSE;
731         }
732
733         // open file
734         TFile file(filename, "CREATE");
735         if (!file.IsOpen()) {
736                 AliError(Form("Can't open file <%s>!", filename.Data()));
737                 return kFALSE;
738         }
739         
740         //SetTreeToFile(entry, &file);
741
742         entry->SetVersion(id.GetVersion());
743         entry->SetSubVersion(id.GetSubVersion());
744
745         // write object (key name: "AliCDBEntry")
746         Bool_t result = file.WriteTObject(entry, "AliCDBEntry");
747         if (!result) AliDebug(2,Form("Can't write entry to file: %s", filename.Data()));
748
749         file.Close();
750         if(result) {
751                 if(!(id.GetPath().Contains("SHUTTLE/STATUS")))
752                         AliInfo(Form("CDB object stored into file %s",filename.Data()));
753         }
754
755         return result;
756 }
757
758 //_____________________________________________________________________________
759 TList* AliCDBLocal::GetIdListFromFile(const char* fileName){
760
761         TString fullFileName(fileName);
762         fullFileName.Prepend(fBaseDirectory+'/');
763         TFile *file = TFile::Open(fullFileName);
764         if (!file) {
765                 AliError(Form("Can't open selection file <%s>!", fullFileName.Data()));
766                 return NULL;
767         }
768         file->cd();
769
770         TList *list = new TList();
771         list->SetOwner();
772         int i=0;
773         TString keycycle;
774         
775         AliCDBId *id;
776         while(1){
777                 i++;
778                 keycycle = "AliCDBId;";
779                 keycycle+=i;
780                 
781                 id = (AliCDBId*) file->Get(keycycle);
782                 if(!id) break;
783                 list->AddFirst(id);
784         }
785         file->Close(); delete file; file=0;     
786         return list;
787 }
788
789 //_____________________________________________________________________________
790 Bool_t AliCDBLocal::Contains(const char* path) const{
791 // check for path in storage's fBaseDirectory
792
793         TString dirName = Form("%s/%s", fBaseDirectory.Data(), path);
794         Bool_t result=kFALSE;
795
796         void* dirPtr = gSystem->OpenDirectory(dirName); 
797         if (dirPtr) result=kTRUE;
798         gSystem->FreeDirectory(dirPtr);
799
800         return result;
801 }
802
803 //_____________________________________________________________________________
804 void AliCDBLocal::QueryValidFiles()
805 {
806 // Query the CDB for files valid for AliCDBStorage::fRun
807 // fills list fValidFileIds with AliCDBId objects created from file name
808
809         if(fVersion != -1) AliWarning ("Version parameter is not used by local storage query!");
810         if(fMetaDataFilter) {
811                 AliWarning ("CDB meta data parameters are not used by local storage query!");
812                 delete fMetaDataFilter; fMetaDataFilter=0;
813         }
814
815         void* storageDirPtr = gSystem->OpenDirectory(fBaseDirectory);
816
817         const char* level0;
818         while ((level0 = gSystem->GetDirEntry(storageDirPtr))) {
819
820                 TString level0Str(level0);
821                 if (level0Str == "." || level0Str == "..") {
822                         continue;
823                 }
824
825                 if (fPathFilter.Level0Comprises(level0)) {
826                         TString level0Dir = Form("%s/%s",fBaseDirectory.Data(),level0);
827                         void* level0DirPtr = gSystem->OpenDirectory(level0Dir);
828                         const char* level1;
829                         while ((level1 = gSystem->GetDirEntry(level0DirPtr))) {
830
831                                 TString level1Str(level1);
832                                 if (level1Str == "." || level1Str == "..") {
833                                         continue;
834                                 }
835
836                                 if (fPathFilter.Level1Comprises(level1)) {
837                                         TString level1Dir = Form("%s/%s/%s",
838                                                         fBaseDirectory.Data(),level0,level1);
839
840                                         void* level1DirPtr = gSystem->OpenDirectory(level1Dir);
841                                         const char* level2;
842                                         while ((level2 = gSystem->GetDirEntry(level1DirPtr))) {
843
844                                                 TString level2Str(level2);
845                                                 if (level2Str == "." || level2Str == "..") {
846                                                         continue;
847                                                 }
848
849                                                 if (fPathFilter.Level2Comprises(level2)) {
850                                                         TString dirName = Form("%s/%s/%s/%s",
851                                                                         fBaseDirectory.Data(),level0,level1,level2);
852
853                                                         void* dirPtr = gSystem->OpenDirectory(dirName);
854
855                                                         const char* filename;
856
857                                                         AliCDBRunRange aRunRange; // the runRange got from filename
858                                                         Int_t aVersion, aSubVersion; // the version and subVersion got from filename
859
860                                                         while ((filename = gSystem->GetDirEntry(dirPtr))) { // loop on files
861
862                                                                 TString aString(filename);
863                                                                 if (aString == "." || aString == "..") continue;
864
865                                                                 if (!FilenameToId(filename, aRunRange, aVersion, aSubVersion)) continue;
866                                                                 AliCDBRunRange runrg(fRun,fRun);
867                                                                 if (!aRunRange.Comprises(runrg)) continue;
868                                                                 // aRunRange contains requested run!
869                                                                 AliCDBPath validPath(level0,level1,level2);
870                                                                 AliCDBId validId(validPath,aRunRange,aVersion,aSubVersion);
871                                                                 fValidFileIds.AddLast(validId.Clone());
872                                                         }
873                                                         gSystem->FreeDirectory(dirPtr);
874                                                 }
875                                         }
876                                         gSystem->FreeDirectory(level1DirPtr);
877                                 }
878                         }
879                         gSystem->FreeDirectory(level0DirPtr);
880                 }
881         }
882         gSystem->FreeDirectory(storageDirPtr);
883
884 }
885
886 //_____________________________________________________________________________
887 Int_t AliCDBLocal::GetLatestVersion(const char* path, Int_t run){
888 // get last version found in the database valid for run and path
889
890         AliCDBPath aCDBPath(path);
891         if(!aCDBPath.IsValid() || aCDBPath.IsWildcard()) {
892                 AliError(Form("Invalid path in request: %s", path));
893                 return -1;
894         }
895
896         AliCDBId query(path, run, run, -1, -1);
897         AliCDBId* dataId = GetId(query);
898
899         if(!dataId) return -1;
900
901         Int_t version = dataId->GetVersion();
902         delete dataId;
903
904         return version;
905
906 }
907
908 //_____________________________________________________________________________
909 Int_t AliCDBLocal::GetLatestSubVersion(const char* path, Int_t run, Int_t version){
910 // get last version found in the database valid for run and path
911
912         AliCDBPath aCDBPath(path);
913         if(!aCDBPath.IsValid() || aCDBPath.IsWildcard()) {
914                 AliError(Form("Invalid path in request: %s", path));
915                 return -1;
916         }
917
918         AliCDBId query(path, run, run, version, -1);
919         AliCDBId *dataId = GetId(query);
920
921         if(!dataId) return -1;
922
923         Int_t subVersion = dataId->GetSubVersion();
924
925         delete dataId;
926         return subVersion;
927
928 }
929
930 /////////////////////////////////////////////////////////////////////////////////////////////////
931 //                                                                                             //
932 // AliCDBLocal factory                                                                         //
933 //                                                                                             //
934 /////////////////////////////////////////////////////////////////////////////////////////////////
935
936 ClassImp(AliCDBLocalFactory)
937
938 //_____________________________________________________________________________
939 Bool_t AliCDBLocalFactory::Validate(const char* dbString) {
940 // check if the string is valid local URI
941
942         TRegexp dbPattern("^local://.+$");
943
944         return TString(dbString).Contains(dbPattern);
945 }
946
947 //_____________________________________________________________________________
948 AliCDBParam* AliCDBLocalFactory::CreateParameter(const char* dbString) {
949 // create AliCDBLocalParam class from the URI string
950
951         if (!Validate(dbString)) {
952                 return NULL;
953         }
954
955         TString pathname(dbString + sizeof("local://") - 1);
956         
957         gSystem->ExpandPathName(pathname);
958
959         if (pathname[0] != '/') {
960                 pathname.Prepend(TString(gSystem->WorkingDirectory()) + '/');
961         }
962
963         return new AliCDBLocalParam(pathname);
964 }
965
966 //_____________________________________________________________________________
967 AliCDBStorage* AliCDBLocalFactory::Create(const AliCDBParam* param) {
968 // create AliCDBLocal storage instance from parameters
969         
970         if (AliCDBLocalParam::Class() == param->IsA()) {
971                 
972                 const AliCDBLocalParam* localParam = 
973                         (const AliCDBLocalParam*) param;
974                 
975                 return new AliCDBLocal(localParam->GetPath());
976         }
977
978         return NULL;
979 }
980
981 /////////////////////////////////////////////////////////////////////////////////////////////////
982 //                                                                                             //
983 // AliCDBLocal Parameter class                                                                 //                                          //
984 //                                                                                             //
985 /////////////////////////////////////////////////////////////////////////////////////////////////
986
987 ClassImp(AliCDBLocalParam)
988
989 //_____________________________________________________________________________
990 AliCDBLocalParam::AliCDBLocalParam():
991  AliCDBParam(),
992  fDBPath()
993  {
994 // default constructor
995
996 }
997
998 //_____________________________________________________________________________
999 AliCDBLocalParam::AliCDBLocalParam(const char* dbPath):
1000  AliCDBParam(),
1001  fDBPath(dbPath)
1002 {
1003 // constructor
1004
1005         SetType("local");
1006         SetURI(TString("local://") + dbPath);
1007 }
1008
1009 //_____________________________________________________________________________
1010 AliCDBLocalParam::~AliCDBLocalParam() {
1011 // destructor
1012
1013 }
1014
1015 //_____________________________________________________________________________
1016 AliCDBParam* AliCDBLocalParam::CloneParam() const {
1017 // clone parameter
1018
1019         return new AliCDBLocalParam(fDBPath);
1020 }
1021
1022 //_____________________________________________________________________________
1023 ULong_t AliCDBLocalParam::Hash() const {
1024 // return Hash function
1025
1026        return fDBPath.Hash();
1027 }
1028
1029 //_____________________________________________________________________________
1030 Bool_t AliCDBLocalParam::IsEqual(const TObject* obj) const {
1031 // check if this object is equal to AliCDBParam obj
1032
1033         if (this == obj) {
1034                 return kTRUE;
1035         }
1036
1037         if (AliCDBLocalParam::Class() != obj->IsA()) {
1038                 return kFALSE;
1039         }
1040
1041         AliCDBLocalParam* other = (AliCDBLocalParam*) obj;
1042
1043         return fDBPath == other->fDBPath;
1044 }
1045