Bring old xrceanget name back for superbuild

Signed-off-by: Raul Sanchez-Mateos <raul@eprosima.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

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

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.
@@ -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,64 @@
 Changelog for package micro-ros_agent
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+5.0.20 (2024-10-14)
+-------------------
+* Bump micro-ROS-Agent to Fast DDS v3.0.1 (`#237 <https://github.com/micro-ROS/micro-ROS-Agent/issues/237>`_)
+
+5.0.2 (2024-05-31)
+------------------
+* Jazzy Release
+* Bump Micro XRCE-DDS Agent (`#226 <https://github.com/micro-ROS/micro-ROS-Agent/issues/226>`_)
+
+5.0.1 (2024-01-29)
+------------------
+* Fix thread include (`#216 <https://github.com/micro-ROS/micro-ROS-Agent/issues/216>`_) (`#218 <https://github.com/micro-ROS/micro-ROS-Agent/issues/218>`_)
+
+5.0.0 (2023-06-06)
+------------------
+* Add empty type key hash to GraphCache (`#189 <https://github.com/micro-ROS/micro-ROS-Agent/issues/189>`_)
+* Contributors: Antonio Cuadros
+
+4.0.2 (2022-09-28)
+------------------
+* Fix Datawriter destruction (`#169 <https://github.com/micro-ROS/micro-ROS-Agent/issues/169>`_) (`#170 <https://github.com/micro-ROS/micro-ROS-Agent/issues/170>`_)
+* Synchronise predicate (`#160 <https://github.com/micro-ROS/micro-ROS-Agent/issues/160>`_) (`#165 <https://github.com/micro-ROS/micro-ROS-Agent/issues/165>`_)
+
+4.0.1 (2022-06-13)
+------------------
+* Fix memory leak in graph manager (`#147 <https://github.com/micro-ROS/micro-ROS-Agent/issues/147>`_) (`#148 <https://github.com/micro-ROS/micro-ROS-Agent/issues/148>`_)
+
+4.0.0 (2022-05-25)
+------------------
+
+3.0.1 (2022-03-25)
+------------------
+* Add services to graph manager (`#127 <https://github.com/micro-ROS/micro-ROS-Agent/issues/127>`_) (`#129 <https://github.com/micro-ROS/micro-ROS-Agent/issues/129>`_)
+* Add used missing includes (`#116 <https://github.com/micro-ROS/micro-ROS-Agent/issues/116>`_) (`#124 <https://github.com/micro-ROS/micro-ROS-Agent/issues/124>`_)
+* Add system logger flag (`#118 <https://github.com/micro-ROS/micro-ROS-Agent/issues/118>`_) (`#119 <https://github.com/micro-ROS/micro-ROS-Agent/issues/119>`_)
+* Add condition variable include (`#113 <https://github.com/micro-ROS/micro-ROS-Agent/issues/113>`_) (`#114 <https://github.com/micro-ROS/micro-ROS-Agent/issues/114>`_)
+* pass system name to xrceagent (`#110 <https://github.com/micro-ROS/micro-ROS-Agent/issues/110>`_) (`#112 <https://github.com/micro-ROS/micro-ROS-Agent/issues/112>`_)
+* Fix memory leak in FastDDS datawriter (`#107 <https://github.com/micro-ROS/micro-ROS-Agent/issues/107>`_) (`#109 <https://github.com/micro-ROS/micro-ROS-Agent/issues/109>`_)
+
+3.0.0 (2021-09-13)
+------------------
+
+1.0.1 (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,13 +19,22 @@ option(UROSAGENT_GENERATE_PROFILE
   )
 set(CMAKE_C_CLANG_TIDY clang-tidy -checks=*)
 
+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)
 find_package(rosidl_cmake REQUIRED)
 find_package(fastcdr REQUIRED)
-find_package(fastrtps REQUIRED)
+find_package(fastdds REQUIRED)
 find_package(fastrtps_cmake_module REQUIRED)
 find_package(rmw_dds_common REQUIRED)
 find_package(rmw REQUIRED)
@@ -59,7 +68,7 @@ ament_target_dependencies(${PROJECT_NAME}
   rosidl_runtime_cpp
   rosidl_typesupport_cpp
   fastcdr
-  fastrtps
+  fastdds
   rmw_dds_common
   rmw
   rmw_fastrtps_shared_cpp
@@ -69,7 +78,7 @@ ament_target_dependencies(${PROJECT_NAME}
 target_link_libraries(${PROJECT_NAME}
   microxrcedds_agent
   fastcdr
-  fastrtps
+  fastdds
   $<$<BOOL:$<PLATFORM_ID:Linux>>:rt>
   $<$<BOOL:$<PLATFORM_ID:Linux>>:dl>
   )
@@ -113,6 +122,13 @@ install(
     lib/${PROJECT_NAME}
   )
 
+install(
+  DIRECTORY
+    launch
+  DESTINATION
+    share/${PROJECT_NAME}
+  )
+
 if(UROSAGENT_GENERATE_PROFILE)
   set(_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}/python")
 
@@ -122,7 +138,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}")
@@ -207,7 +223,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 +257,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/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 3 EXACT QUIET)
+if(NOT xrceagent_FOUND)
+    ExternalProject_Add(xrceagent
+            GIT_REPOSITORY
+                https://github.com/eProsima/Micro-XRCE-DDS-Agent.git
+            GIT_TAG
+                v3.0.0
+            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 {
@@ -41,7 +45,9 @@ public:
 private:
 
     eprosima::uxr::AgentInstance& xrce_dds_agent_instance_;
-    std::unique_ptr<graph_manager::GraphManager> graph_manager_;
+    std::map<eprosima::fastdds::dds::DomainId_t, std::shared_ptr<graph_manager::GraphManager>> graph_manager_map_;
+
+    std::shared_ptr<graph_manager::GraphManager> find_or_create_graph_manager(eprosima::fastdds::dds::DomainId_t domain_id);
 };
 
 }  // namespace agent

micro_ros_agent/include/agent/graph_manager/graph_manager.hpp

