Revert "Implement usage of CCDB Redirect"

Author: ehellbar

Detectors/TPC/base/include/TPCBase/CDBTypes.h

@@ -110,7 +110,7 @@ const std::unordered_map<CDBType, const std::string> CDBTypeMap{
   //
   {CDBType::ConfigFEEPad, "TPC/Config/FEEPad"},
   {CDBType::ConfigFEE, "TPC/Config/FEE"},
-  {CDBType::ConfigRunInfo, "TPC/Config/RunInfoV2"},
+  {CDBType::ConfigRunInfo, "TPC/Config/RunInfo"},
   //
   {CDBType::ParDetector, "TPC/Parameter/Detector"},
   {CDBType::ParElectronics, "TPC/Parameter/Electronics"},

Detectors/TPC/base/include/TPCBase/DeadChannelMapCreator.h

@@ -58,11 +58,10 @@ class DeadChannelMapCreator
   void load(long timeStampOrRun);
   void loadFEEConfigViaRunInfoTS(long timeStamp);
   void loadFEEConfigViaRunInfo(long timeStampOrRun);
-  void loadFEEConfig(long timeStamp = -1);
+  void loadFEEConfig(long tag, long createdNotAfter = -1);
   void loadIDCPadFlags(long timeStampOrRun);
 
   void setDeadChannelMapIDCPadStatus(const CalDetFlag_t& padStatusMap, PadFlags mask = PadFlags::flagAllNoneGood);
-  void setDeadChannelMapFEEConfig(const FEEConfig& feeConfig) { mDeadChannelMapFEE = feeConfig.getDeadChannelMap(); }
 
   const CalDet<bool>& getDeadChannelMapIDC() const { return mDeadChannelMapIDC; }
   const CalDet<bool>& getDeadChannelMapFEE() const { return mDeadChannelMapFEE; }

Detectors/TPC/base/src/CDBInterface.cxx

@@ -556,7 +556,7 @@ void CDBInterface::createFEEConfig()
 
   if (!mUseDefaults) {
     LOGP(info, "trying to load default FEEConfig");
-    mDeadChannelMapCreator.loadFEEConfig(1680525888290); // load oldest physics configuration
+    mDeadChannelMapCreator.loadFEEConfig(7, 1680525888290); // load oldest physics configuration
     if (mFEEConfig) {
       return;
     }

Detectors/TPC/base/src/DeadChannelMapCreator.cxx

@@ -43,12 +43,13 @@ void DeadChannelMapCreator::loadFEEConfigViaRunInfoTS(long timeStamp)
   if (mObjectValidity[CDBType::ConfigRunInfo].isValid(timeStamp)) {
     return;
   }
-
   const auto meta = mCCDBApi.retrieveHeaders(CDBTypeMap.at(CDBType::ConfigRunInfo), {}, timeStamp);
   mObjectValidity[CDBType::ConfigRunInfo].startvalidity = std::stol(meta.at("Valid-From"));
   mObjectValidity[CDBType::ConfigRunInfo].endvalidity = std::stol(meta.at("Valid-Until"));
-
-  loadFEEConfig(timeStamp);
+  const long tag = std::stol(meta.at("Tag"));
+  LOGP(info, "Loading FEE config for time stamp {}, via RunInfo with Tag {}, RunType {}, runNumber {}, validity: {} - {}",
+       timeStamp, tag, meta.at("RunType"), meta.at("runNumber"), meta.at("Valid-From"), meta.at("Valid-Until"));
+  loadFEEConfig(tag, timeStamp);
 }
 
 //______________________________________________________________________________
@@ -58,16 +59,13 @@ void DeadChannelMapCreator::loadFEEConfigViaRunInfo(long timeStampOrRun)
 }
 
 //______________________________________________________________________________
-void DeadChannelMapCreator::loadFEEConfig(long timeStamp)
+void DeadChannelMapCreator::loadFEEConfig(long tag, long createdNotAfter)
 {
-  std::map<std::string, std::string> meta;
-  mFEEConfig.reset(mCCDBApi.retrieveFromTFileAny<o2::tpc::FEEConfig>(CDBTypeMap.at(CDBType::ConfigRunInfo), {}, timeStamp, &meta));
-  std::string redirect = "not found";
-  if (meta.find("Redirect") != meta.end()) {
-    redirect = meta.at("Redirect");
-  }
+  std::map<std::string, std::string> mm, meta;
+  const std::string createdNotAfterS = (createdNotAfter < 0) ? "" : std::to_string(createdNotAfter);
+  mFEEConfig.reset(mCCDBApi.retrieveFromTFileAny<o2::tpc::FEEConfig>(CDBTypeMap.at(CDBType::ConfigFEE), mm, tag, &meta, "", createdNotAfterS));
   if (!mFEEConfig) {
-    LOGP(error, "Could not load {} redirected from {} with Redirect={}, createdNotAfter: {}", CDBTypeMap.at(CDBType::ConfigFEE), CDBTypeMap.at(CDBType::ConfigRunInfo), redirect, timeStamp);
+    LOGP(error, "Could not load {}/{}, createdNotAfter: {}", CDBTypeMap.at(CDBType::ConfigFEE), tag, createdNotAfterS);
     return;
   }
   LOGP(info, "Using FEE config for Tag {}, ETag {}, Last-Modified {}", meta.at("Valid-From"), meta.at("ETag"), meta.at("Last-Modified"));

Detectors/TPC/dcs/src/DCSConfigSpec.cxx

@@ -189,28 +189,18 @@ void DCSConfigDevice::updateRunInfo(gsl::span<const char> configBuff)
     LOGP(error, "{} has wrong format: {}, expected: {}, not writing RunInformation to CCDB", RunInfoFileName, line, runInfoConf);
     return;
   }
