add commands for working with D-Bus properties more easily

devyn · devyn · commit c3fa402d440c · 2024-01-31T01:12:46.000-08:00
diff --git a/src/client.rs b/src/client.rs
@@ -1,6 +1,6 @@
-use dbus::{channel::{Channel, BusType}, Message};
+use dbus::{channel::{Channel, BusType}, Message, arg::messageitem::MessageItem};
 use nu_plugin::LabeledError;
-use nu_protocol::{Spanned, Value};
+use nu_protocol::{Spanned, Value, Span};
 
 use crate::{config::{DbusClientConfig, DbusBusChoice}, dbus_type::DbusType, convert::to_message_item, introspection::Node};
 
@@ -111,6 +111,34 @@ impl DbusClient {
         }
     }
 
+    /// Try to use introspection to get the signature of a property
+    fn get_property_signature_by_introspection(
+        &self,
+        dest: &Spanned<String>,
+        object: &Spanned<String>,
+        interface: &Spanned<String>,
+        property: &Spanned<String>,
+    ) -> Result<Vec<DbusType>, LabeledError> {
+        let node = self.introspect(dest, object)?;
+
+        if let Some(sig) = node.get_property_signature(&interface.item, &property.item) {
+            DbusType::parse_all(&sig).map_err(|err| LabeledError {
+                label: format!("while getting interface {:?} property {:?} signature: {}",
+                    interface.item,
+                    property.item,
+                    err),
+                msg: "try running with --no-introspect or --signature".into(),
+                span: Some(self.config.span),
+            })
+        } else {
+            Err(LabeledError {
+                label: format!("Property {:?} not found on {:?}", property.item, interface.item),
+                msg: "check that this property/interface is correct".into(),
+                span: Some(property.span),
+            })
+        }
+    }
+
     /// Call a D-Bus method and wait for the response
     pub fn call(
         &self,
@@ -180,4 +208,113 @@ impl DbusClient {
 
         crate::convert::from_message(&resp).map_err(|err| self.error(err, context))
     }
+
+    /// Get a D-Bus property from the given object
+    pub fn get(
+        &self,
+        dest: &Spanned<String>,
+        object: &Spanned<String>,
+        interface: &Spanned<String>,
+        property: &Spanned<String>,
+    ) -> Result<Value, LabeledError> {
+        let interface_val = Value::string(&interface.item, interface.span);
+        let property_val = Value::string(&property.item, property.span);
+
+        self.call(
+            dest,
+            object,
+            &Spanned { item: "org.freedesktop.DBus.Properties".into(), span: Span::unknown() },
+            &Spanned { item: "Get".into(), span: Span::unknown() },
+            Some(&Spanned { item: "ss".into(), span: Span::unknown() }),
+            &[interface_val, property_val]
+        ).map(|val| val.into_iter().nth(0).unwrap_or(Value::nothing(Span::unknown())))
+    }
+
+    /// Get all D-Bus properties from the given object
+    pub fn get_all(
+        &self,
+        dest: &Spanned<String>,
+        object: &Spanned<String>,
+        interface: &Spanned<String>,
+    ) -> Result<Value, LabeledError> {
+        let interface_val = Value::string(&interface.item, interface.span);
+
+        self.call(
+            dest,
+            object,
+            &Spanned { item: "org.freedesktop.DBus.Properties".into(), span: Span::unknown() },
+            &Spanned { item: "GetAll".into(), span: Span::unknown() },
+            Some(&Spanned { item: "s".into(), span: Span::unknown() }),
+            &[interface_val]
+        ).map(|val| val.into_iter().nth(0).unwrap_or(Value::nothing(Span::unknown())))
+    }
+
+    /// Set a D-Bus property on the given object
+    pub fn set(
+        &self,
+        dest: &Spanned<String>,
+        object: &Spanned<String>,
+        interface: &Spanned<String>,
+        property: &Spanned<String>,
+        signature: Option<&Spanned<String>>,
+        value: &Value,
+    ) -> Result<(), LabeledError> {
+        let context = "while setting a D-Bus property";
+
+        // Validate inputs before sending to the dbus lib so we don't panic
+        let valid_dest = validate_with!(dbus::strings::BusName, dest)?;
+        let valid_object = validate_with!(dbus::strings::Path, object)?;
+
+        // Parse the signature
+        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_property_signature_by_introspection(dest, object, interface, property) {
+                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() != 1 {
+                self.error(format!(
+                    "expected single object signature, but there are {}", sig.len()), context);
+            }
+        }
+
+        // Construct the method call message
+        let message = Message::new_method_call(
+            valid_dest,
+            valid_object,
+            "org.freedesktop.DBus.Properties",
+            "Set",
+        ).map_err(|err| self.error(err, context))?
+            .append2(&interface.item, &property.item)
+            .append1(
+                // Box it in a variant as required for property setting
+                MessageItem::Variant(Box::new(
+                    to_message_item(value, valid_signature.as_ref().map(|s| &s[0]))?))
+            );
+
+        // Send it on the channel and get the response
+        self.conn.send_with_reply_and_block(message, self.config.timeout.item)
+            .map_err(|err| self.error(err, context))?;
+
+        Ok(())
+    }
 }
