automatically use introspection to determine the right values to pass

Author: devyn

Cargo.toml

@@ -9,3 +9,5 @@ edition = "2021"
 dbus = "0.9.7"
 nu-plugin = "0.89.0"
 nu-protocol = { version = "0.89.0", features = ["plugin"] }
+serde = { version = "1.0.196", features = ["derive"] }
+serde-xml-rs = "0.6.0"

src/client.rs

@@ -2,14 +2,25 @@ use dbus::{channel::{Channel, BusType}, Message};
 use nu_plugin::LabeledError;
 use nu_protocol::{Spanned, Value};
 
-use crate::{config::{DbusClientConfig, DbusBusChoice}, dbus_type::DbusType, convert::to_message_item};
+use crate::{config::{DbusClientConfig, DbusBusChoice}, dbus_type::DbusType, convert::to_message_item, introspection::Node};
 
 /// Executes D-Bus actions on a connection, handling nushell types
 pub struct DbusClient {
     config: DbusClientConfig,
     conn: Channel,
 }
 
+// Convenience macros for error handling
+macro_rules! validate_with {
+    ($type:ty, $spanned:expr) => (<$type>::new(&$spanned.item).map_err(|msg| {
+        LabeledError {
+            label: msg,
+            msg: "this argument is incorrect".into(),
+            span: Some($spanned.span),
+        }
+    }))
+}
+
 impl DbusClient {
     pub fn new(config: DbusClientConfig) -> Result<DbusClient, LabeledError> {
         // Try to connect to the correct D-Bus destination, as specified in the config
@@ -35,6 +46,71 @@ impl DbusClient {
         })
     }
 