-  const auto tagString = data[2];
-  //
-  // retrieve ETag from FEEConfig to set up Redirect
-  const auto headers = mCCDBApi.retrieveHeaders(CDBTypeMap.at(CDBType::ConfigFEE), {}, std::stol(tagString));
-
   std::map<std::string, std::string> md;
   md[o2::base::NameConf::CCDBRunTag.data()] = data[0];
+  md["Tag"] = data[2];
   md["RunType"] = data[3];
   md[o2::ccdb::CcdbObjectInfo::AdjustableEOV] = "true";
-  if (headers.find("ETag") != headers.end()) {
-    auto etag = headers.at("ETag");
-    etag.erase(std::remove(etag.begin(), etag.end(), '"'), etag.end());
-    md["Redirect"] = fmt::format("/{}/{}/{}", CDBTypeMap.at(CDBType::ConfigFEE), tagString, etag);
-  } else {
-    LOGP(error, "No ETag found for Tag {}, not setting Redirect in RunInfo", tagString);
-  }
+  char tempChar{static_cast<char>(std::stoi(md["Tag"]))};
 
   const long startValRCT = std::stol(data[1]);
   const long endValRCT = startValRCT + 48l * 60l * 60l * 1000l;
   if (!mDontWriteRunInfo) {
     o2::ccdb::CcdbObjectInfo w(CDBTypeMap.at(CDBType::ConfigRunInfo), "", "", md, startValRCT, endValRCT);
-    mCCDBApi.storeAsBinaryFile(nullptr, 0, "ignored", "", CDBTypeMap.at(CDBType::ConfigRunInfo), md, startValRCT, endValRCT);
+    mCCDBApi.storeAsBinaryFile(&tempChar, sizeof(tempChar), "tmp.dat", "char", CDBTypeMap.at(CDBType::ConfigRunInfo), md, startValRCT, endValRCT);
     if (!mCCDBApi.isSnapshotMode()) {
       o2::ccdb::adjustOverriddenEOV(mCCDBApi, w);
     }
@@ -265,7 +255,7 @@ void DCSConfigDevice::fillFEEPad(std::string_view configFileName, gsl::span<cons
     nLines = cru_calib_helpers::fillCalPad<2>(calPad, configBuff);
     mFEEPadDataReceived.set(3);
   } else if (configFileName == "CMkValues") {
-    nLines = cru_calib_helpers::fillCalPad<0>(calPad, configBuff);
+    nLines = cru_calib_helpers::fillCalPad<6>(calPad, configBuff);
     mFEEPadDataReceived.set(4);
   }
 

GPU/Workflow/src/GPUWorkflowTPC.cxx

@@ -281,15 +281,11 @@ void GPURecoWorkflowSpec::finaliseCCDBTPC(ConcreteDataMatcher& matcher, void* ob
          mTPCDeadChannelMapCreator->getDeadChannelMapIDC().getSum<int32_t>(), mTPCDeadChannelMapCreator->getDeadChannelMap().getSum<int32_t>());
   } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "TPCRUNINFO", 0)) {
     copyCalibsToBuffer();
-    const auto* fee = static_cast<o2::tpc::FEEConfig*>(obj);
-    mTPCDeadChannelMapCreator->setDeadChannelMapFEEConfig(*fee);
+    mTPCDeadChannelMapCreator->loadFEEConfigViaRunInfoTS(mCreationForCalib);
     mTPCDeadChannelMapCreator->finalizeDeadChannelMap();
     mdEdxCalibContainerBufferNew.get()->setDeadChannelMap(mTPCDeadChannelMapCreator->getDeadChannelMap());
-    LOGP(info,
-         "Updating dead channel map with the FEE info (tag {}) loaded via TPCRUNINFO"
-         " for creation time {}: {} / {} dead pads from FEE info / total, with",
-         std::underlying_type_t<o2::tpc::FEEConfig::Tags>(fee->tag), mCreationForCalib,
-         mTPCDeadChannelMapCreator->getDeadChannelMapFEE().getSum<int32_t>(), mTPCDeadChannelMapCreator->getDeadChannelMap().getSum<int32_t>());
+    LOGP(info, "Updating dead channel map with the FEE info loaded via TPCRUNINFO for creation time {}: {} / {} dead pads from FEE info / total",
+         mCreationForCalib, mTPCDeadChannelMapCreator->getDeadChannelMapFEE().getSum<int32_t>(), mTPCDeadChannelMapCreator->getDeadChannelMap().getSum<int32_t>());
   } else if (mTPCVDriftHelper->accountCCDBInputs(matcher, obj)) {
   } else if (mCalibObjects.mFastTransformHelper->accountCCDBInputs(matcher, obj)) {
   }
@@ -325,7 +321,7 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC<GPUCalibObjectsConst>(ProcessingCon
       }
 
       if (mTPCDeadChannelMapCreator->useSource(tpc::SourcesDeadMap::FEEConfig)) {
-        pc.inputs().get<o2::tpc::FEEConfig*>("tpcruninfo");
+        pc.inputs().get<char*>("tpcruninfo");
       }
 
       if (dEdxCalibContainer->isCorrectionCCDB(o2::tpc::CalibsdEdx::CalResidualGainMap)) {