diff --git a/src/introspection.rs b/src/introspection.rs
@@ -36,6 +36,11 @@ impl Node {
     pub fn get_method_args_signature(&self, interface: &str, method: &str) -> Option<String> {
         Some(self.get_interface(interface)?.get_method(method)?.in_signature())
     }
+
+    /// Find the signature of a property on an interface on this node
+    pub fn get_property_signature(&self, interface: &str, property: &str) -> Option<&str> {
+        Some(&self.get_interface(interface)?.get_property(property)?.r#type)
+    }
 }
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
@@ -62,7 +67,6 @@ impl Interface {
         self.signals.iter().find(|s| s.name == name)
     }
 
-    #[allow(dead_code)]
     pub fn get_property(&self, name: &str) -> Option<&Property> {
         self.properties.iter().find(|p| p.name == name)
     }
diff --git a/src/main.rs b/src/main.rs
@@ -60,8 +60,32 @@ impl Plugin for NuPluginDbus {
                         result: None
                     },
                     PluginExample {
-                        example: "dbus call --dest=org.mpris.MediaPlayer2.spotify \
-                            /org/mpris/MediaPlayer2 org.freedesktop.DBus.Properties Get \
+                        example: "dbus call --dest=org.freedesktop.Notifications \
+                            /org/freedesktop/Notifications org.freedesktop.Notifications \
+                            Notify \"Floppy disks\" 0 \"media-floppy\" \"Rarely seen\" \
+                            \"But sometimes still used\" [] {} 5000".into(),
+                        description: "Show a notification on the desktop for 5 seconds".into(),
+                        result: None
+                    },
+                ]),
+            PluginSignature::build("dbus get")
+                .is_dbus_command()
+                .accepts_dbus_client_options()
+                .usage("Get a D-Bus property")
+                .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None)
+                .required_named("dest", SyntaxShape::String,
+                    "The name of the connection to read the property from",
+                    None)
+                .required("object", SyntaxShape::String,
+                    "The path to the object to read the property from")
+                .required("interface", SyntaxShape::String,
+                    "The name of the interface the property belongs to")
+                .required("property", SyntaxShape::String,
+                    "The name of the property to read")
+                .plugin_examples(vec![
+                    PluginExample {
+                        example: "dbus get --dest=org.mpris.MediaPlayer2.spotify \
+                            /org/mpris/MediaPlayer2 \
                             org.mpris.MediaPlayer2.Player Metadata".into(),
                         description: "Get the currently playing song in Spotify".into(),
                         result: Some(Value::record(nu_protocol::record!(
@@ -73,13 +97,60 @@ impl Plugin for NuPluginDbus {
                             "xesam:url" => str!("https://open.spotify.com/track/51748BvzeeMs4PIdPuyZmv"),
                         ), Span::unknown()))
                     },
+                ]),
+            PluginSignature::build("dbus get-all")
+                .is_dbus_command()
+                .accepts_dbus_client_options()
+                .usage("Get all D-Bus property for the given objects")
+                .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None)
+                .required_named("dest", SyntaxShape::String,
+                    "The name of the connection to read the property from",
+                    None)
+                .required("object", SyntaxShape::String,
+                    "The path to the object to read the property from")
+                .required("interface", SyntaxShape::String,
+                    "The name of the interface the property belongs to")
+                .plugin_examples(vec![
                     PluginExample {
-                        example: "dbus call --dest=org.freedesktop.Notifications \
-                            /org/freedesktop/Notifications org.freedesktop.Notifications \
-                            Notify \"Floppy disks\" 0 \"media-floppy\" \"Rarely seen\" \
-                            \"But sometimes still used\" [] {} 5000".into(),
-                        description: "Show a notification on the desktop for 5 seconds".into(),
-                        result: None
+                        example: "dbus get-all --dest=org.mpris.MediaPlayer2.spotify \
+                            /org/mpris/MediaPlayer2 \
+                            org.mpris.MediaPlayer2.Player".into(),
+                        description: "Get the current player state of Spotify".into(),
+                        result: Some(Value::record(nu_protocol::record!(
+                            "CanPlay" => Value::bool(true, Span::unknown()),
+                            "Volume" => Value::float(0.43, Span::unknown()),
+                            "PlaybackStatus" => str!("Paused"),
+                        ), Span::unknown()))
+                    },
+                ]),
+            PluginSignature::build("dbus set")
+                .is_dbus_command()
+                .accepts_dbus_client_options()
+                .usage("Get all D-Bus property for the given objects")
+                .named("timeout", SyntaxShape::Duration, "How long to wait for a response", None)
+                .named("signature", SyntaxShape::String,
+                    "Signature of the value to set, in D-Bus format.\n    \
+                     If not provided, it will be determined from introspection.\n    \
+                     If --no-introspect is specified and this is not provided, it will \
+                       be guessed (poorly)", None)
+                .required_named("dest", SyntaxShape::String,
+                    "The name of the connection to write the property on",
+                    None)
+                .required("object", SyntaxShape::String,
+                    "The path to the object to write the property on")
+                .required("interface", SyntaxShape::String,
+                    "The name of the interface the property belongs to")
+                .required("property", SyntaxShape::String,
+                    "The name of the property to write")
+                .required("value", SyntaxShape::Any,
+                    "The value to write to the property")
+                .plugin_examples(vec![
+                    PluginExample {
+                        example: "dbus set --dest=org.mpris.MediaPlayer2.spotify \
+                            /org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player \
+                            Volume 0.5".into(),
+                        description: "Set the volume of Spotify to 50%".into(),
+                        result: None,
                     },
                 ]),
         ]
