Update graph destructor

* Fix graph manager datawriters

Fixes

Fix

Fix destruction

* Revert "Fix graph manager datawriters"

This reverts commit 2847a2ebc3.

* Initial

(cherry picked from commit 646ca52aab)

Co-authored-by: Pablo Garrido <pablogs9@gmail.com>

.github/ISSUE_TEMPLATE/general-issue.md

@@ -0,0 +1,24 @@
+---
+name: General issue
+about: General issue template for micro-ROS
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+## Issue template
+
+- Hardware description: <!-- hardware where you are using micro-ROS -->
+- RTOS: <!-- RTOS where you are using micro-ROS -->
+- Installation type: <!-- micro_ros_setup, modules, etc  -->
+- Version or commit hash: <!-- version of micro-ROS used: foxy, rolling  -->
+
+#### Steps to reproduce the issue
+<!-- Detailed instructions on how to reliably reproduce this issue http://sscce.org/-->
+
+#### Expected behavior
+
+#### Actual behavior
+
+#### Additional information

.github/workflows/ci.yml

@@ -9,24 +9,30 @@ jobs:
 
     microros_agent_ci:
         runs-on: ubuntu-20.04
-        container: microros/base:foxy
+        container: microros/base:rolling
 
         steps:
+        - uses: actions/checkout@v2
+          with:
+            path: urosagent
+
         - name: Download dependencies
           run: |
+            apt update
             cd /uros_ws
-            . /opt/ros/foxy/setup.sh
+            . /opt/ros/$ROS_DISTRO/setup.sh
             . install/local_setup.sh
             rosdep update
             ros2 run micro_ros_setup create_agent_ws.sh 
- 
-        - uses: actions/checkout@v2
-          with:
-            path: src/uros/micro-ROS-Agent
+        
+        - name: Patch branch
+          run: |
+            rm -rf /uros_ws/src/uros/micro-ROS-Agent/*
+            cp -R urosagent/* /uros_ws/src/uros/micro-ROS-Agent/
 
         - name: Build
           run:  |
             cd /uros_ws
-            . /opt/ros/foxy/setup.sh
+            . /opt/ros/$ROS_DISTRO/setup.sh
             . install/local_setup.sh
             ros2 run micro_ros_setup build_agent.sh 

README.md

@@ -11,7 +11,7 @@ This repository contains the Micro-ROS Agent package.
 Micro-ROS Agent is a ROS 2 node that wraps the Micro XRCE-DDS Agent.
 For further information about Micro XRCE-DDS Agent click [here](https://github.com/eProsima/Micro-XRCE-DDS-Agent)
 This package is a part of the Micro-ROS project stack.
-For more information about Micro-ROS project click [here](https://microros.github.io/micro-ROS/).
+For more information about Micro-ROS project click [here](https://micro-ros.github.io/).
 
 The node acts as a server between DDS Network and Micro-ROS nodes inside MCU.
 It receives and send messages from Micro-ROS nodes, and keep track of the Micro-ROS nodes exposing them to the ROS 2 network.

micro_ros_agent/CMakeLists.txt

@@ -14,6 +14,9 @@
 
 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
   )
@@ -41,15 +44,26 @@ find_package(ament_cmake_gtest REQUIRED)
 
 find_package(micro_ros_msgs REQUIRED)
 
-add_executable(${PROJECT_NAME}
-  src/main.cpp
+include(GNUInstallDirs)
+set(BIN_INSTALL_DIR     ${CMAKE_INSTALL_BINDIR}     CACHE PATH "Installation directory for binaries")
+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
   )
 
-target_include_directories(${PROJECT_NAME}
+# Library
+add_library(${PROJECT_NAME} ${SRCS})
+
+target_include_directories(${PROJECT_NAME} BEFORE
+  PUBLIC
+    $<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>
   PRIVATE
     include
   )
@@ -74,27 +88,6 @@ target_link_libraries(${PROJECT_NAME}
   $<$<BOOL:$<PLATFORM_ID:Linux>>:dl>
   )
 
-target_compile_options(${PROJECT_NAME}
-  PRIVATE
-    $<$<C_COMPILER_ID:GNU>:-Wall>
-    $<$<C_COMPILER_ID:GNU>:-Wextra>
-    $<$<C_COMPILER_ID:GNU>:-pedantic>
-  )
-
-set_target_properties(${PROJECT_NAME} PROPERTIES
-  CXX_STANDARD
-    14
-  CXX_STANDARD_REQUIRED
-    YES
-  )
-
-set_target_properties(${PROJECT_NAME} PROPERTIES
-  CXX_STANDARD
-    14
-  CXX_STANDARD_REQUIRED
-    YES
-  )
-
 target_compile_options(${PROJECT_NAME}
   PRIVATE
     $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wall>
@@ -102,17 +95,105 @@ target_compile_options(${PROJECT_NAME}
     $<$<OR:$<CXX_COMPILER_ID:GNU>,$<CXX_COMPILER_ID:Clang>>:-Wpedantic>
   )
 
+set_target_properties(${PROJECT_NAME} PROPERTIES
+  CXX_STANDARD
+    14
+  CXX_STANDARD_REQUIRED
+    YES
+  )
+
+# Install agent lib
+install(
+    TARGETS
+        ${PROJECT_NAME}
+    EXPORT
+        ${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
+include(CMakePackageConfigHelpers)
+
+configure_package_config_file(
+      ${PROJECT_SOURCE_DIR}/cmake/Config.cmake.in
+        ${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}
-  )
-
 if(UROSAGENT_GENERATE_PROFILE)
   set(_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}/python")
 
@@ -122,7 +203,7 @@ if(UROSAGENT_GENERATE_PROFILE)
   set(_XML_DEFAULT_READ_BIN "${_OUTPUT_PATH}/bin/Xml_read_default_profiles.py")
   normalize_path(_XML_DEFAULT_READ_BIN "${_XML_DEFAULT_READ_BIN}")
 
-  set(_PYTHON_PKG_TOOL ${PROJECT_NAME})
+  set(_PYTHON_PKG_TOOL utils)
 
   set(_RESOURCE_DIR "${_OUTPUT_PATH}/resource")
   normalize_path(_RESOURCE_DIR "${_RESOURCE_DIR}")
@@ -198,7 +279,7 @@ from ${_PYTHON_PKG_TOOL} import *
   endforeach()
 
   execute_process(
-    COMMAND 
+    COMMAND
       "${PYTHON_EXECUTABLE}" "${_XML_DEFAULT_READ_BIN}" "--default-xml-path" "${_RESOURCE_DIR}"
     OUTPUT_VARIABLE
       _XmlDoc
@@ -207,7 +288,7 @@ from ${_PYTHON_PKG_TOOL} import *
     )
 
   if(NOT _result EQUAL 0)
-    message(FATAL_ERROR "Error in typesuppor generation") 
+    message(FATAL_ERROR "Error in typesupport generation")
   endif()
 
   foreach(package ${_packages})
@@ -241,7 +322,7 @@ from ${_PYTHON_PKG_TOOL} import *
       )
 
     if(NOT _result EQUAL 0)
-      message(FATAL_ERROR "Error in typesuppor generation") 
+      message(FATAL_ERROR "Error in typesupport generation")
     endif()
 
     set(_XmlDoc "${_XmlDoc}${_XmlGen}")

micro_ros_agent/cmake/Config.cmake.in

@@ -0,0 +1,32 @@
+# Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set(@PROJECT_NAME@_VERSION @PROJECT_VERSION@)
+
+@PACKAGE_INIT@
+
+if(MSVC OR MSVC_IDE)
+    set_and_check(@PROJECT_NAME@_BIN_DIR "@PACKAGE_BIN_INSTALL_DIR@")
+endif()
+set_and_check(@PROJECT_NAME@_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
+set_and_check(@PROJECT_NAME@_LIB_DIR "@PACKAGE_LIB_INSTALL_DIR@")
+set_and_check(@PROJECT_NAME@_DATA_DIR "@PACKAGE_DATA_INSTALL_DIR@")
+
+foreach(d @_deps@)
+    list(GET d 0 _name)
+    list(GET d 1 _version)
+    find_package(${_name} ${_version} REQUIRED)
+endforeach()
+
+include(${@PROJECT_NAME@_DATA_DIR}/@PROJECT_NAME@/cmake/@PROJECT_NAME@Targets.cmake)

micro_ros_agent/include/agent/Agent.hpp

@@ -26,11 +26,26 @@ namespace agent {
 
 class Agent
 {
-public:
-
+private:
     Agent();
 
-    ~Agent() = default;
+    ~Agent()
+    {
+        stop();
+    }
+    
+    Agent(const Agent &) = delete;
+
+    Agent(Agent &&) = delete;
+
+    Agent& operator =(
+            const Agent &) = delete;
+
+    Agent& operator =(
+            Agent &&) = delete;
+
+public:
+    static Agent& getInstance();
 
     bool create(
             int argc,
@@ -38,10 +53,14 @@ public:
 
     void run();
 
-private:
+    void stop();
 
+private:
+    bool initialized = false;
     eprosima::uxr::AgentInstance& xrce_dds_agent_instance_;
-    std::unique_ptr<graph_manager::GraphManager> graph_manager_;
+    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);
 };
 
 }  // namespace agent

micro_ros_agent/include/agent/graph_manager/graph_manager.hpp

@@ -75,13 +75,35 @@ public:
     /**
      * @brief   Default constructor.
      */
