CheckRunner.h

Go to the documentation of this file.

// Copyright CERN and copyright holders of ALICE O2. This software is
// distributed under the terms of the GNU General Public License v3 (GPL
// Version 3), copied verbatim in the file "COPYING".
//
// See http://alice-o2.web.cern.ch/license for full licensing information.
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.


#ifndef QC_CHECKER_CHECKRUNNER_H
#define QC_CHECKER_CHECKRUNNER_H

// std & boost
#include <chrono>
#include <memory>
#include <string>
#include <map>
#include <vector>
#include <unordered_set>
// O2
#include <Common/Timer.h>
#include <Framework/Task.h>
#include <Headers/DataHeader.h>
#include <Monitoring/MonitoringFactory.h>
#include <Configuration/ConfigurationInterface.h>
#include <Framework/DataProcessorSpec.h>
// QC
#include "QualityControl/CheckInterface.h"
#include "QualityControl/DatabaseInterface.h"
#include "QualityControl/MonitorObject.h"
#include "QualityControl/QcInfoLogger.h"
#include "QualityControl/Check.h"
#include "QualityControl/UpdatePolicyManager.h"

namespace o2::quality_control::core
{
class ServiceDiscovery;
}

namespace o2::framework
{
struct InputSpec;
struct OutputSpec;
class DataAllocator;
} // namespace o2::framework

namespace o2::monitoring
{
class Monitoring;
}

class TClass;

namespace o2::quality_control::checker
{

class CheckRunner : public framework::Task
{
 public:

  CheckRunner(std::vector<Check> checks, std::string configurationSource);

  CheckRunner(o2::framework::InputSpec input, std::string configurationSource);

  ~CheckRunner() override;

  void init(framework::InitContext& ctx) override;

  void run(framework::ProcessingContext& ctx) override;

  framework::Inputs getInputs() { return mInputs; };
  framework::Outputs getOutputs() { return mOutputs; };

  void setTaskStoreSet(std::unordered_set<std::string> storeSet) { mInputStoreSet = storeSet; }
  std::string getDeviceName() { return mDeviceName; };

  static o2::header::DataDescription createCheckRunnerDataDescription(const std::string taskName);
  static o2::framework::Inputs createInputSpec(const std::string checkName, const std::string configSource);

  static std::string createCheckRunnerIdString() { return "QC-CHECK-RUNNER"; };
  static std::string createCheckRunnerName(std::vector<Check> checks);
  static std::string createSinkCheckRunnerName(o2::framework::InputSpec input);

 private:
  QualityObjectsType check();

  void store(QualityObjectsType& qualityObjects);

  void store(std::vector<std::shared_ptr<MonitorObject>>& monitorObjects);

  void send(QualityObjectsType& qualityObjects, framework::DataAllocator& allocator);

  static o2::framework::Outputs collectOutputs(const std::vector<Check>& checks);

  inline void initDatabase();
  inline void initMonitoring();
  inline void initServiceDiscovery();

  void updateServiceDiscovery(const QualityObjectsType& qualityObjects);

  static std::size_t hash(std::string input_string);

  void prepareCacheData(framework::InputRecord& inputRecord);
  void sendPeriodicMonitoring();

  // General state
  std::string mDeviceName;
  std::vector<Check> mChecks;
  o2::quality_control::core::QcInfoLogger& mLogger;
  std::shared_ptr<o2::quality_control::repository::DatabaseInterface> mDatabase;
  std::unordered_set<std::string> mInputStoreSet;
  std::vector<std::shared_ptr<MonitorObject>> mMonitorObjectStoreVector;
  std::shared_ptr<o2::configuration::ConfigurationInterface> mConfigFile;
  UpdatePolicyManager updatePolicyManager;

  // DPL
  o2::framework::Inputs mInputs;
  o2::framework::Outputs mOutputs;

  // Checks cache
  std::map<std::string, std::shared_ptr<MonitorObject>> mMonitorObjects;

  // Service discovery
  std::shared_ptr<ServiceDiscovery> mServiceDiscovery;
  std::unordered_set<std::string> mListAllQOPaths; // store the names of all the QOs the Checks have generated so far

  // monitoring
  std::shared_ptr<o2::monitoring::Monitoring> mCollector;
  int mTotalNumberObjectsReceived;
  int mTotalNumberCheckExecuted;
  int mTotalNumberQOStored;
  int mTotalNumberMOStored;
  AliceO2::Common::Timer mTimer;
};

} // namespace o2::quality_control::checker

#endif // QC_CHECKER_CHECKRUNNER_H