Merge remote-tracking branch 'forked/main'

Author: BCSol

.github/workflows/generate-bindings.yml

@@ -2,10 +2,10 @@ name: Generate bindings
 
 on:
   schedule:
-    # Run the CI at 02:22 UTC every Tuesday
+    # Run the CI at 00:11 UTC every night
     # We pick an arbitrary time outside of most of the world's work hours
     # to minimize the likelihood of running alongside a heavy workload.
-    - cron: '22 2 * * 2'
+    - cron: '11 0 * * *'
   workflow_dispatch:
 
 env:
@@ -44,7 +44,9 @@ jobs:
     container:
       image: ${{ matrix.docker_image }}
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
+      with:
+        fetch-depth: 0
 
     - name: Setup ROS environment
       uses: ros-tooling/[email protected]
@@ -61,10 +63,11 @@ jobs:
       run: curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
 
     - name: Install bindgen
-      run: cargo binstall -y bindgen
+      run: cargo binstall -y bindgen-cli
 
     - name: Generate bindings
       run: |
+        . /opt/ros/${{ matrix.ros_distribution }}/setup.sh
         cd rclrs/src
         ../generate_bindings.py rcl_wrapper.h ${{ matrix.ros_distribution }} .
 
@@ -78,7 +81,7 @@ jobs:
         git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}
         git remote update origin
         CREATE_PR=0
-        if !git checkout update-bindings-${{ matrix.ros_distribution }}; then
+        if ! git checkout update-bindings-${{ matrix.ros_distribution }}; then
           CREATE_PR=1
           git checkout -b update-bindings-${{ matrix.ros_distribution }}
         fi

.github/workflows/release-plz.yml

@@ -5,6 +5,9 @@ on:
     branches:
       - main
 
+env:
+  RUSTFLAGS: "--cfg ros_distro=\"humble\""
+
 jobs:
   release-plz-release:
     name: Release-plz release

rclrs/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.1](https://github.com/ros2-rust/ros2_rust/compare/v0.5.0...v0.5.1) - 2025-08-23
+
+### Other
+
+- Fix executor timeout ([#519](https://github.com/ros2-rust/ros2_rust/pull/519))
+
 ## [0.5.0](https://github.com/ros2-rust/ros2_rust/compare/v0.4.1...v0.5.0) - 2025-08-15
 
 ### Added

rclrs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rclrs"
-version = "0.5.0"
+version = "0.5.1"
 # This project is not military-sponsored, Jacob's employment contract just requires him to use this email address
 authors = ["Esteve Fernandez <[email protected]>", "Nikolai Morin <[email protected]>", "Jacob Hassold <[email protected]>"]
 edition = "2021"
@@ -45,10 +45,9 @@ tempfile = "3.3.0"
 tokio = { version = "1", features = ["rt", "time", "macros"] }
 
 [build-dependencies]
-# Needed for FFI
-bindgen = "0.70"
 # Needed for uploading documentation to docs.rs
 cfg-if = "1.0.0"
+rustflags = "0.1"
 
 [features]
 default = []
@@ -60,3 +59,4 @@ use_ros_shim = ["rosidl_runtime_rs/use_ros_shim"]
 
 [package.metadata.docs.rs]
 features = ["use_ros_shim"]
+rustc-args = ["--cfg", "ros_distro=\"humble\""]

rclrs/build.rs

@@ -1,12 +1,6 @@
-use std::{
-    env,
-    fs::read_dir,
-    path::{Path, PathBuf},
-};
-
+use std::{env, path::Path};
 const AMENT_PREFIX_PATH: &str = "AMENT_PREFIX_PATH";
 const ROS_DISTRO: &str = "ROS_DISTRO";
-const BINDGEN_WRAPPER: &str = "src/rcl_wrapper.h";
 
 fn get_env_var_or_abort(env_var: &'static str) -> String {
     if let Ok(value) = env::var(env_var) {
@@ -20,22 +14,37 @@ fn get_env_var_or_abort(env_var: &'static str) -> String {
 }
 
 fn main() {
+    println!(
+        "cargo:rustc-check-cfg=cfg(ros_distro, values(\"{}\"))",
+        vec!["humble", "jazzy", "kilted", "rolling"].join("\", \"")
+    );
     let ros_distro = if let Ok(value) = env::var(ROS_DISTRO) {
         value
     } else {
-        let error_msg =
-            "ROS_DISTRO environment variable not set - please source ROS 2 installation first.";
+        use rustflags;
         cfg_if::cfg_if! {
             if #[cfg(feature="use_ros_shim")] {
-                println!("{}", error_msg);
-                return;
+                // // Look for --cfg ros_distro=<ros_distro>
+                for flag in rustflags::from_env() {
+                    if matches!(flag, rustflags::Flag::Cfg { ref name, value : _ } if name == "ros_distro") {
+                        if let rustflags::Flag::Cfg {name:_, value: flag_value} = flag {
+                            println!("cargo:rustc-cfg=ros_distro=\"{}\"", flag_value.unwrap());
+                            return;
+                        } else {
+                            continue;
+                        }
+                    }
+                }
+                let error_msg =
+                    "When using the use_ros_shim feature, you must pass the ROS distribution you are targeting as a compiler flag with --cfg ros_distro=\"<ros_distro>\"";
+                panic!("{}", error_msg);
             } else {
+                let error_msg =
+                    "ROS_DISTRO environment variable not set - please source ROS 2 installation first.";
                 panic!("{}", error_msg);
             }
         }
     };
-
-    println!("cargo:rustc-check-cfg=cfg(ros_distro, values(\"humble\", \"jazzy\", \"rolling\"))");
     println!("cargo:rustc-cfg=ros_distro=\"{ros_distro}\"");
 
     let ament_prefix_paths = get_env_var_or_abort(AMENT_PREFIX_PATH);

rclrs/src/executor.rs

@@ -487,3 +487,30 @@ impl CreateBasicExecutor for Context {
         self.create_executor(runtime)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    use std::time::Duration;
+
+    #[test]
+    fn test_timeout() {
+        let context = Context::default();
+        let mut executor = context.create_basic_executor();
+        let _node = executor
+            .create_node(&format!("test_timeout_{}", line!()))
+            .unwrap();
+
+        for _ in 0..10 {
+            let r = executor.spin(SpinOptions::default().timeout(Duration::from_millis(1)));
+            assert_eq!(r.len(), 1);
+            assert!(matches!(
+                r[0],
+                RclrsError::RclError {
+                    code: RclReturnCode::Timeout,
+                    ..
+                }
+            ));
+        }
+    }
+}

rclrs/src/rcl_bindings.rs

@@ -12,30 +12,41 @@
 #![allow(missing_docs)]
 
 cfg_if::cfg_if! {
-    if #[cfg(feature="use_ros_shim")] {
+    if #[cfg(ros_distro="humble")] {
         include!(
             concat!(
                 env!("CARGO_MANIFEST_DIR"),
-                "/src/rcl_bindings_generated_",
-                "rolling", // rolling will always be a valid ROS distro
-                ".rs",
-            )
-        );
-
-    } else {
+                "/src/rcl_bindings_generated_humble.rs",
+                )
+            );
+    } else if #[cfg(ros_distro="jazzy")] {
         include!(
             concat!(
                 env!("CARGO_MANIFEST_DIR"),
-                "/src/rcl_bindings_generated_",
-                env!("ROS_DISTRO"),
-                ".rs",
-            )
-        );
-
-        pub const RMW_GID_STORAGE_SIZE: usize = rmw_gid_storage_size_constant;
+                "/src/rcl_bindings_generated_jazzy.rs",
+                )
+            );
+    } else if #[cfg(ros_distro="kilted")] {
+        include!(
+            concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/src/rcl_bindings_generated_kilted.rs",
+                )
+            );
+    } else if #[cfg(ros_distro="rolling")] {
+        include!(
+            concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/src/rcl_bindings_generated_rolling.rs",
+                )
+            );
+    } else {
+        panic!("Unsupported ROS distribution");
     }
 }
 
