Edited Readme files and minor adjustments

Author: iutrilla-rti

examples/routing_service/udp_socket_adapter/test/read_shape_from_socket.py

@@ -5,6 +5,9 @@
 This example shows how to implement a simple Routing Service Adapter plugin
 in C++11 to receive data from a UDP socket using RTI Routing Service.
 
+This examples uses dynamic data API and there is no need to know the data type
+information beforehand.
+
 The code in this directory provides the following components:
 
 -   `src/SocketAdapter` implements the plugin that is loaded by *RTI Routing
@@ -16,8 +19,9 @@ propagate information about the discovered input streams (in this case
 sockets) to the Routing Service.
 -   `src/SocketStreamReader` implements an `StreamReader` that reads sample
 information from a UDP socket.
--   `test/send_shape_to_socket.py` implements a simple tester to send shape
-type data to a UDP socket.
+-   `src/SocketStreamWriter` implements an `StreamWriter` that sends sample
+information to a UDP socket.
+
 
 For more details, please refer to the *RTI Routing Service SDK* documentation.
 
@@ -97,19 +101,17 @@ cmake -DCONNEXTDDS_DIR=<connext dir> -DCMAKE_TOOLCHAIN_FILE=<toolchain file crea
 
 To run the example, you just need to run the following commands from the top
 level folder. This example has been written to allow easy experimentation with
-the Shapes Demo shipped with *RTI Connext DDS* installer bundle. You will find
-some hardcoded references to ShapeType and Square. If you wish to create a
-real Routing Service adapter, you should modify the code and XML accordingly.
+the RTI DDSPing tool shipped with *RTI Connext DDS* installer bundle. If you wish 
+to create a real Routing Service adapter, you should modify the code and XML accordingly.
 
-There is 1 configuration (`-cfgName`) in the Routing Service XML file:
+There are 2 configurations (`-cfgName`) in the Routing Service XML file:
 
 -   **SocketAdapterToDDS** - It reads data from a UDP socket using the
-SocketAdapter and outputs it to DDS. You can visualize the ouptut by
-subscribing to Squares in Shapes Demo or running:
+SocketAdapter and outputs it to DDS. You can visualize the ouptut by running:
+
+-   **DDSToSocketAdapter** - It sends data from DDS to a UDP socket. You can 
+publish DDS data by running command:
 
-```bash
- $NDDSHOME/bin/rtiddsspy -printSample
-```
 
 To run Routing Service, you will need first to set up your environment as
 follows.
@@ -139,24 +141,67 @@ $NDDSHOME/bin/rtiroutingservice -cfgFile RsSocketAdapter.xml -cfgName SocketAdap
 Here is an output from a sample run:
 
 ```bash
-$export RTI_LD_LIBRARY_PATH=~/$NDDSHOME/lib/$CONNEXT_ARCH:~/udp_socket_adapter/build/
+$export RTI_LD_LIBRARY_PATH=~/$NDDSHOME/lib/$CONNEXT_ARCH:~/udp_socket_adapter_dynamic/build/
 
 $ $NDDSHOME/bin/rtiroutingservice -cfgFile RsSocketAdapter.xml -cfgName SocketAdapterToDDS
 RTI Routing Service 7.3.0 executing (with name SocketAdapterToSocketAdapter)
 ```
 
