2.0.4

Signed-off-by: Pablo Garrido <pablogs9@gmail.com>

Signed-off-by: Pablo Garrido <pablogs9@gmail.com>
(cherry picked from commit 4f686e8dc1)

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

.github/workflows/ci.yml

@@ -3,36 +3,36 @@ name: CI micro-ROS Agent
 on:
     pull_request:
       branches:
-        - '**'
+        - 'galactic'
+    schedule:
+      - cron: '33 6 * * *'
 
 jobs:
 
     microros_agent_ci:
       runs-on: ubuntu-20.04
-        container: microros/base:foxy
+      strategy:
-
+        fail-fast: false
+        matrix:
+          os: [ ubuntu-20.04 ]
+          ros_distribution: [ galactic ]
+          include:
+            - docker_image: ubuntu:20.04
+              ros_distribution: galactic
+      container:
+        image: ubuntu:20.04
       steps:
       - uses: actions/checkout@v2
+      - uses: ros-tooling/setup-ros@0.3.2
         with:
-            path: urosagent
+          use-ros2-testing: false
-
+          required-ros-distributions: ${{ matrix.ros_distribution }}
-        - name: Download dependencies
+      - name : Download and install dependencies
         run: |
-            apt update
+          apt-get install ros-${{ matrix.ros_distribution }}-micro-ros-msgs
-            cd /uros_ws
+          apt-get install ros-${{ matrix.ros_distribution }}-rmw-fastrtps-cpp
-            . /opt/ros/$ROS_DISTRO/setup.sh
+      - uses : ros-tooling/action-ros-ci@0.2.5
-            . install/local_setup.sh
+        with:
-            rosdep update
+          package-name: "micro_ros_agent"
-            ros2 run micro_ros_setup create_agent_ws.sh 
+          target-ros2-distro: ${{ matrix.ros_distribution }}
 
-        - 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/$ROS_DISTRO/setup.sh
-            . install/local_setup.sh
-            ros2 run micro_ros_setup build_agent.sh 

README.md

@@ -55,3 +55,4 @@ see the file [3rd-party-licenses.txt](3rd-party-licenses.txt).
 Please notice the following issues/limitations:
 
 * There is an unknown issue when dealing with serial ports shared with the micro-ROS agent running inside a Docker. Sometimes it works with a remarkable packet loss.
+* There is an known issues with serial port communication on micro-ros-agent snap version. It is recommended to use the dockerized version or build it from source.

micro_ros_agent/CHANGELOG.rst

