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