@@ -12,28 +12,28 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "fastrtps/Domain.h"
+#ifndef _UROS_AGENT_GRAPH_MANAGER_HPP
-#include <fastrtps/TopicDataType.h>
+#define _UROS_AGENT_GRAPH_MANAGER_HPP
-#include "fastrtps/attributes/ParticipantAttributes.h"
-#include "fastrtps/participant/Participant.h"
-#include "fastrtps/participant/ParticipantListener.h"
-#include "fastrtps/attributes/PublisherAttributes.h"
-#include "fastrtps/publisher/Publisher.h"
-#include <fastrtps/publisher/PublisherListener.h>
-#include <fastrtps/rtps/common/MatchingInfo.h>
 
+#include "fastdds/dds/topic/TopicDataType.hpp"
+#include "fastdds/rtps/attributes/RTPSParticipantAttributes.hpp"
+#include "fastdds/rtps/participant/RTPSParticipant.hpp"
+#include "fastdds/rtps/participant/RTPSParticipantListener.hpp"
+#include "fastdds/rtps/RTPSDomain.hpp"
 #include <fastdds/dds/domain/DomainParticipant.hpp>
 #include <fastdds/dds/domain/DomainParticipantFactory.hpp>
 #include <fastdds/dds/domain/DomainParticipantListener.hpp>
 #include <fastdds/dds/domain/qos/DomainParticipantQos.hpp>
 #include <fastdds/dds/publisher/DataWriter.hpp>
-#include <fastdds/dds/publisher/qos/DataWriterQos.hpp>
 #include <fastdds/dds/publisher/Publisher.hpp>
+#include <fastdds/dds/publisher/PublisherListener.hpp>
+#include <fastdds/dds/publisher/qos/DataWriterQos.hpp>
 #include <fastdds/dds/subscriber/DataReader.hpp>
+#include <fastdds/dds/subscriber/DataReaderListener.hpp>
 #include <fastdds/dds/subscriber/qos/DataReaderQos.hpp>
 #include <fastdds/dds/subscriber/SampleInfo.hpp>
 #include <fastdds/dds/subscriber/Subscriber.hpp>
-#include <fastdds/dds/subscriber/DataReaderListener.hpp>
+#include <fastdds/rtps/common/MatchingInfo.hpp>
 
 #include "rmw/types.h"
 #include "rmw/names_and_types.h"
@@ -58,8 +58,11 @@
 #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>
+#include <thread>
 
 namespace uros {
 namespace agent {
@@ -75,7 +78,7 @@ public:
     /**
      * @brief   Default constructor.
      */
-    GraphManager();
+    GraphManager(eprosima::fastdds::dds::DomainId_t domain_id);
 
     /**
      * @brief   Default destructor.
@@ -89,28 +92,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.
@@ -119,7 +122,7 @@ public:
      * @param   datawriter Pointer to the datawriter to be added.
      */
     void add_datawriter(
-            const eprosima::fastrtps::rtps::GUID_t& datawriter_guid,
+            const eprosima::fastdds::rtps::GUID_t& datawriter_guid,
             const eprosima::fastdds::dds::DomainParticipant* participant,
             const eprosima::fastdds::dds::DataWriter* datawriter);
 
@@ -132,33 +135,18 @@ public:
      * @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 eprosima::fastdds::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::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.
      */
     void remove_datawriter(
-            const eprosima::fastrtps::rtps::GUID_t& datawriter_guid);
+            const eprosima::fastdds::rtps::GUID_t& datawriter_guid);
 
     /**
      * @brief   Adds a DDS datareader to the graph tree.
@@ -167,7 +155,7 @@ public:
      * @param   datareader Pointer to the datareader to be added.
      */
     void add_datareader(
-            const eprosima::fastrtps::rtps::GUID_t& datareader_guid,
+            const eprosima::fastdds::rtps::GUID_t& datareader_guid,
             const eprosima::fastdds::dds::DomainParticipant* participant,
             const eprosima::fastdds::dds::DataReader* datareader);
 
@@ -177,36 +165,21 @@ public:
      * @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.
+     * @param   reader_qos QOS of the datareader to be included into the graph tree.
      */
     void add_datareader(
-            const eprosima::fastrtps::rtps::GUID_t& datareader_guid,
+            const eprosima::fastdds::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::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.
      */
     void remove_datareader(
-            const  eprosima::fastrtps::rtps::GUID_t& datareader_guid);
+            const  eprosima::fastdds::rtps::GUID_t& datareader_guid);
 
     /**
      * @brief   Associates a certain DDS entity with a provided participant.
@@ -215,7 +188,7 @@ public:
      * @param   entity_kind Kind of the DDS entity.
      */
     void associate_entity(
-            const eprosima::fastrtps::rtps::GUID_t& entity_guid,
+            const eprosima::fastdds::rtps::GUID_t& entity_guid,
             const eprosima::fastdds::dds::DomainParticipant* participant,
             const dds::xrce::ObjectKind& entity_kind);
 
@@ -236,21 +209,28 @@ private:
                 GraphManager* graph_manager);
     private:
 
-        template <typename Info>
+        template <typename DiscoveryStatus, typename Info>
         void process_discovery_info(
+                DiscoveryStatus reason,
                 const Info& proxyData);
 
         void on_participant_discovery(
                 eprosima::fastdds::dds::DomainParticipant* participant,
-                eprosima::fastrtps::rtps::ParticipantDiscoveryInfo&& info) override;
+                eprosima::fastdds::rtps::ParticipantDiscoveryStatus reason,
+                const eprosima::fastdds::dds::ParticipantBuiltinTopicData& info,
+                bool& should_be_ignored) override;
 
-        void on_subscriber_discovery(
+        void on_data_reader_discovery(
-                eprosima::fastdds::dds::DomainParticipant* /*participant*/,
+                eprosima::fastdds::dds::DomainParticipant* participant,
-                eprosima::fastrtps::rtps::ReaderDiscoveryInfo&& info) override;
+                eprosima::fastdds::rtps::ReaderDiscoveryStatus reason,
+                const eprosima::fastdds::dds::SubscriptionBuiltinTopicData& info,
+                bool& should_be_ignored) override;
 