+    fn error(&self, err: impl std::fmt::Display, msg: impl std::fmt::Display) -> LabeledError {
+        LabeledError {
+            label: err.to_string(),
+            msg: msg.to_string(),
+            span: Some(self.config.span)
+        }
+    }
+
+    /// Introspect a D-Bus object
+    pub fn introspect(
+        &self,
+        dest: &Spanned<String>,
+        object: &Spanned<String>,
+    ) -> Result<Node, LabeledError> {
+        let context = "while introspecting a D-Bus method";
+        let valid_dest = validate_with!(dbus::strings::BusName, dest)?;
+        let valid_object = validate_with!(dbus::strings::Path, object)?;
+
+        // Create the introspection method call
+        let message = Message::new_method_call(
+            valid_dest,
+            valid_object,
+            "org.freedesktop.DBus.Introspectable",
+            "Introspect"
+        ).map_err(|err| self.error(err, context))?;
+
+        // Send and get the response
+        let resp = self.conn.send_with_reply_and_block(message, self.config.timeout.item)
+            .map_err(|err| self.error(err, context))?;
+
+        // Parse it to a Node
+        let xml: &str = resp.get1()
+            .ok_or_else(|| self.error("Introspect method returned the wrong type", context))?;
+
+        Node::from_xml(xml).map_err(|err| self.error(err, context))
+    }
+
+    /// Try to use introspection to get the signature of a method
+    fn get_method_signature_by_introspection(
+        &self,
+        dest: &Spanned<String>,
+        object: &Spanned<String>,
+        interface: &Spanned<String>,
+        method: &Spanned<String>,
+    ) -> Result<Vec<DbusType>, LabeledError> {
+        let node = self.introspect(dest, object)?;
+
+        if let Some(sig) = node.get_method_args_signature(&interface.item, &method.item) {
+            DbusType::parse_all(&sig).map_err(|err| LabeledError {
+                label: format!("while getting interface {:?} method {:?} signature: {}",
+                    interface.item,
+                    method.item,
+                    err),
+                msg: "try running with --no-introspect or --signature".into(),
+                span: Some(self.config.span),
+            })
+        } else {
+            Err(LabeledError {
+                label: format!("Method {:?} not found on {:?}", method.item, interface.item),
+                msg: "check that this method/interface is correct".into(),
+                span: Some(method.span),
+            })
+        }
+    }
+
     /// Call a D-Bus method and wait for the response
     pub fn call(
         &self,
@@ -45,41 +121,42 @@ impl DbusClient {
         signature: Option<&Spanned<String>>,
         args: &[Value],
     ) -> Result<Vec<Value>, LabeledError> {
-        macro_rules! error {
-            ($label:expr) => (LabeledError {
-                label: $label,
-                msg: "while calling a D-Bus method".into(),
-                span: Some(self.config.span)
-            })
-        }
+        let context = "while calling a D-Bus method";
 
         // Validate inputs before sending to the dbus lib so we don't panic
-        macro_rules! validate_with {
-            ($type:ty, $spanned:expr) => (<$type>::new(&$spanned.item).map_err(|msg| {
-                LabeledError {
-                    label: msg,
-                    msg: "this argument is incorrect".into(),
-                    span: Some($spanned.span),
-                }
-            }))
-        }
         let valid_dest = validate_with!(dbus::strings::BusName, dest)?;
         let valid_object = validate_with!(dbus::strings::Path, object)?;
         let valid_interface = validate_with!(dbus::strings::Interface, interface)?;
         let valid_method = validate_with!(dbus::strings::Member, method)?;
 
         // Parse the signature
-        let valid_signature = signature.map(|s| DbusType::parse_all(&s.item).map_err(|err| {
+        let mut valid_signature = signature.map(|s| DbusType::parse_all(&s.item).map_err(|err| {
             LabeledError {
                 label: err,
                 msg: "in signature specified here".into(),
                 span: Some(s.span),
             }
         })).transpose()?;
 
+        // If not provided, try introspection (unless disabled)
+        if valid_signature.is_none() && self.config.introspect {
+            match self.get_method_signature_by_introspection(dest, object, interface, method) {
+                Ok(sig) => {
+                    valid_signature = Some(sig);
+                },
+                Err(err) => {
+                    eprintln!("Warning: D-Bus introspection failed on {:?}. \
+                        Use `--no-introspect` or pass `--signature` to silence this warning. \
+                        Cause: {}",
+                        object.item,
+                        err.label);
+                }
+            }
+        }
+
         if let Some(sig) = &valid_signature {
             if sig.len() != args.len() {
-                error!(format!("expected {} arguments, got {}", sig.len(), args.len()));
+                self.error(format!("expected {} arguments, got {}", sig.len(), args.len()), context);
             }
         }
 
@@ -89,7 +166,7 @@ impl DbusClient {
             valid_object,
             valid_interface,
             valid_method,
-        ).map_err(|err| error!(err))?;
+        ).map_err(|err| self.error(err, context))?;
 
         // Convert the args to message items
         let sigs_iter = valid_signature.iter().flatten().map(Some).chain(std::iter::repeat(None));
@@ -99,8 +176,8 @@ impl DbusClient {
 
         // Send it on the channel and get the response
         let resp = self.conn.send_with_reply_and_block(message, self.config.timeout.item)
-            .map_err(|err| error!(err.to_string()))?;
+            .map_err(|err| self.error(err, context))?;
 
-        crate::convert::from_message(&resp).map_err(|err| error!(err))
+        crate::convert::from_message(&resp).map_err(|err| self.error(err, context))
     }
 }

src/config.rs

@@ -7,8 +7,12 @@ use nu_protocol::{Spanned, Span};
 #[derive(Debug, Clone)]
 pub struct DbusClientConfig {
     pub span: Span,
+    /// Which bus should we connect to?
     pub bus_choice: Spanned<DbusBusChoice>,
+    /// How long to wait for a method call to return
     pub timeout: Spanned<Duration>,
+    /// Enable introspection if signature unknown (default true)
+    pub introspect: bool,
 }
 
 /// Where to connect to the D-Bus server
@@ -35,6 +39,7 @@ impl TryFrom<&EvaluatedCall> for DbusClientConfig {
             span: call.head,
             bus_choice: Spanned { item: DbusBusChoice::default(), span: call.head },
             timeout: Spanned { item: Duration::from_secs(2), span: call.head },
+            introspect: true,
         };
 
         // Handle recognized config args
@@ -75,6 +80,11 @@ impl TryFrom<&EvaluatedCall> for DbusClientConfig {
                         config.timeout = Spanned { item, span: value.span() };
                     }
                 },
+                "no-introspect" => {
+                    config.introspect = !value.as_ref()
+                        .and_then(|v| v.as_bool().ok())
+                        .unwrap_or(false);
+                },
                 _ => ()
             }
         }

src/convert.rs

@@ -142,12 +142,12 @@ pub fn to_message_item(value: &Value, expected_type: Option<&DbusType>)
             Ok(MessageItem::Double(try_convert!(f64::from_str(&val[..])))),
 
         // List/array
-        (Value::List { vals, .. }, Some(DbusType::Array(content_type))) => {
-            let content_sig = Signature::from(content_type.stringify());
+        (Value::List { vals, .. }, Some(r#type @ DbusType::Array(content_type))) => {
+            let sig = Signature::from(r#type.stringify());
             let items = vals.iter()
                 .map(|content| to_message_item(content, Some(content_type)))
                 .collect::<Result<Vec<MessageItem>, _>>()?;
-            Ok(MessageItem::Array(MessageItemArray::new(items, content_sig).unwrap()))
+            Ok(MessageItem::Array(MessageItemArray::new(items, sig).unwrap()))
         },
 
         // Struct