-    GraphManager();
+    GraphManager(eprosima::fastdds::dds::DomainId_t domain_id);
 
     /**
      * @brief   Default destructor.
      */
     ~GraphManager() = default;
 
+	void stop()
+	{
+		if (microros_graph_publisher_.joinable())
+		{
+			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.
      */
@@ -89,28 +111,22 @@ public:
 
     /**
      * @brief   Adds a DDS participant to the graph tree.
-     * @param   participant Pointer to the participant to be added to the graph.
-     */
-    void add_participant(
-            const eprosima::fastdds::dds::DomainParticipant* participant);
-
-    /**
-     * @brief   Adds a DDS participant to the graph tree.
-     * @param   guid rtps::GUID_t of the participant to be added.
-     * @param   node_name Name of the ROS 2 node associated to the given participant.
+     * @param   participant eprosima::fastdds::dds::DomainParticipant to be added.
+     * @param   from_microros if this participant has been added from micro-ROS.
      * @param   enclave ROS 2 enclave.
      */
     void add_participant(
-            const eprosima::fastrtps::rtps::GUID_t& guid,
-            const std::string& node_name,
-            const std::string& enclave);
+            const eprosima::fastdds::dds::DomainParticipant* participant,
+            bool from_microros = true,
+            const std::string& enclave = "/");
 
     /**
      * @brief   Removes a DDS participant from the graph tree.
-     * @param   guid rtps::GUID_t of the participant to be removed.
+     * @param   participant eprosima::fastdds::dds::DomainParticipant to be removed.
      */
     void remove_participant(
-            const eprosima::fastrtps::rtps::GUID_t& guid);
+        const eprosima::fastdds::dds::DomainParticipant* participant,
+        bool from_microros = true);
 
     /**
      * @brief   Adds a DDS datawriter to the graph tree.
@@ -138,21 +154,6 @@ public:
             const eprosima::fastrtps::rtps::GUID_t& participant_guid,
             const eprosima::fastdds::dds::DataWriterQos& writer_qos);
 
-    /**
-     * @brief   Adds a DDS datawriter to the graph tree.
-     * @param   datawriter_guid rtps::GUID_t of the datawriter to be added.
-     * @param   topic_name Name of the topic to which the datawriter sends information to.
-     * @param   type_name Type name of the sent topic.
-     * @param   participant_guid rtps::GUID_t of the participant which owns this datawriter.
-     * @param   writer_qos QOS of the datawriter to be included into the graph tree.
-     */
-    void add_datawriter(
-            const eprosima::fastrtps::rtps::GUID_t& datawriter_guid,
-            const std::string& topic_name,
-            const std::string& type_name,
-            const eprosima::fastrtps::rtps::GUID_t& participant_guid,
-            const eprosima::fastdds::dds::WriterQos& writer_qos);
-
     /**
      * @brief   Removes a DDS datawriter from the graph tree.
      * @param   datawriter_guid rtps::GUID_t of the datawriter to be removed.
@@ -186,21 +187,6 @@ public:
             const eprosima::fastrtps::rtps::GUID_t& participant_guid,
             const eprosima::fastdds::dds::DataReaderQos& reader_qos);
 
-    /**
-     * @brief   Adds a DDS datareader to the graph tree.
-     * @param   datareader_guid rtps::GUID_t of the datareader to be added.
-     * @param   topic_name Name of the topic to which the datareader sends information to.
-     * @param   type_name Type name of the sent topic.
-     * @param   participant_guid rtps::GUID_t of the participant which owns this datareader.
-     * @param   writer_qos QOS of the datareader to be included into the graph tree.
-     */
-    void add_datareader(
-            const eprosima::fastrtps::rtps::GUID_t& datareader_guid,
-            const std::string& topic_name,
-            const std::string& type_name,
-            const eprosima::fastrtps::rtps::GUID_t& participant_guid,
-            const eprosima::fastdds::dds::ReaderQos& reader_qos);
-
     /**
      * @brief   Removes a DDS datareader from the graph tree.
      * @param   datareader_guid rtps::GUID_t of the datareader to be removed.
@@ -292,31 +278,51 @@ private:
      */
     void update_node_entities_info();
 
