runner_base.hpp

Go to the documentation of this file.

#pragma once
 
#include <stdexcept>
#include <string>
#include <functional>
 
#include <rclcpp/rclcpp.hpp>
 
#include <capabilities2_events/event_node.hpp>
#include <capabilities2_events/event_parameters.hpp>
 
#include <capabilities2_msgs/msg/capability.hpp>
#include <capabilities2_msgs/msg/capability_event_code.hpp>
 
namespace capabilities2_runner
{
struct runner_exception : public std::runtime_error
{
  using std::runtime_error::runtime_error;
 
  runner_exception(const std::string& what) : std::runtime_error(what)
  {
  }
 
  virtual const char* what() const noexcept override
  {
    return std::runtime_error::what();
  }
};
 
struct resource
{
  std::string name;
  std::string resource_type;
  std::string msg_type;
};
 
struct runner_opts
{
  std::string interface;
  std::string provider;
  std::vector<resource> resources;
  std::string global_namespace;
  std::string runner;
  std::string started_by;
  std::string pid;
  int input_count;
};
 
class RunnerBase : public capabilities2_events::EventNode
{
public:
  RunnerBase() : node_(nullptr), run_config_()
  {
  }
 
  ~RunnerBase() = default;
 
  // incorporates event callbacks
 
  virtual void start(rclcpp::Node::SharedPtr node, const runner_opts& run_config, const std::string& bond_id) = 0;
 
  virtual void stop(const std::string& bond_id, const std::string& instance_id = "") = 0;
 
  virtual void trigger(capabilities2_events::EventParameters& parameters, const std::string& bond_id,
                       const std::string& instance_id) = 0;
 
  void init_base(rclcpp::Node::SharedPtr node, const runner_opts& run_config)
  {
    // store node connection source
    capabilities2_msgs::msg::Capability source_capability;
    source_capability.capability = run_config.interface;
    source_capability.provider = run_config.provider;
    set_source(source_capability);
 
    // store node pointer and opts
    node_ = node;
    run_config_ = run_config;
  }
 
  void enable_events(std::shared_ptr<capabilities2_events::EventBase> events)
  {
    if (!is_event_emitter_set())
    {
      set_event_emitter(events);
    }
  }
 
  void add_connection(const std::string& connection_id, const capabilities2_msgs::msg::CapabilityEventCode& type,
                      const capabilities2_msgs::msg::Capability& target,
                      std::function<void(const std::string&, const std::string&, const std::string&,
                                         capabilities2_events::EventParameters)>
                          callback)
  {
    EventNode::add_connection(connection_id, type, target, callback);
  }
 
  const std::string get_package_name()
  {
    return run_config_.interface.substr(0, run_config_.interface.find("/"));
  }
 
  const std::string& get_interface() const
  {
    return run_config_.interface;
  }
 
  const std::string& get_provider() const
  {
    return run_config_.provider;
  }
 
  const std::string& get_started_by() const
  {
    return run_config_.started_by;
  }
 
  const std::string& get_pid() const
  {
    return run_config_.pid;
  }
 
protected:
  // FIXME: implement new event subsystem
 
  virtual capabilities2_events::EventParameters param_on_started()
  {
    return capabilities2_events::EventParameters();
  };
 
  virtual capabilities2_events::EventParameters param_on_stopped()
  {
    return capabilities2_events::EventParameters();
  };
 
  virtual capabilities2_events::EventParameters param_on_failure()
  {
    return capabilities2_events::EventParameters();
  };
 
  virtual capabilities2_events::EventParameters param_on_success()
  {
    return capabilities2_events::EventParameters();
  };
 
  // run config getters
 
  const std::string get_resource_name_by_type(const std::string& resource_type, const std::string& msg_type) const
  {
    for (const auto& resource : run_config_.resources)
    {
      if (resource.resource_type == resource_type)
      {
        if (resource.msg_type == msg_type)
        {
          return resource.name;
        }
      }
    }
 
    throw runner_exception("no resource found: " + msg_type);
  }
 
  const std::string get_parameter_name_by_type(const std::string& param_type) const
  {
    return get_resource_name_by_type("parameter", param_type);
  }
 
  const std::string get_topic_name_by_type(const std::string& topic_type) const
  {
    return get_resource_name_by_type("topic", topic_type);
  }
 
  const std::string get_service_name_by_type(const std::string& srv_type) const
  {
    return get_resource_name_by_type("service", srv_type);
  }
 
  const std::string get_action_name_by_type(const std::string& action_type) const
  {
    return get_resource_name_by_type("action", action_type);
  }
 
  const std::string get_first_resource_name(const std::string& resource_type) const
  {
    for (const auto& resource : run_config_.resources)
    {
      if (resource.resource_type == resource_type)
      {
        return resource.name;
      }
    }
 
    throw runner_exception("no " + resource_type + " resource found for interface: " + run_config_.interface);
  }
 
  const std::string get_first_parameter_name() const
  {
    return get_first_resource_name("parameter");
  }
 
  const std::string get_first_topic_name() const
  {
    return get_first_resource_name("topic");
  }
 
  const std::string get_first_service_name() const
  {
    return get_first_resource_name("service");
  }
 
  const std::string get_first_action_name() const
  {
    return get_first_resource_name("action");
  }
 
  // FIXME: implement new event subsystem
  // STATE CHANGE HELPERS
 
  void emit_started(const std::string& bond_id, const std::string& instance_id,
                    capabilities2_events::EventParameters parameters = capabilities2_events::EventParameters())
  {
    RCLCPP_INFO(node_->get_logger(), "emitting STARTED event with bond_id: %s", bond_id.c_str());
    emit_event(bond_id, instance_id, capabilities2_msgs::msg::CapabilityEventCode::STARTED, parameters);
  }
 
  void emit_stopped(const std::string& bond_id, const std::string& instance_id,
                    capabilities2_events::EventParameters parameters = capabilities2_events::EventParameters())
  {
    RCLCPP_INFO(node_->get_logger(), "emitting STOPPED event with bond_id: %s", bond_id.c_str());
    emit_event(bond_id, instance_id, capabilities2_msgs::msg::CapabilityEventCode::STOPPED, parameters);
  }
 
  void emit_succeeded(const std::string& bond_id, const std::string& instance_id,
                      capabilities2_events::EventParameters parameters = capabilities2_events::EventParameters())
  {
    RCLCPP_INFO(node_->get_logger(), "emitting SUCCEEDED event with bond_id: %s", bond_id.c_str());
    emit_event(bond_id, instance_id, capabilities2_msgs::msg::CapabilityEventCode::SUCCEEDED, parameters);
  }
 
  void emit_failed(const std::string& bond_id, const std::string& instance_id,
                   capabilities2_events::EventParameters parameters = capabilities2_events::EventParameters())
  {
    RCLCPP_INFO(node_->get_logger(), "emitting FAILED event with bond_id: %s", bond_id.c_str());
    emit_event(bond_id, instance_id, capabilities2_msgs::msg::CapabilityEventCode::FAILED, parameters);
  }
 
protected:
  rclcpp::Node::SharedPtr node_;
 
  runner_opts run_config_;
};
 
}  // namespace capabilities2_runner