-        void on_publisher_discovery(
+        void on_data_writer_discovery(
-                eprosima::fastdds::dds::DomainParticipant* /*participant*/,
+                eprosima::fastdds::dds::DomainParticipant* participant,
-                eprosima::fastrtps::rtps::WriterDiscoveryInfo&& info) override;
+                eprosima::fastdds::rtps::WriterDiscoveryStatus reason,
+                const eprosima::fastdds::dds::PublicationBuiltinTopicData& info,
+                bool& should_be_ignored) override;
 
         GraphManager* graphManager_from_;
     };
@@ -292,13 +272,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_;
@@ -310,9 +304,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/include/agent/graph_manager/graph_typesupport.hpp

@@ -15,18 +15,16 @@
 #ifndef UROS_AGENT_GRAPH_PARTICIPANTS_TYPESUPPORT_HPP_
 #define UROS_AGENT_GRAPH_PARTICIPANTS_TYPESUPPORT_HPP_
 
-#include "fastrtps/Domain.h"
+#include "fastdds/dds/publisher/Publisher.hpp"
-#include <fastrtps/TopicDataType.h>
+#include "fastdds/dds/topic/TopicDataType.hpp"
-#include "fastrtps/attributes/ParticipantAttributes.h"
+#include "fastdds/rtps/attributes/RTPSParticipantAttributes.hpp"
-#include "fastrtps/participant/Participant.h"
+#include "fastdds/rtps/participant/RTPSParticipant.hpp"
-#include "fastrtps/participant/ParticipantListener.h"
+#include "fastdds/rtps/participant/RTPSParticipantListener.hpp"
-#include "fastrtps/attributes/PublisherAttributes.h"
+#include "fastdds/rtps/RTPSDomain.hpp"
-#include "fastrtps/publisher/Publisher.h"
-#include <fastrtps/publisher/PublisherListener.h>
-#include <fastrtps/rtps/common/MatchingInfo.h>
-
 #include <fastdds/dds/domain/DomainParticipant.hpp>
 #include <fastdds/dds/domain/qos/DomainParticipantQos.hpp>
+#include <fastdds/dds/publisher/PublisherListener.hpp>
+#include <fastdds/rtps/common/MatchingInfo.hpp>
 
 #include "rmw/types.h"
 #include "rmw/impl/cpp/key_value.hpp"
@@ -59,24 +57,31 @@ public:
     ParticipantEntitiesInfoTypeSupport();
 
     virtual bool serialize(
-            void* data,
+            const void* const data,
-            eprosima::fastrtps::rtps::SerializedPayload_t* payload) override;
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
 
     virtual bool deserialize(
-            eprosima::fastrtps::rtps::SerializedPayload_t* payload,
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
             void* data) override;
 
-    virtual std::function<uint32_t()> getSerializedSizeProvider(
+    virtual uint32_t calculate_serialized_size(
-            void* data) override;
+            const void* const data,
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
 
-    virtual void* createData() override;
+    virtual void* create_data() override;
 
-    virtual void deleteData(void* data) override;
+    virtual void delete_data(void* data) override;
 
-    virtual bool getKey(
+    virtual bool compute_key(
-            void* data,
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
-            eprosima::fastrtps::rtps::InstanceHandle_t* handle,
+            eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
-            bool force_md5) override;
+            bool force_md5 = false) override;
+
+    virtual bool compute_key(
+            const void* const data,
+            eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+            bool force_md5 = false) override;
 
 private:
 
@@ -95,24 +100,31 @@ public:
     MicrorosGraphInfoTypeSupport();
 
     virtual bool serialize(
-            void* data,
+            const void* const data,
-            eprosima::fastrtps::rtps::SerializedPayload_t* payload) override;
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
 
     virtual bool deserialize(
-            eprosima::fastrtps::rtps::SerializedPayload_t* payload,
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
             void* data) override;
 
-    virtual std::function<uint32_t()> getSerializedSizeProvider(
+    virtual uint32_t calculate_serialized_size(
-            void* data) override;
+            const void* const data,
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation) override;
 
-    virtual void* createData() override;
+    virtual void* create_data() override;
 
-    virtual void deleteData(void* data) override;
+    virtual void delete_data(void* data) override;
 
-    virtual bool getKey(
+    virtual bool compute_key(
-            void* data,
+            eprosima::fastdds::rtps::SerializedPayload_t& payload,
-            eprosima::fastrtps::rtps::InstanceHandle_t* handle,
+            eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
-            bool force_md5) override;
+            bool force_md5 = false) override;
+
+    virtual bool compute_key(
+            const void* const data,
+            eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+            bool force_md5 = false) override;
 
 private:
 

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/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>5.0.20</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,12 +17,14 @@
 
 #include <agent/Agent.hpp>
 
+#include <utility>
+#include <memory>
+
 namespace uros {
 namespace agent {
 
 Agent::Agent()
     : xrce_dds_agent_instance_(xrce_dds_agent_instance_.getInstance())
-    , graph_manager_(nullptr)
 {
 }
 
@@ -33,8 +35,6 @@ bool Agent::create(
     bool result = xrce_dds_agent_instance_.create(argc, argv);
     if (result)
     {
-        graph_manager_.reset(new graph_manager::GraphManager());
-
         /**
          * Add CREATE_PARTICIPANT callback.
          */
@@ -43,6 +43,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 +59,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,14 +77,11 @@ bool Agent::create(
                 const eprosima::fastdds::dds::DomainParticipant* participant,
                 const eprosima::fastdds::dds::DataWriter* datawriter) -> void
             {
-                // TODO(jamoralp): Workaround for Fast-DDS bug #9977. Remove when fixed
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
-                const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
+
-                    datawriter->get_instance_handle();
+                graph_manager_->add_datawriter(datawriter->guid(), participant, datawriter);
-                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,
@@ -96,15 +95,13 @@ 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
             {
-                // TODO(jamoralp): Workaround for Fast-DDS bug #9977. Remove when fixed
+
-                const eprosima::fastrtps::rtps::InstanceHandle_t instance_handle =
+                auto graph_manager_ = find_or_create_graph_manager(participant->get_domain_id());
-                    datawriter->get_instance_handle();
+
-                const eprosima::fastrtps::rtps::GUID_t datawriter_guid =
+                graph_manager_->remove_datawriter(datawriter->guid());
-                    eprosima::fastrtps::rtps::iHandle2GUID(instance_handle);
-                graph_manager_->remove_datawriter(datawriter_guid);
             });
 
         xrce_dds_agent_instance_.add_middleware_callback(
@@ -122,11 +119,13 @@ 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 =
+                const eprosima::fastdds::rtps::InstanceHandle_t instance_handle =
                     datareader->get_instance_handle();
-                const eprosima::fastrtps::rtps::GUID_t datareader_guid =
+                const eprosima::fastdds::rtps::GUID_t datareader_guid =
-                    eprosima::fastrtps::rtps::iHandle2GUID(instance_handle);
+                    eprosima::fastdds::rtps::iHandle2GUID(instance_handle);
                 graph_manager_->add_datareader(datareader_guid, participant, datareader);
                 graph_manager_->associate_entity(
                     datareader_guid, participant, dds::xrce::OBJK_DATAREADER);
@@ -143,14 +142,16 @@ 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 =
+                const eprosima::fastdds::rtps::InstanceHandle_t instance_handle =
                     datareader->get_instance_handle();
-                const eprosima::fastrtps::rtps::GUID_t datareader_guid =
+                const eprosima::fastdds::rtps::GUID_t datareader_guid =
-                    eprosima::fastrtps::rtps::iHandle2GUID(instance_handle);
+                    eprosima::fastdds::rtps::iHandle2GUID(instance_handle);
                 graph_manager_->remove_datareader(datareader_guid);
             });
 
@@ -158,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::fastdds::rtps::InstanceHandle_t instance_handle =
+                    datareader->get_instance_handle();
+                const eprosima::fastdds::rtps::GUID_t datareader_guid =
+                    eprosima::fastdds::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::fastdds::rtps::InstanceHandle_t instance_handle =
+                    datareader->get_instance_handle();
+                const eprosima::fastdds::rtps::GUID_t datareader_guid =
+                    eprosima::fastdds::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::fastdds::rtps::InstanceHandle_t instance_handle =
+                    datareader->get_instance_handle();
+                const eprosima::fastdds::rtps::GUID_t datareader_guid =
+                    eprosima::fastdds::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::fastdds::rtps::InstanceHandle_t instance_handle =
+                    datareader->get_instance_handle();
+                const eprosima::fastdds::rtps::GUID_t datareader_guid =
+                    eprosima::fastdds::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;
@@ -168,6 +291,23 @@ void Agent::run()
     return xrce_dds_agent_instance_.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);
+
+    if (it != graph_manager_map_.end()) {
+        return it->second;
+    }else{
+        return graph_manager_map_.insert(
+            std::make_pair(
+                domain_id,
+                std::make_shared<graph_manager::GraphManager>(domain_id)
+            )
+        ).first->second;
+    }
+}
+
 }  // namespace agent
 }  // namespace uros
 #endif  // _UROS_AGENT_AGENT_CPP