+    /**
+     * @brief   Retrieves node name and namespace from
+     *          participant.
+     * @param   participant_name DDS participant name.
+     * @param   node_name ROS2 Node name.
+     * @param   namespace ROS2 Node namespace.
+     */
+    void get_name_and_namespace(
+            std::string participant_name,
+            std::string& node_name,
+            std::string& node_namespace);
+
+    eprosima::fastdds::dds::DomainId_t domain_id_;
     bool graph_changed_;
     bool display_on_change_;
-    const char * enclave_;
     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_;
-    std::unique_ptr<ParticipantListener> participant_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_discovery_datawriter_;
-    std::unique_ptr<eprosima::fastdds::dds::DataWriter> ros_to_microros_graph_datawriter_;
-    std::unique_ptr<eprosima::fastdds::dds::DataReader> ros_discovery_datareader_;
+    ParticipantListener participant_listener_;
+    DatareaderListener datareader_listener_;
+
+    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*
+    > micro_ros_graph_datawriters_;
 };
 
 }  // namespace graph_manager
 }  // namespace agent
 }  // namespace uros
 
-#endif  // _UROS_AGENT_GRAPH_MANAGER_HPP
+#endif  // _UROS_AGENT_GRAPH_MANAGER_HPP

micro_ros_agent/launch/micro_ros_agent_launch.py

@@ -0,0 +1,12 @@
+from launch import LaunchDescription
+from launch_ros.actions import Node
+
+def generate_launch_description():
+    return LaunchDescription([
+        Node(
+            package='micro_ros_agent',
+            executable='micro_ros_agent',
+            name='micro_ros_agent',
+            arguments={"udp4", "-p", "8888", "-v6"}
+        )
+    ])

micro_ros_agent/src/agent/Agent.cpp

