Migrate to ServiceOptions

Signed-off-by: Michael X. Grey <[email protected]>

Author: mxgrey

rclrs/src/node.rs

@@ -16,7 +16,7 @@ pub use self::{builder::*, graph::*, primitive_options::*};
 use crate::{
     rcl_bindings::*, Client, ClientBase, Clock, Context, ContextHandle, GuardCondition,
     ParameterBuilder, ParameterInterface, ParameterVariant, Parameters, Publisher, PublisherOptions,
-    RclrsError, Service, ServiceBase, Subscription, SubscriptionBase, SubscriptionCallback,
+    RclrsError, Service, ServiceBase, ServiceOptions, Subscription, SubscriptionBase, SubscriptionCallback,
     SubscriptionOptions, TimeSource, ENTITY_LIFECYCLE_MUTEX,
 };
 
@@ -297,11 +297,49 @@ impl Node {
 
     /// Creates a [`Service`][1].
     ///
+    /// Pass in only the service name for the `options` argument to use all default service options:
+    /// ```
+    /// # use rclrs::*;
+    /// # let context = Context::new([]).unwrap();
+    /// # let node = create_node(&context, "my_node").unwrap();
+    /// let service = node.create_service::<test_msgs::srv::Empty, _>(
+    ///     "my_service",
+    ///     |_info, _request| {
+    ///         println!("Received request!");
+    ///         test_msgs::srv::Empty_Response::default()
+    ///     },
+    /// );
+    /// ```
+    ///
+    /// Take advantage of the [`IntoPrimitiveOptions`] API to easily build up the
+    /// service options:
+    ///
+    /// ```
+    /// # use rclrs::*;
+    /// # let context = Context::new([]).unwrap();
+    /// # let node = create_node(&context, "my_node").unwrap();
+    /// let service = node.create_service::<test_msgs::srv::Empty, _>(
+    ///     "my_service"
+    ///     .keep_all()
+    ///     .transient_local(),
+    ///     |_info, _request| {
+    ///         println!("Received request!");
+    ///         test_msgs::srv::Empty_Response::default()
+    ///     },
+    /// );
+    /// ```
+    ///
+    /// Any quality of service options that you explicitly specify will override
+    /// the default service options. Any that you do not explicitly specify will
+    /// remain the default service options. Note that services are generally
+    /// expected to use [reliable][2], so is best not to change the reliability
+    /// setting unless you know what you are doing.
+    ///
     /// [1]: crate::Service
-    // TODO: make service's lifetime depend on node's lifetime
-    pub fn create_service<T, F>(
+    /// [2]: crate::QoSReliabilityPolicy::Reliable
+    pub fn create_service<'a, T, F>(
         &self,
-        topic: &str,
+        options: impl Into<ServiceOptions<'a>>,
         callback: F,
     ) -> Result<Arc<Service<T>>, RclrsError>
     where
@@ -310,7 +348,7 @@ impl Node {
     {
         let service = Arc::new(Service::<T>::new(
             Arc::clone(&self.handle),
-            topic,
+            options,
             callback,
         )?);
         { self.services_mtx.lock().unwrap() }
@@ -327,22 +365,22 @@ impl Node {
     /// # let context = Context::new([]).unwrap();
     /// # let node = create_node(&context, "my_node").unwrap();
     /// let subscription = node.create_subscription(
-    ///     "my_subscription",
+    ///     "my_topic",
     ///     |_msg: test_msgs::msg::Empty| {
     ///         println!("Received message!");
     ///     },
     /// );
     /// ```
     ///
-    /// Take advantage of [`IntoPrimitiveOptions`] to easily build up the
+    /// Take advantage of the [`IntoPrimitiveOptions`] API to easily build up the
     /// subscription options:
     ///
     /// ```
     /// # use rclrs::*;
     /// # let context = Context::new([]).unwrap();
     /// # let node = create_node(&context, "my_node").unwrap();
     /// let subscription = node.create_subscription(
-    ///     "my_subscription"
+    ///     "my_topic"
     ///     .keep_last(100)
     ///     .transient_local(),
     ///     |_msg: test_msgs::msg::Empty| {
@@ -351,7 +389,7 @@ impl Node {
     /// );
     ///
     /// let reliable_subscription = node.create_subscription(
-    ///     "my_reliable_subscription"
+    ///     "my_reliable_topic"
     ///     .reliable(),
     ///     |_msg: test_msgs::msg::Empty| {
     ///         println!("Received message!");

rclrs/src/parameter/service.rs

@@ -9,7 +9,8 @@ use rosidl_runtime_rs::Sequence;
 use super::ParameterMap;
 use crate::{
     parameter::{DeclaredValue, ParameterKind, ParameterStorage},
-    rmw_request_id_t, Node, RclrsError, Service,
+    rmw_request_id_t, Node, RclrsError, Service, IntoPrimitiveOptions,
+    QoSProfile,
 };
 
 // The variables only exist to keep a strong reference to the services and are technically unused.
@@ -247,46 +248,52 @@ impl ParameterService {
         // destruction is made for the parameter map.
         let map = parameter_map.clone();
         let describe_parameters_service = node.create_service(
-            &(fqn.clone() + "/describe_parameters"),
+            (fqn.clone() + "/describe_parameters")
+            .qos(QoSProfile::parameter_services_default()),
             move |_req_id: &rmw_request_id_t, req: DescribeParameters_Request| {
                 let map = map.lock().unwrap();
                 describe_parameters(req, &map)
             },
         )?;
         let map = parameter_map.clone();
         let get_parameter_types_service = node.create_service(
-            &(fqn.clone() + "/get_parameter_types"),
+            (fqn.clone() + "/get_parameter_types")
+            .qos(QoSProfile::parameter_services_default()),
             move |_req_id: &rmw_request_id_t, req: GetParameterTypes_Request| {
                 let map = map.lock().unwrap();
                 get_parameter_types(req, &map)
             },
         )?;
         let map = parameter_map.clone();
         let get_parameters_service = node.create_service(
-            &(fqn.clone() + "/get_parameters"),
+            (fqn.clone() + "/get_parameters")
+            .qos(QoSProfile::parameter_services_default()),
             move |_req_id: &rmw_request_id_t, req: GetParameters_Request| {
                 let map = map.lock().unwrap();
                 get_parameters(req, &map)
             },
         )?;
         let map = parameter_map.clone();
         let list_parameters_service = node.create_service(
-            &(fqn.clone() + "/list_parameters"),
+            (fqn.clone() + "/list_parameters")
+            .qos(QoSProfile::parameter_services_default()),
             move |_req_id: &rmw_request_id_t, req: ListParameters_Request| {
                 let map = map.lock().unwrap();
                 list_parameters(req, &map)
             },
         )?;
         let map = parameter_map.clone();
         let set_parameters_service = node.create_service(
-            &(fqn.clone() + "/set_parameters"),
+            (fqn.clone() + "/set_parameters")
+            .qos(QoSProfile::parameter_services_default()),
             move |_req_id: &rmw_request_id_t, req: SetParameters_Request| {
                 let mut map = map.lock().unwrap();
                 set_parameters(req, &mut map)
             },
         )?;
         let set_parameters_atomically_service = node.create_service(
-            &(fqn.clone() + "/set_parameters_atomically"),
+            (fqn.clone() + "/set_parameters_atomically")
+            .qos(QoSProfile::parameter_services_default()),
             move |_req_id: &rmw_request_id_t, req: SetParametersAtomically_Request| {
                 let mut map = parameter_map.lock().unwrap();
                 set_parameters_atomically(req, &mut map)

rclrs/src/service.rs

@@ -9,7 +9,7 @@ use rosidl_runtime_rs::Message;
 use crate::{
     error::{RclReturnCode, ToResult},
     rcl_bindings::*,
-    MessageCow, NodeHandle, RclrsError, ENTITY_LIFECYCLE_MUTEX,
+    IntoPrimitiveOptions, MessageCow, NodeHandle, RclrsError, ENTITY_LIFECYCLE_MUTEX, QoSProfile,
 };
 
 // SAFETY: The functions accessing this type, including drop(), shouldn't care about the thread
@@ -80,9 +80,9 @@ where
     T: rosidl_runtime_rs::Service,
 {
     /// Creates a new service.
-    pub(crate) fn new<F>(
+    pub(crate) fn new<'a, F>(
         node_handle: Arc<NodeHandle>,
-        topic: &str,
+        options: impl Into<ServiceOptions<'a>>,
         callback: F,
     ) -> Result<Self, RclrsError>
     // This uses pub(crate) visibility to avoid instantiating this struct outside
@@ -91,17 +91,19 @@ where
         T: rosidl_runtime_rs::Service,
         F: Fn(&rmw_request_id_t, T::Request) -> T::Response + 'static + Send,
     {
+        let ServiceOptions { name, qos } = options.into();
         // SAFETY: Getting a zero-initialized value is always safe.
         let mut rcl_service = unsafe { rcl_get_zero_initialized_service() };
         let type_support = <T as rosidl_runtime_rs::Service>::get_type_support()
             as *const rosidl_service_type_support_t;
-        let topic_c_string = CString::new(topic).map_err(|err| RclrsError::StringContainsNul {
+        let topic_c_string = CString::new(name).map_err(|err| RclrsError::StringContainsNul {
             err,
-            s: topic.into(),
+            s: name.into(),
         })?;
 
         // SAFETY: No preconditions for this function.
-        let service_options = unsafe { rcl_service_get_default_options() };
+        let mut service_options = unsafe { rcl_service_get_default_options() };
+        service_options.qos = qos.into();
 
         {
             let rcl_node = node_handle.rcl_node.lock().unwrap();
@@ -181,6 +183,26 @@ where
     }
 }
 
+/// `ServiceOptions are used by [`Node::create_service`][1] to initialize a
+/// [`Service`] provider.
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub struct ServiceOptions<'a> {
+    /// The name for the service
+    pub name: &'a str,
+    /// The quality of service for the service.
+    pub qos: QoSProfile,
+}
+
+impl<'a, T: IntoPrimitiveOptions<'a>> From<T> for ServiceOptions<'a> {
+    fn from(value: T) -> Self {
+        let options = value.into_primitive_options();
+        let mut qos = QoSProfile::services_default();
+        options.apply(&mut qos);
+        Self { name: options.name, qos }
+    }
+}
+
 impl<T> ServiceBase for Service<T>
 where
     T: rosidl_runtime_rs::Service,