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