micro_ros_agent/src/agent/graph_manager/graph_manager.cpp

@@ -16,16 +16,23 @@
 #define _UROS_AGENT_GRAPH_MANAGER_CPP
 
 #include <agent/graph_manager/graph_manager.hpp>
+#include <fastdds/dds/core/detail/DDSReturnCode.hpp>
+#include <fastdds/rtps/participant/ParticipantDiscoveryInfo.hpp>
+#include <fastdds/rtps/reader/ReaderDiscoveryStatus.hpp>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace uros {
 namespace agent {
 namespace graph_manager {
 
-GraphManager::GraphManager()
+GraphManager::GraphManager(eprosima::fastdds::dds::DomainId_t domain_id)
-    // : eprosima::fastrtps::ParticipantListener()
+    : domain_id_(domain_id)
-    : graph_changed_(false)
+    , graph_changed_(false)
     , display_on_change_(false)
-    , enclave_("/")
     , mtx_()
     , cv_()
     , graphCache_()
@@ -36,25 +43,27 @@ GraphManager::GraphManager()
     , microros_graph_info_typesupport_(std::make_unique<
         eprosima::fastdds::dds::TypeSupport>(new graph_manager::MicrorosGraphInfoTypeSupport()))
 {
-    // Create DomainParticipant
+    eprosima::fastdds::dds::DomainParticipantFactory::get_instance()->load_profiles();
-    eprosima::fastdds::dds::DomainId_t domain_id(0);
 
+    // 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;
+        eprosima::fastdds::rtps::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
     participant_qos.wire_protocol().builtin.writerHistoryMemoryPolicy =
-        eprosima::fastrtps::rtps::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
+        eprosima::fastdds::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_);
@@ -78,28 +87,26 @@ GraphManager::GraphManager()
         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;
+        eprosima::fastdds::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
 
@@ -109,7 +116,7 @@ GraphManager::GraphManager()
         eprosima::fastdds::dds::HistoryQosPolicyKind::KEEP_LAST_HISTORY_QOS;
     datareader_qos.history().depth = 1;
     datareader_qos.endpoint().history_memory_policy =
-        eprosima::fastrtps::rtps::MemoryManagementPolicy::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
+        eprosima::fastdds::rtps::MemoryManagementPolicy::PREALLOCATED_WITH_REALLOC_MEMORY_MODE;
     datareader_qos.reliability().kind =
         eprosima::fastdds::dds::ReliabilityQosPolicyKind::RELIABLE_RELIABILITY_QOS;
     datareader_qos.durability().kind =
@@ -121,9 +128,11 @@ GraphManager::GraphManager()
 
     // 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();
     });
 
@@ -140,6 +149,7 @@ inline void GraphManager::publish_microros_graph()
             {
                 return this->graph_changed_;
             });
+            graph_changed_ = false;
         }
 
         if (display_on_change_)
