Source code
Revision control
Copy as Markdown
Other Tools
/// NOTE: No longer used - replaced with files in the "tree" directory.
#![allow(dead_code)]
use {MessageItem, Message, MessageType, Connection, ConnectionItem, Error, ErrorName};
use {Signature, Member, Path};
use Interface as IfaceName;
use std::cell::RefCell;
use std::sync::{Arc, Mutex};
use std::collections::BTreeMap;
use std::marker::PhantomData;
use std::ffi::{CStr, CString};
use std::fmt;
use super::arg;
type ArcMap<K, V> = BTreeMap<Arc<K>, Arc<V>>;
#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
/// A D-Bus Argument.
pub struct Argument(Option<String>, Signature<'static>);
impl Argument {
/// Create a new Argument.
pub fn new(name: Option<String>, sig: Signature<'static>) -> Argument { Argument(name, sig) }
fn introspect(&self, indent: &str, dir: &str) -> String {
let n = self.0.as_ref().map(|n| format!("name=\"{}\" ", n)).unwrap_or("".into());
format!("{}<arg {}type=\"{}\"{}/>\n", indent, n, self.1, dir)
}
fn introspect_all(args: &[Argument], indent: &str, dir: &str) -> String {
args.iter().fold("".to_string(), |aa, az| format!("{}{}", aa, az.introspect(indent, dir)))
}
}
// Small helper struct to reduce memory somewhat for objects without annotations
#[derive(Clone, Debug, Default)]
struct Annotations(Option<BTreeMap<String, String>>);
impl Annotations {
fn new() -> Annotations { Annotations(None) }
fn insert<N: Into<String>, V: Into<String>>(&mut self, n: N, v: V) {
if self.0.is_none() { self.0 = Some(BTreeMap::new()) }
self.0.as_mut().unwrap().insert(n.into(), v.into());
}
fn introspect(&self, indent: &str) -> String {
self.0.as_ref().map(|s| s.iter().fold("".into(), |aa, (ak, av)| {
format!("{}{}<annotation name=\"{}\" value=\"{}\"/>\n", aa, indent, ak, av)
})).unwrap_or(String::new())
}
}
// Doesn't work, conflicting impls
// impl<S: Into<Signature>> From<S> for Argument
impl From<Signature<'static>> for Argument {
fn from(t: Signature<'static>) -> Argument { Argument(None, t) }
}
impl<'a> From<&'a str> for Argument {
fn from(t: &'a str) -> Argument { Argument(None, String::from(t).into()) }
}
impl<N: Into<String>, S: Into<Signature<'static>>> From<(N, S)> for Argument {
fn from((n, s): (N, S)) -> Argument { Argument(Some(n.into()), s.into()) }
}
#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
/// A D-Bus Method Error.
pub struct MethodErr(ErrorName<'static>, String);
impl MethodErr {
/// Create an Invalid Args MethodErr.
pub fn invalid_arg<T: fmt::Debug>(a: &T) -> MethodErr {
("org.freedesktop.DBus.Error.InvalidArgs", format!("Invalid argument {:?}", a)).into()
}
/// Create a MethodErr that there are not enough arguments given.
pub fn no_arg() -> MethodErr {
("org.freedesktop.DBus.Error.InvalidArgs", "Not enough arguments").into()
}
/// Create a MethodErr that the method failed in the way specified.
pub fn failed<T: fmt::Display>(a: &T) -> MethodErr {
("org.freedesktop.DBus.Error.Failed", a.to_string()).into()
}
/// Create a MethodErr that the Interface was unknown.
pub fn no_interface<T: fmt::Display>(a: &T) -> MethodErr {
("org.freedesktop.DBus.Error.UnknownInterface", format!("Unknown interface {}", a)).into()
}
/// Create a MethodErr that the Property was unknown.
pub fn no_property<T: fmt::Display>(a: &T) -> MethodErr {
("org.freedesktop.DBus.Error.UnknownProperty", format!("Unknown property {}", a)).into()
}
/// Create a MethodErr that the Property was read-only.
pub fn ro_property<T: fmt::Display>(a: &T) -> MethodErr {
("org.freedesktop.DBus.Error.PropertyReadOnly", format!("Property {} is read only", a)).into()
}
}
impl<T: Into<ErrorName<'static>>, M: Into<String>> From<(T, M)> for MethodErr {
fn from((t, m): (T, M)) -> MethodErr { MethodErr(t.into(), m.into()) }
}
/// Result containing the Messages returned from the Method, or a MethodErr.
pub type MethodResult = Result<Vec<Message>, MethodErr>;
/// A MethodType that wraps an Fn function
pub struct MethodFn<'a>(Box<Fn(&Message, &ObjectPath<MethodFn<'a>>, &Tree<MethodFn<'a>>) -> MethodResult + 'a>);
/// A MethodType that wraps an FnMut function. Calling this recursively will cause a refcell panic.
pub struct MethodFnMut<'a>(Box<RefCell<FnMut(&Message, &ObjectPath<MethodFnMut<'a>>, &Tree<MethodFnMut<'a>>) -> MethodResult + 'a>>);
/// A MethodType that wraps an Fn+Send+Sync function, so it can be called from several threads in parallel.
pub struct MethodSync(Box<Fn(&Message, &ObjectPath<MethodSync>, &Tree<MethodSync>) -> MethodResult + Send + Sync + 'static>);
impl<'a> fmt::Debug for MethodFn<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "<Fn>") }
}
impl<'a> fmt::Debug for MethodFnMut<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "<FnMut>") }
}
impl fmt::Debug for MethodSync {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "<Fn + Send + Sync>") }
}
/// A helper trait used internally to make the tree generic over MethodFn, MethodFnMut and MethodSync.
pub trait MethodType: Sized {
fn call_method(&self, m: &Message, o: &ObjectPath<Self>, i: &Tree<Self>) -> MethodResult;
fn box_method<H>(h: H) -> Self
where H: Fn(&Message, &ObjectPath<Self>, &Tree<Self>) -> MethodResult + Send + Sync + 'static;
}
impl<'a> MethodType for MethodFn<'a> {
fn call_method(&self, m: &Message, o: &ObjectPath<MethodFn<'a>>, i: &Tree<MethodFn<'a>>) -> MethodResult { self.0(m, o, i) }
fn box_method<H>(h: H) -> Self
where H: Fn(&Message, &ObjectPath<MethodFn<'a>>, &Tree<MethodFn<'a>>) -> MethodResult + Send + Sync + 'static {
MethodFn(Box::new(h))
}
}
impl MethodType for MethodSync {
fn call_method(&self, m: &Message, o: &ObjectPath<MethodSync>, i: &Tree<MethodSync>) -> MethodResult { self.0(m, o, i) }
fn box_method<H>(h: H) -> Self
where H: Fn(&Message, &ObjectPath<MethodSync>, &Tree<MethodSync>) -> MethodResult + Send + Sync + 'static {
MethodSync(Box::new(h))
}
}
impl<'a> MethodType for MethodFnMut<'a> {
fn call_method(&self, m: &Message, o: &ObjectPath<MethodFnMut<'a>>, i: &Tree<MethodFnMut<'a>>) -> MethodResult {
let mut z = self.0.borrow_mut();
(&mut *z)(m, o, i)
}
fn box_method<H>(h: H) -> Self
where H: Fn(&Message, &ObjectPath<MethodFnMut<'a>>, &Tree<MethodFnMut<'a>>) -> MethodResult + Send + Sync + 'static {
MethodFnMut(Box::new(RefCell::new(h)))
}
}
#[derive(Debug)]
/// A D-Bus Method.
pub struct Method<M> {
cb: M,
name: Arc<Member<'static>>,
i_args: Vec<Argument>,
o_args: Vec<Argument>,
anns: Annotations,
}
impl<M> Method<M> {
/// Builder method that adds an "in" Argument to this Method.
pub fn in_arg<A: Into<Argument>>(mut self, a: A) -> Self { self.i_args.push(a.into()); self }
/// Builder method that adds an "in" Argument to this Method.
pub fn inarg<A: arg::Arg, S: Into<String>>(mut self, s: S) -> Self { self.i_args.push((s.into(), A::signature()).into()); self }
/// Builder method that adds multiple "in" Arguments to this Method.
pub fn in_args<Z: Into<Argument>, A: IntoIterator<Item=Z>>(mut self, a: A) -> Self {
self.i_args.extend(a.into_iter().map(|b| b.into())); self
}
/// Builder method that adds an "out" Argument to this Method.
pub fn out_arg<A: Into<Argument>>(mut self, a: A) -> Self { self.o_args.push(a.into()); self }
/// Builder method that adds an "out" Argument to this Method.
pub fn outarg<A: arg::Arg, S: Into<String>>(mut self, s: S) -> Self { self.o_args.push((s.into(), A::signature()).into()); self }
/// Builder method that adds multiple "out" Arguments to this Method.
pub fn out_args<Z: Into<Argument>, A: IntoIterator<Item=Z>>(mut self, a: A) -> Self {
self.o_args.extend(a.into_iter().map(|b| b.into())); self
}
/// Add an annotation to the method.
pub fn annotate<N: Into<String>, V: Into<String>>(mut self, name: N, value: V) -> Self {
self.anns.insert(name, value); self
}
/// Add an annotation that this entity is deprecated.
pub fn deprecated(self) -> Self { self.annotate("org.freedesktop.DBus.Deprecated", "true") }
}
impl<M: MethodType> Method<M> {
/// Call the Method.
pub fn call(&self, m: &Message, o: &ObjectPath<M>, i: &Tree<M>) -> MethodResult { self.cb.call_method(m, o, i) }
fn new(n: Member<'static>, cb: M) -> Self { Method { name: Arc::new(n), i_args: vec!(),
o_args: vec!(), anns: Annotations::new(), cb: cb } }
}
#[derive(Debug)]
/// Represents a D-Bus interface.
pub struct Interface<M> {
name: Arc<IfaceName<'static>>,
methods: ArcMap<Member<'static>, Method<M>>,
signals: ArcMap<Member<'static>, Signal>,
properties: ArcMap<String, Property<M>>,
anns: Annotations,
}
impl<M> Interface<M> {
/// Adds a method to the interface.
pub fn add_m(mut self, m: Method<M>) -> Self { self.methods.insert(m.name.clone(), Arc::new(m)); self }
/// Adds a signal to the interface.
pub fn add_s(mut self, s: Signal) -> Self { self.signals.insert(s.name.clone(), Arc::new(s)); self }
/// Adds a signal to the interface. Lets you keep another clone of the signal
/// (which you can use to emit the signal, once it belongs to an object path).
///
/// Note: You are not allowed to add a signal to more than one interface.
pub fn add_s_arc(mut self, s: Arc<Signal>) -> Self { self.signals.insert(s.name.clone(), s); self }
/// Adds a signal to the interface. Returns a reference to the signal
/// (which you can use to emit the signal, once it belongs to an object path).
pub fn add_s_ref(&mut self, s: Signal) -> Arc<Signal> {
let s = Arc::new(s);
self.signals.insert(s.name.clone(), s.clone());
s
}
/// Adds a property to the interface.
pub fn add_p(mut self, p: Property<M>) -> Self { self.properties.insert(p.name.clone(), Arc::new(p)); self }
/// Adds a property to the interface. Lets you keep another clone of the property
/// (which you can use to get and set the current value of the property).
///
/// Note: You are not allowed to add a property to more than one interface. Later function calls might panic if you do so.
pub fn add_p_arc(mut self, p: Arc<Property<M>>) -> Self { self.properties.insert(p.name.clone(), p); self }
/// Adds a property to the interface. Returns a reference to the property
/// (which you can use to get and set the current value of the property).
pub fn add_p_ref(&mut self, p: Property<M>) -> Arc<Property<M>> {
let p = Arc::new(p);
self.properties.insert(p.name.clone(), p.clone());
p
}
/// Add an annotation to this Inteface.
pub fn annotate<N: Into<String>, V: Into<String>>(mut self, name: N, value: V) -> Self {
self.anns.insert(name, value); self
}
/// Add an annotation that this entity is deprecated.
pub fn deprecated(self) -> Self { self.annotate("org.freedesktop.DBus.Deprecated", "true") }
fn new(t: IfaceName<'static>) -> Interface<M> {
Interface { name: Arc::new(t), methods: BTreeMap::new(), signals: BTreeMap::new(),
properties: BTreeMap::new(), anns: Annotations::new()
}
}
}
#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug)]
/// Enumerates the different signaling behaviors a Property can have
/// to being changed.
pub enum EmitsChangedSignal {
/// The Property emits a signal that includes the new value.
True,
/// The Property emits a signal that does not include the new value.
Invalidates,
/// The Property cannot be changed.
Const,
/// The Property does not emit a signal when changed.
False,
}
#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug)]
/// The possible access characteristics a Property can have.
pub enum Access {
/// The Property can only be read (Get).
Read,
/// The Property can be read or written.
ReadWrite,
/// The Property can only be written (Set).
Write,
}
impl Access {
fn introspect(&self) -> &'static str {
match self {
&Access::Read => "read",
&Access::ReadWrite => "readwrite",
&Access::Write => "write",
}
}
}
#[derive(Debug)]
/// A D-Bus Property.
pub struct Property<M> {
name: Arc<String>,
value: Mutex<MessageItem>,
emits: EmitsChangedSignal,
rw: Access,
set_cb: Option<M>,
owner: Mutex<Option<(Arc<Path<'static>>, Arc<IfaceName<'static>>)>>,
anns: Annotations,
}
impl<M: MethodType> Property<M> {
/// Gets the value of the Property.
pub fn get_value(&self) -> MessageItem {
self.value.lock().unwrap().clone()
}
/// Gets the signal (if any) associated with the Property.
pub fn get_signal(&self) -> Option<Message> {
self.owner.lock().unwrap().as_ref().map(|&(ref p, ref i)| {
Message::signal(&p, &"org.freedesktop.DBus.Properties".into(), &"PropertiesChanged".into())
.append(String::from(&***i))
})
}
/// Returns error if "emits" is "Const", and the property is in a
/// tree. Returns messages to be sent over a connection, this
/// could be the PropertiesChanged signal.
pub fn set_value(&self, m: MessageItem) -> Result<Vec<Message>,()> {
let ss = match self.emits {
EmitsChangedSignal::False => None,
EmitsChangedSignal::Const => if self.get_signal().is_some() { return Err(()) } else { None },
EmitsChangedSignal::True => self.get_signal().map(|s|
s.append2(arg::Dict::new(vec!((&**self.name, arg::Variant(m.clone())))), arg::Array::<&str, _>::new(vec!()))
),
EmitsChangedSignal::Invalidates => self.get_signal().map(|s| {
s.append2(arg::Dict::<&str, arg::Variant<MessageItem>, _>::new(vec!()), arg::Array::new(vec!(&**self.name)))
}),
};
*self.value.lock().unwrap() = m;
Ok(ss.map(|s| vec!(s)).unwrap_or(vec!()))
}
/// Builder method that allows setting the Property's signal
/// behavior when changed.
pub fn emits_changed(mut self, e: EmitsChangedSignal) -> Self {
self.emits = e;
assert!(self.rw == Access::Read || self.emits != EmitsChangedSignal::Const);
self
}
/// Builder method that allows setting the Property as readable,
/// writable, or both.
pub fn access(mut self, e: Access) -> Self {
self.rw = e;
assert!(self.rw == Access::Read || self.emits != EmitsChangedSignal::Const);
self
}
/// Helper method to check accessibility before getting a value.
pub fn remote_get(&self, _: &Message) -> Result<MessageItem, MethodErr> {
// TODO: We should be able to call a user-defined callback here instead...
if self.rw == Access::Write { return Err(MethodErr::failed(&format!("Property {} is write only", &self.name))) }
Ok(self.get_value())
}
/// Helper method to verify and extract a MessageItem from a Set message
pub fn verify_remote_set(&self, m: &Message) -> Result<MessageItem, MethodErr> {
let items = m.get_items();
let s: &MessageItem = try!(items.get(2).ok_or_else(|| MethodErr::no_arg())
.and_then(|i| i.inner().map_err(|_| MethodErr::invalid_arg(&i))));
if self.rw == Access::Read { Err(MethodErr::ro_property(&self.name)) }
else if s.type_sig() != self.value.lock().unwrap().type_sig() {
Err(MethodErr::failed(&format!("Property {} cannot change type to {}", &self.name, s.type_sig())))
}
else { Ok(s.clone()) }
}
fn remote_set(&self, m: &Message, o: &ObjectPath<M>, t: &Tree<M>) -> Result<Vec<Message>, MethodErr> {
if let Some(ref cb) = self.set_cb {
cb.call_method(m, o, t)
}
else {
let s = try!(self.verify_remote_set(m));
self.set_value(s).map_err(|_| MethodErr::ro_property(&self.name))
}
}
/// Add an annotation to this Property.
pub fn annotate<N: Into<String>, V: Into<String>>(mut self, name: N, value: V) -> Self {
self.anns.insert(name, value); self
}
/// Add an annotation that this entity is deprecated.
pub fn deprecated(self) -> Self { self.annotate("org.freedesktop.DBus.Deprecated", "true") }
fn new(s: String, i: MessageItem) -> Property<M> {
Property { name: Arc::new(s), emits: EmitsChangedSignal::True, rw: Access::Read,
value: Mutex::new(i), owner: Mutex::new(None), anns: Annotations::new(), set_cb: None }
}
}
impl Property<MethodSync> {
/// Sets a callback to be called when a "Set" call is coming in from the remote side.
/// Might change to something more ergonomic.
/// For multi-thread use.
pub fn on_set<H>(mut self, m: H) -> Self
where H: Fn(&Message, &ObjectPath<MethodSync>, &Tree<MethodSync>) -> MethodResult + Send + Sync + 'static {
self.set_cb = Some(MethodSync::box_method(m));
self
}
}
impl<'a> Property<MethodFn<'a>> {
/// Sets a callback to be called when a "Set" call is coming in from the remote side.
/// Might change to something more ergonomic.
/// For single-thread use.
pub fn on_set<H: 'a>(mut self, m: H) -> Self
where H: Fn(&Message, &ObjectPath<MethodFn<'a>>, &Tree<MethodFn<'a>>) -> MethodResult {
self.set_cb = Some(MethodFn(Box::new(m)));
self
}
}
impl<'a> Property<MethodFnMut<'a>> {
/// Sets a callback to be called when a "Set" call is coming in from the remote side.
/// Might change to something more ergonomic.
/// For single-thread use.
pub fn on_set<H: 'a>(mut self, m: H) -> Self
where H: FnMut(&Message, &ObjectPath<MethodFnMut<'a>>, &Tree<MethodFnMut<'a>>) -> MethodResult {
self.set_cb = Some(MethodFnMut(Box::new(RefCell::new(m))));
self
}
}
#[derive(Debug)]
/// A D-Bus Signal.
pub struct Signal {
name: Arc<Member<'static>>,
arguments: Vec<Argument>,
owner: Mutex<Option<(Arc<Path<'static>>, Arc<IfaceName<'static>>)>>,
anns: Annotations,
}
impl Signal {
/// Returns a message which emits the signal when sent.
/// Panics if the signal is not inserted in an object path.
pub fn emit(&self, items: &[MessageItem]) -> Message {
let mut m = {
let lock = self.owner.lock().unwrap();
let &(ref p, ref i) = lock.as_ref().unwrap();
Message::signal(p, i, &self.name)
};
m.append_items(items);
m
}
/// Returns a message which emits the signal when sent.
/// Panics if the signal is not inserted in an object path.
///
/// Same as "emit" but does not take a "MessageItem" argument.
pub fn msg(&self) -> Message { self.emit(&[]) }
/// Builder method that adds an Argument to the Signal.
pub fn arg<A: Into<Argument>>(mut self, a: A) -> Self { self.arguments.push(a.into()); self }
/// Builder method that adds an Argument to the Signal.
pub fn sarg<A: arg::Arg, S: Into<String>>(mut self, s: S) -> Self { self.arguments.push((s.into(), A::signature()).into()); self }
/// Builder method that adds multiple "rguments to the Signel.
pub fn args<Z: Into<Argument>, A: IntoIterator<Item=Z>>(mut self, a: A) -> Self {
self.arguments.extend(a.into_iter().map(|b| b.into())); self
}
/// Add an annotation to this Signal.
pub fn annotate<N: Into<String>, V: Into<String>>(mut self, name: N, value: V) -> Self {
self.anns.insert(name, value); self
}
/// Add an annotation that this entity is deprecated.
pub fn deprecated(self) -> Self { self.annotate("org.freedesktop.DBus.Deprecated", "true") }
}
fn introspect_map<T, I: fmt::Display, C: Fn(&T) -> (String, String)>
(h: &ArcMap<I, T>, name: &str, indent: &str, func: C) -> String {
h.iter().fold("".into(), |a, (k, v)| {
let (params, contents) = func(v);
format!("{}{}<{} name=\"{}\"{}{}>\n",
a, indent, name, &**k, params, if contents.len() > 0 {
format!(">\n{}{}</{}", contents, indent, name)
}
else { format!("/") }
)
})
}
#[derive(Debug)]
/// A D-Bus Object Path.
pub struct ObjectPath<M> {
name: Arc<Path<'static>>,
ifaces: ArcMap<IfaceName<'static>, Interface<M>>,
}
impl<M: MethodType> ObjectPath<M> {
fn new(p: Path<'static>) -> ObjectPath<M> {
ObjectPath { name: Arc::new(p), ifaces: BTreeMap::new() }
}
fn get_iface<'a>(&'a self, i: Option<&'a CStr>) -> Result<&Arc<Interface<M>>, MethodErr> {
let iface_name = try!(i.ok_or_else(|| MethodErr::invalid_arg(&0)));
let j = try!(IfaceName::from_slice(iface_name.to_bytes_with_nul()).map_err(|e| MethodErr::invalid_arg(&e)));
self.ifaces.get(&j).ok_or_else(|| MethodErr::no_interface(&j))
}
fn prop_set(&self, m: &Message, o: &ObjectPath<M>, t: &Tree<M>) -> MethodResult {
let (iname, p) = m.get2();
let iface = try!(self.get_iface(iname));
let prop_name: &str = try!(p.ok_or_else(|| MethodErr::invalid_arg(&1)));
let prop: &Property<M> = try!(iface.properties.get(&String::from(prop_name))
.ok_or_else(|| MethodErr::no_property(&prop_name)));
let mut r = try!(prop.remote_set(m, o, t));
r.push(m.method_return());
Ok(r)
}
fn prop_get(&self, m: &Message) -> MethodResult {
let (iname, p) = m.get2();
let iface = try!(self.get_iface(iname));
let prop_name: &str = try!(p.ok_or_else(|| MethodErr::invalid_arg(&1)));
let prop: &Property<M> = try!(iface.properties.get(&String::from(prop_name))
.ok_or_else(|| MethodErr::no_property(&prop_name)));
let r = try!(prop.remote_get(m));
Ok(vec!(m.method_return().append1(arg::Variant(r))))
}
fn prop_get_all(&self, m: &Message) -> MethodResult {
let iface = try!(self.get_iface(m.get1()));
let mut q = vec!();
for v in iface.properties.values() {
q.push((&**v.name, arg::Variant(try!(v.remote_get(m)))));
}
Ok(vec!(m.method_return().append1(arg::Dict::new(q))))
}
fn add_property_handler(&mut self) {
let ifname = IfaceName::from("org.freedesktop.DBus.Properties");
if self.ifaces.contains_key(&ifname) { return };
let f: Factory<M> = Factory(PhantomData);
let i = Interface::<M>::new(ifname)
.add_m(f.method_sync("Get", |m,o,_| o.prop_get(m) )
.inarg::<&str,_>("interface_name")
.inarg::<&str,_>("property_name")
.outarg::<arg::Variant<()>,_>("value"))
.add_m(f.method_sync("GetAll", |m,o,_| o.prop_get_all(m))
.inarg::<&str,_>("interface_name")
.outarg::<arg::Dict<&str, arg::Variant<()>, ()>,_>("props"))
.add_m(f.method_sync("Set", |m,o,t| o.prop_set(m, o, t))
.inarg::<&str,_>("interface_name")
.inarg::<&str,_>("property_name")
.inarg::<arg::Variant<()>,_>("value"));
self.ifaces.insert(i.name.clone(), Arc::new(i));
}
/// Add an Interface to this Object Path.
pub fn add(mut self, p: Interface<M>) -> Self {
use std::mem;
for s in p.signals.values() {
let n = Some((self.name.clone(), p.name.clone()));
let o = mem::replace(&mut *s.owner.lock().unwrap(), n);
assert!(o.is_none(), "Signal {} already added to object path", s.name);
};
for s in p.properties.values() {
let n = Some((self.name.clone(), p.name.clone()));
let o = mem::replace(&mut *s.owner.lock().unwrap(), n);
assert!(o.is_none(), "Property {} already added to object path", s.name);
};
if !p.properties.is_empty() { self.add_property_handler(); }
self.ifaces.insert(p.name.clone(), Arc::new(p));
self
}
/// Adds introspection support for this object path.
pub fn introspectable(self) -> Self {
let ifname: IfaceName = "org.freedesktop.DBus.Introspectable".into();
if self.ifaces.contains_key(&ifname) { return self };
let f: Factory<M> = Factory(PhantomData);
self.add(Interface::<M>::new(ifname)
.add_m(f.method_sync("Introspect",
|m,o,t| Ok(vec!(m.method_return().append(o.introspect(t)))))
.out_arg(("xml_data", "s"))))
}
fn handle(&self, m: &Message, t: &Tree<M>) -> MethodResult {
let i = try!(m.interface().and_then(|i| self.ifaces.get(&i)).ok_or(
("org.freedesktop.DBus.Error.UnknownInterface", "Unknown interface")));
let me = try!(m.member().and_then(|me| i.methods.get(&me)).ok_or(
("org.freedesktop.DBus.Error.UnknownMethod", "Unknown method")));
me.call(m, &self, t)
}
fn introspect(&self, tree: &Tree<M>) -> String {
let ifacestr = introspect_map(&self.ifaces, "interface", " ", |iv|
(format!(""), format!("{}{}{}{}",
introspect_map(&iv.methods, "method", " ", |m| (format!(""), format!("{}{}{}",
Argument::introspect_all(&m.i_args, " ", " direction=\"in\""),
Argument::introspect_all(&m.o_args, " ", " direction=\"out\""),
m.anns.introspect(" ")
))),
introspect_map(&iv.properties, "property", " ", |p| (
format!(" type=\"{}\" access=\"{}\"", p.get_value().type_sig(), p.rw.introspect()),
p.anns.introspect(" ")
)),
introspect_map(&iv.signals, "signal", " ", |s| (format!(""), format!("{}{}",
Argument::introspect_all(&s.arguments, " ", ""),
s.anns.introspect(" ")
))),
iv.anns.introspect(" ")
))
);
let olen = self.name.len()+1;
let childstr = tree.children(&self, true).iter().fold("".to_string(), |na, n|
format!("{} <node name=\"{}\"/>\n", na, &n.name[olen..])
);
let nodestr = format!(r##"<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node name="{}">
{}{}</node>"##, self.name, ifacestr, childstr);
nodestr
}
fn get_managed_objects(&self, t: &Tree<M>) -> MessageItem {
let mut paths = t.children(&self, false);
paths.push(&self);
MessageItem::Array(
paths.iter().map(|p| ((&*p.name).clone().into(), MessageItem::Array(
p.ifaces.values().map(|i| ((&**i.name).into(), MessageItem::Array(
i.properties.values().map(|pp| ((&**pp.name).into(), Box::new(pp.get_value()
).into()).into()).collect(), "{sv}".into()
)).into()).collect(), "{sa{sv}}".into()
)).into()).collect(), "{oa{sa{sv}}}".into()
)
}
/// Adds ObjectManager support for this object path.
///
/// It is not possible to add/remove interfaces while the object path belongs to a tree,
/// hence no InterfacesAdded / InterfacesRemoved signals are sent.
pub fn object_manager(self) -> Self {
let ifname: IfaceName = "org.freedesktop.DBus.ObjectManager".into();
if self.ifaces.contains_key(&ifname) { return self };
let f: Factory<M> = Factory(PhantomData);
self.add(Interface::<M>::new(ifname)
.add_m(f.method_sync("GetManagedObjects",
|m,o,t| Ok(vec!(m.method_return().append(o.get_managed_objects(t)))))
.out_arg("a{oa{sa{sv}}}")))
}
}
/// An iterator adapter that handles incoming method calls.
///
/// Method calls that match an object path in the tree are handled and consumed by this
/// iterator. Other messages are passed through.
pub struct TreeServer<'a, I, M: 'a> {
iter: I,
conn: &'a Connection,
tree: &'a Tree<M>,
}
impl<'a, I: Iterator<Item=ConnectionItem>, M: 'a + MethodType> Iterator for TreeServer<'a, I, M> {
type Item = ConnectionItem;
fn next(&mut self) -> Option<ConnectionItem> {
loop {
let n = self.iter.next();
if let &Some(ConnectionItem::MethodCall(ref msg)) = &n {
if let Some(v) = self.tree.handle(&msg) {
// Probably the wisest is to ignore any send errors here -
// maybe the remote has disconnected during our processing.
for m in v { let _ = self.conn.send(m); };
continue;
}
}
return n;
}
}
}
/// A collection of object paths.
#[derive(Debug)]
pub struct Tree<M> {
paths: ArcMap<Path<'static>, ObjectPath<M>>
}
impl<M: MethodType> Tree<M> {
fn children(&self, o: &ObjectPath<M>, direct_only: bool) -> Vec<&ObjectPath<M>> {
let parent: &str = &o.name;
let plen = parent.len()+1;
self.paths.values().filter_map(|v| {
let k: &str = &v.name;
if !k.starts_with(parent) || k.len() <= plen || &k[plen-1..plen] != "/" {None} else {
let child = &k[plen..];
if direct_only && child.contains("/") {None} else {Some(&**v)}
}
}).collect()
}
/// Add an Object Path to this Tree.
///
/// Note: This does not unregister a path with the connection, so if the tree is currently registered,
/// you might want to call Connection::register_object_path to add the path manually.
pub fn add(mut self, p: ObjectPath<M>) -> Self {
self.paths.insert(p.name.clone(), Arc::new(p));
self
}
/// Adds an ObjectPath to this Tree. Returns a reference to the ObjectPath.
/// The note for add() also applies here.
pub fn add_o_ref(&mut self, p: ObjectPath<M>) -> Arc<ObjectPath<M>> {
let name = p.name.clone();
let o = Arc::new(p);
self.paths.insert(name, o.clone());
o
}
/// Remove a object path from the Tree. Returns the object path removed, or None if not found.
///
/// Note: This does not unregister a path with the connection, so if the tree is currently registered,
/// you might want to call Connection::unregister_object_path to remove the path manually.
pub fn remove(&mut self, p: &Path<'static>) -> Option<Arc<ObjectPath<M>>> {
// There is no real reason p needs to have a static lifetime; but
// the borrow checker doesn't agree. :-(
self.paths.remove(p)
}
/// Registers or unregisters all object paths in the tree.
pub fn set_registered(&self, c: &Connection, b: bool) -> Result<(), Error> {
let mut regd_paths = Vec::new();
for p in self.paths.keys() {
if b {
match c.register_object_path(p) {
Ok(()) => regd_paths.push(p.clone()),
Err(e) => {
while let Some(rp) = regd_paths.pop() {
c.unregister_object_path(&rp);
}
return Err(e)
}
}
} else {
c.unregister_object_path(p);
}
}
Ok(())
}
/// Handles a message. Will return None in case the object path was not
/// found, or otherwise a list of messages to be sent back.
pub fn handle(&self, m: &Message) -> Option<Vec<Message>> {
if m.msg_type() != MessageType::MethodCall { None }
else { m.path().and_then(|p| self.paths.get(&p).map(|s| s.handle(m, &self)
.unwrap_or_else(|e| vec!(m.error(&e.0, &CString::new(e.1).unwrap()))))) }
}
/// This method takes an `ConnectionItem` iterator (you get it from `Connection::iter()`)
/// and handles all matching items. Non-matching items (e g signals) are passed through.
pub fn run<'a, I: Iterator<Item=ConnectionItem>>(&'a self, c: &'a Connection, i: I) -> TreeServer<'a, I, M> {
TreeServer { iter: i, tree: &self, conn: c }
}
}
/// The factory is used to create object paths, interfaces, methods etc.
///
/// There are three factories:
///
/// **Fn** - all methods are `Fn()`.
///
/// **FnMut** - all methods are `FnMut()`. This means they can mutate their environment,
/// which has the side effect that if you call it recursively, it will RefCell panic.
///
/// **Sync** - all methods are `Fn() + Send + Sync + 'static`. This means that the methods
/// can be called from different threads in parallel.
#[derive(Debug, Copy, Clone)]
pub struct Factory<M>(PhantomData<M>);
impl<'a> Factory<MethodFn<'a>> {
/// Creates a new factory for single-thread use.
pub fn new_fn() -> Self { Factory(PhantomData) }
/// Creates a new method for single-thread use.
pub fn method<'b, H: 'b, T>(&self, t: T, handler: H) -> Method<MethodFn<'b>>
where H: Fn(&Message, &ObjectPath<MethodFn<'b>>, &Tree<MethodFn<'b>>) -> MethodResult, T: Into<Member<'static>> {
Method::new(t.into(), MethodFn(Box::new(handler)))
}
/// Creates a new property for single-thread use.
pub fn property<'b, T: Into<String>, I: Into<MessageItem>>(&self, t: T, i: I) -> Property<MethodFn<'b>> {
Property::new(t.into(), i.into())
}
/// Creates a new interface for single-thread use.
pub fn interface<'b, T: Into<IfaceName<'static>>>(&self, t: T) -> Interface<MethodFn<'b>> { Interface::new(t.into()) }
/// Creates a new tree for single-thread use.
pub fn tree<'b>(&self) -> Tree<MethodFn<'b>> { Tree { paths: BTreeMap::new() }}
/// Creates a new object path for single-thread use.
pub fn object_path<'b, T: Into<Path<'static>>>(&self, t: T) -> ObjectPath<MethodFn<'b>> { ObjectPath::new(t.into()) }
}
impl<'a> Factory<MethodFnMut<'a>> {
/// Creates a new factory for single-thread + mutable fns use.
pub fn new_fnmut() -> Self { Factory(PhantomData) }
/// Creates a new method for single-thread use.
/// This method can mutate its environment, so it will panic in case
/// it is called recursively.
pub fn method<'b, H: 'b, T>(&self, t: T, handler: H) -> Method<MethodFnMut<'b>>
where H: FnMut(&Message, &ObjectPath<MethodFnMut<'b>>, &Tree<MethodFnMut<'b>>) -> MethodResult, T: Into<Member<'static>> {
Method::new(t.into(), MethodFnMut(Box::new(RefCell::new(handler))))
}
/// Creates a new mutable property for single-thread use.
pub fn property<'b, T: Into<String>, I: Into<MessageItem>>(&self, t: T, i: I) -> Property<MethodFnMut<'b>> {
Property::new(t.into(), i.into())
}
/// Creates a new mutable interface for single-thread use.
pub fn interface<'b, T: Into<IfaceName<'static>>>(&self, t: T) -> Interface<MethodFnMut<'b>> { Interface::new(t.into()) }
/// Creates a new mutable tree for single-thread use.
pub fn tree<'b>(&self) -> Tree<MethodFnMut<'b>> { Tree { paths: BTreeMap::new() }}
/// Creates a new mutable object path for single-thread use.
pub fn object_path<'b, T: Into<Path<'static>>>(&self, t: T) -> ObjectPath<MethodFnMut<'b>> { ObjectPath::new(t.into()) }
}
impl Factory<MethodSync> {
/// Creates a new factory for multi-thread use.
/// Trees created will be able to Send and Sync, i e,
/// it can handle several messages in parallel.
pub fn new_sync() -> Self { Factory(PhantomData) }
/// Creates a new method for multi-thread use.
/// This puts bounds on the callback to enable it to be called from several threads
/// in parallel.
pub fn method<H, T>(&self, t: T, handler: H) -> Method<MethodSync>
where H: Fn(&Message, &ObjectPath<MethodSync>, &Tree<MethodSync>) -> MethodResult + Send + Sync + 'static, T: Into<Member<'static>> {
Method::new(t.into(), MethodSync(Box::new(handler)))
}
/// Creates a new property for multi-threaded use.
pub fn property<T: Into<String>, I: Into<MessageItem>>(&self, t: T, i: I) -> Property<MethodSync> {
Property::new(t.into(), i.into())
}
/// Creates a new interface for multi-threaded use.
pub fn interface<T: Into<IfaceName<'static>>>(&self, t: T) -> Interface<MethodSync> { Interface::new(t.into()) }
/// Creates a new tree for multi-threaded use.
pub fn tree(&self) -> Tree<MethodSync> { Tree { paths: BTreeMap::new() }}
/// Creates a new object path for multi-threaded use.
pub fn object_path<T: Into<Path<'static>>>(&self, t: T) -> ObjectPath<MethodSync> { ObjectPath::new(t.into()) }
}
impl<M> Factory<M> {
/// Create a Signal.
pub fn signal<T: Into<Member<'static>>>(&self, t: T) -> Signal {
Signal { name: Arc::new(t.into()), arguments: vec!(), owner: Mutex::new(None), anns: Annotations::new() }
}
}
impl<M: MethodType> Factory<M> {
/// Creates a new method with bounds enough to be used in all trees.
pub fn method_sync<H, T>(&self, t: T, handler: H) -> Method<M>
where H: Fn(&Message, &ObjectPath<M>, &Tree<M>) -> MethodResult + Send + Sync + 'static, T: Into<Member<'static>> {
Method::new(t.into(), M::box_method(handler))
}
}
#[test]
fn factory_test() {
let f = Factory::new_fn();
f.interface("com.example.hello").deprecated();
let b = 5i32;
f.method("GetSomething", |m,_,_| Ok(vec!({ let mut z = m.method_return(); z.append_items(&[b.into()]); z})));
let t = f.tree().add(f.object_path("/funghi").add(f.interface("a.b.c").deprecated()));
let t = t.add(f.object_path("/ab")).add(f.object_path("/a")).add(f.object_path("/a/b/c")).add(f.object_path("/a/b"));
assert_eq!(t.children(t.paths.get(&Path::from("/a")).unwrap(), true).len(), 1);
}
#[test]
fn test_sync_prop() {
let f = Factory::new_sync();
let mut i = f.interface("com.example.echo");
let p = i.add_p_ref(f.property("EchoCount", 7i32));
let tree1 = Arc::new(f.tree().add(f.object_path("/echo").introspectable().add(i)));
let tree2 = tree1.clone();
println!("{:#?}", tree2);
::std::thread::spawn(move || {
let r = p.set_value(9i32.into()).unwrap();
let signal = r.get(0).unwrap();
assert_eq!(signal.msg_type(), MessageType::Signal);
let mut msg = Message::new_method_call("com.example.echoserver", "/echo", "com.example", "dummy").unwrap();
super::message::message_set_serial(&mut msg, 3);
tree2.handle(&msg);
});
let mut msg = Message::new_method_call("com.example.echoserver", "/echo", "org.freedesktop.DBus.Properties", "Get").unwrap()
.append("com.example.echo").append("EchoCount");
super::message::message_set_serial(&mut msg, 4);
let r = tree1.handle(&msg).unwrap();
let r1 = r.get(0).unwrap();
println!("{:?}", r1.get_items());
let vv: super::arg::Variant<i32> = r1.get1().unwrap();
assert!(vv.0 == 7 || vv.0 == 9);
}
/* This test case no longer works, for unknown reason, see
#[test]
fn prop_lifetime_simple() {
let count;
let f = Factory::new_fnmut();
count = Arc::new(f.property("changes", 0i32));
let mut i = f.interface("com.example.dbus.rs").add_p_arc(count.clone());
let _setme = i.add_p_ref(f.property("setme", 0u8).access(Access::ReadWrite).on_set(|_,_,_| {
let v: i32 = count.get_value().inner().unwrap();
count.set_value((v + 1).into()).unwrap();
Ok(vec!())
}));
}
*/
#[test]
fn prop_server() {
let setme: Arc<RefCell<Option<Arc<Property<_>>>>>; // Yikes!
setme = Arc::new(RefCell::new(None));
let f = Factory::new_fnmut();
let mut i = f.interface("com.example.dbus.rs");
let count = i.add_p_ref(f.property("changes", 0i32));
let count2 = count.clone();
let setme2 = setme.clone();
let setme3 = Arc::new(f.property("setme", 0u8).access(Access::ReadWrite).on_set(move |m,_,_| {
let ss2 = setme2.borrow();
let ss = ss2.as_ref().unwrap();
let s = try!(ss.verify_remote_set(m));
let r = try!(ss.set_value(s).map_err(|_| MethodErr::ro_property(&ss.name)));
let v: i32 = count2.get_value().inner().unwrap();
count2.set_value((v + 1).into()).unwrap();
Ok(r)
}));
*setme.borrow_mut() = Some(setme3.clone());
let i = i.add_p_arc(setme3);
let tree = f.tree().add(f.object_path("/example").add(i));
let mut msg = Message::new_method_call("com.example.dbus.rs", "/example", "org.freedesktop.DBus.Properties", "Get").unwrap()
.append("com.example.dbus.rs").append("changes");
super::message::message_set_serial(&mut msg, 10);
let r = tree.handle(&msg).unwrap();
let r1 = r.get(0).unwrap();
let ii = r1.get_items();
let vv: &MessageItem = ii.get(0).unwrap().inner().unwrap();
let v: i32 = vv.inner().unwrap();
assert_eq!(v, 0);
// Read-only
let mut msg = Message::new_method_call("com.example.dbus.rs", "/example", "org.freedesktop.DBus.Properties", "Set").unwrap()
.append("com.example.dbus.rs").append("changes").append(5i32);
super::message::message_set_serial(&mut msg, 20);
let mut r = tree.handle(&msg).unwrap();
assert!(r.get_mut(0).unwrap().as_result().is_err());
// Wrong type
let mut msg = Message::new_method_call("com.example.dbus.rs", "/example", "org.freedesktop.DBus.Properties", "Set").unwrap()
.append("com.example.dbus.rs").append("setme").append(8i32);
super::message::message_set_serial(&mut msg, 30);
let mut r = tree.handle(&msg).unwrap();
assert!(r.get_mut(0).unwrap().as_result().is_err());
// Correct!
let mut msg = Message::new_method_call("com.example.dbus.rs", "/example", "org.freedesktop.DBus.Properties", "Set").unwrap()
.append("com.example.dbus.rs").append("setme").append(Box::new(9u8.into()));
super::message::message_set_serial(&mut msg, 30);
let mut r = tree.handle(&msg).unwrap();
println!("{:?}", r[0].as_result());
let c: i32 = count.get_value().inner().unwrap();
assert_eq!(c, 1);
}
#[test]
fn test_introspection() {
let f = Factory::new_sync();
let t = f.object_path("/echo").introspectable()
.add(f.interface("com.example.echo")
.add_m(f.method("Echo", |_,_,_| unimplemented!()).in_arg(("request", "s")).out_arg(("reply", "s")))
.add_p(f.property("EchoCount", 7i32))
.add_s(f.signal("Echoed").arg(("data", "s")).deprecated())
);
let actual_result = t.introspect(&f.tree().add(f.object_path("/echo/subpath")));
println!("\n=== Introspection XML start ===\n{}\n=== Introspection XML end ===", actual_result);
let expected_result = r##"<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node name="/echo">
<interface name="com.example.echo">
<method name="Echo">
<arg name="request" type="s" direction="in"/>
<arg name="reply" type="s" direction="out"/>
</method>
<property name="EchoCount" type="i" access="read"/>
<signal name="Echoed">
<arg name="data" type="s"/>
<annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
</signal>
</interface>
<interface name="org.freedesktop.DBus.Introspectable">
<method name="Introspect">
<arg name="xml_data" type="s" direction="out"/>
</method>
</interface>
<interface name="org.freedesktop.DBus.Properties">
<method name="Get">
<arg name="interface_name" type="s" direction="in"/>
<arg name="property_name" type="s" direction="in"/>
<arg name="value" type="v" direction="out"/>
</method>
<method name="GetAll">
<arg name="interface_name" type="s" direction="in"/>
<arg name="props" type="a{sv}" direction="out"/>
</method>
<method name="Set">
<arg name="interface_name" type="s" direction="in"/>
<arg name="property_name" type="s" direction="in"/>
<arg name="value" type="v" direction="in"/>
</method>
</interface>
<node name="subpath"/>
</node>"##;
assert_eq!(expected_result, actual_result);
}