@@ -22,18 +22,24 @@ namespace agent {
 
 Agent::Agent()
     : xrce_dds_agent_instance_(xrce_dds_agent_instance_.getInstance())
-    , graph_manager_(nullptr)
 {
 }
 
+Agent& Agent::getInstance()
+{
+    static Agent instance;
+    return instance;
+}
+
 bool Agent::create(
         int argc,
         char** argv)
 {
     bool result = xrce_dds_agent_instance_.create(argc, argv);
-    if (result)
+
+    if (result && !initialized)
     {
-        graph_manager_.reset(new graph_manager::GraphManager());
+        initialized = true;
 
         /**
          * Add CREATE_PARTICIPANT callback.
@@ -43,6 +49,7 @@ bool Agent::create(
             ([&](
                 const eprosima::fastdds::dds::DomainParticipant* participant) -> void
             {
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
                 graph_manager_->add_participant(participant);
             });
         xrce_dds_agent_instance_.add_middleware_callback(
@@ -58,7 +65,8 @@ bool Agent::create(
             ([&](
                 const eprosima::fastdds::dds::DomainParticipant* participant) -> void
             {
-                graph_manager_->remove_participant(participant->guid());
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
+                graph_manager_->remove_participant(participant);
             });
         xrce_dds_agent_instance_.add_middleware_callback(
             eprosima::uxr::Middleware::Kind::FASTDDS,
@@ -75,6 +83,8 @@ 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
                 const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
                     datawriter->get_instance_handle();
@@ -96,9 +106,12 @@ bool Agent::create(
             const eprosima::fastdds::dds::DomainParticipant *,
             const eprosima::fastdds::dds::DataWriter *)> on_delete_datawriter
             ([&](
-                const eprosima::fastdds::dds::DomainParticipant* /*participant*/,
+                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
                 const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
                     datawriter->get_instance_handle();
@@ -122,6 +135,8 @@ bool Agent::create(
                 const eprosima::fastdds::dds::DomainParticipant* participant,
                 const eprosima::fastdds::dds::DataReader* datareader) -> void
             {
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
+
                 // TODO(jamoralp): Workaround for Fast-DDS bug #9977. Remove when fixed
                 const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
                     datareader->get_instance_handle();
@@ -143,9 +158,11 @@ bool Agent::create(
             const eprosima::fastdds::dds::DomainParticipant *,
             const eprosima::fastdds::dds::DataReader *)> on_delete_datareader
             ([&](
-                const eprosima::fastdds::dds::DomainParticipant* /*participant*/,
+                const eprosima::fastdds::dds::DomainParticipant* participant,
                 const eprosima::fastdds::dds::DataReader* datareader) -> void
             {
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
+
                 // TODO(jamoralp): Workaround for Fast-DDS bug #9977. Remove when fixed
                 const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
                     datareader->get_instance_handle();
@@ -165,7 +182,30 @@ bool Agent::create(
 
 void Agent::run()
 {
-    return xrce_dds_agent_instance_.run();
+    xrce_dds_agent_instance_.run();
+}
+
+void Agent::stop()
+{
+    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)
+{
+    auto it = graph_manager_map_.find(domain_id);
+
+    if (it != graph_manager_map_.end()) {
+        return &it->second;
+    }else{
+        return &graph_manager_map_.emplace(domain_id, domain_id).first->second;
+    }
 }
 
 }  // namespace agent

micro_ros_agent/src/agent/graph_manager/graph_manager.cpp

@@ -21,85 +21,87 @@ namespace uros {
 namespace agent {
 namespace graph_manager {
 
-GraphManager::GraphManager()
-    // : eprosima::fastrtps::ParticipantListener()
-    : graph_changed_(false)
+GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
+    : domain_id_(domain_id)
+    , graph_changed_(false)
     , display_on_change_(false)
-    , enclave_("/")
     , mtx_()
     , cv_()
     , graphCache_()
-    , participant_listener_(std::make_unique<ParticipantListener>(this))
-    , datareader_listener_(std::make_unique<DatareaderListener>(this))
-    , participant_info_typesupport_(std::make_unique<
-        eprosima::fastdds::dds::TypeSupport>(new graph_manager::ParticipantEntitiesInfoTypeSupport()))
-    , microros_graph_info_typesupport_(std::make_unique<
-        eprosima::fastdds::dds::TypeSupport>(new graph_manager::MicrorosGraphInfoTypeSupport()))
+    , participant_listener_(this)
+    , datareader_listener_(this)
+    , participant_info_typesupport_()
+    , microros_graph_info_typesupport_()
 {
-    // Create DomainParticipant
-    eprosima::fastdds::dds::DomainId_t domain_id(0);
+    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 =
         eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->get_default_participant_qos();
 
-    size_t length = snprintf(nullptr, 0, "enclave=%s;", enclave_) + 1;
+    const char * enclave = "/";
+    size_t length = snprintf(nullptr, 0, "enclave=%s;", enclave) + 1;
     participant_qos.user_data().resize(length);
     snprintf(reinterpret_cast<char *>(participant_qos.user_data().data_vec().data()),
-        length, "enclave=%s;", enclave_);
+        length, "enclave=%s;", enclave);
 
-    participant_qos.name(enclave_);
+    participant_qos.name(enclave);
     participant_qos.wire_protocol().builtin.readerHistoryMemoryPolicy =
         eprosima::fastrtps::rtps::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
     participant_qos.wire_protocol().builtin.writerHistoryMemoryPolicy =
         eprosima::fastrtps::rtps::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
 
-    participant_.reset(eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->
-        create_participant(domain_id, participant_qos, participant_listener_.get()));
+    eprosima::fastdds::dds::StatusMask par_mask = eprosima::fastdds::dds::StatusMask::none();
+
+    participant_ = eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->
+        create_participant(domain_id_, participant_qos, &participant_listener_, par_mask);
 
     // Register participant within typesupport
-    participant_->register_type(*participant_info_typesupport_);
-    participant_->register_type(*microros_graph_info_typesupport_);
+    participant_->register_type(participant_info_typesupport_);
+    participant_->register_type(microros_graph_info_typesupport_);
 
     // Create publisher
-    publisher_.reset(participant_->create_publisher(
-        eprosima::fastdds::dds::PUBLISHER_QOS_DEFAULT));
+    publisher_ = participant_->create_publisher(
+        eprosima::fastdds::dds::PUBLISHER_QOS_DEFAULT);
 
     // Create subscriber
-    subscriber_.reset(participant_->create_subscriber(
-        eprosima::fastdds::dds::SUBSCRIBER_QOS_DEFAULT));
+    subscriber_ = participant_->create_subscriber(
+        eprosima::fastdds::dds::SUBSCRIBER_QOS_DEFAULT);
 
     // Create topics
-    ros_discovery_topic_.reset(participant_->create_topic("ros_discovery_info",
-        participant_info_typesupport_->get_type_name(),
-        eprosima::fastdds::dds::TOPIC_QOS_DEFAULT));
+    ros_discovery_topic_ = participant_->create_topic("ros_discovery_info",
+        participant_info_typesupport_.get_type_name(),
+        eprosima::fastdds::dds::TOPIC_QOS_DEFAULT);
 
-    ros_to_microros_graph_topic_.reset(participant_->create_topic("ros_to_microros_graph",
-        microros_graph_info_typesupport_->get_type_name(),
-        eprosima::fastdds::dds::TOPIC_QOS_DEFAULT));
+    ros_to_microros_graph_topic_ = participant_->create_topic("ros_to_microros_graph",
+        microros_graph_info_typesupport_.get_type_name(),
+        eprosima::fastdds::dds::TOPIC_QOS_DEFAULT);
 
     // Create datawriters
-    eprosima::fastdds::dds::DataWriterQos datawriter_qos =
+    datawriter_qos_ =
         eprosima::fastdds::dds::DATAWRITER_QOS_DEFAULT;
 
-    datawriter_qos.history().kind =
+    datawriter_qos_.history().kind =
         eprosima::fastdds::dds::HistoryQosPolicyKind::KEEP_LAST_HISTORY_QOS;
-    datawriter_qos.history().depth = 1;
-    datawriter_qos.endpoint().history_memory_policy =
+    datawriter_qos_.history().depth = 1;
+    datawriter_qos_.endpoint().history_memory_policy =
         eprosima::fastrtps::rtps::MemoryManagementPolicy::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
-    datawriter_qos.publish_mode().kind =
+    datawriter_qos_.publish_mode().kind =
         eprosima::fastdds::dds::PublishModeQosPolicyKind::ASYNCHRONOUS_PUBLISH_MODE;
-    datawriter_qos.reliability().kind =
+    datawriter_qos_.reliability().kind =
         eprosima::fastdds::dds::ReliabilityQosPolicyKind::RELIABLE_RELIABILITY_QOS;
-    datawriter_qos.durability().kind =
+    datawriter_qos_.durability().kind =
         eprosima::fastdds::dds::DurabilityQosPolicyKind::TRANSIENT_LOCAL_DURABILITY_QOS;
 
-    ros_discovery_datawriter_.reset(
-        publisher_->create_datawriter(ros_discovery_topic_.get(), datawriter_qos));
-
-    datawriter_qos.history().kind =
+    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_.reset(
-        publisher_->create_datawriter(ros_to_microros_graph_topic_.get(), datawriter_qos));
+
+    ros_to_microros_graph_datawriter_ = 
+        publisher_->create_datawriter(ros_to_microros_graph_topic_, ros_to_microros_datawriter_qos_);
 
     // Create datareaders
 
@@ -115,9 +117,9 @@ GraphManager::GraphManager()
     datareader_qos.durability().kind =
         eprosima::fastdds::dds::DurabilityQosPolicyKind::TRANSIENT_LOCAL_DURABILITY_QOS;
 
-    ros_discovery_datareader_.reset(
-        subscriber_->create_datareader(ros_discovery_topic_.get(),
-            datareader_qos, datareader_listener_.get()));
+    ros_discovery_datareader_ = 
+        subscriber_->create_datareader(ros_discovery_topic_,
+            datareader_qos, &datareader_listener_);
 
     // Set graph cache on change callback function
     graphCache_.set_on_change_callback([this]()
@@ -138,10 +140,15 @@ inline void GraphManager::publish_microros_graph()
             std::unique_lock<std::mutex> lock(mtx_);
             cv_.wait(lock, [this]()
             {
-                return this->graph_changed_;
+                return this->graph_changed_ || exit;
             });
         }
 
+        if (exit)
+        {
+            break;
+        }
+
         if (display_on_change_)
         {
             std::cout << "Updated uros Graph: graph changed" << std::endl;
@@ -293,34 +300,57 @@ inline void GraphManager::publish_microros_graph()
 }
 
 void GraphManager::add_participant(
-        const eprosima::fastdds::dds::DomainParticipant* participant)
-{
-    const eprosima::fastdds::dds::DomainParticipantQos qos = participant->get_qos();
-    this->add_participant(participant->guid(), qos.name().to_string(), enclave_);
-}
-
-void GraphManager::add_participant(
-        const eprosima::fastrtps::rtps::GUID_t& guid,
-        const std::string& node_name,
+        const eprosima::fastdds::dds::DomainParticipant* participant,
+        bool from_microros,
         const std::string& enclave)
 {
-    const rmw_gid_t gid = rmw_fastrtps_shared_cpp::create_rmw_gid("rmw_fastrtps_cpp", guid);
+    const eprosima::fastdds::dds::DomainParticipantQos qos = participant->get_qos();
+    const rmw_gid_t gid = rmw_fastrtps_shared_cpp::create_rmw_gid("rmw_fastrtps_cpp", participant->guid());
 
     graphCache_.add_participant(gid, enclave);
 
-    if (node_name != enclave) // Do not add root node
+    // Do not add root node and
+    // do not announce non-micro-ROS participants
+    if (qos.name().to_string() != "/" && from_microros)
     {
+        std::string isolated_node_name, isolated_namespace;
+        get_name_and_namespace(qos.name().to_string(), isolated_node_name, isolated_namespace);
+
         rmw_dds_common::msg::ParticipantEntitiesInfo info =
-            graphCache_.add_node(gid, node_name, enclave_);
-        ros_discovery_datawriter_->write(static_cast<void *>(&info));
+            graphCache_.add_node(gid, isolated_node_name, isolated_namespace);
+
+        auto it = micro_ros_graph_datawriters_.find(participant);
+        if (it == micro_ros_graph_datawriters_.end())
+        {
+            // Create datawriter
+            eprosima::fastdds::dds::DataWriter* datawriter;
+            datawriter = publisher_->create_datawriter(ros_discovery_topic_, datawriter_qos_);
+
+            it = micro_ros_graph_datawriters_.insert(
+                std::make_pair(participant, std::move(datawriter))).first;
+        }
+
+        it->second->write(static_cast<void *>(&info));
     }
 }
 
 void GraphManager::remove_participant(
-        const eprosima::fastrtps::rtps::GUID_t& guid)
+        const eprosima::fastdds::dds::DomainParticipant* participant,
+        bool from_microros)
 {
-    const rmw_gid_t gid = rmw_fastrtps_shared_cpp::create_rmw_gid("rmw_fastrtps_cpp", guid);
+    const rmw_gid_t gid = rmw_fastrtps_shared_cpp::create_rmw_gid("rmw_fastrtps_cpp", participant->guid());
     graphCache_.remove_participant(gid);
+
+    if (from_microros)
+    {
+        rmw_dds_common::msg::ParticipantEntitiesInfo info;
+        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);
+    }
 }
 
 void GraphManager::add_datawriter(
@@ -351,24 +381,6 @@ void GraphManager::add_datawriter(
         type_name, participant_gid, qos_profile, false);
 }
 
-void GraphManager::add_datawriter(
-        const eprosima::fastrtps::rtps::GUID_t& datawriter_guid,
-        const std::string& topic_name,
-        const std::string& type_name,
-        const eprosima::fastrtps::rtps::GUID_t& participant_guid,
-        const eprosima::fastdds::dds::WriterQos& writer_qos)
-{
-    const rmw_gid_t datawriter_gid = rmw_fastrtps_shared_cpp::create_rmw_gid(
-        "rmw_fastrtps_cpp", datawriter_guid);
-    const rmw_gid_t participant_gid = rmw_fastrtps_shared_cpp::create_rmw_gid(
-        "rmw_fastrtps_cpp", participant_guid);
-    rmw_qos_profile_t qos_profile = rmw_qos_profile_unknown;
-    dds_qos_to_rmw_qos(writer_qos, &qos_profile);
-
-    graphCache_.add_entity(datawriter_gid, topic_name,
-        type_name, participant_gid, qos_profile, false);
-}
-
 void GraphManager::remove_datawriter(
         const eprosima::fastrtps::rtps::GUID_t& datawriter_guid)
 {
@@ -406,24 +418,6 @@ void GraphManager::add_datareader(
         type_name, participant_gid, qos_profile, true);
 }
 
-void GraphManager::add_datareader(
-        const eprosima::fastrtps::rtps::GUID_t& datareader_guid,
-        const std::string& topic_name,
-        const std::string& type_name,
-        const eprosima::fastrtps::rtps::GUID_t& participant_guid,
-        const eprosima::fastdds::dds::ReaderQos& reader_qos)
-{
-    const rmw_gid_t datareader_gid = rmw_fastrtps_shared_cpp::create_rmw_gid(
-        "rmw_fastrtps_cpp", datareader_guid);
-    const rmw_gid_t participant_gid = rmw_fastrtps_shared_cpp::create_rmw_gid(
-        "rmw_fastrtps_cpp", participant_guid);
-    rmw_qos_profile_t qos_profile = rmw_qos_profile_unknown;
-    dds_qos_to_rmw_qos(reader_qos, &qos_profile);
-
-    graphCache_.add_entity(datareader_gid, topic_name,
-        type_name, participant_gid, qos_profile, true);
-}
-
 void GraphManager::remove_datareader(
         const eprosima::fastrtps::rtps::GUID_t& datareader_guid)
 {
@@ -450,14 +444,18 @@ void GraphManager::associate_entity(
     {
         case dds::xrce::OBJK_DATAWRITER:
         {
+            std::string isolated_node_name, isolated_namespace;
+            get_name_and_namespace(qos.name().c_str(), isolated_node_name, isolated_namespace);
             info = graphCache_.associate_writer(
-                entity_gid, participant_gid, qos.name().c_str(), enclave_);
+                entity_gid, participant_gid, isolated_node_name, isolated_namespace);
             break;
         }
         case dds::xrce::OBJK_DATAREADER:
         {
+            std::string isolated_node_name, isolated_namespace;
+            get_name_and_namespace(qos.name().c_str(), isolated_node_name, isolated_namespace);
             info = graphCache_.associate_reader(
-                entity_gid, participant_gid, qos.name().c_str(), enclave_);
+                entity_gid, participant_gid, isolated_node_name, isolated_namespace);
             break;
         }
         default:
@@ -465,7 +463,9 @@ void GraphManager::associate_entity(
             break;
         }
     }
-    ros_discovery_datawriter_->write(static_cast<void *>(&info));
+
+    auto it = micro_ros_graph_datawriters_.find(participant);
+    it->second->write(static_cast<void *>(&info));
 }
 
 
@@ -550,13 +550,50 @@ void GraphManager::update_node_entities_info()
     if (ros_discovery_datareader_->take_next_sample(&entities_info, &sample_info) ==
         eprosima::fastrtps::types::ReturnCode_t::RETCODE_OK)
     {
-        if (sample_info.instance_state == eprosima::fastdds::dds::InstanceStateKind::ALIVE)
+        if (sample_info.instance_state == eprosima::fastdds::dds::InstanceStateKind::ALIVE_INSTANCE_STATE)
         {
             graphCache_.update_participant_entities(entities_info);
         }
     }
 }
 
+void GraphManager::get_name_and_namespace(
+    std::string participant_name,
+    std::string& node_name,
+    std::string& node_namespace)
+{
+    // Remove first / if exists
+    if (participant_name.rfind("/", 0) == 0)
+    {
+        participant_name.erase(participant_name.begin());
+    }
+
+    // Split node name in domain and node name
+    std::istringstream iss(participant_name);
+    std::vector<std::string> result;
+    std::string token;
+
+    while(std::getline(iss, token, '/'))
+    {
+        result.push_back(token);
+    }
+
+    if (result.size() > 1)
+    {
+        node_namespace = "/" + result[0];
+        for (size_t i = 1; i < result.size(); i++)
+        {
+            node_name.append(result[i] + "/");
+        }
+        node_name.pop_back();
+    }
+    else
+    {
+        node_name = participant_name;
+        node_namespace = "/";
+    }
+}
+
 GraphManager::ParticipantListener::ParticipantListener(
         GraphManager* graph_manager)
     : eprosima::fastdds::dds::DomainParticipantListener()
@@ -582,13 +619,13 @@ void GraphManager::ParticipantListener::on_participant_discovery(
             const std::string enclave =
                 std::string(name_found->second.begin(), name_found->second.end());
 
-            graphManager_from_->add_participant(participant->guid(), info.info.m_participantName.to_string(), enclave);
+            graphManager_from_->add_participant(participant, false, enclave);
             break;
         }
         case eprosima::fastrtps::rtps::ParticipantDiscoveryInfo::REMOVED_PARTICIPANT:
         case eprosima::fastrtps::rtps::ParticipantDiscoveryInfo::DROPPED_PARTICIPANT:
         {
-            graphManager_from_->remove_participant(info.info.m_guid);
+            graphManager_from_->remove_participant(participant, false);
             break;
         }
         default:
@@ -598,6 +635,52 @@ void GraphManager::ParticipantListener::on_participant_discovery(
     }
 }
 
+static eprosima::fastdds::dds::DataWriterQos writer_qos_conversion(
+    const eprosima::fastdds::dds::WriterQos& writer_qos)
+{
+    eprosima::fastdds::dds::DataWriterQos datawriter_qos;
+    datawriter_qos.durability(writer_qos.m_durability);
+    datawriter_qos.durability_service(writer_qos.m_durabilityService);
+    datawriter_qos.deadline(writer_qos.m_deadline);
+    datawriter_qos.latency_budget(writer_qos.m_latencyBudget);
+    datawriter_qos.liveliness(writer_qos.m_liveliness);
+    datawriter_qos.reliability(writer_qos.m_reliability);
+    datawriter_qos.destination_order(writer_qos.m_destinationOrder);
+    datawriter_qos.lifespan(writer_qos.m_lifespan);
+    datawriter_qos.user_data(writer_qos.m_userData);
+    datawriter_qos.ownership(writer_qos.m_ownership);
+    datawriter_qos.ownership_strength(writer_qos.m_ownershipStrength);
+    datawriter_qos.publish_mode(writer_qos.m_publishMode);
+    datawriter_qos.representation(writer_qos.representation);
+    datawriter_qos.data_sharing(writer_qos.data_sharing);
+
+    return datawriter_qos;
+}
+
+static eprosima::fastdds::dds::DataReaderQos reader_qos_conversion(
+    const eprosima::fastdds::dds::ReaderQos& reader_qos)
+{
+    eprosima::fastdds::dds::DataReaderQos datareader_qos;
+
+    datareader_qos.durability(reader_qos.m_durability);
+    datareader_qos.deadline(reader_qos.m_deadline);
+    datareader_qos.latency_budget(reader_qos.m_latencyBudget);
+    datareader_qos.liveliness(reader_qos.m_liveliness);
+    datareader_qos.reliability(reader_qos.m_reliability);
+    datareader_qos.destination_order(reader_qos.m_destinationOrder);
+    datareader_qos.user_data(reader_qos.m_userData);
+    datareader_qos.ownership(reader_qos.m_ownership);
+    datareader_qos.time_based_filter(reader_qos.m_timeBasedFilter);
+    datareader_qos.lifespan(reader_qos.m_lifespan);
+    datareader_qos.durability_service(reader_qos.m_durabilityService);
+    eprosima::fastdds::dds::TypeConsistencyQos consistency;
+    consistency.type_consistency = reader_qos.type_consistency;
+    datareader_qos.type_consistency(consistency);
+    datareader_qos.data_sharing(reader_qos.data_sharing);
+
+    return datareader_qos;
+}
+
 template <>
 void GraphManager::ParticipantListener::process_discovery_info<eprosima::fastrtps::rtps::ReaderDiscoveryInfo>(
         const eprosima::fastrtps::rtps::ReaderDiscoveryInfo& reader_info)
@@ -614,7 +697,7 @@ void GraphManager::ParticipantListener::process_discovery_info<eprosima::fastrtp
             const std::string type_name = reader_info.info.typeName().to_string();
 
             graphManager_from_->add_datareader(reader_info.info.guid(), topic_name, type_name,
-                iHandle2GUID(reader_info.info.RTPSParticipantKey()), reader_info.info.m_qos);
+                iHandle2GUID(reader_info.info.RTPSParticipantKey()), reader_qos_conversion(reader_info.info.m_qos));
             break;
         }
         default:
@@ -641,7 +724,7 @@ void GraphManager::ParticipantListener::process_discovery_info<eprosima::fastrtp
             const std::string type_name = writer_info.info.typeName().to_string();
 
             graphManager_from_->add_datawriter(writer_info.info.guid(), topic_name, type_name,
-                iHandle2GUID(writer_info.info.RTPSParticipantKey()), writer_info.info.m_qos);
+                iHandle2GUID(writer_info.info.RTPSParticipantKey()), writer_qos_conversion(writer_info.info.m_qos));
             break;
         }
         default:
@@ -657,7 +740,6 @@ void GraphManager::ParticipantListener::on_subscriber_discovery(
         eprosima::fastrtps::rtps::ReaderDiscoveryInfo&& info)
 {
     process_discovery_info<eprosima::fastrtps::rtps::ReaderDiscoveryInfo>(info);
-    // graphManager_from_->associate_entity(info.info.guid(), participant, dds::xrce::OBJK_DATAREADER);
 }
 
 void GraphManager::ParticipantListener::on_publisher_discovery(
@@ -665,7 +747,6 @@ void GraphManager::ParticipantListener::on_publisher_discovery(
         eprosima::fastrtps::rtps::WriterDiscoveryInfo&& info)
 {
     process_discovery_info<eprosima::fastrtps::rtps::WriterDiscoveryInfo>(info);
-    // graphManager_from_->associate_entity(info.info.guid(), participant, dds::xrce::OBJK_DATAWRITER);
 }
 
 GraphManager::DatareaderListener::DatareaderListener(

micro_ros_agent/src/main.cpp

@@ -16,12 +16,74 @@
 
 int main(int argc, char** argv)
 {
-    uros::agent::Agent micro_ros_agent;
+    uros::agent::Agent& micro_ros_agent = micro_ros_agent.getInstance();
 
-    if (!micro_ros_agent.create(argc, argv))
+    /** Bypass '--ros-args' flag, as we use our own CLI parser.
+      * As a workaround for launch files, arguments will be passed from
+      * ros2launch as a single token with spaces,
+      * to preserve the correct argument order; split it here.
+      * TODO(jamoralp): investigate ROS2 tools for properly parsing params from launch
+      **/
+    std::vector<std::string> params;
+    for (int i = 0; i < argc; ++i)
+    {
+        if(strcmp("--ros-args", argv[i]) == 0)
+        {
+            argc = i;
+            break;
+        }
+        params.emplace_back(std::string(argv[i]));
+    }
+
+    auto it = std::find(params.begin(), params.end(), "--ros-args");
+    if (params.end() != it)
+    {
+        if ((it - params.begin()) != 2)
+        {
+            std::ostringstream ss;
+            ss << "Error: when using ros2 launch, please specify ";
+            ss << "your arguments in a single variable." << std::endl;
+            ss << "Instead of 'arguments: {'udp4', '-p', '8888'}', do ";
+            ss << "'arguments: {'udp4 -p 8888'}" << std::endl;
+
+            std::cerr << ss.str();
+            return 1;
+        }
+        const std::string& agent_args(params.at(1));
+        std::istringstream iss(agent_args);
+        std::vector<std::string> agent_args_split(
+            std::istream_iterator<std::string>{iss},
+            std::istream_iterator<std::string>());
+
+        char** agent_argv = new char*[agent_args_split.size() + 1];
+        agent_argv[0] = argv[0];
+        char** agent_argv_it = &agent_argv[1];
+
+        for (const auto& arg : agent_args_split)
+        {
+            *agent_argv_it = new char[arg.length() + 1];
+            strcpy(*agent_argv_it, arg.c_str());
+            agent_argv_it++;
+        }
+
+        bool success = micro_ros_agent.create(agent_args_split.size() + 1, agent_argv);
+
+        for (size_t i = 1; i <= agent_args_split.size(); ++i)
+        {
+            delete [] agent_argv[i];
+        }
+        delete [] agent_argv;
+
+        if (!success)
+        {
+            return 1;
+        }
+    }
+    else if (!micro_ros_agent.create(argc, argv))
     {
         return 1;
     }
+
     micro_ros_agent.run();
 
     return 0;

snap/hooks/configure

@@ -0,0 +1,104 @@
+#!/bin/sh -e
+
+# Confirm that the transport is valid
+transport="$(snapctl get transport)"
+case "$transport" in
+	udp4) ;;
+	udp6) ;;
+	tcp4) ;;
+	tcp6) ;;
+	serial) ;;
+	pseudoterminal) ;;
+	*)
+		echo "'$transport' is not a supported transport" >&2
+		return 1
+		;;
+esac
+
+# Confirm that the middleware is valid
+middleware="$(snapctl get middleware)"
+case "$middleware" in
+	dds) ;;
+	rtps) ;;
+	ced) ;;
+	*)
+		echo "'$middleware' is not a supported middleware" >&2
+		return 1
+		;;
+esac
+
+if [ "$transport" = "serial" ] || [ "$transport" = "pseudoterminal" ]; then
+	# A serial transport if being used, which requires a valid baud rate
+	# as well as a valid device
+	baudrate="$(snapctl get baudrate)"
+	if ! expr "$baudrate" : '^[0-9]\+$' > /dev/null; then
+		echo "'$baudrate' is not a valid baud rate" >&2
+		return 1
+	fi
+
+	device="$(snapctl get device)"
+	if [ -z "$device" ]; then
+		echo "Device must be specified" >&2
+		return 1
+	fi
+else
+	port="$(snapctl get port)"
+	if ! expr "$port" : '^[0-9]\+$' > /dev/null; then
+		echo "'$port' is not a valid port" >&2
+		return 1
+	fi
+fi
+
+# Confirm that discovery is a boolean
+discovery="$(snapctl get discovery)"
+case "$discovery" in
+	true)
+		# Confirm that discovery port is valid
+		port="$(snapctl get discovery-port)"
+		if ! expr "$port" : '^[0-9]\+$' > /dev/null; then
+			echo "'$port' is not a valid discovery port" >&2
+			return 1
+		fi
+		;;
+	false) ;;
+	*)
+		echo "'$discovery' is not a valid boolean for discovery" >&2
+		return 1
+		;;
+esac
+
+# Confirm that the verbosity is valid
+verbosity="$(snapctl get verbosity)"
+if ! expr "$verbosity" : '^[0-6]$' > /dev/null; then
+	echo "'$verbosity' is not a valid verbosity" >&2
+	return 1
+fi
+
+# Confirm that p2p port is valid (assuming it's set)
+p2p_port="$(snapctl get p2p-port)"
+if [ -n "$p2p_port" ]; then
+	port="$(snapctl get p2p-port)"
+	if ! expr "$port" : '^[0-9]\+$' > /dev/null; then
+		echo "'$port' is not a valid p2p port" >&2
+		return 1
+	fi
+fi
+
+# Confirm that daemon is a boolean, and enable the service if true
+daemon="$(snapctl get daemon)"
+case "$daemon" in
+	true)
+		snapctl start --enable "$SNAP_INSTANCE_NAME.daemon"
+
+		# In case it was alraedy started and the configuration changed,
+		# restart the service
+		snapctl restart "$SNAP_INSTANCE_NAME.daemon"
+		;;
+	false)
+		snapctl stop --disable "$SNAP_INSTANCE_NAME.daemon"
+		;;
+	*)
+		echo "'$daemon' is not a valid boolean for daemon" >&2
+		return 1
+		;;
+esac