@@ -147,7 +157,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;
 
@@ -293,38 +302,59 @@ 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(
-        const eprosima::fastrtps::rtps::GUID_t& datawriter_guid,
+        const eprosima::fastdds::rtps::GUID_t& datawriter_guid,
         const eprosima::fastdds::dds::DomainParticipant* participant,
         const eprosima::fastdds::dds::DataWriter* datawriter)
 {
@@ -335,10 +365,10 @@ void GraphManager::add_datawriter(
 }
 
 void GraphManager::add_datawriter(
-        const eprosima::fastrtps::rtps::GUID_t& datawriter_guid,
+        const eprosima::fastdds::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::rtps::GUID_t& participant_guid,
         const eprosima::fastdds::dds::DataWriterQos& writer_qos)
 {
     const rmw_gid_t datawriter_gid = rmw_fastrtps_shared_cpp::create_rmw_gid(
@@ -347,30 +377,12 @@ void GraphManager::add_datawriter(
         "rmw_fastrtps_cpp", participant_guid);
     const rmw_qos_profile_t qos_profile = fastdds_qos_to_rmw_qos(writer_qos);
 
-    graphCache_.add_entity(datawriter_gid, topic_name,
+    graphCache_.add_entity(datawriter_gid, topic_name, type_name,
-        type_name, participant_gid, qos_profile, false);
+        rosidl_get_zero_initialized_type_hash(), 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)
+        const eprosima::fastdds::rtps::GUID_t& datawriter_guid)
 {
     const rmw_gid_t datawriter_gid = rmw_fastrtps_shared_cpp::create_rmw_gid(
         "rmw_fastrtps_cpp", datawriter_guid);
@@ -379,7 +391,7 @@ void GraphManager::remove_datawriter(
 }
 
 void GraphManager::add_datareader(
-        const eprosima::fastrtps::rtps::GUID_t& datareader_guid,
+        const eprosima::fastdds::rtps::GUID_t& datareader_guid,
         const eprosima::fastdds::dds::DomainParticipant* participant,
         const eprosima::fastdds::dds::DataReader* datareader)
 {
@@ -390,10 +402,10 @@ void GraphManager::add_datareader(
 }
 
 void GraphManager::add_datareader(
-        const eprosima::fastrtps::rtps::GUID_t& datareader_guid,
+        const eprosima::fastdds::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::rtps::GUID_t& participant_guid,
         const eprosima::fastdds::dds::DataReaderQos& reader_qos)
 {
     const rmw_gid_t datareader_gid = rmw_fastrtps_shared_cpp::create_rmw_gid(
@@ -402,30 +414,17 @@ void GraphManager::add_datareader(
         "rmw_fastrtps_cpp", participant_guid);
     const rmw_qos_profile_t qos_profile = fastdds_qos_to_rmw_qos(reader_qos);
 
-    graphCache_.add_entity(datareader_gid, topic_name,
+    // TODO(acuadros95): Use typesupport to calculate type hash on micro-ROS and save and get it from reader_qos.user_data.
-        type_name, participant_gid, qos_profile, true);
+    // Related PRs:
-}
+    // https://github.com/ros2/rmw_dds_common/pull/70
-
+    // https://github.com/ros2/rmw_fastrtps/pull/671
-void GraphManager::add_datareader(
+    // https://github.com/ros2/rmw_fastrtps/pull/680
-        const eprosima::fastrtps::rtps::GUID_t& datareader_guid,
+    graphCache_.add_entity(datareader_gid, topic_name, type_name,
-        const std::string& topic_name,
+        rosidl_get_zero_initialized_type_hash(), participant_gid, qos_profile, true);
-        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)
+        const eprosima::fastdds::rtps::GUID_t& datareader_guid)
 {
     const rmw_gid_t datareader_gid = rmw_fastrtps_shared_cpp::create_rmw_gid(
         "rmw_fastrtps_cpp", datareader_guid);
@@ -434,7 +433,7 @@ void GraphManager::remove_datareader(
 }
 
 void GraphManager::associate_entity(
-        const eprosima::fastrtps::rtps::GUID_t& entity_guid,
+        const eprosima::fastdds::rtps::GUID_t& entity_guid,
         const eprosima::fastdds::dds::DomainParticipant* participant,
         const dds::xrce::ObjectKind& entity_kind)
 {
@@ -450,14 +449,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 +468,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));
 }
 
 
@@ -548,15 +553,52 @@ void GraphManager::update_node_entities_info()
     rmw_dds_common::msg::ParticipantEntitiesInfo entities_info;
     eprosima::fastdds::dds::SampleInfo sample_info;
     if (ros_discovery_datareader_->take_next_sample(&entities_info, &sample_info) ==
-        eprosima::fastrtps::types::ReturnCode_t::RETCODE_OK)
+        eprosima::fastdds::dds::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()
@@ -566,13 +608,18 @@ GraphManager::ParticipantListener::ParticipantListener(
 
 void GraphManager::ParticipantListener::on_participant_discovery(
         eprosima::fastdds::dds::DomainParticipant* participant,
-        eprosima::fastrtps::rtps::ParticipantDiscoveryInfo&& info)
+        eprosima::fastdds::rtps::ParticipantDiscoveryStatus reason,
+        const eprosima::fastdds::dds::ParticipantBuiltinTopicData& info,
+        bool& should_be_ignored)
 {
-    switch (info.status)
+    static_cast<void>(participant);
+    static_cast<void>(should_be_ignored);
+
+    switch (reason)
     {
-        case eprosima::fastrtps::rtps::ParticipantDiscoveryInfo::DISCOVERED_PARTICIPANT:
+        case eprosima::fastdds::rtps::ParticipantDiscoveryStatus::DISCOVERED_PARTICIPANT:
         {
-            auto map = rmw::impl::cpp::parse_key_value(info.info.m_userData);
+            auto map = rmw::impl::cpp::parse_key_value(info.user_data);
             auto name_found = map.find("enclave");
 
             if (map.end() == name_found)
@@ -582,13 +629,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.guid);
+            graphManager_from_->get_graph_cache().add_participant(gid, enclave);
             break;
         }
-        case eprosima::fastrtps::rtps::ParticipantDiscoveryInfo::REMOVED_PARTICIPANT:
+        case eprosima::fastdds::rtps::ParticipantDiscoveryStatus::REMOVED_PARTICIPANT:
-        case eprosima::fastrtps::rtps::ParticipantDiscoveryInfo::DROPPED_PARTICIPANT:
+        case eprosima::fastdds::rtps::ParticipantDiscoveryStatus::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.guid);
+            graphManager_from_->get_graph_cache().remove_participant(gid);
             break;
         }
         default:
@@ -598,74 +647,134 @@ void GraphManager::ParticipantListener::on_participant_discovery(
     }
 }
 
+static eprosima::fastdds::dds::DataWriterQos writer_qos_conversion(
+    const eprosima::fastdds::dds::PublicationBuiltinTopicData& writer_info)
+{
+    eprosima::fastdds::dds::DataWriterQos datawriter_qos;
+    eprosima::fastdds::dds::RTPSReliableWriterQos reliable_writer_qos;
+    reliable_writer_qos.disable_positive_acks = writer_info.disable_positive_acks;
+
+    datawriter_qos.durability(writer_info.durability);
+    datawriter_qos.durability_service(writer_info.durability_service);
+    datawriter_qos.deadline(writer_info.deadline);
+    datawriter_qos.latency_budget(writer_info.latency_budget);
+    datawriter_qos.liveliness(writer_info.liveliness);
+    datawriter_qos.reliability(writer_info.reliability);
+    datawriter_qos.lifespan(writer_info.lifespan);
+    datawriter_qos.user_data(writer_info.user_data);
+    datawriter_qos.ownership(writer_info.ownership);
+    datawriter_qos.ownership_strength(writer_info.ownership_strength);
+    datawriter_qos.destination_order(writer_info.destination_order);
+    datawriter_qos.reliable_writer_qos(reliable_writer_qos);
+    datawriter_qos.representation(writer_info.representation);
+    datawriter_qos.data_sharing(writer_info.data_sharing);
+
+    return datawriter_qos;
+}
+
+static eprosima::fastdds::dds::DataReaderQos reader_qos_conversion(
+    const eprosima::fastdds::rtps::SubscriptionBuiltinTopicData& reader_info)
+{
+    eprosima::fastdds::dds::DataReaderQos datareader_qos;
+    eprosima::fastdds::dds::RTPSReliableReaderQos reliable_reader_qos;
+    reliable_reader_qos.disable_positive_acks = reader_info.disable_positive_acks;
+
+    datareader_qos.durability(reader_info.durability);
+    datareader_qos.deadline(reader_info.deadline);
+    datareader_qos.latency_budget(reader_info.latency_budget);
+    datareader_qos.lifespan(reader_info.lifespan);
+    datareader_qos.liveliness(reader_info.liveliness);
+    datareader_qos.reliability(reader_info.reliability);
+    datareader_qos.ownership(reader_info.ownership);
+    datareader_qos.destination_order(reader_info.destination_order);
+    datareader_qos.user_data(reader_info.user_data);
+    datareader_qos.time_based_filter(reader_info.time_based_filter);
+    datareader_qos.type_consistency(reader_info.type_consistency);
+    datareader_qos.reliable_reader_qos(reliable_reader_qos);
+    datareader_qos.representation(reader_info.representation);
+    datareader_qos.data_sharing(reader_info.data_sharing);
+
+    return datareader_qos;
+}
+
+template <>
+void GraphManager::ParticipantListener::process_discovery_info<eprosima::fastdds::rtps::ReaderDiscoveryStatus, eprosima::fastdds::rtps::SubscriptionBuiltinTopicData>(
+        eprosima::fastdds::rtps::ReaderDiscoveryStatus reason,
+        const eprosima::fastdds::rtps::SubscriptionBuiltinTopicData& reader_info)
+{
+    switch (reason)
+    {
+        case eprosima::fastdds::rtps::ReaderDiscoveryStatus::CHANGED_QOS_READER:
+        {
+            return;
+        }
+        case eprosima::fastdds::rtps::ReaderDiscoveryStatus::DISCOVERED_READER:
+        {
+            const std::string topic_name = reader_info.topic_name.to_string();
+            const std::string type_name = reader_info.type_name.to_string();
+
+            graphManager_from_->add_datareader(reader_info.guid, topic_name, type_name,
+                reader_info.participant_guid, reader_qos_conversion(reader_info));
+            break;
+        }
+        default:
+        {
+            graphManager_from_->remove_datareader(reader_info.guid);
+            break;
+        }
+    }
+}
+
 template <>
-void GraphManager::ParticipantListener::process_discovery_info<eprosima::fastrtps::rtps::ReaderDiscoveryInfo>(
+void GraphManager::ParticipantListener::process_discovery_info<eprosima::fastdds::rtps::WriterDiscoveryStatus, eprosima::fastdds::rtps::PublicationBuiltinTopicData>(
-        const eprosima::fastrtps::rtps::ReaderDiscoveryInfo& reader_info)
+        eprosima::fastdds::rtps::WriterDiscoveryStatus reason,
+        const eprosima::fastdds::rtps::PublicationBuiltinTopicData& writer_info)
 {
-    switch (reader_info.status)
+    switch (reason)
     {
-        case eprosima::fastrtps::rtps::ReaderDiscoveryInfo::CHANGED_QOS_READER:
+        case eprosima::fastdds::rtps::WriterDiscoveryStatus::CHANGED_QOS_WRITER:
         {
             return;
         }
-        case eprosima::fastrtps::rtps::ReaderDiscoveryInfo::DISCOVERED_READER:
+        case eprosima::fastdds::rtps::WriterDiscoveryStatus::DISCOVERED_WRITER:
         {
-            const std::string topic_name = reader_info.info.topicName().to_string();
+            const std::string topic_name = writer_info.topic_name.to_string();
-            const std::string type_name = reader_info.info.typeName().to_string();
+            const std::string type_name = writer_info.type_name.to_string();
 
-            graphManager_from_->add_datareader(reader_info.info.guid(), topic_name, type_name,
+            graphManager_from_->add_datawriter(writer_info.guid, topic_name, type_name,
-                iHandle2GUID(reader_info.info.RTPSParticipantKey()), reader_info.info.m_qos);
+                writer_info.participant_guid, writer_qos_conversion(writer_info));
             break;
         }
         default:
         {
-            graphManager_from_->remove_datareader(reader_info.info.guid());
+            graphManager_from_->remove_datawriter(writer_info.guid);
             break;
         }
     }
 }
 
-template <>
+void GraphManager::ParticipantListener::on_data_reader_discovery(
-void GraphManager::ParticipantListener::process_discovery_info<eprosima::fastrtps::rtps::WriterDiscoveryInfo>(
+        eprosima::fastdds::dds::DomainParticipant* participant,
-        const eprosima::fastrtps::rtps::WriterDiscoveryInfo& writer_info)
+        eprosima::fastdds::rtps::ReaderDiscoveryStatus reason,
+        const eprosima::fastdds::dds::SubscriptionBuiltinTopicData& info,
+        bool& should_be_ignored)
 {
-    switch (writer_info.status)
+    static_cast<void>(participant);
-    {
+    static_cast<void>(should_be_ignored);
-        case eprosima::fastrtps::rtps::WriterDiscoveryInfo::CHANGED_QOS_WRITER:
-        {
-            return;
-        }
-        case eprosima::fastrtps::rtps::WriterDiscoveryInfo::DISCOVERED_WRITER:
-        {
-            const std::string topic_name = writer_info.info.topicName().to_string();
-            const std::string type_name = writer_info.info.typeName().to_string();
 
-            graphManager_from_->add_datawriter(writer_info.info.guid(), topic_name, type_name,
+    process_discovery_info<eprosima::fastdds::rtps::ReaderDiscoveryStatus, eprosima::fastdds::rtps::SubscriptionBuiltinTopicData>(reason, info);
-                iHandle2GUID(writer_info.info.RTPSParticipantKey()), writer_info.info.m_qos);
-            break;
-        }
-        default:
-        {
-            graphManager_from_->remove_datawriter(writer_info.info.guid());
-            break;
-        }
-    }
 }
 
-void GraphManager::ParticipantListener::on_subscriber_discovery(
+void GraphManager::ParticipantListener::on_data_writer_discovery(
-        eprosima::fastdds::dds::DomainParticipant* /*participant*/,
+        eprosima::fastdds::dds::DomainParticipant* participant,
-        eprosima::fastrtps::rtps::ReaderDiscoveryInfo&& info)
+        eprosima::fastdds::rtps::WriterDiscoveryStatus reason,
+        const eprosima::fastdds::dds::PublicationBuiltinTopicData& info,
+        bool& should_be_ignored)
 {
-    process_discovery_info<eprosima::fastrtps::rtps::ReaderDiscoveryInfo>(info);
+    static_cast<void>(participant);
-    // graphManager_from_->associate_entity(info.info.guid(), participant, dds::xrce::OBJK_DATAREADER);
+    static_cast<void>(should_be_ignored);
-}
 
-void GraphManager::ParticipantListener::on_publisher_discovery(
+    process_discovery_info<eprosima::fastdds::rtps::WriterDiscoveryStatus, eprosima::fastdds::rtps::PublicationBuiltinTopicData>(reason, info);
-        eprosima::fastdds::dds::DomainParticipant* /*participant*/,
-        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 {
@@ -39,27 +41,30 @@ ParticipantEntitiesInfoTypeSupport::ParticipantEntitiesInfoTypeSupport()
         ss << message_namespace << "::";
     }
     ss << "dds_::" << message_name << "_";
-    this->setName(ss.str().c_str());
+    this->set_name(ss.str().c_str());
 
-    bool full_bounded = true;
+    char full_bounded;
-    m_typeSize = 4 + callbacks_->max_serialized_size(full_bounded);
+    max_serialized_type_size = 4 + callbacks_->max_serialized_size(full_bounded);
 }
 
 bool ParticipantEntitiesInfoTypeSupport::serialize(
-        void * data,
+        const void* const data,
-        eprosima::fastrtps::rtps::SerializedPayload_t * payload)
+        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+        eprosima::fastdds::dds::DataRepresentationId_t data_representation)
 {
-    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char *>(payload->data),
+    static_cast<void>(data_representation);
-        payload->max_size);
+
+    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char *>(payload.data),
+        payload.max_size);
     eprosima::fastcdr::Cdr scdr(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
-        eprosima::fastcdr::Cdr::DDS_CDR);
+        eprosima::fastcdr::DDS_CDR);
 
     scdr.serialize_encapsulation();
     if (callbacks_->cdr_serialize(data, scdr))
     {
-        payload->encapsulation = (scdr.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS) ?
+        payload.encapsulation = (scdr.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS) ?
             CDR_BE : CDR_LE;
-        payload->length = static_cast<uint32_t>(scdr.getSerializedDataLength());
+        payload.length = static_cast<uint32_t>(scdr.get_serialized_data_length());
         return true;
     }
     else
