Async Execution

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/src/minimal_client.rs

@@ -1,34 +1,32 @@
-use std::env;
-
 use anyhow::{Error, Result};
+use rclrs::{Context, SpinOptions, Promise};
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = 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")?;
 
-    let request = example_interfaces::srv::AddTwoInts_Request { a: 41, b: 1 };
-
     println!("Starting client");
 
     while !client.service_is_ready()? {
         std::thread::sleep(std::time::Duration::from_millis(10));
     }
 
-    client.async_send_request_with_callback(
-        &request,
-        move |response: example_interfaces::srv::AddTwoInts_Response| {
-            println!(
-                "Result of {} + {} is: {}",
-                request.a, request.b, response.sum
-            );
-        },
-    )?;
+    let request = example_interfaces::srv::AddTwoInts_Request { a: 41, b: 1 };
+
+    let response: Promise<example_interfaces::srv::AddTwoInts_Response> = client.call(&request).unwrap();
 
-    std::thread::sleep(std::time::Duration::from_millis(500));
+    let promise = executor.commands().run(async move {
+        let response = response.await.unwrap();
+        println!(
+            "Result of {} + {} is: {}",
+            request.a, request.b, response.sum,
+        );
+    });
 
     println!("Waiting for response");
-    rclrs::spin(node).map_err(|err| err.into())
+    executor.spin(SpinOptions::new().until_promise_resolved(promise))?;
+    Ok(())
 }

examples/minimal_client_service/src/minimal_client_async.rs

@@ -1,12 +1,10 @@
-use std::env;
-
 use anyhow::{Error, Result};
+use rclrs::{Context, SpinOptions};
 
-#[tokio::main]
-async fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+fn main() -> Result<(), Error> {
+    let mut executor = 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")?;
 
@@ -18,18 +16,17 @@ async fn main() -> Result<(), Error> {
 
     let request = example_interfaces::srv::AddTwoInts_Request { a: 41, b: 1 };
 
-    let future = client.call_async(&request);
+    let promise = client.call_then(
+        &request,
+        move |response: example_interfaces::srv::AddTwoInts_Response| {
+            println!(
+                "Result of {} + {} is: {}",
+                request.a, request.b, response.sum,
+            );
+        }
+    ).unwrap();
 
     println!("Waiting for response");
-
-    let rclrs_spin = tokio::task::spawn_blocking(move || rclrs::spin(node));
-
-    let response = future.await?;
-    println!(
-        "Result of {} + {} is: {}",
-        request.a, request.b, response.sum
-    );
-
-    rclrs_spin.await.ok();
+    executor.spin(SpinOptions::new().until_promise_resolved(promise))?;
     Ok(())
 }

examples/minimal_client_service/src/minimal_service.rs

@@ -1,25 +1,30 @@
-use std::env;
-
 use anyhow::{Error, Result};
+use rclrs::{Context, ServiceInfo, SpinOptions};
 
 fn handle_service(
-    _request_header: &rclrs::rmw_request_id_t,
     request: example_interfaces::srv::AddTwoInts_Request,
+    info: ServiceInfo,
 ) -> example_interfaces::srv::AddTwoInts_Response {
-    println!("request: {} + {}", request.a, request.b);
+    let timestamp = info
+        .received_timestamp
+        .map(|t| format!(" at [{t:?}]"))
+        .unwrap_or(String::new());
+
+    println!("request{timestamp}: {} + {}", request.a, request.b);
     example_interfaces::srv::AddTwoInts_Response {
         sum: request.a + request.b,
     }
 }
 
 fn main() -> Result<(), Error> {
-    let context = rclrs::Context::new(env::args())?;
+    let mut executor = 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(SpinOptions::default())?;
+    Ok(())
 }

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

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,24 @@
-use std::env;
-
 use anyhow::{Error, Result};
+use std::sync::Mutex;
+use rclrs::ReadOnlyLoanedMessage;
 
 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 num_messages = Mutex::new(0usize);
 
     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;
+        move |msg: ReadOnlyLoanedMessage<std_msgs::msg::UInt32>| {
+            let mut num = num_messages.lock().unwrap();
+            *num += 1;
             println!("I heard: '{}'", msg.data);
-            println!("(Got {} messages so far)", num_messages);
+            println!("(Got {} messages so far)", *num);
         },
     )?;
 
-    rclrs::spin(node).map_err(|err| err.into())
+    executor.spin(rclrs::SpinOptions::default())?;
+    Ok(())
 }