Store action clients and servers in the Node

Author: nwn

rclrs/src/node.rs

@@ -13,7 +13,7 @@ use rosidl_runtime_rs::Message;
 
 pub use self::{builder::*, graph::*};
 use crate::{
-    rcl_bindings::*, ActionClient, ActionServer, CancelResponse, Client, ClientBase, Clock,
+    rcl_bindings::*, ActionClient, ActionClientBase, ActionServer, ActionServerBase, CancelResponse, Client, ClientBase, Clock,
     Context, ContextHandle, GoalResponse, GoalUuid, GuardCondition, ParameterBuilder,
     ParameterInterface, ParameterVariant, Parameters, Publisher, QoSProfile, RclrsError,
     ServerGoalHandle, Service, ServiceBase, Subscription, SubscriptionBase, SubscriptionCallback,
@@ -64,6 +64,8 @@ pub struct Node {
     pub(crate) guard_conditions_mtx: Mutex<Vec<Weak<GuardCondition>>>,
     pub(crate) services_mtx: Mutex<Vec<Weak<dyn ServiceBase>>>,
     pub(crate) subscriptions_mtx: Mutex<Vec<Weak<dyn SubscriptionBase>>>,
+    pub(crate) action_servers_mtx: Mutex<Vec<Weak<dyn ActionServerBase>>>,
+    pub(crate) action_clients_mtx: Mutex<Vec<Weak<dyn ActionClientBase>>>,
     time_source: TimeSource,
     parameter: ParameterInterface,
     pub(crate) handle: Arc<NodeHandle>,
@@ -207,7 +209,7 @@ impl Node {
         T: rosidl_runtime_rs::Service,
     {
         let client = Arc::new(Client::<T>::new(Arc::clone(&self.handle), topic)?);
-        { self.clients_mtx.lock().unwrap() }.push(Arc::downgrade(&client) as Weak<dyn ClientBase>);
+        self.clients_mtx.lock().unwrap().push(Arc::downgrade(&client) as Weak<dyn ClientBase>);
         Ok(client)
     }
 
@@ -220,8 +222,8 @@ impl Node {
         T: rosidl_runtime_rs::Action,
     {
         let action_client = Arc::new(ActionClient::<T>::new(Arc::clone(&self.handle), topic)?);
-        // self.action_clients
-        //     .push(Arc::downgrade(&action_client) as Weak<dyn ActionClientBase>);
+        self.action_clients_mtx.lock().unwrap()
+            .push(Arc::downgrade(&action_client) as Weak<dyn ActionClientBase>);
         Ok(action_client)
     }
 
@@ -250,8 +252,8 @@ impl Node {
             handle_cancel,
             handle_accepted,
         )?);
-        // self.action_servers
-        //     .push(Arc::downgrade(&action_server) as Weak<dyn ActionClientBase>);
+        self.action_servers_mtx.lock().unwrap()
+            .push(Arc::downgrade(&action_server) as Weak<dyn ActionServerBase>);
         Ok(action_server)
     }
 
@@ -269,7 +271,7 @@ impl Node {
             Arc::clone(&self.handle.context_handle),
             None,
         ));
-        { self.guard_conditions_mtx.lock().unwrap() }
+        self.guard_conditions_mtx.lock().unwrap()
             .push(Arc::downgrade(&guard_condition) as Weak<GuardCondition>);
         guard_condition
     }
@@ -291,7 +293,7 @@ impl Node {
             Arc::clone(&self.handle.context_handle),
             Some(Box::new(callback) as Box<dyn Fn() + Send + Sync>),
         ));
-        { self.guard_conditions_mtx.lock().unwrap() }
+        self.guard_conditions_mtx.lock().unwrap()
             .push(Arc::downgrade(&guard_condition) as Weak<GuardCondition>);
         guard_condition
     }
@@ -330,7 +332,7 @@ impl Node {
             topic,
             callback,
         )?);
-        { self.services_mtx.lock().unwrap() }
+        self.services_mtx.lock().unwrap()
             .push(Arc::downgrade(&service) as Weak<dyn ServiceBase>);
         Ok(service)
     }
@@ -354,36 +356,36 @@ impl Node {
             qos,
             callback,
         )?);
-        { self.subscriptions_mtx.lock() }
+        self.subscriptions_mtx.lock()
             .unwrap()
             .push(Arc::downgrade(&subscription) as Weak<dyn SubscriptionBase>);
         Ok(subscription)
     }
 
     /// Returns the subscriptions that have not been dropped yet.
     pub(crate) fn live_subscriptions(&self) -> Vec<Arc<dyn SubscriptionBase>> {
-        { self.subscriptions_mtx.lock().unwrap() }
+        self.subscriptions_mtx.lock().unwrap()
             .iter()
             .filter_map(Weak::upgrade)
             .collect()
     }
 
     pub(crate) fn live_clients(&self) -> Vec<Arc<dyn ClientBase>> {
-        { self.clients_mtx.lock().unwrap() }
+        self.clients_mtx.lock().unwrap()
             .iter()
             .filter_map(Weak::upgrade)
             .collect()
     }
 
     pub(crate) fn live_guard_conditions(&self) -> Vec<Arc<GuardCondition>> {
-        { self.guard_conditions_mtx.lock().unwrap() }
+        self.guard_conditions_mtx.lock().unwrap()
             .iter()
             .filter_map(Weak::upgrade)
             .collect()
     }
 
     pub(crate) fn live_services(&self) -> Vec<Arc<dyn ServiceBase>> {
-        { self.services_mtx.lock().unwrap() }
+        self.services_mtx.lock().unwrap()
             .iter()
             .filter_map(Weak::upgrade)
             .collect()

rclrs/src/node/builder.rs

@@ -314,6 +314,8 @@ impl NodeBuilder {
             guard_conditions_mtx: Mutex::new(vec![]),
             services_mtx: Mutex::new(vec![]),
             subscriptions_mtx: Mutex::new(vec![]),
+            action_servers_mtx: Mutex::new(vec![]),
+            action_clients_mtx: Mutex::new(vec![]),
             time_source: TimeSource::builder(self.clock_type)
                 .clock_qos(self.clock_qos)
                 .build(),