Add rosout logging to rclrs

rclrs/src/client.rs

@@ -43,7 +43,7 @@ impl Drop for ClientHandle {
         // 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_client_fini(rcl_client, &mut *rcl_node);
+            rcl_client_fini(rcl_client, &mut **rcl_node);
         }
     }
 }
@@ -115,7 +115,7 @@ where
             unsafe {
                 rcl_client_init(
                     &mut rcl_client,
-                    &*rcl_node,
+                    &**rcl_node,
                     type_support,
                     topic_c_string.as_ptr(),
                     &client_options,
@@ -263,7 +263,7 @@ where
     pub fn service_is_ready(&self) -> Result<bool, RclrsError> {
         let mut is_ready = false;
         let client = &mut *self.handle.rcl_client.lock().unwrap();
-        let node = &mut *self.handle.node_handle.rcl_node.lock().unwrap();
+        let node = &mut **self.handle.node_handle.rcl_node.lock().unwrap();
 
         unsafe {
             // SAFETY both node and client are guaranteed to be valid here

rclrs/src/context.rs

@@ -34,6 +34,10 @@ impl Drop for rcl_context_t {
                 // SAFETY: The entity lifecycle mutex is locked to protect against the risk of
                 // global variables in the rmw implementation being unsafely modified during cleanup.
                 rcl_shutdown(self);
+
+                // SAFETY: No preconditions for rcl_logging_fini
+                rcl_logging_fini();
+
                 rcl_context_fini(self);
             }
         }
@@ -56,6 +60,10 @@ unsafe impl Send for rcl_context_t {}
 /// - middleware-specific data, e.g. the domain participant in DDS
 /// - the allocator used (left as the default by `rclrs`)
 ///
+/// The context also configures the rcl_logging_* layer to allow publication to /rosout
+/// (as well as the terminal).  TODO: This behaviour should be configurable using an
+/// "auto logging initialise" flag as per rclcpp and rclpy.
+///
 pub struct Context {
     pub(crate) handle: Arc<ContextHandle>,
 }
@@ -142,6 +150,24 @@ impl Context {
             rcl_init_options_fini(&mut rcl_init_options).ok()?;
             // Move the check after the last fini()
             ret?;
+
+            // TODO: "Auto set-up logging" is forced but should be configurable as per rclcpp and rclpy
+            // SAFETY:
+            // * Lock the mutex as we cannot guarantee that rcl_* functions are protecting their global variables
+            // * Context is validated before we reach this point
+            // * No other preconditions for calling this function
+            let ret = {
+                let _lifecycle_lock = ENTITY_LIFECYCLE_MUTEX.lock().unwrap();
+                // Note: shadowing the allocator above.  The rcutils_get_default_allocator provides us with mechanisms for allocating and freeing
+                // memory, e.g. calloc/free. As these are function pointers and will be the same each time we call the method, it is safe to
+                // perform this shadowing
+                // Alternate is to call rcl_init_options_get_allocator however, we've freed the allocator above and restructuring the call
+                // sequence is unnecessarily complex
+                let allocator = rcutils_get_default_allocator();
+
+                rcl_logging_configure(&rcl_context.global_arguments, &allocator).ok()
+            };
+            ret?
         }
         Ok(Self {
             handle: Arc::new(ContextHandle {

rclrs/src/lib.rs

@@ -11,6 +11,7 @@ mod clock;
 mod context;
 mod error;
 mod executor;
+mod logging;
 mod node;
 mod parameter;
 mod publisher;
@@ -38,6 +39,7 @@ pub use clock::*;
 pub use context::*;
 pub use error::*;
 pub use executor::*;
+pub use logging::*;
 pub use node::*;
 pub use parameter::*;
 pub use publisher::*;