-Now you'll need to send data to the UDP sockets. By default, Shapes are
-expected on `127.0.0.1:10203`. You can change these default values on
-`RsSocketAdapter.xml`.
+Now you'll need to send data to the UDP sockets. By default, DDS Ping data is
+expected on `127.0.0.1:10203`. You can change both the expected type and topic name 
+and the UDP socket configuration on `RsSocketAdapter.xml`.
+
+To run a simple test, run in different terminals:
+
+```bash
+$export RTI_LD_LIBRARY_PATH=~/$NDDSHOME/lib/$CONNEXT_ARCH:~/udp_socket_adapter_dynamic/build/
+
+$ $NDDSHOME/bin/rtiroutingservice -cfgFile RsSocketAdapter.xml -cfgName DDSToSocketAdapter
+RTI Routing Service 7.3.0 executing (with configuration=DDSToSocketAdapter)
+```
+
+
+```bash
+ $NDDSHOME/bin/rtiddsping -publisher -domainId 0
+```
+
+## Running a data-diode example
+
+You can configure a data-diode scenario by using two Routing Services instances;
+- One using **DDSToSocketAdapter** configuration to publish DDS data over a one direction UDP socket
+- The other using **SocketAdapterToDDS** configuration to convert back to DDS samples
+                                                                                        
+  ┌───────────┐  ┌─────────────┐                         ┌─────────────┐  ┌───────────┐ 
+  │  Connext  │  │   Routing   │    ┌────────────────┐   │   Routing   │  │  Connext  │ 
+  │    App    ├─►│   Service   ├───►│ UDP DATA DIODE ├──►│   Service   ├─►│    App    │ 
+  │           │  │ DDS TO UDP  │    └────────────────┘   │ UDP TO DDS  │  │           │ 
+  └───────────┘  └─────────────┘                         └─────────────┘  └───────────┘ 
+                                                                                        
+To run this example in a local machine:
+```bash
+$export RTI_LD_LIBRARY_PATH=~/$NDDSHOME/lib/$CONNEXT_ARCH:~/udp_socket_adapter_dynamic/build/
+
+$ $NDDSHOME/bin/rtiroutingservice -cfgFile RsSocketAdapter.xml -cfgName SocketAdapterToDDS
+RTI Routing Service 7.3.0 executing (with configuration=SocketAdapterToDDS)
+```
+And in a different terminal:
+```bash
+$export RTI_LD_LIBRARY_PATH=~/$NDDSHOME/lib/$CONNEXT_ARCH:~/udp_socket_adapter_dynamic/build/
+
+$ $NDDSHOME/bin/rtiroutingservice -cfgFile RsSocketAdapter.xml -cfgName DDSToSocketAdapter
+RTI Routing Service 7.3.0 executing (with configuration=DDSToSocketAdapter)
+```
 
-To run the Shape tester that mimics a legacy UDP socket sender, run:
+Using the default configuration from RsSocketAdapter.xml, you need to publish DDS Ping data 
+on domain id 0 and subscribe to DSS Ping data on domain id 1:
 
 ```bash
-python3 test/send_shape_to_socket.py 127.0.0.1 10203
+ $NDDSHOME/bin/rtiddsping -publisher -domainId 0
 ```
 
-You can now open a Shapes Demo instance on domain 0 and subscribe to Squares.
-You should start receiving a red Square.
+```bash
+ $NDDSHOME/bin/rtiddsping -subscriber -domainId 1
+```
 
 ## Requirements
 

examples/routing_service/udp_socket_adapter_dynamic/README.md

@@ -9,27 +9,25 @@
         </adapter_plugin>
     </plugin_library>
 
-    <!-- Demonstrates a scenario where the SocketAdapter reads squares data from a socket 
-            and the DDSAdapter writes it to a DDS domain which can be subscribed to in 
-            Shapes Demo or using 'rtiddsspy -printSample' -->
+    <!-- Demonstrates a scenario where the SocketAdapter reads ping data from a socket 
+            and the DDSAdapter writes it to a DDS domain -->
     <routing_service name="SocketAdapterToDDS">
         <domain_route name="SocketBridge">
             <connection name="SocketConnection" plugin_name="AdapterLib::SocketAdapter">
-                <registered_type name="ShapeType" type_name="ShapeType" />
+                <registered_type name="PingType" type_name="PingType" />
             </connection>
             <participant name="DDSConnection">
-                <domain_id>0</domain_id>
+                <domain_id>1</domain_id>
                 <domain_participant_qos base_name="BuiltinQosLib::Generic.Common" />
-
-                <registered_type name="ShapeType" type_name="ShapeType" />
+                <registered_type name="PingType" type_name="PingType" />
             </participant>
             <session name="session">
                 <route>
                     <input connection="SocketConnection">
