CommandFacility.hpp

Go to the documentation of this file.

 
#ifndef CMDLIB_INCLUDE_CMDLIB_COMMANDFACILITY_HPP_
#define CMDLIB_INCLUDE_CMDLIB_COMMANDFACILITY_HPP_
 
#include "cmdlib/cmd/Nljs.hpp"
#include "CommandedObject.hpp"
#include "Issues.hpp"
 
#include <cetlib/BasicPluginFactory.h>
#include <cetlib/compiler_macros.h>
 
#include <tbb/concurrent_queue.h>
 
#include <future>
#include <functional>
#include <atomic>
#include <memory>
#include <string>
 
#ifndef EXTERN_C_FUNC_DECLARE_START
#define EXTERN_C_FUNC_DECLARE_START                                                                                    \
  extern "C"                                                                                                           \
  {
#endif
 
#define DEFINE_DUNE_COMMAND_FACILITY(klass)                                                                            \
  EXTERN_C_FUNC_DECLARE_START                                                                                          \
  std::unique_ptr<dunedaq::cmdlib::CommandFacility> make()                                                             \
  {                                                                                                                    \
    return std::unique_ptr<dunedaq::cmdlib::CommandFacility>(new klass());                                             \
  }                                                                                                                    \
  }
 
namespace dunedaq::cmdlib {
 
class CommandFacility
{
public:
  explicit CommandFacility(std::string /*uri*/) {}
  virtual ~CommandFacility();
  CommandFacility(const CommandFacility&) =
    delete; 
  CommandFacility& operator=(const CommandFacility&) =
    delete; 
  CommandFacility(CommandFacility&&) =
    delete; 
  CommandFacility& operator=(CommandFacility&&) =
    delete; 
 
  void set_commanded(CommandedObject& commanded, std::string name);
 
  virtual void run(std::atomic<bool>& end_marker) = 0;
 
  void execute_command(const cmdobj_t& cmd, cmd::CommandReply meta);
 
protected:
  virtual void completion_callback(const cmdobj_t& cmd, cmd::CommandReply& meta) = 0;
 
  std::string m_name;
 
private:
 
  void handle_command(const cmdobj_t& cmd, cmd::CommandReply meta);
 
  void executor();
 
  mutable CommandedObject* m_commanded_object = nullptr;
 
 
  typedef tbb::concurrent_queue<std::future<void>> CompletionQueue;
  CompletionQueue m_completion_queue;
 
  typedef std::function<void(const cmdobj_t&, cmd::CommandReply)> CommandCallback;
  CommandCallback m_command_callback = nullptr;
 
  std::atomic<bool> m_active;
 
  std::thread m_executor;
 
};
template <typename... ARGS>
std::shared_ptr<CommandFacility>
make_command_facility(
  std::string const& uri,
  ARGS&&... args)
{
  auto sep = uri.find("://");
  std::string scheme;
  if (sep == std::string::npos) { // simple path
      scheme = "stdin";
  } else { // with scheme
      scheme = uri.substr(0, sep);
  }
  std::string plugin_name = scheme + "CommandFacility";
  static cet::BasicPluginFactory bpf("duneCommandFacility", "make");
  std::shared_ptr<CommandFacility> cf_ptr;
  try {
    cf_ptr = bpf.makePlugin<std::shared_ptr<CommandFacility>>(
      plugin_name,
      uri,
      std::forward<ARGS>(args)...
    );
  } catch (const cet::exception &cexpt) {
    throw CommandFacilityCreationFailed(ERS_HERE, uri, cexpt);
  } catch (const ers::Issue &iexpt) {
    throw CommandFacilityCreationFailed(ERS_HERE, uri, iexpt);
  } catch (...) {  // NOLINT JCF Jan-27-2021 violates letter of the law but not the spirit
    throw CommandFacilityCreationFailed(ERS_HERE, uri, "Unknown error.");
  }
  return cf_ptr;
}
 
} // namespace dunedaq::cmdlib
 
#endif // CMDLIB_INCLUDE_CMDLIB_COMMANDFACILITY_HPP_