@@ -2,6 +2,44 @@
 Changelog for package micro-ros_agent
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+2.0.4 (2022-09-28)
+------------------
+* Fix Datawriter destruction (`#169 <https://github.com/micro-ROS/micro-ROS-Agent/issues/169>`_) (`#172 <https://github.com/micro-ROS/micro-ROS-Agent/issues/172>`_)
+* Synchronise predicate (`#160 <https://github.com/micro-ROS/micro-ROS-Agent/issues/160>`_) (`#166 <https://github.com/micro-ROS/micro-ROS-Agent/issues/166>`_)
+
+2.0.3 (2022-06-13)
+------------------
+* Fix memory leak in graph manager (`#147 <https://github.com/micro-ROS/micro-ROS-Agent/issues/147>`_) (`#150 <https://github.com/micro-ROS/micro-ROS-Agent/issues/150>`_)
+
+2.0.2 (2022-05-25)
+------------------
+
+2.0.1 (2022-03-25)
+------------------
+* Add services to graph manager (`#127 <https://github.com/micro-ROS/micro-ROS-Agent/issues/127>`_)
+* Add used missing includes (`#116 <https://github.com/micro-ROS/micro-ROS-Agent/issues/116>`_) (`#125 <https://github.com/micro-ROS/micro-ROS-Agent/issues/125>`_)
+* Add system logger flag (`#118 <https://github.com/micro-ROS/micro-ROS-Agent/issues/118>`_)
+* Add condition variable include (`#113 <https://github.com/micro-ROS/micro-ROS-Agent/issues/113>`_)
+* pass system name to xrceagent (`#110 <https://github.com/micro-ROS/micro-ROS-Agent/issues/110>`_)
+* Fix memory leak in FastDDS datawriter (`#107 <https://github.com/micro-ROS/micro-ROS-Agent/issues/107>`_)
+* Contributors: Antonio Cuadros, Pablo Garrido, Roland Schwan, mergify[bot]
+
+2.0.0 (2021-09-13)
+------------------
+* Remove XRCE dependency and add superbuild (`#97 <https://github.com/micro-ROS/micro-ROS-Agent/issues/97>`_)
+* Fixed launch file by using a list for arguments. Ensures order of items is kept. (`#93 <https://github.com/micro-ROS/micro-ROS-Agent/issues/93>`_) (`#94 <https://github.com/micro-ROS/micro-ROS-Agent/issues/94>`_)
+* Modify argument type (`#91 <https://github.com/micro-ROS/micro-ROS-Agent/issues/91>`_)
+* Fix graph manager datawriters behaviour (`#84 <https://github.com/micro-ROS/micro-ROS-Agent/issues/84>`_)
+* Graph manager: Fix participant mask for listener callbacks (`#81 <https://github.com/micro-ROS/micro-ROS-Agent/issues/81>`_)
+* Fix agent launch (`#78 <https://github.com/micro-ROS/micro-ROS-Agent/issues/78>`_)
+* Fix graph manager node namespaces (`#75 <https://github.com/micro-ROS/micro-ROS-Agent/issues/75>`_)
+* Fix Rolling agent (`#61 <https://github.com/micro-ROS/micro-ROS-Agent/issues/61>`_)
+* Add multi domain graph manager (`#69 <https://github.com/micro-ROS/micro-ROS-Agent/issues/69>`_)
+* Add ros2 launch capabilities and example launch file (`#47 <https://github.com/micro-ROS/micro-ROS-Agent/issues/47>`_)
+* Snap build for the micro-ROS-Agent (`#43 <https://github.com/micro-ROS/micro-ROS-Agent/issues/43>`_)
+* Create graph manager after checking passed CLI arguments and launch xrce-dds server (`#41 <https://github.com/micro-ROS/micro-ROS-Agent/issues/41>`_)
+* Contributors: Antonio Cuadros, Jose Antonio Moral, Pablo Garrido, mergify[bot]
+
 0.0.1 (2019-04-24)
 -----------------
 * Initial release

micro_ros_agent/CMakeLists.txt

@@ -19,7 +19,16 @@ option(UROSAGENT_GENERATE_PROFILE
   )
 set(CMAKE_C_CLANG_TIDY clang-tidy -checks=*)
 
-project(micro_ros_agent LANGUAGES CXX)
+option(MICROROSAGENT_SUPERBUILD "Enable superbuild compilation." ON)
+option(UAGENT_USE_SYSTEM_LOGGER "Force use of system installed spdlog logger on superbuild." OFF)
+
+if(NOT MICROROSAGENT_SUPERBUILD)
+    project(micro_ros_agent LANGUAGES CXX)
+else()
+    project(uagent_superbuild NONE)
+    include(${PROJECT_SOURCE_DIR}/cmake/SuperBuild.cmake)
+    return()
+endif()
 
 find_package(ament_cmake REQUIRED)
 find_package(microxrcedds_agent REQUIRED)

micro_ros_agent/cmake/SuperBuild.cmake

