Add drake_ros_bazel_installed Bazel workspace.

.github/workflows/bazelized.yml

@@ -0,0 +1,29 @@
+name: Bazel ROS Continuous Integration
+
+on:
+  pull_request:
+    branches:
+      - main
+      - develop
+
+defaults:
+  run:
+    working-directory: drake_ros_bazel_installed
+
+jobs:
+  build_and_test:
+    runs-on: ubuntu-latest
+    container:
+      image: ros:rolling-ros-base-focal
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: "/home/runner/.cache/bazel"
+          key: bazel
+      - name: Install prerequisites
+        run: yes | ./setup/install_prereqs.sh
+      - name: Build Bazel workspace
+        run: bazel build //...
+      - name: Test Bazel workspace
+        run: bazel test //... @ros2//...

drake_ros_bazel_installed/.bazelrc

@@ -0,0 +1,9 @@
+# Perform optimized builds.
+build -c opt
+
+# Use C++17.
+build --cxxopt=-std=c++17
+build --host_cxxopt=-std=c++17
+
+# Use Python 3.
+build --python_path=/usr/bin/python3

drake_ros_bazel_installed/BUILD.bazel

@@ -0,0 +1 @@
+# Empty build file to mark package root.

drake_ros_bazel_installed/README.md

@@ -0,0 +1,33 @@
+# Bazel Project with ROS 2 as a Precompiled External
+
+This project pulls in a system installed ROS 2 distribution as a Bazel external repository.
+
+For an introduction to Bazel, refer to [Getting Started with Bazel](https://docs.bazel.build/versions/master/getting-started.html).
+
+## Platform support
+
+This project targets ROS 2 Rolling distributions on Ubuntu Focal 20.04 only.
+
+## Instructions
+
+First, install the required dependencies:
+
+```sh
+sudo ./setup/install_prereqs.sh
+```
+
+To build all packages:
+
+```sh
+bazel build //...
+```
+
+To run binaries directly:
+
+```sh
+bazel run //drake_ros_apps:oracle_cc
+```
+
+```sh
+bazel run //drake_ros_apps:inquirer_py
+```

drake_ros_bazel_installed/WORKSPACE

@@ -0,0 +1,9 @@
+workspace(name = "drake_ros")
+
+load("//tools/workspace/python:repository.bzl", "python_repository")
+
+python_repository(name = "python_dev")
+
+load("//tools/workspace/ros2:repository.bzl", "ros2_repository")
+
+ros2_repository(name = "ros2")

drake_ros_bazel_installed/drake_ros_apps/BUILD.bazel

@@ -0,0 +1,93 @@
+# -*- mode: python -*-
+# vi: set ft=python :
+
+load("@ros2//:ros_cc.bzl", "ros_cc_binary")
+load("@ros2//:ros_py.bzl", "ros_py_binary")
+load("@ros2//:rosidl.bzl", "rosidl_interfaces_group")
+
+rosidl_interfaces_group(
+    name = "drake_ros_apps_msgs",
+    interfaces = [
+        "msg/Status.msg",
+    ],
+    deps = [
+        "//drake_ros_common:drake_ros_common_msgs",
+        "@ros2//:builtin_interfaces",
+    ],
+)
+
+ros_cc_binary(
+    name = "oracle_cc",
+    srcs = ["oracle.cc"],
+    deps = [
+        ":drake_ros_apps_msgs_cc",
+        "//drake_ros_common:drake_ros_common_msgs_cc",
+        "@ros2//:rclcpp_cc",
+        "@ros2//:rclcpp_action_cc",
+    ],
+    rmw_implementation = "rmw_cyclonedds_cpp",
+    tags = ["requires-network"],
+)
+
+ros_cc_binary(
+    name = "inquirer_cc",
+    srcs = ["inquirer.cc"],
+    deps = [
+        ":drake_ros_apps_msgs_cc",
+        "//drake_ros_common:drake_ros_common_msgs_cc",
+        "@ros2//:rclcpp_cc",
+        "@ros2//:rclcpp_action_cc",
+    ],
+    rmw_implementation = "rmw_cyclonedds_cpp",
+    tags = ["requires-network"],
+)
+
+ros_py_binary(
+    name = "oracle_py",
+    srcs = ["oracle.py"],
+    main = "oracle.py",
+    deps = [
+        ":drake_ros_apps_msgs_py",
+        "//drake_ros_common:drake_ros_common_msgs_py",
+        "@ros2//:rclpy_py",
+    ],
+    rmw_implementation = "rmw_cyclonedds_cpp",
+    tags = ["requires-network"],
+)
+
+ros_py_binary(
+    name = "inquirer_py",
+    srcs = ["inquirer.py"],
+    main = "inquirer.py",
+    deps = [
+        ":drake_ros_apps_msgs_py",
+        "//drake_ros_common:drake_ros_common_msgs_py",
+        "@ros2//:rclpy_py",
+    ],
+    rmw_implementation = "rmw_cyclonedds_cpp",
+    tags = ["requires-network"],
+)
+
+sh_test(
+    name = "gdb_oracle_cc_test",
+    srcs = ["test/exec.sh"],
+    args = [
+        "gdb",
+        "-x", "$(location :test/oracle_cc.gdb)", "--batch", "--args",
+        "$(location :oracle_cc)", "--ros-args", "--disable-external-lib-logs",
+    ],
+    data = ["test/oracle_cc.gdb", ":oracle_cc"],
+    size = "small",
+)
+
+sh_test(
+    name = "lldb_oracle_cc_test",
+    srcs = ["test/exec.sh"],
+    args = [
+        "lldb",
+        "-s", "$(location :test/oracle_cc.lldb)", "--batch", "--",
+        "$(location :oracle_cc)", "--ros-args", "--disable-external-lib-logs",
+    ],
+    data = ["test/oracle_cc.lldb", ":oracle_cc"],
+    size = "small",
+)

drake_ros_bazel_installed/drake_ros_apps/README.md

@@ -0,0 +1,18 @@
+## Demo `drake_ros` apps
+
+This package exercises `rosidl` interface generation and usage in C++ and Python, with cross-package interface dependencies.
+
+To check that the resulting interfaces are functional, it includes a demo applications in C++ and Python. Namely:
+
+- Equivalent `oracle_(cc|py)` applications that publish `drake_ros_apps_msgs/msg/Status` messages, serve a `drake_ros_common_msgs/srv/Query`service, and provide a `drake_ros_common_msgs/action/Do` action.
+- Equivalent `inquirer_(cc|py)` applications that subscribe to `drake_ros_apps_msgs/msg/Status` messages, make `drake_ros_common_msgs/srv/Query` service requests, and invoke the `drake_ros_common_msgs/action/Do` action.
+
+You may run a C++ oracle against a Python inquirer, and vice versa:
+
+```sh
+bazel run //drake_ros_apps:oracle_py
+```
+
+```sh
+bazel run //drake_ros_apps:inquirer_cc
+```

drake_ros_bazel_installed/drake_ros_apps/inquirer.cc

@@ -0,0 +1,133 @@
+#include <functional>
+#include <memory>
+
+#include <rclcpp/rclcpp.hpp>
+#include <rclcpp_action/client.hpp>
+#include <rclcpp_action/create_client.hpp>
+
+#include "drake_ros_apps_msgs/msg/status.hpp"
+#include "drake_ros_common_msgs/action/do.hpp"
+#include "drake_ros_common_msgs/srv/query.hpp"
+
+using namespace std::chrono_literals;
+
+namespace drake_ros_apps {
+
+class Inquirer : public rclcpp::Node {
+ public:
+  Inquirer() : Node("inquirer") {
+    using namespace std::placeholders;
+    status_sub_ = this->create_subscription<drake_ros_apps_msgs::msg::Status>(
+        "status", rclcpp::QoS(rclcpp::KeepLast(1)),
+        std::bind(&Inquirer::on_status, this, _1));
+
+    query_client_ =
+        this->create_client<drake_ros_common_msgs::srv::Query>("query");
+
+    action_client_ =
+        rclcpp_action::create_client<drake_ros_common_msgs::action::Do>(this,
+                                                                        "do");
+
+    inquire_timer_ =
+        this->create_wall_timer(5s, std::bind(&Inquirer::inquire, this));
+  }
+
+ private:
+  using QueryClient = rclcpp::Client<drake_ros_common_msgs::srv::Query>;
+
+  void handle_reply(QueryClient::SharedFuture future) const {
+    RCLCPP_INFO(this->get_logger(), "oracle said: %s",
+                future.get()->reply.c_str());
+  }
+
+  using ActionGoalHandle =
+      rclcpp_action::ClientGoalHandle<drake_ros_common_msgs::action::Do>;
+  void handle_rite_request_response(
+      const std::shared_ptr<ActionGoalHandle> handle) const {
+    if (!handle) {
+      RCLCPP_ERROR(this->get_logger(), "oracle rejected rite request");
+    } else {
+      RCLCPP_INFO(this->get_logger(), "oracle rite in progress");
+    }
+  }
+
+  void handle_rite_feedback(
+      std::shared_ptr<ActionGoalHandle> handle,
+      const std::shared_ptr<const ActionGoalHandle::Feedback> feedback) const {
+    RCLCPP_INFO(this->get_logger(), "oracle is %s", feedback->message.c_str());
+  }
+
+  void handle_rite_result(const ActionGoalHandle::WrappedResult& result) const {
+    switch (result.code) {
+      case rclcpp_action::ResultCode::SUCCEEDED:
+        RCLCPP_INFO(this->get_logger(), "oracle rite is complete");
+        break;
+      case rclcpp_action::ResultCode::ABORTED:
+        RCLCPP_ERROR(this->get_logger(), "oracle rite aborted due to %s",
+                     result.result->reason.c_str());
+        break;
+      case rclcpp_action::ResultCode::CANCELED:
+        RCLCPP_WARN(this->get_logger(), "oracle rite was cancelled");
+        break;
+      default:
+        RCLCPP_ERROR(this->get_logger(), "oracle rite status unknown");
+        break;
+    }
+  }
+
+  void inquire() const {
+    using namespace std::placeholders;
+
+    if (query_client_->service_is_ready()) {
+      auto request =
+          std::make_shared<drake_ros_common_msgs::srv::Query::Request>();
+      request->query = "how's it going?";
+      RCLCPP_INFO(this->get_logger(), "oracle, %s", request->query.c_str());
+      query_client_->async_send_request(
+          request, std::bind(&Inquirer::handle_reply, this, _1));
+    } else {
+      RCLCPP_WARN(this->get_logger(), "oracle not available for queries");
+    }
+
+    if (action_client_->action_server_is_ready()) {
+      rclcpp_action::Client<drake_ros_common_msgs::action::Do>::SendGoalOptions
+          options;
+      options.goal_response_callback =
+          std::bind(&Inquirer::handle_rite_request_response, this, _1);
+      options.feedback_callback =
+          std::bind(&Inquirer::handle_rite_feedback, this, _1, _2);
+      options.result_callback =
+          std::bind(&Inquirer::handle_rite_result, this, _1);
+      drake_ros_common_msgs::action::Do::Goal goal;
+      goal.action = "rite";
+      goal.period = rclcpp::Duration::from_seconds(0.1);
+      goal.timeout = rclcpp::Duration::from_seconds(1.0);
+      action_client_->async_send_goal(goal, options);
+    } else {
+      RCLCPP_WARN(this->get_logger(), "oracle not available for actions");
+    }
+  }
+
+  void on_status(const drake_ros_apps_msgs::msg::Status& msg) const {
+    RCLCPP_INFO(get_logger(), "%s status (%lu): %s", msg.origin.c_str(),
+                msg.status.sequence_id, msg.status.message.c_str());
+  }
+
+  std::shared_ptr<rclcpp::Subscription<drake_ros_apps_msgs::msg::Status>>
+      status_sub_;
+  std::shared_ptr<rclcpp::Client<drake_ros_common_msgs::srv::Query>>
+      query_client_;
+  std::shared_ptr<rclcpp_action::Client<drake_ros_common_msgs::action::Do>>
+      action_client_;
+  std::shared_ptr<rclcpp::TimerBase> inquire_timer_;
+};
+
+}  // namespace drake_ros_apps
+
+int main(int argc, char** argv) {
+  rclcpp::init(argc, argv);
+
+  rclcpp::spin(std::make_shared<drake_ros_apps::Inquirer>());
+
+  rclcpp::shutdown();
+}