-                        <creation_mode>ON_DOMAIN_MATCH</creation_mode>
-                        <registered_type_name>ShapeType</registered_type_name>
-                        <stream_name>Square</stream_name>
-                        <!-- You must set these 3 properties -->
+                        <creation_mode>IMMEDIATE</creation_mode>
+                        <registered_type_name>PingType</registered_type_name>
+                        <stream_name>PingStream</stream_name>
+                        <!-- You must set these 2 properties -->
                         <property>
                             <value>
                                 <!-- Receive address for UDP data -->
@@ -40,27 +38,38 @@
                                 <!-- Receive port for UDP data -->
                                 <element>
                                     <name>receive_port</name>
-                                    <value>10204</value>
+                                    <value>10203</value>
                                 </element>
                             </value>
                         </property>
                     </input>
                     <dds_output participant="DDSConnection">
-                        <creation_mode>ON_ROUTE_MATCH</creation_mode>
-                        <registered_type_name>ShapeType</registered_type_name>
-                        <!-- Topic used to send data. We only support 1 topic for simplicity.
-                            You could use Triangle or Circle if you also modify the other
-                            references to Square that are hardcoded in the adapter code -->
-                        <topic_name>Square</topic_name>
+                        <creation_mode>ON_DOMAIN_MATCH</creation_mode>
+                        <registered_type_name>PingType</registered_type_name>
+                        <topic_name>PingTopic</topic_name>
                         <datawriter_qos base_name="BuiltinQosLib::Generic.Common" />
                     </dds_output>
                 </route>
+            </session>
+        </domain_route>
+    </routing_service>
+
+    <routing_service name="DDSToSocketAdapter">
+        <domain_route name="SocketBridge">
+            <connection name="SocketConnection" plugin_name="AdapterLib::SocketAdapter">
+                <registered_type name="PingType" type_name="PingType" />
+            </connection>
+            <participant name="DDSConnection">
+                <domain_id>0</domain_id>
+                <domain_participant_qos base_name="BuiltinQosLib::Generic.Common" />
+                <registered_type name="PingType" type_name="PingType" />
+            </participant>
+            <session>
                 <route>
                     <output connection="SocketConnection">
                         <creation_mode>ON_ROUTE_MATCH</creation_mode>
-                        <!--creation_mode>IMMEDIATE</creation_mode-->
-                        <registered_type_name>ShapeType</registered_type_name>
-                        <stream_name>Square</stream_name>
+                        <registered_type_name>PingType</registered_type_name>
+                        <stream_name>PingStream</stream_name>
                         <property> <!--Set
                             the IP addresses and ports for sender and destination-->
                             <value>
@@ -79,16 +88,15 @@
                                 </element>
                                 <element>
                                     <name>dest_port</name>
-                                    <value>10204</value>
+                                    <value>10203</value>
                                 </element>
                             </value>
                         </property>
                     </output>
                     <dds_input participant="DDSConnection">
                         <creation_mode>ON_DOMAIN_MATCH</creation_mode>
-                        <!--creation_mode>IMMEDIATE</creation_mode-->
-                        <registered_type_name>ShapeType</registered_type_name>
-                        <topic_name>Square</topic_name>
+                        <registered_type_name>PingType</registered_type_name>
+                        <topic_name>PingTopic</topic_name>
                         <datareader_qos base_name="BuiltinQosLib::Generic.Common" />
                     </dds_input>
                 </route>

examples/routing_service/udp_socket_adapter_dynamic/RsSocketAdapter.xml

@@ -13,6 +13,7 @@
 #include "SocketConnection.hpp"
 #include "SocketStreamReader.hpp"
 #include "SocketStreamWriter.hpp"
+#include "SocketStreamWriter.hpp"
 
 using namespace rti::routing;
 using namespace rti::routing::adapter;
@@ -35,10 +36,10 @@ StreamReader *SocketConnection::create_stream_reader(
 }
 
 StreamWriter *SocketConnection::create_stream_writer(
-        Session *session,
-        const StreamInfo &info,
-        const PropertySet &properties)
-{
+    Session *session,
+    const StreamInfo &info,
+    const PropertySet &properties)
+    {
     return new SocketStreamWriter(this, info, properties);
 }
 

examples/routing_service/udp_socket_adapter_dynamic/src/SocketConnection.cxx