@@ -99,6 +170,9 @@ impl Plugin for NuPluginDbus {
             }),
 
             "dbus call" => self.call(call),
+            "dbus get" => self.get(call),
+            "dbus get-all" => self.get_all(call),
+            "dbus set" => self.set(call),
 
             _ => Err(LabeledError {
                 label: "Plugin invoked with unknown command name".into(),
@@ -156,4 +230,39 @@ impl NuPluginDbus {
             _            => Ok(Value::list(values, Span::unknown()))
         }
     }
+
+    fn get(&self, call: &EvaluatedCall) -> Result<Value, LabeledError> {
+        let config = DbusClientConfig::try_from(call)?;
+        let dbus = DbusClient::new(config)?;
+        dbus.get(
+            &call.get_flag("dest")?.unwrap(),
+            &call.req(0)?,
+            &call.req(1)?,
+            &call.req(2)?,
+        )
+    }
+
+    fn get_all(&self, call: &EvaluatedCall) -> Result<Value, LabeledError> {
+        let config = DbusClientConfig::try_from(call)?;
+        let dbus = DbusClient::new(config)?;
+        dbus.get_all(
+            &call.get_flag("dest")?.unwrap(),
+            &call.req(0)?,
+            &call.req(1)?,
+        )
+    }
+
+    fn set(&self, call: &EvaluatedCall) -> Result<Value, LabeledError> {
+        let config = DbusClientConfig::try_from(call)?;
+        let dbus = DbusClient::new(config)?;
+        dbus.set(
+            &call.get_flag("dest")?.unwrap(),
+            &call.req(0)?,
+            &call.req(1)?,
+            &call.req(2)?,
+            call.get_flag("signature")?.as_ref(),
+            &call.req(3)?,
+        )?;
+        Ok(Value::nothing(Span::unknown()))
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,11 @@ impl Node {`
`36`	`36`	`pub fn get_method_args_signature(&self, interface: &str, method: &str) -> Option<String> {`
`37`	`37`	`Some(self.get_interface(interface)?.get_method(method)?.in_signature())`
`38`	`38`	`}`
	`39`	`+`
	`40`	`+ /// Find the signature of a property on an interface on this node`
	`41`	`+ pub fn get_property_signature(&self, interface: &str, property: &str) -> Option<&str> {`
	`42`	`+ Some(&self.get_interface(interface)?.get_property(property)?.r#type)`
	`43`	`+ }`
`39`	`44`	`}`
`40`	`45`
`41`	`46`	`#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]`
`@@ -62,7 +67,6 @@ impl Interface {`
`62`	`67`	`self.signals.iter().find(\|s\| s.name == name)`
`63`	`68`	`}`
`64`	`69`
`65`		`- #[allow(dead_code)]`
`66`	`70`	`pub fn get_property(&self, name: &str) -> Option<&Property> {`
`67`	`71`	`self.properties.iter().find(\|p\| p.name == name)`
`68`	`72`	`}`