added backward compatible example

Author: alberto

README.md

@@ -101,6 +101,12 @@ The other process create an approximate and an exact time subscribers.
 
 One process sets its own parameters. The other reads them.
 
+#### Backward compatibility
+
+[**README**](simple_backward_compatible)
+
+Allow nodes compiled against different versions of a message interface to communicate.
+
 
 #### Secure ROS2
 

simple_backward_compatible/CMakeLists.txt

@@ -0,0 +1,49 @@
+cmake_minimum_required(VERSION 3.5)
+project(simple_backward_compatible)
+
+## Comment the following line if you want to build V1 of the code to test backward compatibility
+#set(BUILD_V2 true)
+
+# Default to C++14
+if(NOT CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 14)
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+find_package(ament_cmake REQUIRED)
+find_package(rosidl_default_generators REQUIRED)
+find_package(rclcpp REQUIRED)
+
+if (BUILD_V2)
+  add_definitions(-DBUILD_V2)
+  set (INTERFACES_PATH "interfaces_v2")
+else()
+  set (INTERFACES_PATH "interfaces_v1")
+endif()
+
+set(dependencies
+  rclcpp
+)
+
+message(" -------------------> BUILDING ${INTERFACES_PATH}")
+
+rosidl_generate_interfaces(${PROJECT_NAME}
+  ${INTERFACES_PATH}/msg/OptionalFields.msg
+)
+
+add_executable(publisher_main src/publisher_main.cpp)
+ament_target_dependencies(publisher_main ${dependencies})
+rosidl_target_interfaces(publisher_main ${PROJECT_NAME} "rosidl_typesupport_cpp")
+
+add_executable(subscriber_main src/subscriber_main.cpp)
+ament_target_dependencies(subscriber_main ${dependencies})
+rosidl_target_interfaces(subscriber_main ${PROJECT_NAME} "rosidl_typesupport_cpp")
+
+install(TARGETS publisher_main subscriber_main
+  DESTINATION lib/${PROJECT_NAME}
+)
+
+ament_package()

simple_backward_compatible/README.md

@@ -0,0 +1,64 @@
+# Simple Backward Compatibility
+
+
+This package is meant to be used to demonstrate how to create messages with optional fields and how to exploit them for achieving backward compatibility.
+
+Long story short, usually when you add a new field to a message interface and then you try to send these updated messages to a subscriber which has been compiled against an old version of the message library (i.e. without the new field) a memory error will arise.
+
+
+ROS2 introduces optional fields which are dynamically allocated by the subscriber.
+
+
+## How to use it
+
+Let's start by creating a workspace and compile two simple publisher and subscriber nodes.
+
+```
+mkdir -p ws_v1/src
+cd ws_v1/src
+ln -s <PATH_TO_THIS_REPO>/simple_backward_compatible .
+cd ..
+colcon build
+```
+
+The nodes created in this workspace will communicate using [this message interface](interfaces_v1/msg/Optional_fields.msg) which we will call v1.
+
+You can immediately run the subscriber node.
+
+```
+source install/local_setup.sh
+ros2 run simple_backward_compatible subscriber_main
+```
+
+Now, while the subscriber is still running, open a new terminal and create a second workspace.
+
+```
+mkdir -p ws_v2/src
+cd ws_v2/src
+ln -s <PATH_TO_THIS_REPO>/simple_backward_compatible .
+cd ..
+```
+
+However this time, before compiling, let's make a quick change.
+Open with a text editor `CMakeLists.txt` and uncomment line #5 (the one saying `#set(BUILD_V2 true)`).
+Then build.
+
+```
+colcon build
+```
+
+You have just told the compiler to use a different version of the message interface, which you can find [here](interfaces_v2/msg/Optional_fields.msg) and we will call it v2.
+
+As you can see, the new messages have some additional fields characterized by variable length arrays.
+You can note from the [publisher code](src/publisher_main.cpp) that the fields of the updated message are being properly filled with values.
+
+Now run a publisher node from this second workspace.
+
+```
+source install/local_setup.sh
+ros2 run simple_backward_compatible publisher_main
+```
+
+You will note that the two nodes are communicating properly, even if compiled against two different versions of the message interfaces.
+
+**NOTE**: if you try to run a v2 subscriber and a v1 publisher you will still get a memory error.

simple_backward_compatible/interfaces_v1/msg/OptionalFields.msg

@@ -0,0 +1 @@
+string data

simple_backward_compatible/interfaces_v2/msg/OptionalFields.msg

