API Changes: execution structure, options pattern, and arcs

examples/message_demo/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "examples_rclrs_message_demo"
-version = "0.4.1"
+version = "0.5.0"
 authors = ["Nikolai Morin <nnmmgit@gmail.com>"]
 edition = "2021"
 
@@ -12,7 +12,7 @@ path = "src/message_demo.rs"
 anyhow = {version = "1", features = ["backtrace"]}
 
 [dependencies.rclrs]
-version = "0.4"
+version = "0.5"
 
 [dependencies.rosidl_runtime_rs]
 version = "0.4"

examples/message_demo/src/message_demo.rs

@@ -1,4 +1,4 @@
-use std::{convert::TryInto, env, sync::Arc};
+use std::convert::TryInto;
 
 use anyhow::{Error, Result};
 use rosidl_runtime_rs::{seq, BoundedSequence, Message, Sequence};
@@ -138,38 +138,32 @@ fn demonstrate_sequences() {
 fn demonstrate_pubsub() -> Result<(), Error> {
     println!("================== Interoperability demo ==================");
     // Demonstrate interoperability between idiomatic and RMW-native message types
-    let context = rclrs::Context::new(env::args())?;
-    let node = rclrs::create_node(&context, "message_demo")?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let node = executor.create_node("message_demo")?;
 
-    let idiomatic_publisher = node.create_publisher::<rclrs_example_msgs::msg::VariousTypes>(
-        "topic",
-        rclrs::QOS_PROFILE_DEFAULT,
-    )?;
-    let direct_publisher = node.create_publisher::<rclrs_example_msgs::msg::rmw::VariousTypes>(
-        "topic",
-        rclrs::QOS_PROFILE_DEFAULT,
-    )?;
+    let idiomatic_publisher =
+        node.create_publisher::<rclrs_example_msgs::msg::VariousTypes>("topic")?;
+    let direct_publisher =
+        node.create_publisher::<rclrs_example_msgs::msg::rmw::VariousTypes>("topic")?;
 
     let _idiomatic_subscription = node
         .create_subscription::<rclrs_example_msgs::msg::VariousTypes, _>(
             "topic",
-            rclrs::QOS_PROFILE_DEFAULT,
             move |_msg: rclrs_example_msgs::msg::VariousTypes| println!("Got idiomatic message!"),
         )?;
     let _direct_subscription = node
         .create_subscription::<rclrs_example_msgs::msg::rmw::VariousTypes, _>(
             "topic",
-            rclrs::QOS_PROFILE_DEFAULT,
             move |_msg: rclrs_example_msgs::msg::rmw::VariousTypes| {
                 println!("Got RMW-native message!")
             },
         )?;
     println!("Sending idiomatic message.");
     idiomatic_publisher.publish(rclrs_example_msgs::msg::VariousTypes::default())?;
-    rclrs::spin_once(Arc::clone(&node), None)?;
+    executor.spin(rclrs::SpinOptions::spin_once())?;
     println!("Sending RMW-native message.");
     direct_publisher.publish(rclrs_example_msgs::msg::rmw::VariousTypes::default())?;
-    rclrs::spin_once(Arc::clone(&node), None)?;
+    executor.spin(rclrs::SpinOptions::spin_once())?;
 
     Ok(())
 }

examples/minimal_client_service/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "examples_rclrs_minimal_client_service"
-version = "0.4.1"
+version = "0.5.0"
 authors = ["Esteve Fernandez <esteve@apache.org>"]
 edition = "2021"
 
@@ -21,7 +21,7 @@ anyhow = {version = "1", features = ["backtrace"]}
 tokio = { version = "1", features = ["macros", "rt", "rt-multi-thread", "time"] }
 
 [dependencies.rclrs]
-version = "0.4"
+version = "0.5"
 
 [dependencies.rosidl_runtime_rs]
 version = "0.4"

examples/minimal_client_service/src/minimal_client.rs

@@ -1,11 +1,9 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_client")?;
+    let node = executor.create_node("minimal_client")?;
 
     let client = node.create_client::<example_interfaces::srv::AddTwoInts>("add_two_ints")?;
 
@@ -30,5 +28,7 @@ fn main() -> Result<(), Error> {
     std::thread::sleep(std::time::Duration::from_millis(500));
 
     println!("Waiting for response");
-    rclrs::spin(node).map_err(|err| err.into())
+    executor
+        .spin(rclrs::SpinOptions::default())
+        .map_err(|err| err.into())
 }

examples/minimal_client_service/src/minimal_client_async.rs

@@ -1,12 +1,10 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_client")?;
+    let node = executor.create_node("minimal_client")?;
 
     let client = node.create_client::<example_interfaces::srv::AddTwoInts>("add_two_ints")?;
 
@@ -22,7 +20,8 @@ async fn main() -> Result<(), Error> {
 
     println!("Waiting for response");
 
-    let rclrs_spin = tokio::task::spawn_blocking(move || rclrs::spin(node));
+    let rclrs_spin =
+        tokio::task::spawn_blocking(move || executor.spin(rclrs::SpinOptions::default()));
 
     let response = future.await?;
     println!(

examples/minimal_client_service/src/minimal_service.rs

@@ -1,5 +1,3 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn handle_service(
@@ -13,13 +11,15 @@ fn handle_service(
 }
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_service")?;
+    let node = executor.create_node("minimal_service")?;
 
     let _server = node
         .create_service::<example_interfaces::srv::AddTwoInts, _>("add_two_ints", handle_service)?;
 
     println!("Starting server");
-    rclrs::spin(node).map_err(|err| err.into())
+    executor
+        .spin(rclrs::SpinOptions::default())
+        .map_err(|err| err.into())
 }

examples/minimal_pub_sub/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "examples_rclrs_minimal_pub_sub"
-version = "0.4.1"
+version = "0.5.0"
 # This project is not military-sponsored, Jacob's employment contract just requires him to use this email address
 authors = ["Esteve Fernandez <esteve@apache.org>", "Nikolai Morin <nnmmgit@gmail.com>", "Jacob Hassold <jacob.a.hassold.civ@army.mil>"]
 edition = "2021"
@@ -29,7 +29,7 @@ path = "src/zero_copy_publisher.rs"
 anyhow = {version = "1", features = ["backtrace"]}
 
 [dependencies.rclrs]
-version = "0.4"
+version = "0.5"
 
 [dependencies.rosidl_runtime_rs]
 version = "0.4"

examples/minimal_pub_sub/src/minimal_publisher.rs

@@ -1,14 +1,12 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let context = rclrs::Context::default_from_env()?;
+    let executor = context.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_publisher")?;
+    let node = executor.create_node("minimal_publisher")?;
 
-    let publisher =
-        node.create_publisher::<std_msgs::msg::String>("topic", rclrs::QOS_PROFILE_DEFAULT)?;
+    let publisher = node.create_publisher::<std_msgs::msg::String>("topic")?;
 
     let mut message = std_msgs::msg::String::default();
 

examples/minimal_pub_sub/src/minimal_subscriber.rs

@@ -1,23 +1,23 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let context = rclrs::Context::default_from_env()?;
+    let mut executor = context.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_subscriber")?;
+    let node = executor.create_node("minimal_subscriber")?;
 
     let mut num_messages: usize = 0;
 
     let _subscription = node.create_subscription::<std_msgs::msg::String, _>(
         "topic",
-        rclrs::QOS_PROFILE_DEFAULT,
         move |msg: std_msgs::msg::String| {
             num_messages += 1;
             println!("I heard: '{}'", msg.data);
             println!("(Got {} messages so far)", num_messages);
         },
     )?;
 
-    rclrs::spin(node).map_err(|err| err.into())
+    executor
+        .spin(rclrs::SpinOptions::default())
+        .map_err(|err| err.into())
 }

examples/minimal_pub_sub/src/minimal_two_nodes.rs

@@ -1,23 +1,23 @@
-use std::{
-    env,
-    sync::{
-        atomic::{AtomicU32, Ordering},
-        Arc, Mutex,
-    },
+use std::sync::{
+    atomic::{AtomicU32, Ordering},
+    Arc, Mutex,
 };
 
 use anyhow::{Error, Result};
 
 struct MinimalSubscriber {
     num_messages: AtomicU32,
-    node: Arc<rclrs::Node>,
-    subscription: Mutex<Option<Arc<rclrs::Subscription<std_msgs::msg::String>>>>,
+    node: rclrs::Node,
+    subscription: Mutex<Option<rclrs::Subscription<std_msgs::msg::String>>>,
 }
 
 impl MinimalSubscriber {
-    pub fn new(name: &str, topic: &str) -> Result<Arc<Self>, rclrs::RclrsError> {
-        let context = rclrs::Context::new(env::args())?;
-        let node = rclrs::create_node(&context, name)?;
+    pub fn new(
+        executor: &rclrs::Executor,
+        name: &str,
+        topic: &str,
+    ) -> Result<Arc<Self>, rclrs::RclrsError> {
+        let node = executor.create_node(name)?;
         let minimal_subscriber = Arc::new(MinimalSubscriber {
             num_messages: 0.into(),
             node,
@@ -29,7 +29,6 @@ impl MinimalSubscriber {
             .node
             .create_subscription::<std_msgs::msg::String, _>(
                 topic,
-                rclrs::QOS_PROFILE_DEFAULT,
                 move |msg: std_msgs::msg::String| {
                     minimal_subscriber_aux.callback(msg);
                 },
@@ -50,14 +49,15 @@ impl MinimalSubscriber {
 }
 
 fn main() -> Result<(), Error> {
-    let publisher_context = rclrs::Context::new(env::args())?;
-    let publisher_node = rclrs::create_node(&publisher_context, "minimal_publisher")?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
+    let publisher_node = executor.create_node("minimal_publisher")?;
 
-    let subscriber_node_one = MinimalSubscriber::new("minimal_subscriber_one", "topic")?;
-    let subscriber_node_two = MinimalSubscriber::new("minimal_subscriber_two", "topic")?;
+    let _subscriber_node_one =
+        MinimalSubscriber::new(&executor, "minimal_subscriber_one", "topic")?;
+    let _subscriber_node_two =
+        MinimalSubscriber::new(&executor, "minimal_subscriber_two", "topic")?;
 
-    let publisher = publisher_node
-        .create_publisher::<std_msgs::msg::String>("topic", rclrs::QOS_PROFILE_DEFAULT)?;
+    let publisher = publisher_node.create_publisher::<std_msgs::msg::String>("topic")?;
 
     std::thread::spawn(move || -> Result<(), rclrs::RclrsError> {
         let mut message = std_msgs::msg::String::default();
@@ -71,11 +71,7 @@ fn main() -> Result<(), Error> {
         }
     });
 
-    let executor = rclrs::SingleThreadedExecutor::new();
-
-    executor.add_node(&publisher_node)?;
-    executor.add_node(&subscriber_node_one.node)?;
-    executor.add_node(&subscriber_node_two.node)?;
-
-    executor.spin().map_err(|err| err.into())
+    executor
+        .spin(rclrs::SpinOptions::default())
+        .map_err(|err| err.into())
 }

examples/minimal_pub_sub/src/zero_copy_publisher.rs

@@ -1,14 +1,12 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let context = rclrs::Context::default_from_env()?;
+    let executor = context.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_publisher")?;
+    let node = executor.create_node("minimal_publisher")?;
 
-    let publisher =
-        node.create_publisher::<std_msgs::msg::rmw::UInt32>("topic", rclrs::QOS_PROFILE_DEFAULT)?;
+    let publisher = node.create_publisher::<std_msgs::msg::rmw::UInt32>("topic")?;
 
     let mut publish_count: u32 = 1;
 

examples/minimal_pub_sub/src/zero_copy_subscriber.rs

@@ -1,23 +1,22 @@
-use std::env;
-
 use anyhow::{Error, Result};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = rclrs::Context::default_from_env()?.create_basic_executor();
 
-    let node = rclrs::create_node(&context, "minimal_subscriber")?;
+    let node = executor.create_node("minimal_subscriber")?;
 
     let mut num_messages: usize = 0;
 
     let _subscription = node.create_subscription::<std_msgs::msg::UInt32, _>(
         "topic",
-        rclrs::QOS_PROFILE_DEFAULT,
         move |msg: rclrs::ReadOnlyLoanedMessage<'_, std_msgs::msg::UInt32>| {
             num_messages += 1;
             println!("I heard: '{}'", msg.data);
             println!("(Got {} messages so far)", num_messages);
         },
     )?;
 
-    rclrs::spin(node).map_err(|err| err.into())
+    executor
+        .spin(rclrs::SpinOptions::default())
+        .map_err(|err| err.into())
 }