Basic method call support, no args or response handling yet

Author: devyn

Cargo.toml

@@ -6,5 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+dbus = "0.9.7"
 nu-plugin = "0.89.0"
 nu-protocol = { version = "0.89.0", features = ["plugin"] }

src/client.rs

@@ -0,0 +1,78 @@
+use dbus::{blocking::LocalConnection, channel::{Channel, BusType}};
+use nu_plugin::LabeledError;
+use nu_protocol::Spanned;
+
+use crate::config::{DbusClientConfig, DbusBusChoice};
+
+/// Executes D-Bus actions on a connection, handling nushell types
+pub struct DbusClient {
+    config: DbusClientConfig,
+    conn: LocalConnection,
+}
+
+impl DbusClient {
+    pub fn new(config: DbusClientConfig) -> Result<DbusClient, LabeledError> {
+        // Try to connect to the correct D-Bus destination, as specified in the config
+        let channel = match &config.bus_choice.item {
+            DbusBusChoice::Session => Channel::get_private(BusType::Session),
+            DbusBusChoice::System => Channel::get_private(BusType::System),
+            DbusBusChoice::Started => Channel::get_private(BusType::Starter),
+            DbusBusChoice::Peer(address) => Channel::open_private(address),
+            DbusBusChoice::Bus(address) => Channel::open_private(address).and_then(|mut ch| {
+                ch.register()?;
+                Ok(ch)
+            }),
+        }.map_err(|err| {
+            LabeledError {
+                label: err.to_string(),
+                msg: "while connecting to D-Bus as specified here".into(),
+                span: Some(config.bus_choice.span),
+            }
+        })?;
+        Ok(DbusClient {
+            config,
+            conn: LocalConnection::from(channel)
+        })
+    }
+
+    /// Call a D-Bus method and wait for the response
+    pub fn call(
+        &self,
+        dest: &Spanned<String>,
+        object: &Spanned<String>,
+        interface: &Spanned<String>,
+        method: &Spanned<String>,
+    ) -> Result<(), LabeledError> {
+        // TODO convert & return response
+        // TODO accept arguments
+        // 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)?;
+
+        // Send method call
+        let proxy = self.conn.with_proxy(
+            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(())
+    }
+}

src/config.rs

@@ -0,0 +1,84 @@
+use std::time::Duration;
+
+use nu_plugin::{EvaluatedCall, LabeledError};
+use nu_protocol::{Spanned, Span};
+
+/// General configuration related to the D-Bus client connection
+#[derive(Debug, Clone)]
+pub struct DbusClientConfig {
+    pub span: Span,
+    pub bus_choice: Spanned<DbusBusChoice>,
+    pub timeout: Spanned<Duration>,
+}
+
+/// Where to connect to the D-Bus server
+#[derive(Debug, Clone, Default)]
+pub enum DbusBusChoice {
+    /// Connect to the session bus
+    #[default]
+    Session,
+    /// Connect to the system bus
+    System,
+    /// Connect to the bus that started this process
+    Started,
+    /// Connect to a bus instance at the given address
+    Bus(String),
+    /// Connect to a non-bus D-Bus server at the given address (will not send Hello)
+    Peer(String),
+}
+
+impl TryFrom<&EvaluatedCall> for DbusClientConfig {
+    type Error = LabeledError;
+
+    fn try_from(call: &EvaluatedCall) -> Result<Self, Self::Error> {
+        let mut config = DbusClientConfig {
+            span: call.head,
+            bus_choice: Spanned { item: DbusBusChoice::default(), span: call.head },
+            timeout: Spanned { item: Duration::from_secs(2), span: call.head },
+        };
+
+        // Handle recognized config args
+        for (name, value) in &call.named {
+            match &name.item[..] {
+                r#type @ ("session" | "system" | "started") => {
+                    if value.is_none() || value.as_ref().is_some_and(|v| v.is_true()) {
+                        let dest = match r#type {
+                            "session" => DbusBusChoice::Session,
+                            "system" => DbusBusChoice::System,
+                            "started" => DbusBusChoice::Started,
+                            _ => unreachable!()
+                        };
+                        config.bus_choice = Spanned { item: dest, span: name.span };
+                    }
+                },
+                r#type @ ("bus" | "peer") => {
+                    if let Some(value) = value {
+                        let address = value.as_string()?;
+                        let dest = match r#type {
+                            "bus" => DbusBusChoice::Bus(address),
+                            "peer" => DbusBusChoice::Peer(address),
+                            _ => unreachable!()
+                        };
+                        config.bus_choice = Spanned { item: dest, span: value.span() };
+                    }
+                },
+                "timeout" => {
+                    if let Some(value) = value {
+                        let nanos: u64 = value.as_duration()?.try_into().map_err(|_| {
+                            LabeledError {
+                                label: "Timeout must be a positive duration".into(),
+                                msg: "invalid timeout specified here".into(),
+                                span: Some(value.span()),
+                            }
+                        })?;
+                        let item = Duration::from_nanos(nanos);
+                        config.timeout = Spanned { item, span: value.span() };
+                    }
+                },
+                _ => ()
+            }
+        }
+
+        Ok(config)
+    }
+}