@@ -0,0 +1,68 @@
+# Copyright 2019 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.
+
+include(ExternalProject)
+
+unset(_deps)
+
+enable_language(C)
+enable_language(CXX)
+
+unset(xrceagent_DIR CACHE)
+find_package(xrceagent 2 EXACT QUIET)
+if(NOT xrceagent_FOUND)
+    ExternalProject_Add(xrceagent
+            GIT_REPOSITORY
+                https://github.com/eProsima/Micro-XRCE-DDS-Agent.git
+            GIT_TAG
+                ros2
+            PREFIX
+                ${PROJECT_BINARY_DIR}/agent
+            INSTALL_DIR
+                ${CMAKE_INSTALL_PREFIX}
+            CMAKE_CACHE_ARGS
+                -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
+                -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
+                -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+                -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS}
+                -DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS}
+                -DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS}
+                -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS}
+                -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
+                -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+                -DCMAKE_PREFIX_PATH:PATH=<INSTALL_DIR>
+                -DCMAKE_SYSTEM_NAME:STRING=${CMAKE_SYSTEM_NAME}
+                -DUAGENT_USE_SYSTEM_FASTDDS:BOOL=ON
+                -DUAGENT_USE_SYSTEM_FASTCDR:BOOL=ON
+                -DUAGENT_USE_SYSTEM_LOGGER:BOOL=${UAGENT_USE_SYSTEM_LOGGER}
+                -DUAGENT_CED_PROFILE:BOOL=OFF
+                -DUAGENT_P2P_PROFILE:BOOL=OFF
+                -DUAGENT_BUILD_EXECUTABLE:BOOL=OFF
+                -DUAGENT_ISOLATED_INSTALL:BOOL=OFF
+            )
+endif()
+
+# Main project.
+ExternalProject_Add(micro_ros_agent
+    SOURCE_DIR
+        ${PROJECT_SOURCE_DIR}
+    BINARY_DIR
+        ${CMAKE_CURRENT_BINARY_DIR}
+    CMAKE_CACHE_ARGS
+        -DMICROROSAGENT_SUPERBUILD:BOOL=OFF
+    INSTALL_COMMAND
+        ""
+    DEPENDS
+        xrceagent
+    )

micro_ros_agent/include/agent/Agent.hpp

@@ -20,6 +20,10 @@
 #include <uxr/agent/middleware/utils/Callbacks.hpp>
 
 #include <agent/graph_manager/graph_manager.hpp>