@@ -69,47 +74,58 @@ bool ParticipantEntitiesInfoTypeSupport::serialize(
 }
 
 bool ParticipantEntitiesInfoTypeSupport::deserialize(
-        eprosima::fastrtps::rtps::SerializedPayload_t * payload,
+        eprosima::fastdds::rtps::SerializedPayload_t& payload,
         void * data)
 {
-    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char *>(payload->data),
+    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char *>(payload.data),
-        payload->length);
+        payload.length);
     eprosima::fastcdr::Cdr dcdr(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
-        eprosima::fastcdr::Cdr::DDS_CDR);
+        eprosima::fastcdr::DDS_CDR);
 
     dcdr.read_encapsulation();
     return callbacks_->cdr_deserialize(dcdr, data);
 }
 
-std::function<uint32_t()> ParticipantEntitiesInfoTypeSupport::getSerializedSizeProvider(
+uint32_t ParticipantEntitiesInfoTypeSupport::calculate_serialized_size(
-        void * data)
+            const void* const data,
-{
+            eprosima::fastdds::dds::DataRepresentationId_t data_representation)
-    return [data, this]() -> uint32_t
 {
+    static_cast<void>(data_representation);
+
     return static_cast<uint32_t>(4 + callbacks_->get_serialized_size(data));
-    };
 }
 
