Use new strategy to verify message transmitting (#250)

* Use new strategy to verify message transmitting

Before we used console output of C++ and Python subscription to
check the message, this may sometimes fail on low performance machine.
Now we use a new strategy to verify message:
* Rclnodejs publisher sends message to C++ or Python subscriptions
* The subscriptions then send the message back by creating a new publisher
* The rclnodejs side then creates a new subscription to receive messages

Therefore, there is no need to keep the rclnodejs subscription - C++/Python
publisher cases any more.

Fix: #222

Author: qiuzhong

scripts/compile_cpp.js

@@ -19,22 +19,40 @@ const os = require('os');
 const path = require('path');
 const child = require('child_process');
 
-var platform = os.platform();
+// var platform = os.platform();
 var rootDir = path.dirname(__dirname);
 var testCppDir = path.join(rootDir, 'test', 'cpp');
 
-var publisher = (platform === 'win32') ? 'publisher_msg.exe' : 'publisher_msg';
-var subscription = (platform === 'win32') ? 'subscription_msg.exe' : 'subscription_msg';
+function getExecutable(input) {
+  if (os.platform() === 'win32')
+    return input + '.exe';
+
+  return input;
+}
+
+var publisher = getExecutable('publisher_msg');
+var subscription = getExecutable('subscription_msg');
+var listener = getExecutable('listener');
+var client = getExecutable('add_two_ints_client');
+
+function getExecutablePath(input) {
+  var releaseDir = '';
+  if (os.platform() === 'win32')
+    releaseDir = 'Release';
+
+  return path.join(rootDir, 'build', 'cpp_nodes', releaseDir, input);
+}
+
+var publisherPath = getExecutablePath(publisher);
+var subscriptionPath = getExecutablePath(subscription);
+var listenerPath = getExecutablePath(listener);
+var clientPath = getExecutablePath(client);
 
-var publisherPath = path.join(rootDir, 'build', 'cpp_nodes',
-  (platform === 'win32') ? 'Release' : '', publisher);
-var subscriptionPath = path.join(rootDir, 'build', 'cpp_nodes',
-  (platform === 'win32') ? 'Release' : '', subscription);
 
 function copyFile(platform, srcFile, destFile) {
   // eslint-disable-next-line
   if (!fs.existsSync(destFile)) {
-    if (platform === 'win32') {
+    if (os.platform() === 'win32') {
       child.spawn('cmd.exe', ['/c', `copy ${srcFile} ${destFile}`]);
     } else {
       child.spawn('sh', ['-c', `cp ${srcFile} ${destFile}`]);
@@ -44,16 +62,18 @@ function copyFile(platform, srcFile, destFile) {
 
 function copyAll(fileList, dest) {
   fileList.forEach((file) => {
-    copyFile(platform, file, path.join(dest, path.basename(file)));
+    copyFile(os.platform(), file, path.join(dest, path.basename(file)));
   });
 }
 
 // eslint-disable-next-line
-if (!fs.existsSync(publisherPath) && !fs.existsSync(subscriptionPath)) {
+if (!fs.existsSync(publisherPath) && !fs.existsSync(subscriptionPath) &&
+  // eslint-disable-next-line
+  !fs.existsSync(listenerPath) && !fs.existsSync(clientPath)) {
   var compileProcess = child.spawn('ament', ['build', testCppDir, '--skip-install']);
   compileProcess.on('close', (code) => {
-    copyAll([publisherPath, subscriptionPath], testCppDir);
+    copyAll([publisherPath, subscriptionPath, listenerPath, clientPath], testCppDir);
   });
 } else {
-  copyAll([publisherPath, subscriptionPath], testCppDir);
+  copyAll([publisherPath, subscriptionPath, , listenerPath, clientPath], testCppDir);
 }

test/blacklist.json

@@ -1,5 +1,5 @@
 {
-  "Linux": ["test-cross-lang.js", "test-interactive.js", "test-multi-nodes.js"],
-  "Darwin": ["test-cross-lang.js", "test-interactive.js", "test-multi-nodes.js"],
-  "Windows_NT": ["test-cross-lang.js", "test-interactive.js", "test-multi-nodes.js"]
+  "Linux": [],
+  "Darwin": [],
+  "Windows_NT": []
 }

test/client_setup.js

@@ -19,13 +19,15 @@ const rclnodejs = require('../index.js');
 rclnodejs.init().then(function() {
   var node = rclnodejs.createNode('client');
   const AddTwoInts = 'example_interfaces/srv/AddTwoInts';
+  const Int8 = 'std_msgs/msg/Int8';
   var client = node.createClient(AddTwoInts, 'add_two_ints');
   const request = {
     a: 1,
     b: 2,
   };
-  client.sendRequest(request, function(response) {
-    process.stdout.write(response.sum.toString());
+  var publisher = node.createPublisher(Int8, 'back_add_two_ints');
+  client.sendRequest(request, (response) => {
+    publisher.publish(response.sum);
   });
   rclnodejs.spin(node);
 

test/cpp/CMakeLists.txt

@@ -31,3 +31,5 @@ endfunction()
 
 custom_executable(publisher_msg)
 custom_executable(subscription_msg)
+custom_executable(listener)
+custom_executable(add_two_ints_client)

test/cpp/add_two_ints_client.cpp

@@ -0,0 +1,109 @@
+// Copyright 2014 Open Source Robotics Foundation, Inc.
+//
+// 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 <chrono>
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include "rclcpp/rclcpp.hpp"
+#include "rcutils/cmdline_parser.h"
+
+#include "std_msgs/msg/int8.hpp"
+#include "example_interfaces/srv/add_two_ints.hpp"
+
+using namespace std::chrono_literals;
+
+rclcpp::Publisher<std_msgs::msg::Int8>::SharedPtr publisher = nullptr;
+
+void print_usage()
+{
+  printf("Usage for add_two_ints_client app:\n");
+  printf("add_two_ints_client [-t topic_name] [-h]\n");
+  printf("options:\n");
+  printf("-h : Print this help function.\n");
+  printf("-s service_name : Specify the service name for this client. Defaults to add_two_ints.\n");
+}
+
+// TODO(wjwwood): make this into a method of rclcpp::client::Client.
+example_interfaces::srv::AddTwoInts_Response::SharedPtr send_request(
+  rclcpp::Node::SharedPtr node,
+  rclcpp::Client<example_interfaces::srv::AddTwoInts>::SharedPtr client,
+  example_interfaces::srv::AddTwoInts_Request::SharedPtr request)
+{
+  auto result = client->async_send_request(request);
+  // Wait for the result.
+  if (rclcpp::spin_until_future_complete(node, result) ==
+    rclcpp::executor::FutureReturnCode::SUCCESS)
+  {
+    return result.get();
+  } else {
+    return NULL;
+  }
+}
+
+int main(int argc, char ** argv)
+{
+  rclcpp::init(argc, argv);
+
+  auto node = rclcpp::Node::make_shared("add_two_ints_client");
+
+  if (rcutils_cli_option_exist(argv, argv + argc, "-h")) {
+    print_usage();
+    return 0;
+  }
+
+  auto topic = std::string("add_two_ints");
+  if (rcutils_cli_option_exist(argv, argv + argc, "-s")) {
+    topic = std::string(rcutils_cli_get_option(argv, argv + argc, "-s"));
+  }
+  auto client = node->create_client<example_interfaces::srv::AddTwoInts>(topic);
+
+  auto request = std::make_shared<example_interfaces::srv::AddTwoInts::Request>();
+  request->a = 2;
+  request->b = 3;
+
+  while (!client->wait_for_service(1s)) {
+    if (!rclcpp::ok()) {
+      printf("add_two_ints_client was interrupted while waiting for the service. Exiting.\n");
+      return 0;
+    }
+    printf("service not available, waiting again...\n");
+  }
+
+  // TODO(wjwwood): make it like `client->send_request(node, request)->sum`
+  // TODO(wjwwood): consider error condition
+  rmw_qos_profile_t custom_qos_profile = rmw_qos_profile_default;
+  custom_qos_profile.depth = 7;
+  auto msg = std::make_shared<std_msgs::msg::Int8>();
+  publisher = node->create_publisher<std_msgs::msg::Int8>(
+    std::string("back_") + topic, custom_qos_profile);
+
+
+  auto future_result = client->async_send_request(request);
+
+  // Wait for the result.
+  if (rclcpp::spin_until_future_complete(node, future_result) ==
+    rclcpp::executor::FutureReturnCode::SUCCESS)
+  {
+    // printf("Result of add_two_ints: %zd\n", future_result.get()->sum);
+    msg->data = future_result.get()->sum;
+    publisher->publish(msg);
+  } else {
+    printf("add_two_ints_client_async was interrupted. Exiting.\n");
+  }  
+
+  rclcpp::shutdown();
+  return 0;
+}

test/cpp/listener.cpp

@@ -0,0 +1,66 @@
+// Copyright 2014 Open Source Robotics Foundation, Inc.
+//
+// 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 <iostream>
+#include <memory>
+#include <string>
+
+#include "rclcpp/rclcpp.hpp"
+#include "rcutils/cmdline_parser.h"
+
+#include "std_msgs/msg/string.hpp"
+
+rclcpp::Publisher<std_msgs::msg::String>::SharedPtr publisher = nullptr;
+
+void print_usage()
+{
+  printf("Usage for listener app:\n");
+  printf("listener [-t topic_name] [-h]\n");
+  printf("options:\n");
+  printf("-h : Print this help function.\n");
+  printf("-t topic_name : Specify the topic on which to subscribe. Defaults to chatter.\n");
+}
+
+void chatterCallback(const std_msgs::msg::String::SharedPtr msg)
+{
+  publisher->publish(msg);
+}
+
+
+
+int main(int argc, char * argv[])
+{
+  rclcpp::init(argc, argv);
+  auto node = rclcpp::Node::make_shared("listener");
+
+  if (rcutils_cli_option_exist(argv, argv + argc, "-h")) {
+    print_usage();
+    return 0;
+  }
+  rmw_qos_profile_t custom_qos_profile = rmw_qos_profile_default;
+  custom_qos_profile.depth = 7;
+  auto topic = std::string("chatter");
+  if (rcutils_cli_option_exist(argv, argv + argc, "-t")) {
+    topic = std::string(rcutils_cli_get_option(argv, argv + argc, "-t"));
+  }
+
+  publisher = node->create_publisher<std_msgs::msg::String>(
+    std::string("back_") + topic, custom_qos_profile);
+  auto sub = node->create_subscription<std_msgs::msg::String>(
+    topic, chatterCallback, rmw_qos_profile_default);
+  
+  rclcpp::spin(node);
+
+  return 0;
+}