InfrastructureGenerator.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_CORE_INFRASTRUCTUREGENERATOR_H
#define QC_CORE_INFRASTRUCTUREGENERATOR_H

#include <vector>
#include <string>

namespace o2::framework
{
class CompletionPolicy;
}
#include <Framework/WorkflowSpec.h>
#include <Framework/DataProcessorSpec.h>

namespace o2::quality_control
{
namespace core
{

class InfrastructureGenerator
{
 public:
  InfrastructureGenerator() = delete;

  static framework::WorkflowSpec generateStandaloneInfrastructure(std::string configurationSource);

  static void generateStandaloneInfrastructure(framework::WorkflowSpec& workflow, std::string configurationSource);

  static framework::WorkflowSpec generateLocalInfrastructure(std::string configurationSource, std::string host);

  static void generateLocalInfrastructure(framework::WorkflowSpec& workflow, std::string configurationSource, std::string host);

  static o2::framework::WorkflowSpec generateRemoteInfrastructure(std::string configurationSource);

  static void generateRemoteInfrastructure(framework::WorkflowSpec& workflow, std::string configurationSource);

  static void customizeInfrastructure(std::vector<framework::CompletionPolicy>& policies);

  static void printVersion();

 private:
  // Dedicated methods for creating each QC component to hide implementation details.

  static void generateDataSamplingPolicyLocalProxy(framework::WorkflowSpec& workflow,
                                                   const std::string& policyName,
                                                   const framework::Inputs& inputSpecs,
                                                   const std::string& localPort);
  static void generateDataSamplingPolicyRemoteProxy(framework::WorkflowSpec& workflow,
                                                    const framework::Outputs& outputSpecs,
                                                    const std::string& localMachine,
                                                    const std::string& localPort);
  static void generateLocalTaskLocalProxy(framework::WorkflowSpec& workflow,
                                          size_t id,
                                          std::string taskName,
                                          std::string remoteHost,
                                          std::string remotePort);
  static void generateLocalTaskRemoteProxy(framework::WorkflowSpec& workflow,
                                           std::string taskName,
                                           size_t numberOfLocalMachines,
                                           std::string remotePort);
  static void generateMergers(framework::WorkflowSpec& workflow,
                              std::string taskName,
                              size_t numberOfLocalMachines,
                              double cycleDurationSeconds,
                              std::string mergingMode);
  static vector<framework::OutputSpec> generateCheckRunners(framework::WorkflowSpec& workflow, std::string configurationSource);
  static void generateAggregator(framework::WorkflowSpec& workflow, std::string configurationSource, vector<framework::OutputSpec>& checkRunnerOutputs);
  static void generatePostProcessing(framework::WorkflowSpec& workflow, std::string configurationSource);
};

} // namespace core

// exposing the class above as a main QC interface, syntactic sugar

inline framework::WorkflowSpec generateStandaloneInfrastructure(std::string configurationSource)
{
  return core::InfrastructureGenerator::generateStandaloneInfrastructure(configurationSource);
}

inline void generateStandaloneInfrastructure(framework::WorkflowSpec& workflow, std::string configurationSource)
{
  core::InfrastructureGenerator::generateStandaloneInfrastructure(workflow, configurationSource);
}

inline framework::WorkflowSpec generateLocalInfrastructure(std::string configurationSource, std::string host)
{
  return core::InfrastructureGenerator::generateLocalInfrastructure(configurationSource, host);
}

inline void generateLocalInfrastructure(framework::WorkflowSpec& workflow, std::string configurationSource, std::string host)
{
  core::InfrastructureGenerator::generateLocalInfrastructure(workflow, configurationSource, host);
}

inline framework::WorkflowSpec generateRemoteInfrastructure(std::string configurationSource)
{
  return core::InfrastructureGenerator::generateRemoteInfrastructure(configurationSource);
}

inline void generateRemoteInfrastructure(framework::WorkflowSpec& workflow, std::string configurationSource)
{
  core::InfrastructureGenerator::generateRemoteInfrastructure(workflow, configurationSource);
}

inline void customizeInfrastructure(std::vector<framework::CompletionPolicy>& policies)
{
  core::InfrastructureGenerator::customizeInfrastructure(policies);
}

} // namespace o2::quality_control

#endif //QC_CORE_INFRASTRUCTUREGENERATOR_H