-void * ParticipantEntitiesInfoTypeSupport::createData()
+void * ParticipantEntitiesInfoTypeSupport::create_data()
 {
     return static_cast<void *>(nullptr);
 }
 
-void ParticipantEntitiesInfoTypeSupport::deleteData(
+void ParticipantEntitiesInfoTypeSupport::delete_data(
         void * data)
 {
     (void) data;
 }
 
-bool ParticipantEntitiesInfoTypeSupport::getKey(
+bool ParticipantEntitiesInfoTypeSupport::compute_key(
-        void * data,
+        eprosima::fastdds::rtps::SerializedPayload_t& payload,
-        eprosima::fastrtps::rtps::InstanceHandle_t * handle,
+        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
-        bool force_md5)
+        bool force_md5 /* = false */)
+{
+    (void) payload;
+    (void) ihandle;
+    (void) force_md5;
+    return is_compute_key_provided;
+}
+
+bool ParticipantEntitiesInfoTypeSupport::compute_key(
+        const void * const data,
+        eprosima::fastdds::rtps::InstanceHandle_t& handle,
+        bool force_md5 /* = false */)
 {
     (void) data;
     (void) handle;
     (void) force_md5;
-    return m_isGetKeyDefined;
+    return is_compute_key_provided;
 }
 
 
@@ -131,27 +147,30 @@ MicrorosGraphInfoTypeSupport::MicrorosGraphInfoTypeSupport()
         ss << message_namespace << "::";
     }
     ss << "dds_::" << message_name << "_";