+pub const RMW_GID_STORAGE_SIZE: usize = rmw_gid_storage_size_constant;
+
 /// Wrapper around [`std::slice::from_raw_parts`] that accommodates the rcl
 /// convention of providing a null pointer to represent empty arrays. This
 /// violates the safety requirements of [`std::slice::from_raw_parts`].

rclrs/src/wait_set.rs

@@ -114,32 +114,39 @@ impl WaitSet {
                 })
             }
         };
+
         // SAFETY: The comments in rcl mention "This function cannot operate on the same wait set
         // in multiple threads, and the wait sets may not share content."
-        // We cannot currently guarantee that the wait sets may not share content, but it is
-        // mentioned in the doc comment for `add_subscription`.
-        // Also, the rcl_wait_set is obviously valid.
-        match unsafe { rcl_wait(&mut self.handle.rcl_wait_set, timeout_ns) }.ok() {
-            Ok(_) => (),
+        // * The we have exclusive access to rcl_wait_set because this is a
+        //   mutable borrow of WaitSet, which houses rcl_wait_set.
+        // * We guarantee that the wait sets do not share content by funneling
+        //   the waitable of each primitive to one (and only one) WaitSet when
+        //   the primitive gets constructed. The waitables are never allowed to
+        //   move between wait sets.
+        let r = match unsafe { rcl_wait(&mut self.handle.rcl_wait_set, timeout_ns) }.ok() {
+            Ok(_) => Ok(()),
             Err(error) => match error {
                 RclrsError::RclError { code, msg } => match code {
-                    RclReturnCode::WaitSetEmpty => (),
-                    _ => return Err(RclrsError::RclError { code, msg }),
+                    RclReturnCode::WaitSetEmpty => Ok(()),
+                    _ => Err(RclrsError::RclError { code, msg }),
                 },
-                _ => return Err(error),
+                _ => Err(error),
             },
-        }
+        };
 
         // Remove any waitables that are no longer being used
         for waitable in self.primitives.values_mut() {
             waitable.retain(|w| w.in_use());
         }
 
-        // For the remaining entities, check if they were activated and then run
-        // the callback for those that were.
-        for waiter in self.primitives.values_mut().flat_map(|v| v) {
-            if waiter.is_ready(&self.handle.rcl_wait_set) {
-                f(&mut *waiter.primitive)?;
+        // Do not check the readiness if an error was reported.
+        if !r.is_err() {
+            // For the remaining entities, check if they were activated and then run
+            // the callback for those that were.
+            for waiter in self.primitives.values_mut().flat_map(|v| v) {
+                if waiter.is_ready(&self.handle.rcl_wait_set) {
+                    f(&mut *waiter.primitive)?;
+                }
             }
         }
 
@@ -160,7 +167,7 @@ impl WaitSet {
             );
         }
 
-        Ok(())
+        r
     }
 
     /// Get a count of the different kinds of entities in the wait set.