Sketch out action client as well

Author: nwn

rclrs/src/action.rs

@@ -25,6 +25,44 @@ pub enum CancelResponse {
     Accept = 2,
 }
 
+// SAFETY: The functions accessing this type, including drop(), shouldn't care about the thread
+// they are running in. Therefore, this type can be safely sent to another thread.
+unsafe impl Send for rcl_action_client_t {}
+
+// SAFETY: The functions accessing this type, including drop(), shouldn't care about the thread
+// they are running in. Therefore, this type can be safely sent to another thread.
+unsafe impl Send for rcl_action_server_t {}
+
+/// Manage the lifecycle of an `rcl_action_client_t`, including managing its dependencies
+/// on `rcl_node_t` and `rcl_context_t` by ensuring that these dependencies are
+/// [dropped after][1] the `rcl_action_client_t`.
+///
+/// [1]: <https://doc.rust-lang.org/reference/destructors.html>
+pub struct ActionClientHandle {
+    rcl_action_client: Mutex<rcl_action_client_t>,
+    node_handle: Arc<NodeHandle>,
+    pub(crate) in_use_by_wait_set: Arc<AtomicBool>,
+}
+
+impl ActionClientHandle {
+    pub(crate) fn lock(&self) -> MutexGuard<rcl_action_client_t> {
+        self.rcl_action_client.lock().unwrap()
+    }
+}
+
+impl Drop for ActionClientHandle {
+    fn drop(&mut self) {
+        let rcl_action_client = self.rcl_action_client.get_mut().unwrap();
+        let mut rcl_node = self.node_handle.rcl_node.lock().unwrap();
+        let _lifecycle_lock = ENTITY_LIFECYCLE_MUTEX.lock().unwrap();
+        // SAFETY: The entity lifecycle mutex is locked to protect against the risk of
+        // global variables in the rmw implementation being unsafely modified during cleanup.
+        unsafe {
+            rcl_action_client_fini(rcl_action_client, &mut *rcl_node);
+        }
+    }
+}
+
 /// Manage the lifecycle of an `rcl_action_server_t`, including managing its dependencies
 /// on `rcl_node_t` and `rcl_context_t` by ensuring that these dependencies are
 /// [dropped after][1] the `rcl_action_server_t`.
@@ -55,6 +93,16 @@ impl Drop for ActionServerHandle {
     }
 }
 
+/// Trait to be implemented by concrete ActionClient structs.
+///
+/// See [`ActionClient<T>`] for an example
+pub trait ActionClientBase: Send + Sync {
+    /// Internal function to get a reference to the `rcl` handle.
+    fn handle(&self) -> &ActionClientHandle;
+    // /// Tries to take a new request and run the callback with it.
+    // fn execute(&self) -> Result<(), RclrsError>;
+}
+
 /// Trait to be implemented by concrete ActionServer structs.
 ///
 /// See [`ActionServer<T>`] for an example
@@ -69,7 +117,8 @@ pub struct ActionClient<T>
 where
     T: rosidl_runtime_rs::Action,
 {
-    _marker: PhantomData<T>,
+    _marker: PhantomData<fn() -> T>,
+    pub(crate) handle: Arc<ActionClientHandle>,
 }
 
 impl<T> ActionClient<T>
@@ -81,17 +130,68 @@ where
     where
         T: rosidl_runtime_rs::Action,
     {
+        // SAFETY: Getting a zero-initialized value is always safe.
+        let mut rcl_action_client = unsafe { rcl_action_get_zero_initialized_client() };
+        let type_support = <T as rosidl_runtime_rs::Action>::get_type_support()
+            as *const rosidl_action_type_support_t;
+        let topic_c_string = CString::new(topic).map_err(|err| RclrsError::StringContainsNul {
+            err,
+            s: topic.into(),
+        })?;
+
+        // SAFETY: No preconditions for this function.
+        let action_client_options = unsafe { rcl_action_client_get_default_options() };
+
+        {
+            let mut rcl_node = node_handle.rcl_node.lock().unwrap();
+            let _lifecycle_lock = ENTITY_LIFECYCLE_MUTEX.lock().unwrap();
+
+            // SAFETY:
+            // * The rcl_client was zero-initialized as expected by this function.
+            // * The rcl_node is kept alive by the NodeHandle because it is a dependency of the client.
+            // * The topic name and the options are copied by this function, so they can be dropped
+            //   afterwards.
+            // * The entity lifecycle mutex is locked to protect against the risk of global
+            //   variables in the rmw implementation being unsafely modified during initialization.
+            unsafe {
+                rcl_action_client_init(
+                    &mut rcl_action_client,
+                    &mut *rcl_node,
+                    type_support,
+                    topic_c_string.as_ptr(),
+                    &action_client_options,
+                )
+                .ok()?;
+            }
+        }
+
+        let handle = Arc::new(ActionClientHandle {
+            rcl_action_client: Mutex::new(rcl_action_client),
+            node_handle,
+            in_use_by_wait_set: Arc::new(AtomicBool::new(false)),
+        });
+
         Ok(Self {
             _marker: Default::default(),
+            handle,
         })
     }
 }
 
+impl<T> ActionClientBase for ActionClient<T>
+where
+    T: rosidl_runtime_rs::Action,
+{
+    fn handle(&self) -> &ActionClientHandle {
+        &self.handle
+    }
+}
+
 pub struct ActionServer<T>
 where
     T: rosidl_runtime_rs::Action,
 {
-    _marker: PhantomData<T>,
+    _marker: PhantomData<fn() -> T>,
     pub(crate) handle: Arc<ActionServerHandle>,
     // goal_callback: (),
     // cancel_callback: (),
@@ -133,10 +233,10 @@ where
                 rcl_action_server_init(
                     &mut rcl_action_server,
                     &mut *rcl_node,
-                    todo!(),
+                    todo!("pass in a rcl_clock_t"),
                     type_support,
                     topic_c_string.as_ptr(),
-                    &action_server_options as *const _,
+                    &action_server_options,
                 )
                 .ok()?;
             }
@@ -155,6 +255,15 @@ where
     }
 }
 
+impl<T> ActionServerBase for ActionServer<T>
+where
+    T: rosidl_runtime_rs::Action,
+{
+    fn handle(&self) -> &ActionServerHandle {
+        &self.handle
+    }
+}
+
 pub struct ServerGoalHandle<T>
 where
     T: rosidl_runtime_rs::Action,