@@ -0,0 +1,3 @@
+string data
+bool[<=1] optional_boolean
+int32[] optional_vector

simple_backward_compatible/package.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>simple_backward_compatible</name>
+  <version>0.0.1</version>
+  <description>Examples of sending backward compatible messages to an old subscriber</description>
+  <maintainer email="[email protected]">Alberto Soragna</maintainer>
+  <license>MIT</license>
+  <author>Alberto Soragna</author>
+
+  <buildtool_depend>ament_cmake</buildtool_depend>
+  <buildtool_depend>rosidl_default_generators</buildtool_depend>
+
+  <build_depend>rclcpp</build_depend>
+
+  <exec_depend>rclcpp</exec_depend>
+  <exec_depend>rosidl_default_runtime</exec_depend>
+
+  <member_of_group>rosidl_interface_packages</member_of_group>
+
+  <export>
+    <build_type>ament_cmake</build_type>
+  </export>
+</package>
+

simple_backward_compatible/src/publisher_main.cpp

@@ -0,0 +1,62 @@
+#include <memory>
+#include <iostream>
+#include <thread>
+#include <sstream>
+
+#include "rclcpp/rclcpp.hpp"
+#include "simple_backward_compatible/msg/optional_fields.hpp"
+
+using namespace std::chrono_literals;
+using OptionalFieldsMsg = simple_backward_compatible::msg::OptionalFields;
+
+class SimplePublisherNode : public rclcpp::Node {
+
+public:
+
+    SimplePublisherNode() : Node("publisher_node")
+    {
+        _publisher = this->create_publisher<OptionalFieldsMsg>("my_topic");
+
+        auto period = 500ms;
+        _timer = this->create_wall_timer(period, std::bind(&SimplePublisherNode::publish, this));
+        _count = 0;
+    }
+
+    void publish()
+    {
+        OptionalFieldsMsg::SharedPtr message(new OptionalFieldsMsg());
+
+        _count ++;
+        message->data = "Hello, world! " + std::to_string(_count);
+        #ifdef BUILD_V2
+            message->optional_boolean.push_back(true);
+            message->optional_vector = { 10, 20, 30 };
+        #endif
+
+        _publisher->publish(message);
+
+        #ifdef BUILD_V2
+            RCLCPP_INFO(this->get_logger(), "Publishing VERSION2: '%s'", message->data.c_str());
+        #else
+            RCLCPP_INFO(this->get_logger(), "Publishing: '%s'", message->data.c_str());
+        #endif
+    }
+
+private:
+    rclcpp::Publisher<OptionalFieldsMsg>::SharedPtr _publisher;
+    rclcpp::TimerBase::SharedPtr _timer;
+    int _count;
+};
+
+
+int main(int argc, char ** argv)
+{
+  rclcpp::init(argc, argv);
+
+  std::shared_ptr<SimplePublisherNode> node = std::make_shared<SimplePublisherNode>();
+
+  rclcpp::spin(node);
+
+  rclcpp::shutdown();
+  return 0;
+}

simple_backward_compatible/src/subscriber_main.cpp

@@ -0,0 +1,46 @@
+#include <memory>
+#include <iostream>
+#include <thread>
+#include <sstream>
+
+#include "rclcpp/rclcpp.hpp"
+#include "simple_backward_compatible/msg/optional_fields.hpp"
+
+using OptionalFieldsMsg = simple_backward_compatible::msg::OptionalFields;
+
+class SimpleSubscriberNode : public rclcpp::Node {
+
+public:
+
+    SimpleSubscriberNode() : Node("subscriber_node")
+    {
+        _subscriber = this->create_subscription<OptionalFieldsMsg>("my_topic",
+            std::bind(&SimpleSubscriberNode::simple_callback, this, std::placeholders::_1));
+    }
+
+
+private:
+
+    void simple_callback(const OptionalFieldsMsg::SharedPtr msg)
+    {
+        RCLCPP_INFO(this->get_logger(), "Received msg: '%s'", msg->data.c_str());
+    }
+
+    rclcpp::Subscription<OptionalFieldsMsg>::SharedPtr _subscriber;
+};
+
+
+
+int main(int argc, char ** argv)
+{
+  rclcpp::init(argc, argv);
+
+  std::shared_ptr<SimpleSubscriberNode> node = std::make_shared<SimpleSubscriberNode>();
+
+  rclcpp::spin(node);
+
+  rclcpp::shutdown();
+  return 0;
+}
+
+