Add stop agent

micro_ros_agent/CMakeLists.txt

@@ -14,9 +14,6 @@
 
 cmake_minimum_required(VERSION 3.5)
 
-option(BUILD_SHARED_LIBS "Control shared/static building." ON)
-option(UBUILD_AGENT_EXECUTABLE "Control shared/static building." ON)
-
 option(UROSAGENT_GENERATE_PROFILE
   "Generates agent.refs according to the .msgs provided in the .repos" OFF
   )
@@ -44,26 +41,15 @@ find_package(ament_cmake_gtest REQUIRED)
 
 find_package(micro_ros_msgs REQUIRED)
 
-include(GNUInstallDirs)
+add_executable(${PROJECT_NAME}
-set(BIN_INSTALL_DIR     ${CMAKE_INSTALL_BINDIR}     CACHE PATH "Installation directory for binaries")
+  src/main.cpp
-set(INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE PATH "Installation directory for C headers")
-set(LIB_INSTALL_DIR     ${CMAKE_INSTALL_LIBDIR}     CACHE PATH "Installation directory for libraries")
-set(DATA_INSTALL_DIR    ${CMAKE_INSTALL_DATADIR}    CACHE PATH "Installation directory for data")
-
-# Set source files
-set(SRCS
   src/agent/Agent.cpp
   src/agent/graph_manager/graph_manager.cpp
   src/agent/graph_manager/graph_typesupport.cpp
   src/agent/utils/demangle.cpp
   )
 
-# Library
+target_include_directories(${PROJECT_NAME}
-add_library(${PROJECT_NAME} ${SRCS})
-
-target_include_directories(${PROJECT_NAME} BEFORE
-  PUBLIC
-    $<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>
   PRIVATE
     include
   )
@@ -90,9 +76,9 @@ target_link_libraries(${PROJECT_NAME}
 
 target_compile_options(${PROJECT_NAME}
   PRIVATE
-    $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wall>
+    $<$<C_COMPILER_ID:GNU>:-Wall>
-    $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wextra>
+    $<$<C_COMPILER_ID:GNU>:-Wextra>
-    $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wpedantic>
+    $<$<C_COMPILER_ID:GNU>:-pedantic>
   )
 
 set_target_properties(${PROJECT_NAME} PROPERTIES
@@ -102,98 +88,38 @@ set_target_properties(${PROJECT_NAME} PROPERTIES
     YES
   )
 
-# Install agent lib
+set_target_properties(${PROJECT_NAME} PROPERTIES
-install(
+  CXX_STANDARD
-    TARGETS
+    14
-        ${PROJECT_NAME}
+  CXX_STANDARD_REQUIRED
-    EXPORT
+    YES
-        ${PROJECT_NAME}Targets
-    RUNTIME DESTINATION
-        ${BIN_INSTALL_DIR}
-    LIBRARY DESTINATION
-        ${LIB_INSTALL_DIR}
-    ARCHIVE DESTINATION
-        ${LIB_INSTALL_DIR}
-    COMPONENT
-        libraries
-    )
-
-# Install includes
-install(
-    DIRECTORY
-        ${PROJECT_SOURCE_DIR}/include/agent
-    DESTINATION
-        ${INCLUDE_INSTALL_DIR}
-    FILES_MATCHING
-        PATTERN "*.hpp"
-        PATTERN "*.h"
-    )
-
-# Export library
-install(
-  EXPORT
-      ${PROJECT_NAME}Targets
-  DESTINATION
-      ${DATA_INSTALL_DIR}/${PROJECT_NAME}/cmake
   )
 
-# Package configuration
+target_compile_options(${PROJECT_NAME}
-include(CMakePackageConfigHelpers)
+  PRIVATE
-
+    $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wall>
-configure_package_config_file(
+    $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wextra>
-      ${PROJECT_SOURCE_DIR}/cmake/Config.cmake.in
+    $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wpedantic>
-        ${PROJECT_BINARY_DIR}/cmake/config/${PROJECT_NAME}Config.cmake
-    INSTALL_DESTINATION
-        ${DATA_INSTALL_DIR}/${PROJECT_NAME}/cmake
-    PATH_VARS
-        BIN_INSTALL_DIR
-        INCLUDE_INSTALL_DIR
-        LIB_INSTALL_DIR
-        DATA_INSTALL_DIR
-    )
-
-install(
-  FILES
-      ${PROJECT_BINARY_DIR}/cmake/config/${PROJECT_NAME}Config.cmake
-  DESTINATION
-      ${DATA_INSTALL_DIR}/${PROJECT_NAME}/cmake
   )
 
-if(UBUILD_AGENT_EXECUTABLE)
-  add_executable(micro_ros_agent_bin
-    ${SRCS}
-    src/main.cpp
-    )
-
-  target_include_directories(micro_ros_agent_bin
-    PRIVATE
-      $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-    )
-
-  target_link_libraries(micro_ros_agent_bin ${PROJECT_NAME})
-
-  set_target_properties(micro_ros_agent_bin
-      PROPERTIES OUTPUT_NAME ${PROJECT_NAME})
-
-  install(
-    TARGETS
-      micro_ros_agent_bin
-    DESTINATION
-      lib/${PROJECT_NAME}
-    )
-
-  install(
-    DIRECTORY
-      launch
-    DESTINATION
-      share/${PROJECT_NAME}
-    )
-endif()
-
 ament_export_dependencies(microxrcedds_agent)
 
 ament_package()
 
+install(
+  TARGETS
+    ${PROJECT_NAME}
+  DESTINATION
+    lib/${PROJECT_NAME}
+  )
+
+install(
+  DIRECTORY
+    launch
+  DESTINATION
+    share/${PROJECT_NAME}
+  )
+
 if(UROSAGENT_GENERATE_PROFILE)
   set(_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}/python")
 

micro_ros_agent/include/agent/Agent.hpp

@@ -26,26 +26,35 @@ namespace agent {
 
 class Agent
 {
-private:
+public:
+
     Agent();
 
-    ~Agent()
+    ~Agent() = default;
-    {
-        stop();
-    }
 
-    Agent(const Agent &) = delete;
+    /**
-
+     * @brief   Agent class shall not be copy constructible.
-    Agent(Agent &&) = delete;
+     */
-
+    UXR_AGENT_EXPORT Agent(
-    Agent& operator =(
             const Agent &) = delete;
 
-    Agent& operator =(
+    UXR_AGENT_EXPORT Agent(
             Agent &&) = delete;
 
-public:
+    /**
-    static Agent& getInstance();
+     * @brief   Agent class shall not be copy assignable.
+     */
+    UXR_AGENT_EXPORT Agent& operator =(
+            const Agent &) = delete;
+
+    UXR_AGENT_EXPORT Agent& operator =(
+            Agent &&) = delete;
+
+    static Agent& getInstance()
+    {
+        static Agent instance;
+        return instance;
+    }
 
     bool create(
             int argc,
@@ -55,14 +64,71 @@ public:
 
     void stop();
 
-private:
+    void add_callbacks();
-    bool initialized = false;
-    eprosima::uxr::AgentInstance& xrce_dds_agent_instance_;
-    std::map<eprosima::fastdds::dds::DomainId_t, graph_manager::GraphManager> graph_manager_map_;
 
-    graph_manager::GraphManager* find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t domain_id);
+private:
+    eprosima::uxr::AgentInstance& xrce_dds_agent_instance_;
+    std::map<eprosima::fastdds::dds::DomainId_t, std::shared_ptr<graph_manager::GraphManager>> graph_manager_map_;
+    std::shared_ptr<graph_manager::GraphManager> find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t domain_id);
+    bool started = false;
 };
 
+template<typename AgentType>
+class AgentAPI
+{
+public:
+    AgentAPI()
+    : agent_instance_(agent_instance_.getInstance())
+    {};
+
+    ~AgentAPI() = default;
+
+    void create(uint16_t port)
+	{
+		xrce_dds_agent_instance_API.configure(port);
+	}
+
+	void create(std::string dev, const std::string baudrate);
+	void create(std::vector<std::string> devs, const std::string baudrate);
+	void create(const std::string baudrate);
+
+    void set_verbose_level(uint8_t verbose_level)
+    {
+        xrce_dds_agent_instance_API.set_verbose_level(verbose_level);
+    }
+
+    void run()
+    {
+        agent_instance_.add_callbacks();
+        xrce_dds_agent_instance_API.run();
+    }
+
+    void stop()
+    {
+        xrce_dds_agent_instance_API.stop();
+    }
+
+private:
+    Agent& agent_instance_;
+    eprosima::uxr::AgentInstanceAPI<AgentType> xrce_dds_agent_instance_API;
+};
+
+template<> inline UXR_AGENT_EXPORT void AgentAPI<eprosima::uxr::TermiosAgent>::create(std::string dev, const std::string baudrate)
+{
+    xrce_dds_agent_instance_API.configure(dev, baudrate);
+}
+
+template<> inline UXR_AGENT_EXPORT void AgentAPI<eprosima::uxr::MultiTermiosAgent>::create(std::vector<std::string> devs, const std::string baudrate)
+{
+    xrce_dds_agent_instance_API.configure(devs, baudrate);
+
+}
+
+template<> inline UXR_AGENT_EXPORT void AgentAPI<eprosima::uxr::PseudoTerminalAgent>::create(const std::string baudrate)
+{
+    xrce_dds_agent_instance_API.configure(baudrate);
+}
+
 }  // namespace agent
 }  // namespace uros
 #endif  // _UROS_AGENT_AGENT_HPP

micro_ros_agent/include/agent/graph_manager/graph_manager.hpp

@@ -80,29 +80,16 @@ public:
     /**
      * @brief   Default destructor.
      */
-    ~GraphManager() = default;
+    ~GraphManager()
+    {
+        exit = true;
+        cv_.notify_one();
 
-	void stop()
+        if (microros_graph_publisher_.joinable())
-	{
+        {
-		if (microros_graph_publisher_.joinable())
+            microros_graph_publisher_.join();
-		{
+        }
-			exit = true;
+    }
-			cv_.notify_one();
-			microros_graph_publisher_.join();
-		}
-
-		subscriber_->delete_datareader(ros_discovery_datareader_);
-		publisher_->delete_datawriter(ros_to_microros_graph_datawriter_);
-
-		participant_->delete_subscriber(subscriber_);
-		participant_->delete_publisher(publisher_);
-
-		// Delete topics
-		participant_->delete_topic(ros_discovery_topic_);
-		participant_->delete_topic(ros_to_microros_graph_topic_);
-
-		eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->delete_participant(participant_);
-	}
 
     /**
      * @brief   Implementation of the notification logic that updates the micro-ROS graph.
@@ -320,33 +307,34 @@ private:
             std::string& node_name,
             std::string& node_namespace);
 
+    bool exit = false;
     eprosima::fastdds::dds::DomainId_t domain_id_;
     bool graph_changed_;
     bool display_on_change_;
     std::thread microros_graph_publisher_;
     std::mutex mtx_;
     std::condition_variable cv_;
-    volatile bool exit = false;
 
     eprosima::fastdds::dds::DataWriterQos datawriter_qos_;
 
     rmw_dds_common::GraphCache graphCache_;
-    ParticipantListener participant_listener_;
+    std::unique_ptr<ParticipantListener> participant_listener_;
-    DatareaderListener datareader_listener_;
+    std::unique_ptr<DatareaderListener> datareader_listener_;
+
+    std::unique_ptr<eprosima::fastdds::dds::TypeSupport> participant_info_typesupport_;
+    std::unique_ptr<eprosima::fastdds::dds::TypeSupport> microros_graph_info_typesupport_;
+    std::unique_ptr<eprosima::fastdds::dds::DomainParticipant> participant_;
+    std::unique_ptr<eprosima::fastdds::dds::Publisher> publisher_;
+    std::unique_ptr<eprosima::fastdds::dds::Subscriber> subscriber_;
+    std::unique_ptr<eprosima::fastdds::dds::Topic> ros_discovery_topic_;
+    std::unique_ptr<eprosima::fastdds::dds::Topic> ros_to_microros_graph_topic_;
+    std::unique_ptr<eprosima::fastdds::dds::DataWriter> ros_to_microros_graph_datawriter_;
+    std::unique_ptr<eprosima::fastdds::dds::DataReader> ros_discovery_datareader_;
 
-    eprosima::fastdds::dds::TypeSupport participant_info_typesupport_;
-    eprosima::fastdds::dds::TypeSupport microros_graph_info_typesupport_;
-    eprosima::fastdds::dds::DomainParticipant* participant_;
-    eprosima::fastdds::dds::Publisher* publisher_;
-    eprosima::fastdds::dds::Subscriber* subscriber_;
-    eprosima::fastdds::dds::Topic* ros_discovery_topic_;
-    eprosima::fastdds::dds::Topic* ros_to_microros_graph_topic_;
-    eprosima::fastdds::dds::DataWriter* ros_to_microros_graph_datawriter_;
-    eprosima::fastdds::dds::DataReader* ros_discovery_datareader_;
     // Store a auxiliary publishers and datawriter for each participant created in micro-ROS
     std::map<
         const eprosima::fastdds::dds::DomainParticipant*,
-        eprosima::fastdds::dds::DataWriter*
+        std::unique_ptr<eprosima::fastdds::dds::DataWriter>
     > micro_ros_graph_datawriters_;
 };
 

micro_ros_agent/src/agent/Agent.cpp

@@ -25,22 +25,17 @@ Agent::Agent()
 {
 }
 
-Agent& Agent::getInstance()
-{
-    static Agent instance;
-    return instance;
-}
-
 bool Agent::create(
         int argc,
         char** argv)
 {
-    bool result = xrce_dds_agent_instance_.create(argc, argv);
+    return xrce_dds_agent_instance_.create(argc, argv);
+}
 
-    if (result && !initialized)
+void Agent::add_callbacks()
+{
+    if (!started)
     {
-        initialized = true;
-
         /**
          * Add CREATE_PARTICIPANT callback.
          */
@@ -109,7 +104,6 @@ bool Agent::create(
                 const eprosima::fastdds::dds::DomainParticipant* participant,
                 const eprosima::fastdds::dds::DataWriter* datawriter) -> void
             {
-
                 auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
 
                 // TODO(jamoralp): Workaround for Fast-DDS bug #9977. Remove when fixed
@@ -175,36 +169,35 @@ bool Agent::create(
             eprosima::uxr::Middleware::Kind::FASTDDS,
             eprosima::uxr::middleware::CallbackKind::DELETE_DATAREADER,
             std::move(on_delete_datareader));
-    }
 
-    return result;
+        started = true;
+    }
 }
 
 void Agent::run()
 {
-    xrce_dds_agent_instance_.run();
+    return xrce_dds_agent_instance_.run();
 }
 
 void Agent::stop()
 {
-    xrce_dds_agent_instance_.stop();
+    return xrce_dds_agent_instance_.stop();
-
-    for (auto & element : graph_manager_map_)
-    {
-        element.second.stop();
-    }
-
-    graph_manager_map_.clear();
 }
 
-graph_manager::GraphManager* Agent::find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t domain_id)
+std::shared_ptr<graph_manager::GraphManager> Agent::find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t domain_id)
 {
-    auto it = graph_manager_map_.find(domain_id);
+
+auto it = graph_manager_map_.find(domain_id);
 
     if (it != graph_manager_map_.end()) {
-        return &it->second;
+        return it->second;
     }else{
-        return &graph_manager_map_.emplace(domain_id, domain_id).first->second;
+        return graph_manager_map_.insert(
+            std::make_pair(
+                domain_id,
+                std::make_shared<graph_manager::GraphManager>(domain_id)
+            )
+        ).first->second;
     }
 }
 

micro_ros_agent/src/agent/graph_manager/graph_manager.cpp

@@ -28,14 +28,14 @@ GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
     , mtx_()
     , cv_()
     , graphCache_()
-    , participant_listener_(this)
+    , participant_listener_(std::make_unique<ParticipantListener>(this))
-    , datareader_listener_(this)
+    , datareader_listener_(std::make_unique<DatareaderListener>(this))
-    , participant_info_typesupport_()
+    , participant_info_typesupport_(std::make_unique<
-    , microros_graph_info_typesupport_()
+        eprosima::fastdds::dds::TypeSupport>(new graph_manager::ParticipantEntitiesInfoTypeSupport()))
+    , microros_graph_info_typesupport_(std::make_unique<
+        eprosima::fastdds::dds::TypeSupport>(new graph_manager::MicrorosGraphInfoTypeSupport()))
 {
     eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->load_profiles();
-    participant_info_typesupport_ = (eprosima::fastdds::dds::TypeSupport) new graph_manager::ParticipantEntitiesInfoTypeSupport();
-    microros_graph_info_typesupport_ = (eprosima::fastdds::dds::TypeSupport) new graph_manager::MicrorosGraphInfoTypeSupport();
 
     // Create DomainParticipant
     eprosima::fastdds::dds::DomainParticipantQos participant_qos =
@@ -54,29 +54,29 @@ GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
         eprosima::fastrtps::rtps::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
 
     eprosima::fastdds::dds::StatusMask par_mask = eprosima::fastdds::dds::StatusMask::none();
-    participant_ = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->
+    participant_.reset(eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->
-        create_participant(domain_id_, participant_qos, &participant_listener_, par_mask);
+        create_participant(domain_id_, participant_qos, participant_listener_.get(), par_mask));
 
     // Register participant within typesupport
-    participant_->register_type(participant_info_typesupport_);
+    participant_->register_type(*participant_info_typesupport_);
-    participant_->register_type(microros_graph_info_typesupport_);
+    participant_->register_type(*microros_graph_info_typesupport_);
 
     // Create publisher
-    publisher_ = participant_->create_publisher(
+    publisher_.reset(participant_->create_publisher(
-        eprosima::fastdds::dds::PUBLISHER_QOS_DEFAULT);
+        eprosima::fastdds::dds::PUBLISHER_QOS_DEFAULT));
 
     // Create subscriber
-    subscriber_ = participant_->create_subscriber(
+    subscriber_.reset(participant_->create_subscriber(
-        eprosima::fastdds::dds::SUBSCRIBER_QOS_DEFAULT);
+        eprosima::fastdds::dds::SUBSCRIBER_QOS_DEFAULT));
 
     // Create topics
-    ros_discovery_topic_ = participant_->create_topic("ros_discovery_info",
+    ros_discovery_topic_.reset(participant_->create_topic("ros_discovery_info",
-        participant_info_typesupport_.get_type_name(),
+        participant_info_typesupport_->get_type_name(),
-        eprosima::fastdds::dds::TOPIC_QOS_DEFAULT);
+        eprosima::fastdds::dds::TOPIC_QOS_DEFAULT));
 
-    ros_to_microros_graph_topic_ = participant_->create_topic("ros_to_microros_graph",
+    ros_to_microros_graph_topic_.reset(participant_->create_topic("ros_to_microros_graph",
-        microros_graph_info_typesupport_.get_type_name(),
+        microros_graph_info_typesupport_->get_type_name(),
-        eprosima::fastdds::dds::TOPIC_QOS_DEFAULT);
+        eprosima::fastdds::dds::TOPIC_QOS_DEFAULT));
 
     // Create datawriters
     datawriter_qos_ =
@@ -97,8 +97,8 @@ GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
     eprosima::fastdds::dds::DataWriterQos ros_to_microros_datawriter_qos_ = datawriter_qos_;
     ros_to_microros_datawriter_qos_.history().kind =
         eprosima::fastdds::dds::HistoryQosPolicyKind::KEEP_ALL_HISTORY_QOS;
-    ros_to_microros_graph_datawriter_ = 
+    ros_to_microros_graph_datawriter_.reset(
-        publisher_->create_datawriter(ros_to_microros_graph_topic_, ros_to_microros_datawriter_qos_);
+        publisher_->create_datawriter(ros_to_microros_graph_topic_.get(), ros_to_microros_datawriter_qos_));
 
     // Create datareaders
 
@@ -114,9 +114,9 @@ GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
     datareader_qos.durability().kind =
         eprosima::fastdds::dds::DurabilityQosPolicyKind::TRANSIENT_LOCAL_DURABILITY_QOS;
 
-    ros_discovery_datareader_ = 
+    ros_discovery_datareader_.reset(
-        subscriber_->create_datareader(ros_discovery_topic_,
+        subscriber_->create_datareader(ros_discovery_topic_.get(),
-            datareader_qos, &datareader_listener_);
+            datareader_qos, datareader_listener_.get()));
 
     // Set graph cache on change callback function
     graphCache_.set_on_change_callback([this]()
@@ -320,8 +320,8 @@ void GraphManager::add_participant(
         if (it == micro_ros_graph_datawriters_.end())
         {
             // Create datawriter
-            eprosima::fastdds::dds::DataWriter* datawriter;
+            std::unique_ptr<eprosima::fastdds::dds::DataWriter> datawriter;
-            datawriter = publisher_->create_datawriter(ros_discovery_topic_, datawriter_qos_);
+            datawriter.reset(publisher_->create_datawriter(ros_discovery_topic_.get(), datawriter_qos_));
 
             it = micro_ros_graph_datawriters_.insert(
                 std::make_pair(participant, std::move(datawriter))).first;
@@ -344,10 +344,8 @@ void GraphManager::remove_participant(
         rmw_dds_common::convert_gid_to_msg(&gid, &info.gid);
         auto it = micro_ros_graph_datawriters_.find(participant);
         it->second->write(static_cast<void *>(&info));
-
-        publisher_->delete_datawriter(it->second);
-        micro_ros_graph_datawriters_.erase(participant);
     }
+    micro_ros_graph_datawriters_.erase(participant);
 }
 
 void GraphManager::add_datawriter(

micro_ros_agent/src/main.cpp

@@ -16,7 +16,7 @@
 
 int main(int argc, char** argv)
 {
-    uros::agent::Agent& micro_ros_agent = micro_ros_agent.getInstance();
+    uros::agent::Agent micro_ros_agent;
 
     /** Bypass '--ros-args' flag, as we use our own CLI parser.
       * As a workaround for launch files, arguments will be passed from