snap/hooks/install

@@ -0,0 +1,19 @@
+#!/bin/sh -e
+
+# Set default configuration values
+snapctl set transport=udp4
+snapctl set middleware=dds
+snapctl set verbosity=4
+snapctl set discovery=false
+snapctl set discovery-port=7400
+snapctl set p2p-port!  # unset
+
+# Network-specific things
+snapctl set port=8888
+
+# Serial-specific things
+snapctl set baudrate=115200
+snapctl set device!  # unset
+
+# By default the daemon is disabled
+snapctl set daemon=false

snap/local/micro-ros-agent-daemon

@@ -0,0 +1,27 @@
+#!/bin/sh -e
+
+set -- --middleware "$(snapctl get middleware)" "$@"
+set -- --verbose "$(snapctl get verbosity)" "$@"
+
+transport="$(snapctl get transport)"
+if [ "$transport" = "serial" ] || [ "$transport" = "pseudoterminal" ]; then
+	set -- --dev "$(snapctl get device)" "$@"
+else
+	set -- --port "$(snapctl get port)" "$@"
+fi
+
+if [ "$(snapctl get discovery)" = "true" ]; then
+	set -- --discovery "$@"
+
+	discovery_port="$(snapctl get discovery-port)"
+	if [ -n "$discovery_port" ]; then
+		set -- --disport "$discovery_port" "$@"
+	fi
+fi
+
+p2p_port="$(snapctl get p2p-port)"
+if [ -n "$p2p_port" ]; then
+	set -- --p2p "$p2p_port" "$@"
+fi
+
+exec "$SNAP/lib/micro_ros_agent/micro_ros_agent" "$transport" "$@"