+
+#include <map>
+#include <memory>
+
 // TODO(jamoralp): class Documentation
 namespace uros {
 namespace agent {

micro_ros_agent/include/agent/graph_manager/graph_manager.hpp

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#ifndef _UROS_AGENT_GRAPH_MANAGER_HPP
+#define _UROS_AGENT_GRAPH_MANAGER_HPP
+
 #include "fastrtps/Domain.h"
 #include <fastrtps/TopicDataType.h>
 #include "fastrtps/attributes/ParticipantAttributes.h"
@@ -58,8 +61,10 @@
 #include <agent/graph_manager/graph_typesupport.hpp>
 #include <agent/utils/demangle.hpp>
 
-#ifndef _UROS_AGENT_GRAPH_MANAGER_HPP
+#include <condition_variable>
-#define _UROS_AGENT_GRAPH_MANAGER_HPP
+#include <string>
+#include <memory>
+#include <map>
 
 namespace uros {
 namespace agent {
@@ -89,28 +94,28 @@ public:
 
     /**
      * @brief   Adds a DDS participant to the graph tree.
-     * @param   participant Pointer to the participant to be added to the graph.
+     * @param   participant eprosima::fastdds::dds::DomainParticipant to be added.
-     */
+     * @param   from_microros if this participant has been added from micro-ROS.
-    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   enclave ROS 2 enclave.
      */
     void add_participant(
-            const eprosima::fastrtps::rtps::GUID_t& guid,
+            const eprosima::fastdds::dds::DomainParticipant* participant,
-            const std::string& node_name,
+            bool from_microros = true,
-            const std::string& enclave);
+            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   Getter for the graph cache.
+     * @return  Reference to inner graph cache
+     */
+    rmw_dds_common::GraphCache& get_graph_cache() { return graphCache_; }
 
     /**
      * @brief   Adds a DDS datawriter to the graph tree.
@@ -138,21 +143,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 +176,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,14 +267,27 @@ 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_;
 
+    eprosima::fastdds::dds::DataWriterQos datawriter_qos_;
+
     rmw_dds_common::GraphCache graphCache_;
     std::unique_ptr<ParticipantListener> participant_listener_;
     std::unique_ptr<DatareaderListener> datareader_listener_;
@@ -311,9 +299,14 @@ private:
     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_;
+
+    // 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

micro_ros_agent/launch/micro_ros_agent_launch.py

@@ -7,6 +7,6 @@ def generate_launch_description():
             package='micro_ros_agent',
             executable='micro_ros_agent',
             name='micro_ros_agent',
-            arguments={'udp4 --port 8888 -v6'}
+            arguments=["udp4", "-p", "8888", "-v6"]
         )
     ])

micro_ros_agent/package.xml

@@ -2,9 +2,10 @@
 <?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="3">
   <name>micro_ros_agent</name>
-  <version>0.0.1</version>
+  <version>2.0.4</version>
-  <description>DDS-XCRE agent implementation </description>
+  <description>micro-ROS Agent package</description>
-  <maintainer email="borjaouterelo@eprosima.com">Borja Outerelo</maintainer>
+  <maintainer email="pablogarrido@eprosima.com">Pablo Garrido</maintainer>
+  <maintainer email="antoniocuadros@eprosima.com">Antonio Cuadros</maintainer>
   <license>Apache License 2.0</license>
 
   <buildtool_depend>ament_cmake</buildtool_depend>
@@ -14,7 +15,6 @@
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>ament_lint_common</test_depend>
 
-  <depend>microxrcedds_agent</depend>
   <depend>rmw</depend>
   <depend>rcutils</depend>
   <depend>rmw_fastrtps_shared_cpp</depend>

micro_ros_agent/src/agent/Agent.cpp

@@ -17,6 +17,9 @@
 
 #include <agent/Agent.hpp>
 
+#include <utility>
+#include <memory>
+
 namespace uros {
 namespace agent {
 
@@ -40,12 +43,7 @@ bool Agent::create(
             ([&](
                 const eprosima::fastdds::dds::DomainParticipant* participant) -> void
             {
-                auto graph_manager_ =
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
-                    find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t(
-                        participant->get_domain_id()
-                    )
-                );
-
                 graph_manager_->add_participant(participant);
             });
         xrce_dds_agent_instance_.add_middleware_callback(
@@ -61,13 +59,8 @@ bool Agent::create(
             ([&](
                 const eprosima::fastdds::dds::DomainParticipant* participant) -> void
             {
-                auto graph_manager_ =
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
-                    find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t(
+                graph_manager_->remove_participant(participant);
-                        participant->get_domain_id()
-                    )
-                );
-
-                graph_manager_->remove_participant(participant->guid());
             });
         xrce_dds_agent_instance_.add_middleware_callback(
             eprosima::uxr::Middleware::Kind::FASTDDS,
@@ -84,20 +77,11 @@ bool Agent::create(
                 const eprosima::fastdds::dds::DomainParticipant* participant,
                 const eprosima::fastdds::dds::DataWriter* datawriter) -> void
             {
-                auto graph_manager_ =
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
-                    find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t(
-                        participant->get_domain_id()
-                    )
-                );
 
-                // TODO(jamoralp): Workaround for Fast-DDS bug #9977. Remove when fixed
+                graph_manager_->add_datawriter(datawriter->guid(), participant, datawriter);
-                const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
-                    datawriter->get_instance_handle();
-                const eprosima::fastrtps::rtps::GUID_t datawriter_guid =
-                    iHandle2GUID(instance_handle);
-                graph_manager_->add_datawriter(datawriter_guid, participant, datawriter);
                 graph_manager_->associate_entity(
-                    datawriter_guid, participant, dds::xrce::OBJK_DATAWRITER);
+                    datawriter->guid(), participant, dds::xrce::OBJK_DATAWRITER);
             });
         xrce_dds_agent_instance_.add_middleware_callback(
             eprosima::uxr::Middleware::Kind::FASTDDS,
@@ -115,18 +99,9 @@ bool Agent::create(
                 const eprosima::fastdds::dds::DataWriter* datawriter) -> void
             {
 
-                auto graph_manager_ =
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
-                    find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t(
-                        participant->get_domain_id()
-                    )
-                );
 
-                // TODO(jamoralp): Workaround for Fast-DDS bug #9977. Remove when fixed
+                graph_manager_->remove_datawriter(datawriter->guid());
-                const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
-                    datawriter->get_instance_handle();
-                const eprosima::fastrtps::rtps::GUID_t datawriter_guid =
-                    eprosima::fastrtps::rtps::iHandle2GUID(instance_handle);
-                graph_manager_->remove_datawriter(datawriter_guid);
             });
 
         xrce_dds_agent_instance_.add_middleware_callback(
@@ -144,11 +119,7 @@ bool Agent::create(
                 const eprosima::fastdds::dds::DomainParticipant* participant,
                 const eprosima::fastdds::dds::DataReader* datareader) -> void
             {
-                auto graph_manager_ =
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
-                    find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t(
-                        participant->get_domain_id()
-                    )
-                );
 
                 // TODO(jamoralp): Workaround for Fast-DDS bug #9977. Remove when fixed
                 const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
@@ -174,11 +145,7 @@ bool Agent::create(
                 const eprosima::fastdds::dds::DomainParticipant* participant,
                 const eprosima::fastdds::dds::DataReader* datareader) -> void
             {
-                auto graph_manager_ =
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
-                    find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t(
-                        participant->get_domain_id()
-                    )
-                );
 
                 // TODO(jamoralp): Workaround for Fast-DDS bug #9977. Remove when fixed
                 const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
@@ -192,6 +159,128 @@ bool Agent::create(
             eprosima::uxr::Middleware::Kind::FASTDDS,
             eprosima::uxr::middleware::CallbackKind::DELETE_DATAREADER,
             std::move(on_delete_datareader));
+
+        /**
+         * Add CREATE_REQUESTER callback.
+         */
+        std::function<void (
+            const eprosima::fastdds::dds::DomainParticipant *,
+            const eprosima::fastdds::dds::DataWriter *,
+            const eprosima::fastdds::dds::DataReader *)> on_create_requester
+            ([&](
+                const eprosima::fastdds::dds::DomainParticipant* participant,
+                const eprosima::fastdds::dds::DataWriter* datawriter,
+                const eprosima::fastdds::dds::DataReader * datareader) -> void
+            {
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
+
+                graph_manager_->add_datawriter(datawriter->guid(), participant, datawriter);
+                graph_manager_->associate_entity(
+                    datawriter->guid(), participant, dds::xrce::OBJK_DATAWRITER);
+
+                // TODO(pablogs): Workaround for Fast-DDS bug #9977. Remove when fixed
+                const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
+                    datareader->get_instance_handle();
+                const eprosima::fastrtps::rtps::GUID_t datareader_guid =
+                    eprosima::fastrtps::rtps::iHandle2GUID(instance_handle);
+                graph_manager_->add_datareader(datareader_guid, participant, datareader);
+                graph_manager_->associate_entity(
+                    datareader_guid, participant, dds::xrce::OBJK_DATAREADER);
+            });
+        xrce_dds_agent_instance_.add_middleware_callback(
+            eprosima::uxr::Middleware::Kind::FASTDDS,
+            eprosima::uxr::middleware::CallbackKind::CREATE_REQUESTER,
+            std::move(on_create_requester));
+
+        /**
+         * Add DELETE_REQUESTER callback.
+         */
+        std::function<void (
+            const eprosima::fastdds::dds::DomainParticipant *,
+            const eprosima::fastdds::dds::DataWriter *,
+            const eprosima::fastdds::dds::DataReader *)> on_delete_requester
+            ([&](
+                const eprosima::fastdds::dds::DomainParticipant* participant,
+                const eprosima::fastdds::dds::DataWriter* datawriter,
+                const eprosima::fastdds::dds::DataReader * datareader) -> void
+            {
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
+
+                graph_manager_->remove_datawriter(datawriter->guid());
+
+                // TODO(pablogs): Workaround for Fast-DDS bug #9977. Remove when fixed
+                const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
+                    datareader->get_instance_handle();
+                const eprosima::fastrtps::rtps::GUID_t datareader_guid =
+                    eprosima::fastrtps::rtps::iHandle2GUID(instance_handle);
+                graph_manager_->remove_datareader(datareader_guid);
+            });
+
+        xrce_dds_agent_instance_.add_middleware_callback(
+            eprosima::uxr::Middleware::Kind::FASTDDS,
+            eprosima::uxr::middleware::CallbackKind::DELETE_REQUESTER,
+            std::move(on_delete_requester));
+
+        /**
+         * Add CREATE_REPLIER callback.
+         */
+        std::function<void (
+            const eprosima::fastdds::dds::DomainParticipant *,
+            const eprosima::fastdds::dds::DataWriter *,
+            const eprosima::fastdds::dds::DataReader *)> on_create_replier
+            ([&](
+                const eprosima::fastdds::dds::DomainParticipant* participant,
+                const eprosima::fastdds::dds::DataWriter* datawriter,
+                const eprosima::fastdds::dds::DataReader * datareader) -> void
+            {
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
+
+                graph_manager_->add_datawriter(datawriter->guid(), participant, datawriter);
+                graph_manager_->associate_entity(
+                    datawriter->guid(), participant, dds::xrce::OBJK_DATAWRITER);
+
+                // TODO(pablogs): Workaround for Fast-DDS bug #9977. Remove when fixed
+                const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
+                    datareader->get_instance_handle();
+                const eprosima::fastrtps::rtps::GUID_t datareader_guid =
+                    eprosima::fastrtps::rtps::iHandle2GUID(instance_handle);
+                graph_manager_->add_datareader(datareader_guid, participant, datareader);
+                graph_manager_->associate_entity(
+                    datareader_guid, participant, dds::xrce::OBJK_DATAREADER);
+            });
+        xrce_dds_agent_instance_.add_middleware_callback(
+            eprosima::uxr::Middleware::Kind::FASTDDS,
+            eprosima::uxr::middleware::CallbackKind::CREATE_REPLIER,
+            std::move(on_create_replier));
+
+        /**
+         * Add DELETE_REPLIER callback.
+         */
+        std::function<void (
+            const eprosima::fastdds::dds::DomainParticipant *,
+            const eprosima::fastdds::dds::DataWriter *,
+            const eprosima::fastdds::dds::DataReader *)> on_delete_replier
+            ([&](
+                const eprosima::fastdds::dds::DomainParticipant* participant,
+                const eprosima::fastdds::dds::DataWriter* datawriter,
+                const eprosima::fastdds::dds::DataReader * datareader) -> void
+            {
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
+
+                graph_manager_->remove_datawriter(datawriter->guid());
+
+                // TODO(pablogs): Workaround for Fast-DDS bug #9977. Remove when fixed
+                const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
+                    datareader->get_instance_handle();
+                const eprosima::fastrtps::rtps::GUID_t datareader_guid =
+                    eprosima::fastrtps::rtps::iHandle2GUID(instance_handle);
+                graph_manager_->remove_datareader(datareader_guid);
+            });
+
+        xrce_dds_agent_instance_.add_middleware_callback(
+            eprosima::uxr::Middleware::Kind::FASTDDS,
+            eprosima::uxr::middleware::CallbackKind::DELETE_REPLIER,
+            std::move(on_delete_replier));
     }
 
     return result;
@@ -204,16 +293,14 @@ void Agent::run()
 
 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;
     }else{
         return graph_manager_map_.insert(
-            std::pair<
+            std::make_pair(
-                eprosima::fastdds::dds::DomainId_t,
-                std::shared_ptr<graph_manager::GraphManager>
-            >(
                 domain_id,
                 std::make_shared<graph_manager::GraphManager>(domain_id)
             )

micro_ros_agent/src/agent/graph_manager/graph_manager.cpp

@@ -17,16 +17,19 @@
 
 #include <agent/graph_manager/graph_manager.hpp>
 
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
 namespace uros {
 namespace agent {
 namespace graph_manager {
 
 GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
-    // : eprosima::fastrtps::ParticipantListener()
     : domain_id_(domain_id)
     , graph_changed_(false)
     , display_on_change_(false)
-    , enclave_("/")
     , mtx_()
     , cv_()
     , graphCache_()
@@ -37,23 +40,27 @@ GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
     , microros_graph_info_typesupport_(std::make_unique<
         eprosima::fastdds::dds::TypeSupport>(new graph_manager::MicrorosGraphInfoTypeSupport()))
 {
+    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->load_profiles();
+
     // 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;
 
+    eprosima::fastdds::dds::StatusMask par_mask = eprosima::fastdds::dds::StatusMask::none();
     participant_.reset(eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->
-        create_participant(domain_id_, participant_qos, participant_listener_.get()));
+        create_participant(domain_id_, participant_qos, participant_listener_.get(), par_mask));
 
     // Register participant within typesupport
     participant_->register_type(*participant_info_typesupport_);
@@ -77,28 +84,26 @@ GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
         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_.history().depth = 1;
-    datawriter_qos.endpoint().history_memory_policy =
+    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(
+    eprosima::fastdds::dds::DataWriterQos ros_to_microros_datawriter_qos_ = datawriter_qos_;
-        publisher_->create_datawriter(ros_discovery_topic_.get(), datawriter_qos));
+    ros_to_microros_datawriter_qos_.history().kind =
-
+        eprosima::fastdds::dds::HistoryQosPolicyKind::KEEP_LAST_HISTORY_QOS;
-    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));
+        publisher_->create_datawriter(ros_to_microros_graph_topic_.get(), ros_to_microros_datawriter_qos_));
 
     // Create datareaders
 
@@ -120,9 +125,11 @@ GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
 
     // Set graph cache on change callback function
     graphCache_.set_on_change_callback([this]()
+    {
         {
             std::unique_lock<std::mutex> lock(this->mtx_);
             this->graph_changed_ = true;
+        }
         this->cv_.notify_one();
     });
 
@@ -139,6 +146,7 @@ inline void GraphManager::publish_microros_graph()
             {
                 return this->graph_changed_;
             });
+            graph_changed_ = false;
         }
 
         if (display_on_change_)
@@ -146,7 +154,6 @@ inline void GraphManager::publish_microros_graph()
             std::cout << "Updated uros Graph: graph changed" << std::endl;
             std::cout << graphCache_ << std::endl;
         }
-        graph_changed_ = false;
 
         micro_ros_msgs::msg::Graph graph_message;
 
@@ -292,34 +299,55 @@ inline void GraphManager::publish_microros_graph()
 }
 
 void GraphManager::add_participant(
-        const eprosima::fastdds::dds::DomainParticipant* participant)
+        const eprosima::fastdds::dds::DomainParticipant* participant,
-{
+        bool from_microros,
-    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 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_);
+            graphCache_.add_node(gid, isolated_node_name, isolated_namespace);
-        ros_discovery_datawriter_->write(static_cast<void *>(&info));
+
+        auto it = micro_ros_graph_datawriters_.find(participant);
+        if (it == micro_ros_graph_datawriters_.end())
+        {
+            // Create datawriter
+            eprosima::fastdds::dds::DataWriter * datawriter = publisher_->create_datawriter(ros_discovery_topic_.get(), datawriter_qos_);
+
+            it = micro_ros_graph_datawriters_.insert(
+                std::make_pair(participant, 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(
@@ -350,24 +378,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)
 {
@@ -405,24 +415,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)
 {
@@ -449,14 +441,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:
@@ -464,7 +460,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));
 }
 
 
@@ -549,13 +547,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()
@@ -564,7 +599,7 @@ GraphManager::ParticipantListener::ParticipantListener(
 }
 
 void GraphManager::ParticipantListener::on_participant_discovery(
-        eprosima::fastdds::dds::DomainParticipant* participant,
+        eprosima::fastdds::dds::DomainParticipant* /* participant */,
         eprosima::fastrtps::rtps::ParticipantDiscoveryInfo&& info)
 {
     switch (info.status)
@@ -581,13 +616,15 @@ 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);
+            const rmw_gid_t gid = rmw_fastrtps_shared_cpp::create_rmw_gid("rmw_fastrtps_cpp", info.info.m_guid);
+            graphManager_from_->get_graph_cache().add_participant(gid, enclave);
             break;
         }
         case eprosima::fastrtps::rtps::ParticipantDiscoveryInfo::REMOVED_PARTICIPANT:
         case eprosima::fastrtps::rtps::ParticipantDiscoveryInfo::DROPPED_PARTICIPANT:
         {
-            graphManager_from_->remove_participant(info.info.m_guid);
+            const rmw_gid_t gid = rmw_fastrtps_shared_cpp::create_rmw_gid("rmw_fastrtps_cpp", info.info.m_guid);
+            graphManager_from_->get_graph_cache().remove_participant(gid);
             break;
         }
         default:
@@ -597,6 +634,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)
@@ -613,7 +696,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:
@@ -640,7 +723,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:
@@ -656,7 +739,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(
@@ -664,7 +746,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/agent/graph_manager/graph_typesupport.cpp

@@ -17,6 +17,8 @@
 
 #include <agent/graph_manager/graph_typesupport.hpp>
 
+#include <string>
+
 namespace uros {
 namespace agent {
 namespace graph_manager {

micro_ros_agent/src/main.cpp

@@ -14,6 +14,9 @@
 
 #include <agent/Agent.hpp>
 
+#include <string>
+#include <vector>
+
 int main(int argc, char** argv)
 {
     uros::agent::Agent micro_ros_agent;
@@ -27,6 +30,11 @@ int main(int argc, char** argv)
     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]));
     }