QC-1289 Use consistently Bookkeeping facade in QC

The previously implemented token loading mechanism could not work because BookkeepingQualitySink was not using our Bookkeeping facade class, but the BkpClient directly.
This commit makes BookkeepingQualitySink use it, thus take advantage of the token loading which was implemented there.

Author: knopers8

Framework/include/QualityControl/Bookkeeping.h

@@ -23,6 +23,9 @@ namespace o2::quality_control::core
 {
 class Activity;
 
+// \brief A singleton class to handle the bookkeeping service interactions.
+//
+// All calls in QC code to Bookkeeping service should go through this class.
 class Bookkeeping
 {
  public:
@@ -39,6 +42,11 @@ class Bookkeeping
   void init(const std::string& url);
   void registerProcess(int runNumber, const std::string& name, const std::string& detector, bkp::DplProcessType type, const std::string& args);
 
+  // send QC flags to the bookkeeping service
+  std::vector<int> sendFlagsForSynchronous(uint32_t runNumber, const std::string& detectorName, const std::vector<QcFlag>& qcFlags);
+  std::vector<int> sendFlagsForDataPass(uint32_t runNumber, const std::string& passName, const std::string& detectorName, const std::vector<QcFlag>& qcFlags);
+  std::vector<int> sendFlagsForSimulationPass(uint32_t runNumber, const std::string& productionName, const std::string& detectorName, const std::vector<QcFlag>& qcFlags);
+
  private:
   Bookkeeping() = default;
 

Framework/include/QualityControl/BookkeepingQualitySink.h

@@ -39,6 +39,7 @@ class BookkeepingQualitySink : public framework::Task
   // sendCallback is mainly used for testing without the necessity to do grpc calls
   BookkeepingQualitySink(const std::string& grpcUri, Provenance, SendCallback sendCallback = send);
 
+  void init(framework::InitContext&) override;
   void run(framework::ProcessingContext&) override;
 
   void endOfStream(framework::EndOfStreamContext& context) override;

Framework/src/Bookkeeping.cxx

@@ -26,6 +26,17 @@ using namespace o2::bkp::api;
 namespace o2::quality_control::core
 {
 
+std::string readClientToken()
+{
+  if (auto tokenEnv = std::getenv("QC_BKP_CLIENT_TOKEN"); tokenEnv != NULL && std::strlen(tokenEnv) > 0) {
+    ILOG(Info, Ops) << "Using token from environment variable QC_BKP_CLIENT_TOKEN" << ENDM;
+    return tokenEnv;
+  }
+
+  ILOG(Debug, Devel) << "Could not find an env var QC_BKP_CLIENT_TOKEN, using BKP client without an authentication token" << ENDM;
+  return "";
+}
+
 void Bookkeeping::init(const std::string& url)
 {
   if (mInitialized) {
@@ -42,9 +53,11 @@ void Bookkeeping::init(const std::string& url)
     return;
   }
 
+  const auto token = readClientToken();
+
   try {
-    if (auto tokenEnv = std::getenv("QC_BKP_CLIENT_TOKEN"); tokenEnv != NULL) {
-      mClient = BkpClientFactory::create(url, tokenEnv);
+    if (!token.empty()) {
+      mClient = BkpClientFactory::create(url, token);
     } else {
       mClient = BkpClientFactory::create(url);
     }
@@ -79,4 +92,29 @@ void Bookkeeping::registerProcess(int runNumber, const std::string& name, const
   }
   mClient->dplProcessExecution()->registerProcessExecution(runNumber, type, getHostName(), name, args, detector);
 }
+
+std::vector<int> Bookkeeping::sendFlagsForSynchronous(uint32_t runNumber, const std::string& detectorName, const std::vector<QcFlag>& qcFlags)
+{
+  if (!mInitialized) {
+    return {};
+  }
+  return mClient->qcFlag()->createForSynchronous(runNumber, detectorName, qcFlags);
+}
+
+std::vector<int> Bookkeeping::sendFlagsForDataPass(uint32_t runNumber, const std::string& passName, const std::string& detectorName, const std::vector<QcFlag>& qcFlags)
+{
+  if (!mInitialized) {
+    return {};
+  }
+  return mClient->qcFlag()->createForDataPass(runNumber, passName, detectorName, qcFlags);
+}
+
+std::vector<int> Bookkeeping::sendFlagsForSimulationPass(uint32_t runNumber, const std::string& productionName, const std::string& detectorName, const std::vector<QcFlag>& qcFlags)
+{
+  if (!mInitialized) {
+    return {};
+  }
+  return mClient->qcFlag()->createForSimulationPass(runNumber, productionName, detectorName, qcFlags);
+}
+
 } // namespace o2::quality_control::core

Framework/src/BookkeepingQualitySink.cxx

@@ -44,8 +44,7 @@ void BookkeepingQualitySink::customizeInfrastructure(std::vector<framework::Comp
 
 void BookkeepingQualitySink::send(const std::string& grpcUri, const BookkeepingQualitySink::FlagsMap& flags, Provenance provenance)
 {
-  auto bkpClient = o2::bkp::api::BkpClientFactory::create(grpcUri);
-  auto& qcClient = bkpClient->qcFlag();
+  auto& bkpClient = o2::quality_control::core::Bookkeeping::getInstance();
 
   std::optional<int> runNumber;
   std::optional<std::string> passName;
@@ -98,20 +97,19 @@ void BookkeepingQualitySink::send(const std::string& grpcUri, const BookkeepingQ
     try {
       switch (provenance) {
         case Provenance::SyncQC:
-          qcClient->createForSynchronous(runNumber.value(), detector, bkpQcFlags);
+          bkpClient.sendFlagsForSynchronous(runNumber.value(), detector, bkpQcFlags);
           break;
         case Provenance::AsyncQC:
-          qcClient->createForDataPass(runNumber.value(), passName.value(), detector, bkpQcFlags);
+          bkpClient.sendFlagsForDataPass(runNumber.value(), passName.value(), detector, bkpQcFlags);
           break;
         case Provenance::MCQC:
-          qcClient->createForSimulationPass(runNumber.value(), periodName.value(), detector, bkpQcFlags);
+          bkpClient.sendFlagsForSimulationPass(runNumber.value(), periodName.value(), detector, bkpQcFlags);
           break;
       }
+      ILOG(Info, Support) << "Sent " << bkpQcFlags.size() << " flags for detector '" << detector << "'" << ENDM;
     } catch (const std::runtime_error& err) {
-      ILOG(Error, Support) << "Failed to send flags for detector: " << detector
-                           << " with error: " << err.what() << ENDM;
+      ILOG(Error, Support) << "Encountered errors while sending flags for detector '" << detector << "', details: " << err.what() << ENDM;
     }
-    ILOG(Info, Support) << "Sent " << bkpQcFlags.size() << " flags for detector: " << detector << ENDM;
   }
 }
 
@@ -130,6 +128,11 @@ auto collectionForQualityObject(const QualityObject& qualityObject) -> std::uniq
     qualityObject.getActivity().mProvenance);
 }
 
+void BookkeepingQualitySink::init(framework::InitContext& context)
+{
+  o2::quality_control::core::Bookkeeping::getInstance().init(mGrpcUri);
+}
+
 void BookkeepingQualitySink::run(framework::ProcessingContext& context)
 {
   for (auto const& ref : framework::InputRecordWalker(context.inputs())) {