@@ -1,5 +1,5 @@
 /*
- * (c) 2024 Copyright, Real-Time Innovations, Inc.  All rights reserved.
+ * (c) 2019 Copyright, Real-Time Innovations, Inc.  All rights reserved.
  *
  * RTI grants Licensee a license to use, modify, compile, and create derivative
  * works of the Software.  Licensee has the right to distribute object form
@@ -12,58 +12,55 @@
 
 #include <algorithm>
 #include <cctype>
+#include <chrono>
 #include <sstream>
 #include <thread>
-#include <chrono>
 
-#include <iostream>
 #include <cstring>
+#include <iostream>
 #ifdef _WIN32
     #include <winsock2.h>
     #pragma comment(lib, "ws2_32.lib")
 #else
-    #include <sys/types.h>
-    #include <sys/socket.h>
-    #include <netinet/in.h>
     #include <arpa/inet.h>
+    #include <netinet/in.h>
+    #include <sys/socket.h>
+    #include <sys/types.h>
     #include <unistd.h>
 #endif
-
 #include "SocketStreamReader.hpp"
 #include <rti/core/Exception.hpp>
+#include <rti/routing/Logger.hpp>
 #include <rti/topic/cdr/Serialization.hpp>
 
+
 using namespace dds::core::xtypes;
 using namespace rti::routing;
 using namespace rti::routing::adapter;
 
 void SocketStreamReader::socket_reading_thread()
 {
     while (!stop_thread_) {
-        /**
-         * Essential to protect against concurrent data access to
-         * buffer_ from the take() methods running on a different
-         * Routing Service thread.
-         */
-        std::unique_lock<std::mutex> lock(buffer_mutex_);
+        int received_bytes = 0;
         socket->receive_data(
                 received_buffer_,
-                &received_bytes_,
+                &received_bytes,
                 BUFFER_MAX_SIZE);
-        lock.unlock();
 
         // Most likely received nothing or there was an error
         // Not doing any error handling here
-        if (received_bytes_ <= 0) {
+        if (received_bytes <= 0) {
             // Sleep for a small period of time to avoid busy waiting
             std::this_thread::sleep_for(std::chrono::milliseconds(10));
             continue;
         }
-
         /**
          * Here we notify Routing Service, that there is data available
          * on the StreamReader, triggering a call to take().
          */
+
+         received_bytes_ = received_bytes;
+
         reader_listener_->on_data_available(this);
     }
 
@@ -80,8 +77,7 @@ SocketStreamReader::SocketStreamReader(
 {
     socket_connection_ = connection;
     reader_listener_ = listener;
-    adapter_type_ =
-            static_cast<DynamicType *>(info.type_info().type_representation());
+    adapter_type_ = static_cast<DynamicType *>(info.type_info().type_representation());
 
     // Parse the properties provided in the xml configuration file
     for (const auto &property : properties) {
@@ -92,35 +88,21 @@ SocketStreamReader::SocketStreamReader(
         }
     }
 
-    // If any of the mandatory properties is not specified, throw exception
-    if (receive_address_.size() == 0 || receive_port_ == 0) {
-        throw dds::core::IllegalOperationError(
-                "You must set receive_address and receive_port "
-                "in the RsSocketAdapter.xml file");
-    }
-
-    // Create the UDP socket to receive data
     socket = std::unique_ptr<UdpSocket>(
             new UdpSocket(receive_address_.c_str(), receive_port_));
 
-    // Start the receive thread for UDP data
     socketreader_thread_ =
             std::thread(&SocketStreamReader::socket_reading_thread, this);
 }
 
-/**
- * This is the Routing Service take(). It's called when the
- * socket_receive_thread calls on_data_available()
- */
 void SocketStreamReader::take(
         std::vector<dds::core::xtypes::DynamicData *> &samples,
         std::vector<dds::sub::SampleInfo *> &infos)
 {
     dds::core::xtypes::DynamicData deserialized_sample(*adapter_type_);
     std::vector<char> received_buffer = std::vector<char>(received_buffer_, received_buffer_ + received_bytes_);
     rti::core::xtypes::from_cdr_buffer(deserialized_sample, received_buffer);
-    std::cout << deserialized_sample << std::endl;
-
+    
     samples.resize(1);
     infos.resize(1);