src/main.rs

@@ -1,27 +1,55 @@
 use nu_plugin::{serve_plugin, MsgPackSerializer, Plugin, EvaluatedCall, LabeledError};
-use nu_protocol::{PluginSignature, Value};
+use nu_protocol::{PluginSignature, Value, SyntaxShape, PluginExample};
+
+mod config;
+mod client;
+
+use config::*;
+use client::*;
 
 fn main() {
     serve_plugin(&mut NuPluginDbus, MsgPackSerializer)
 }
 
+/// The main plugin interface for nushell
 struct NuPluginDbus;
 
 impl Plugin for NuPluginDbus {
     fn signature(&self) -> Vec<PluginSignature> {
         vec![
             PluginSignature::build("dbus")
-                .usage("Commands for interacting with D-Bus")
-                .search_terms(vec!["dbus".into()])
-                .category(nu_protocol::Category::Platform),
+                .is_dbus_command()
+                .usage("Commands for interacting with D-Bus"),
+            PluginSignature::build("dbus call")
+                .is_dbus_command()
+                .accepts_dbus_client_options()
+                .usage("Call a method and get its response")
+                .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None)
+                .required_named("dest", SyntaxShape::String,
+                    "The name of the connection to send the method to",
+                    None)
+                .required("object", SyntaxShape::String,
+                    "The path to the object to call the method on")
+                .required("interface", SyntaxShape::String,
+                    "The name of the interface the method belongs to")
+                .required("method", SyntaxShape::String,
+                    "The name of the method to send")
+                .plugin_examples(vec![
+                    PluginExample {
+                        example: "dbus call --dest=org.freedesktop.DBus \
+                            /org/freedesktop/DBus org.freedesktop.DBus.Peer Ping".into(),
+                        description: "Ping the D-Bus server itself".into(),
+                        result: None
+                    }
+                ]),
         ]
     }
 
     fn run(
         &mut self,
         name: &str,
         call: &EvaluatedCall,
-        input: &Value,
+        _input: &Value,
     ) -> Result<Value, LabeledError> {
         match name {
             "dbus" => Err(LabeledError {
@@ -30,6 +58,8 @@ impl Plugin for NuPluginDbus {
                 span: Some(call.head)
             }),
 
+            "dbus call" => self.call(call),
+
             _ => Err(LabeledError {
                 label: "Plugin invoked with unknown command name".into(),
                 msg: "unknown command".into(),
@@ -38,3 +68,42 @@ impl Plugin for NuPluginDbus {
         }
     }
 }
+
+/// For conveniently adding the base options to a dbus command
+trait DbusSignatureUtilExt {
+    fn is_dbus_command(self) -> Self;
+    fn accepts_dbus_client_options(self) -> Self;
+}
+
+impl DbusSignatureUtilExt for PluginSignature {
+    fn is_dbus_command(self) -> Self {
+        self.search_terms(vec!["dbus".into()])
+            .category(nu_protocol::Category::Platform)
+    }
+
+    fn accepts_dbus_client_options(self) -> Self {
+        self.switch("session", "Send to the session message bus (default)", None)
+            .switch("system", "Send to the system message bus", None)
+            .switch("started", "Send to the bus that started this process, if applicable", None)
+            .named("bus", SyntaxShape::String, "Send to the bus server at the given address", None)
+            .named("peer", SyntaxShape::String,
+                "Send to a non-bus D-Bus server at the given address. \
+                 Will not call the Hello method on initialization.",
+                None)
+    }
+}
+
+impl NuPluginDbus {
+    fn call(&self, call: &EvaluatedCall) -> Result<Value, LabeledError> {
+        let config = DbusClientConfig::try_from(call)?;
+        let dbus = DbusClient::new(config)?;
+        dbus.call(
+            &call.get_flag("dest")?.unwrap(),
+            &call.req(0)?,
+            &call.req(1)?,
+            &call.req(2)?,
+        )?;
+        // TODO handle response
+        Ok(Value::nothing(call.head))
+    }
+}