mostly complete implementation of dbus response to nushell

Author: devyn

src/client.rs

@@ -1,13 +1,13 @@
-use dbus::{blocking::LocalConnection, channel::{Channel, BusType}};
+use dbus::{channel::{Channel, BusType}, Message};
 use nu_plugin::LabeledError;
-use nu_protocol::Spanned;
+use nu_protocol::{Spanned, Value};
 
 use crate::config::{DbusClientConfig, DbusBusChoice};
 
 /// Executes D-Bus actions on a connection, handling nushell types
 pub struct DbusClient {
     config: DbusClientConfig,
-    conn: LocalConnection,
+    conn: Channel,
 }
 
 impl DbusClient {
@@ -31,7 +31,7 @@ impl DbusClient {
         })?;
         Ok(DbusClient {
             config,
-            conn: LocalConnection::from(channel)
+            conn: channel
         })
     }
 
@@ -42,9 +42,16 @@ impl DbusClient {
         object: &Spanned<String>,
         interface: &Spanned<String>,
         method: &Spanned<String>,
-    ) -> Result<(), LabeledError> {
-        // TODO convert & return response
+    ) -> Result<Value, LabeledError> {
         // TODO accept arguments
+        macro_rules! error {
+            ($label:expr) => (LabeledError {
+                label: $label,
+                msg: "while calling a D-Bus method".into(),
+                span: Some(self.config.span)
+            })
+        }
+
         // 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| {
@@ -60,19 +67,18 @@ impl DbusClient {
         let valid_interface = validate_with!(dbus::strings::Interface, interface)?;
         let valid_method = validate_with!(dbus::strings::Member, method)?;
 
-        // Send method call
-        let proxy = self.conn.with_proxy(
+        // Construct the method call message
+        let message = Message::new_method_call(
             valid_dest,
             valid_object,
-            self.config.timeout.item
-        );
-        let () = proxy.method_call(valid_interface, valid_method, ()).map_err(|err| {
-            LabeledError {
-                label: err.to_string(),
-                msg: "while calling a D-Bus method".into(),
-                span: Some(self.config.span),
-            }
-        })?;
-        Ok(())
+            valid_interface,
+            valid_method,
+        ).map_err(|err| error!(err))?;
+
+        // 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()))?;
+
+        Ok(crate::convert::from_message(&resp)?)
     }
 }

src/convert.rs

@@ -0,0 +1,70 @@
+use dbus::{Message, arg::{ArgType, RefArg}};
+use nu_plugin::LabeledError;
+use nu_protocol::{Value, Span, Record};
+
+pub fn from_message(message: &Message) -> Result<Value, LabeledError> {
+    let mut out = vec![];
+    for refarg in message.iter_init() {
+        if let Some(o) = from_refarg(&refarg) {
+            out.push(o);
+        }
+    }
+    Ok(Value::list(out, Span::unknown()))
+}
+
+pub fn from_refarg(refarg: &dyn RefArg) -> Option<Value> {
+    Some(match refarg.arg_type() {
+        ArgType::Array => {
+            if refarg.signature().starts_with("a{") {
+                // This is a dictionary
+                let mut record = Record::new();
+                for entry in refarg.as_iter().unwrap() {
+                    let mut entry_iter = entry.as_iter().unwrap();
+                    let key = entry_iter.next().unwrap();
+                    let val = entry_iter.next().unwrap();
+                    if let Some(key) = key.as_str() {
+                        record.insert(key, from_refarg(val)?);
+                    }
+                }
+                Value::record(record, Span::unknown())
+            } else if &*refarg.signature() == "ay" {
+                // Byte array - better to return as binary
+                let bytes = dbus::arg::cast::<Vec<u8>>(&refarg.box_clone()).unwrap().to_owned();
+                Value::binary(bytes, Span::unknown())
+            } else {
+                // It's an array
+                Value::list(
+                    refarg.as_iter().unwrap().map(from_refarg).flatten().collect(),
+                    Span::unknown())
+            }
+        },
+        ArgType::Variant => {
+            let inner = refarg.as_iter().unwrap().nth(0).unwrap();
+            return from_refarg(inner);
+        },
+        ArgType::Boolean =>
+            Value::bool(refarg.as_i64().unwrap() != 0, Span::unknown()),
+
+        // Strings
+        ArgType::String | ArgType::ObjectPath | ArgType::Signature =>
+            Value::string(refarg.as_str().unwrap(), Span::unknown()),
+        // Ints
+        ArgType::Byte | ArgType::Int16 | ArgType::UInt16 | ArgType::Int32 |
+        ArgType::UInt32 | ArgType::Int64 | ArgType::UnixFd =>
+            Value::int(refarg.as_i64().unwrap(), Span::unknown()),
+        // Floats
+        ArgType::Double =>
+            Value::float(refarg.as_f64().unwrap(), Span::unknown()),
+
+        ArgType::Struct =>
+            Value::list(
+                refarg.as_iter().unwrap().map(from_refarg).flatten().collect(),
+                Span::unknown()),
+
+        ArgType::DictEntry => todo!(),
+        ArgType::UInt64 => todo!(), // nushell only supports up to i64
+
+        // End of iterator
+        ArgType::Invalid => return None,
+    })
+}

src/main.rs

@@ -3,6 +3,7 @@ use nu_protocol::{PluginSignature, Value, SyntaxShape, PluginExample};
 
 mod config;
 mod client;
+mod convert;
 
 use config::*;
 use client::*;
@@ -102,8 +103,6 @@ impl NuPluginDbus {
             &call.req(0)?,
             &call.req(1)?,
             &call.req(2)?,
-        )?;
-        // TODO handle response
-        Ok(Value::nothing(call.head))
+        )
     }
 }