snap/snapcraft.yaml

@@ -0,0 +1,168 @@
+name: micro-ros-agent
+base: core20
+version: git
+summary: Bridge between Micro ROS client applications and ROS 2
+description: |
+  Micro-ROS, whose default implementation is based on eProsima's
+  Micro XRCE-DDS middleware, is composed of client applications
+  which interact with the ROS 2 world by means of an Agent.
+  This agent keeps tracks of the entities created by means of
+  requests performed on the microcontroller side, and uses them
+  to communicate with the ROS 2 dataspace.
+
+  Being an extension of the Micro XRCE-DDS Agent, the micro-ROS
+  agent supports being run by the user like this:
+
+      $ micro-ros-agent --help
+
+  In addition, the Agent supports running as a service that can be
+  enabled with:
+
+      $ snap set micro-ros-agent daemon=true
+
+  If the service is enabled, by default it uses the `udp4` transport on
+  port 8888. The following parameters can be changed (these are
+  specific to the service, the `micro-ros-agent` command simply
+  takes command-line arguments, but the capabilities are the same):
+
+  * `transport`. Supported transports are `udp4`, `udp6`, `tcp4`,
+    `tcp6`, `serial`, and `pseudoterminal`. Default is `udp4`. Change
+    with:
+
+        $ snap set micro-ros-agent transport="new transport"
+
+  * `middleware`. Supported kinds of middleware are `ced`, `rtps`, and
+    `dds`. Default is `dds`. Change with:
+
+        $ snap set micro-ros-agent middleware="new middleware"
+
+  * `verbosity`. Supported verbosity levels are 0-6, defaulting to 4.
+    Change with:
+
+        $ snap set micro-ros-agent verbosity="selected verbosity"
+
+  * `discovery`. Enable or disable the discovery server. Defaults to
+    "false". Change with:
+
+        $ snap set micro-ros-agent discovery="true or false"
+
+  * `discovery-port`. Port on which the discovery server (see above)
+    listens. Defaults to 7400. Change with:
+
+        $ snap set micro-ros-agent discovery-port="selected port"
+
+  * `p2p-port`. Port to use for the P2P profile. Change with:
+
+        $ snap set micro-ros-agent p2p-port="selected port"
+
+  * `port`. Port on which the agent listens. Only applicable to one of
+    the UDP or TCP transports (see above). Defaults to 8888. Change with:
+
+        $ snap set micro-ros-agent port="selected port"
+
+  * `baudrate`. Baud rate to use when accessing serial ports. Only
+    applicable when using the `serial` or `pseudoterminal` transport.
+    Defaults to 115200. Change with:
+
+        $ snap set micro-ros-agent baudrate="baud rate"
+
+  * `device`. The serial device to use. Only applicable when using the
+    `serial` or `pseudoterminal` transport. Change with:
+
+        $ snap set micro-ros-agent device="device path"
+
+  If connecting the micro-ROS Agent using an IP based connection mode,
+  that is, `udp4`, `udp6`, `tcp4` or `tcp6`, care must be taken to
+  connect first the `micro-ros-agent-shm-netplug` plug.
+  This is due to the fact that ROS 2 Foxy is using Fast-DDS as the
+  default DDS middleware, and Fast-DDS comes with *shared memory transport*.
+  Thus, this plugin must be enabled, in order to gain access to the
+  `/dev/shm` folder from the snap image, prior to running it:
+
+      $ sudo snap connect micro-ros-agent:micro-ros-agent-shm-netplug
+
+  When using the snap with a serial device, some steps need to be taken
+  in order to establish a successful connection:
+
+  * Refresh your local installation of the snap `core` package:
+
+        $ sudo snap refresh core --edge
+
+  * Enable the hotplug feature and restart the `snapd` daemon:
+
+        $ sudo snap set core experimental.hotplug=true
+        $ sudo systemctl restart snapd
+
+  * After plugging the microcontroller to the serial port, execute
+    the `snap interface serial-port` command. You should see something
+    like this:
+
+          name:    serial-port
+          summary: allows accessing a specific serial port
+          plugs:
+            - micro-ros-agent
+          slots:
+          - snapd:cp2102cp2109uartbrid (allows accessing a specific serial port)
+
+  * Connect your snap image to the desired serial port (replace accordingly):
+
+        $ snap connect micro-ros-agent:serial-port snapd:cp2102cp2109uartbrid
+
+  After this, you can execute your snap as usual,
+  using `sudo micro-ros-agent serial -d <serial-dev>`.
+
+grade: stable
+confinement: strict
+
+architectures:
+  - build-on: amd64
+  - build-on: arm64
+  - build-on: armhf
+  - build-on: ppc64el
+
+parts:
+
+  uros-agent:
+    plugin: colcon
+    source: .
+    override-build: |
+        set +u
+        git clone https://github.com/eProsima/Micro-XRCE-DDS-Agent.git -b $ROS_DISTRO
+        git clone https://github.com/eProsima/Micro-CDR.git -b $ROS_DISTRO
+        git clone https://github.com/micro-ROS/micro_ros_msgs.git -b $ROS_DISTRO
+        git clone https://github.com/micro-ROS/rosidl_typesupport_microxrcedds.git -b $ROS_DISTRO
+        git clone https://github.com/micro-ROS/rmw-microxrcedds.git -b $ROS_DISTRO
+        git clone https://github.com/micro-ROS/micro-ROS-Agent.git -b $ROS_DISTRO
+        . /opt/ros/$ROS_DISTRO/setup.sh
+        colcon build --merge-install --install-base $SNAPCRAFT_PRIME --cmake-args "-DUAGENT_BUILD_EXECUTABLE=OFF -DUAGENT_USE_SYSTEM_FASTDDS=ON" --packages-up-to micro_ros_agent
+        set -u
+    build-packages: [make, gcc, g++]
+    stage-packages: [ros-foxy-ros2launch]
+
+  runner:
+    plugin: dump
+    source: snap/local/
+    organize:
+      '*': usr/bin/
+
+plugs:
+  micro-ros-agent-shm-netplug:
+    interface: system-files
+    allow-auto-connection: true
+    write:
+      - /dev/shm
+
+apps:
+  micro-ros-agent:
+    command: lib/micro_ros_agent/micro_ros_agent
+    environment:
+        LD_LIBRARY_PATH: "$LD_LIBRARY_PATH:$SNAP/lib"
+    plugs: [network, network-bind, serial-port, micro-ros-agent-shm-netplug]
+    extensions: [ros2-foxy]
+
+  daemon:
+    command: usr/bin/micro-ros-agent-daemon
+    environment:
+        LD_LIBRARY_PATH: "$LD_LIBRARY_PATH:$SNAP/lib"
+    daemon: simple
+    plugs: [network, network-bind, serial-port, micro-ros-agent-shm-netplug]