o2-ecs-grp-create creates CTP/Config if --original-run <run> passed at SOR

Will clone the CTP/Config/Config of (replayed) original-run with the credentials of the new synthetic run

Author: shahor02

Detectors/GRP/workflows/CMakeLists.txt

@@ -45,6 +45,7 @@ o2_add_executable(grp-create
                   SOURCES src/create-grp-ecs.cxx
                   PUBLIC_LINK_LIBRARIES O2::DetectorsCommonDataFormats
                                         O2::DataFormatsParameters
+                                        O2::DataFormatsCTP
                                         O2::CommonUtils
                                         O2::CCDB
                                         Boost::program_options)

Detectors/GRP/workflows/src/create-grp-ecs.cxx

@@ -15,8 +15,10 @@
 #include <regex>
 #include <TSystem.h>
 #include "DataFormatsParameters/GRPECSObject.h"
+#include "DataFormatsCTP/Configuration.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "CCDB/CcdbApi.h"
+#include "CCDB/BasicCCDBManager.h"
 #include "CommonUtils/NameConf.h"
 #include "CommonUtils/StringUtils.h"
 
@@ -31,6 +33,7 @@ enum CCDBRefreshMode { NONE,
 
 int createGRPECSObject(const std::string& dataPeriod,
                        int run,
+                       int runOrig, // in case of replay
                        int runTypeI,
                        int nHBPerTF,
                        const std::string& _detsReadout,
@@ -50,6 +53,7 @@ int createGRPECSObject(const std::string& dataPeriod,
   int retValGLO = 0;
   int retValRCT = 0;
   int retValGLOmd = 0;
+  int retValCTP = 0;
 
   // substitute TRG by CTP
   std::regex regCTP(R"((^\s*|,\s*)(TRG)(\s*,|\s*$))");
@@ -120,9 +124,8 @@ int createGRPECSObject(const std::string& dataPeriod,
   };
 
   toKeyValPairs(metaDataStr);
-
+  CcdbApi api;
   if (!ccdbServer.empty()) {
-    CcdbApi api;
     const std::string objPath{"GLO/Config/GRPECS"};
     api.init(ccdbServer);
     metadata["responsible"] = "ECS";
@@ -181,21 +184,46 @@ int createGRPECSObject(const std::string& dataPeriod,
         }
       }
     }
+
+    if (runOrig > 0 && runOrig != run && tend < tstart) { // create CTP config
+      try {
+        auto& bcm = o2::ccdb::BasicCCDBManager::instance();
+        bcm.setURL(ccdbServer);
+        bcm.setFatalWhenNull(false);
+        auto ctpConfOrig = bcm.getForRun<o2::ctp::CTPConfiguration>("CTP/Config/Config", runOrig);
+        if (!ctpConfOrig) {
+          throw std::runtime_error(fmt::format("Failed to access CTP/Config/Config for original run {}", runOrig));
+        }
+        ctpConfOrig->setRunNumber(run);
+        std::map<std::string, std::string> metadataCTP;
+        metadataCTP["runNumber"] = fmt::format("{}", run);
+        metadataCTP["comment"] = fmt::format("cloned from run {}", runOrig);
+        retValCTP = api.storeAsTFileAny(ctpConfOrig, "CTP/Config/Config", metadataCTP, tstart, tendVal);
+        if (retValCTP == 0) {
+          LOGP(info, "Uploaded to {}/{} with validity {}:{} for SOR:{}/EOR:{}, cloned from run {}", ccdbServer, "CTP/Config/Config", tstart, tendVal, tstart, tend, runOrig);
+        } else {
+          LOGP(alarm, "Upload to {}/{} with validity {}:{} for SOR:{}/EOR:{} (cloned from run {}) FAILED, returned with code {}", ccdbServer, "CTP/Config/Config", tstart, tendVal, tstart, tend, runOrig, retValCTP);
+        }
+      } catch (std::exception e) {
+        LOGP(error, "Failed to create CTP/Config/Config from the original run {}, reason: {}", runOrig, e.what());
+        return false;
+      }
+    }
   } else { // write a local file
     auto fname = o2::base::NameConf::getGRPECSFileName();
     TFile grpF(fname.c_str(), "recreate");
     grpF.WriteObjectAny(&grpecs, grpecs.Class(), o2::base::NameConf::CCDBOBJECT.data());
     LOG(info) << "Stored to local file " << fname;
   }
-  //
+
   if (refresh != CCDBRefreshMode::NONE && !ccdbServer.empty()) {
     auto cmd = fmt::format("curl -I -i -s \"{}{}latest/%5Cw%7B3%7D/.*/`date +%s000`/?prepare={}\"", ccdbServer, ccdbServer.back() == '/' ? "" : "/", refresh == CCDBRefreshMode::SYNC ? "sync" : "true");
     auto t0 = std::chrono::high_resolution_clock::now();
     auto res = gSystem->Exec(cmd.c_str());
     auto t1 = std::chrono::high_resolution_clock::now();
     LOGP(info, "Executed [{}] -> {} in {:.3f} s", cmd, res, std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count() / 1000.f);
   }
-  if (retValGLO != 0 || retValRCT != 0 || retValGLOmd != 0) {
+  if (retValGLO != 0 || retValRCT != 0 || retValGLOmd != 0 || retValCTP != 0) {
     return 4;
   }
   return 0;
@@ -233,6 +261,7 @@ int main(int argc, char** argv)
     add_option("refresh", bpo::value<string>()->default_value("")->implicit_value("async"), R"(refresh server cache after upload: "none" (or ""), "async" (non-blocking) and "sync" (blocking))");
     add_option("marginSOR", bpo::value<long>()->default_value(4 * o2::ccdb::CcdbObjectInfo::DAY), "validity at SOR");
     add_option("marginEOR", bpo::value<long>()->default_value(10 * o2::ccdb::CcdbObjectInfo::MINUTE), "validity margin to add after EOR");
+    add_option("original-run,o", bpo::value<int>()->default_value(0), "if >0, use as the source run to create CTP/Config/Config object");
     opt_all.add(opt_general).add(opt_hidden);
     bpo::store(bpo::command_line_parser(argc, argv).options(opt_all).positional(opt_pos).run(), vm);
 
@@ -278,6 +307,7 @@ int main(int argc, char** argv)
   int retVal = createGRPECSObject(
     vm["period"].as<std::string>(),
     vm["run"].as<int>(),
+    vm["original-run"].as<int>(),
     vm["run-type"].as<int>(),
     vm["hbf-per-tf"].as<int>(),
     vm["detectors"].as<std::string>(),