-    this->setName(ss.str().c_str());
+    this->set_name(ss.str().c_str());
 
-    bool full_bounded = true;
+    char full_bounded;
-    m_typeSize = 4 + callbacks_->max_serialized_size(full_bounded);
+    max_serialized_type_size = 4 + callbacks_->max_serialized_size(full_bounded);
 }
 
 bool MicrorosGraphInfoTypeSupport::serialize(
-        void * data,
+        const void* const data,
-        eprosima::fastrtps::rtps::SerializedPayload_t * payload)
+        eprosima::fastdds::rtps::SerializedPayload_t& payload,
+        eprosima::fastdds::dds::DataRepresentationId_t data_representation)
 {
-    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char *>(payload->data),
+    static_cast<void>(data_representation);
-        payload->max_size);
+
+    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char *>(payload.data),
+        payload.max_size);
     eprosima::fastcdr::Cdr scdr(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
-        eprosima::fastcdr::Cdr::DDS_CDR);
+        eprosima::fastcdr::DDS_CDR);
 
     scdr.serialize_encapsulation();
     if (callbacks_->cdr_serialize(data, scdr))
     {
-        payload->encapsulation = (scdr.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS) ?
+        payload.encapsulation = (scdr.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS) ?
             CDR_BE : CDR_LE;
-        payload->length = static_cast<uint32_t>(scdr.getSerializedDataLength());
+        payload.length = static_cast<uint32_t>(scdr.get_serialized_data_length());
         return true;
     }
     else
@@ -161,47 +180,58 @@ bool MicrorosGraphInfoTypeSupport::serialize(
 }
 
 bool MicrorosGraphInfoTypeSupport::deserialize(
-        eprosima::fastrtps::rtps::SerializedPayload_t * payload,
+        eprosima::fastdds::rtps::SerializedPayload_t& payload,
         void* data)
 {
-    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char *>(payload->data),
+    eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char *>(payload.data),
-        payload->length);
+        payload.length);
     eprosima::fastcdr::Cdr dcdr(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
-        eprosima::fastcdr::Cdr::DDS_CDR);
+        eprosima::fastcdr::DDS_CDR);
 
     dcdr.read_encapsulation();
     return callbacks_->cdr_deserialize(dcdr, data);
 }
 
-std::function<uint32_t()> MicrorosGraphInfoTypeSupport::getSerializedSizeProvider(
+uint32_t MicrorosGraphInfoTypeSupport::calculate_serialized_size(
-        void * data)
+        const void* const data,
-{
+        eprosima::fastdds::dds::DataRepresentationId_t data_representation)
-    return [data, this]() -> uint32_t
 {
+    static_cast<void>(data_representation);
+
     return static_cast<uint32_t>(4 + callbacks_->get_serialized_size(data));
-    };
 }
 
-void * MicrorosGraphInfoTypeSupport::createData()
+void * MicrorosGraphInfoTypeSupport::create_data()
 {
     return static_cast<void *>(nullptr);
 }
 
-void MicrorosGraphInfoTypeSupport::deleteData(
+void MicrorosGraphInfoTypeSupport::delete_data(
         void * data)
 {
     (void) data;
 }
 
-bool MicrorosGraphInfoTypeSupport::getKey(
+bool MicrorosGraphInfoTypeSupport::compute_key(
-        void * data,
+        eprosima::fastdds::rtps::SerializedPayload_t& payload,
-        eprosima::fastrtps::rtps::InstanceHandle_t * handle,
+        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
-        bool force_md5)
+        bool force_md5 /* = false */)
+{
+    (void) payload;
+    (void) ihandle;
+    (void) force_md5;
+    return is_compute_key_provided;
+}
+
+bool MicrorosGraphInfoTypeSupport::compute_key(
+        const void* const data,
+        eprosima::fastdds::rtps::InstanceHandle_t& ihandle,
+        bool force_md5 /* = false */)
 {
     (void) data;
-    (void) handle;
+    (void) ihandle;
     (void) force_md5;
-    return m_isGetKeyDefined;
+    return is_compute_key_provided;
 }
 
 }  // namespace graph_manager

micro_ros_agent/src/main.cpp

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