dbus 0.1.5

data/ext/ruby-dbus-pending-call.c

@@ -0,0 +1,98 @@
+/*--------------------------------------------------
+ * D-BUS bindings for Ruby
+ * (C) Copyright 2004 Leon Breedt
+ * (C) Copyright 2004 Provenco Group Ltd
+ *
+ * Licensed under the same terms as the D-BUS library
+ *--------------------------------------------------*/
+
+#include "ruby-dbus.h"
+
+VALUE cDBusPendingCall;
+
+RDBUS_GENERATE_NEW(cDBusPendingCall, DBusPendingCall *, dbus_pending_call_unref)
+RDBUS_GENERATE_GET(DBusPendingCall)
+
+/*
+ *  call-seq:
+ *      cancel => nil
+ *
+ *  Cancels the pending call, any reply or error received will be
+ *  ignored.
+ */
+static VALUE
+cDBusPendingCall_cancel(VALUE self)
+{
+  dbus_pending_call_cancel(CALL_GET(self));
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      get_completed => true|false
+ *
+ *  Returns +true+ if the pending call has received a reply.
+ */
+static VALUE
+cDBusPendingCall_get_completed(VALUE self)
+{
+  if (dbus_pending_call_get_completed(CALL_GET(self)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      get_reply => message
+ *
+ *  Returns the reply DBusMessage, or +nil+ if no reply
+ *  has been received yet.
+ */
+static VALUE
+cDBusPendingCall_get_reply(VALUE self)
+{
+  DBusMessage *msg = NULL;
+
+  msg = dbus_pending_call_get_reply(CALL_GET(self));
+  if (msg != NULL)
+    return RDBUS_NEW(cDBusMessage, msg);
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      block => nil
+ *
+ *  Blocks until the pending call is completed and a reply is
+ *  available.
+ *
+ *  The blocking behaviour is the same as that for
+ *  DBusConnection#send_with_reply_and_block.
+ */
+static VALUE
+cDBusPendingCall_block(VALUE self)
+{
+  dbus_pending_call_block(CALL_GET(self));
+  return Qnil;
+}
+
+/*
+ *  Document-class: DBus::Binding::DBusPendingCall
+ *
+ *  A DBusPendingCall is used to retrieve asynchronous replies to
+ *  method call messages.
+ *
+ *  See DBusConnection#send_with_reply.
+ */
+void
+Init_dbus_pending_call()
+{
+  cDBusPendingCall = rb_define_class_under(mDBusBinding, "DBusPendingCall", rb_cObject);
+
+  rb_define_singleton_method(cDBusPendingCall, "new", rdbus_private_method, 0);
+
+  rb_define_method(cDBusPendingCall, "cancel", cDBusPendingCall_cancel, 0);
+  rb_define_method(cDBusPendingCall, "get_completed", cDBusPendingCall_get_completed, 0);
+  rb_define_method(cDBusPendingCall, "get_reply", cDBusPendingCall_get_reply, 0);
+  rb_define_method(cDBusPendingCall, "block", cDBusPendingCall_block, 0);
+}

data/ext/ruby-dbus-server.c

@@ -0,0 +1,126 @@
+/*--------------------------------------------------
+ * D-BUS bindings for Ruby
+ * (C) Copyright 2004 Leon Breedt
+ * (C) Copyright 2004 Provenco Group Ltd
+ *
+ * Licensed under the same terms as the D-BUS library
+ *--------------------------------------------------*/
+
+#include "ruby-dbus.h"
+
+static void _server_free(DBusServer *server);
+
+VALUE cDBusServer;
+
+RDBUS_GENERATE_NEW(cDBusServer, DBusServer *, _server_free)
+RDBUS_GENERATE_GET(DBusServer)
+
+static void
+_server_free(DBusServer *server)
+{
+  dbus_server_disconnect(server);
+  dbus_server_unref(server);
+}
+
+/*
+ *  call-seq:
+ *      listen(address) => server
+ *
+ *  Creates a new server instance listening for connections on the given
+ *  address.
+ *
+ *  See DBusConnection#new for details on the format of the address.
+ */
+static VALUE
+cDBusServer_listen(VALUE klass, VALUE address)
+{
+  DBusServer *server = NULL;
+
+  RDBUS_TRY(server = dbus_server_listen(StringValuePtr(address), &error));
+  RDBUS_RAISE_IF(server == NULL, "failed to create DBusServer");
+  return RDBUS_NEW(cDBusServer, server);
+}
+
+/*
+ *  call-seq:
+ *      disconnect => nil
+ *
+ *  Releases the server's address and stops listening for new clients.
+ */
+static VALUE
+cDBusServer_disconnect(VALUE self)
+{
+  dbus_server_disconnect(SERVER_GET(self));
+  return Qnil;
+}
+
+/*
+ *  call-seq:
+ *      get_is_connected => true|false
+ *
+ *  Returns +true+ if the server is still listening for new clients.
+ */
+static VALUE
+cDBusServer_get_is_connected(VALUE self)
+{
+  if (dbus_server_get_is_connected(SERVER_GET(self)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *      get_address => address
+ *
+ *  Returns the address the server is listening on.
+ */
+static VALUE
+cDBusServer_get_address(VALUE self)
+{
+  char *address = NULL;
+  VALUE address_r;
+
+  address = dbus_server_get_address(SERVER_GET(self));
+  if (address == NULL)
+    return Qnil;
+  address_r = rb_str_new2(address);
+  dbus_free(address);
+  return address_r;
+}
+
+/*
+ *  call-seq:
+ *      setup_with_g_main => nil
+ *
+ *  Sets up the dispatching of the server to integrate with the GLIB main
+ *  loop.
+ */
+static VALUE
+cDBusServer_setup_with_g_main(VALUE self)
+{
+  dbus_server_setup_with_g_main(SERVER_GET(self), NULL);
+  return Qnil;
+}
+
+/*
+ *  Document-class: DBus::Binding::DBusServer
+ *
+ *  A DBusServer listens for and handles connections from clients.
+ *
+ *  This class isn't particularly useful right now, as it does not provide new
+ *  connection, watch, and timeout callback functionality yet.
+ */
+void
+Init_dbus_server()
+{
+  cDBusServer = rb_define_class_under(mDBusBinding, "DBusServer", rb_cObject);
+
+  rb_define_singleton_method(cDBusServer, "new", cDBusServer_listen, 1);
+  rb_define_singleton_method(cDBusServer, "listen", cDBusServer_listen, 1);
+
+  rb_define_method(cDBusServer, "disconnect", cDBusServer_disconnect, 0);
+  rb_define_method(cDBusServer, "get_is_connected", cDBusServer_get_is_connected, 0);
+  rb_define_method(cDBusServer, "get_address", cDBusServer_get_address, 0);
+  
+  rb_define_method(cDBusServer, "setup_with_g_main", cDBusServer_setup_with_g_main, 0);
+}

data/ext/ruby-dbus.h

@@ -0,0 +1,127 @@
+/*---------------------------------------------------
+ *
+ * D-BUS bindings for Ruby
+ * (C) Copyright 2004 Provenco Group Ltd
+ *
+ * Licensed under the same terms as the D-BUS library
+ *
+ *--------------------------------------------------*/
+
+#ifndef RUBY_DBUS_H
+#define RUBY_DBUS_H
+
+
+#define DBUS_API_SUBJECT_TO_CHANGE 1
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include "ruby.h"
+
+#define RDBUS_GENERATE_PROTO_NEW(klass, ctype) \
+  VALUE _rdbus_ ##klass## _new_from(ctype obj)
+
+#define RDBUS_GENERATE_PROTO_GET(ctype) \
+  ctype * _rdbus_ ##ctype## _get_wrapped(VALUE value)
+
+#define RDBUS_GENERATE_NEW(klass, ctype, free) \
+  RDBUS_GENERATE_NEW_WITH_MARK(klass, ctype, NULL, free)
+
+#define RDBUS_GENERATE_NEW_WITH_MARK(klass, ctype, mark, free) \
+  RDBUS_GENERATE_PROTO_NEW(klass, ctype)                       \
+  {                                                            \
+    return Data_Wrap_Struct(klass, mark, free, obj);           \
+  }
+
+#define RDBUS_GENERATE_GET(ctype)                         \
+  RDBUS_GENERATE_PROTO_GET(ctype)                         \
+  {                                                       \
+    ctype *obj = NULL;                                    \
+    Data_Get_Struct(value, ctype, obj);                   \
+    if (obj == NULL)                                      \
+      rb_raise(eDBusError, "failed to retrieve " #ctype); \
+    return obj;                                           \
+  }
+
+#define RDBUS_TRY_ERR(expr, klass)    \
+  do {                                \
+    DBusError error;                  \
+    dbus_error_init(&error);          \
+    (expr);                           \
+    if (dbus_error_is_set(&error))    \
+      rb_raise(klass, error.message); \
+  } while (0);
+
+#define RDBUS_TRY(expr) \
+  RDBUS_TRY_ERR((expr), eDBusError)
+
+#define RDBUS_NEW(klass, obj) \
+  _rdbus_ ##klass## _new_from(obj)
+
+#define RDBUS_GET(ctype, value) \
+  _rdbus_ ##ctype## _get_wrapped(value)
+
+#define RDBUS_RAISE_IF(cond, message) \
+  if (cond) rb_raise(eDBusError, message)
+
+
+
+#define CONN_GET(obj) \
+  RDBUS_GET(DBusConnection, obj)
+
+#define MSG_GET(obj) \
+  (RDBUS_GET(DBusMessage, obj))
+
+#define ITER_GET(obj) \
+  (RDBUS_GET(RubyDBusMessageIter, obj)->real_iter)
+
+#define CALL_GET(obj) \
+  (RDBUS_GET(DBusPendingCall, obj))
+
+#define SERVER_GET(obj) \
+  (RDBUS_GET(DBusServer, obj))
+
+
+
+extern VALUE mDBus;
+extern VALUE mDBusBinding;
+extern VALUE cDBusConnection;
+extern VALUE cDBusServer;
+extern VALUE cDBusMessage;
+extern VALUE cDBusMessageIter;
+extern VALUE cDBusPendingCall;
+extern VALUE eDBusError;
+
+typedef struct _RubyDBusMessageIter RubyDBusMessageIter;
+
+
+
+void Init_dbus_bus();
+void Init_dbus_connection();
+void Init_dbus_message();
+void Init_dbus_message_iter();
+void Init_dbus_pending_call();
+void Init_dbus_server();
+
+RDBUS_GENERATE_PROTO_NEW(cDBusConnection, DBusConnection *);
+RDBUS_GENERATE_PROTO_NEW(cDBusMessage, DBusMessage *);
+RDBUS_GENERATE_PROTO_NEW(cDBusMessageIter, RubyDBusMessageIter *);
+RDBUS_GENERATE_PROTO_NEW(cDBusPendingCall, DBusPendingCall *);
+RDBUS_GENERATE_PROTO_NEW(cDBusServer, DBusServer *);
+
+RDBUS_GENERATE_PROTO_GET(DBusConnection);
+RDBUS_GENERATE_PROTO_GET(DBusMessage);
+RDBUS_GENERATE_PROTO_GET(DBusMessageIter);
+RDBUS_GENERATE_PROTO_GET(DBusPendingCall);
+RDBUS_GENERATE_PROTO_GET(DBusServer);
+
+RubyDBusMessageIter *rdbus_message_iter_new (DBusMessage *msg, short is_append_iter);
+VALUE                rdbus_private_method   (VALUE klass);
+
+
+/* --- Externals (copied from Python bindings) --- */
+void dbus_connection_setup_with_g_main (DBusConnection *connection,
+                                        GMainContext   *context);
+void dbus_server_setup_with_g_main     (DBusServer     *server,
+                                        GMainContext   *context);
+void dbus_g_thread_init                ();
+
+#endif

data/lib/dbus.rb

@@ -0,0 +1,359 @@
+#-----------------------------------------------------
+# D-BUS bindings for Ruby
+# (C) Copyright 2004 Leon Breedt
+# (C) Copyright 2004 Provenco Group Ltd
+#
+# Licensed under the same terms as the D-BUS library
+#-----------------------------------------------------
+
+require 'dbus.so'
+require 'dbus/version'
+require 'dbus/binding'
+
+module DBus
+
+  # Represents a connection to a DBus daemon
+  class Bus
+    TYPE_SESSION = BUS_SESSION
+    TYPE_SYSTEM = BUS_SYSTEM
+    TYPE_ACTIVATION = BUS_ACTIVATION
+
+    def initialize(bus_type=TYPE_SESSION, glib_mainloop=true)
+      @connection = DBus::Binding::bus_get(bus_type)
+      @connection.add_filter(method(:signal_dispatcher))
+      @rules = {}
+      @connection.setup_with_g_main if glib_mainloop
+    end
+
+    def get_connection
+      @connection
+    end
+
+    def get_service(name="org.freedesktop.Broadcast")
+      RemoteService.new(self, name)
+    end
+
+    # Add a handler +handler_proc+ for the match rule resulting from
+    # passing the parameters to Bus#build_signal_rule. Multiple handlers
+    # can be installed for the same signal.
+    def add_signal_receiver(handler_proc, signal_name=nil, interface=nil, service=nil, path=nil)
+      rule = build_signal_rule(signal_name, interface, service, path)
+      @rules[rule] ||= []
+      @rules[rule] << handler_proc unless @rules[rule].include?(handler_proc)
+      DBus::Binding::bus_add_match(@connection, rule)
+    end
+
+    # Remove the handler +handler_proc+ for a match rule previously added using
+    # Bus#add_signal_receiver.
+    def remove_signal_receiver(handler_proc, signal_name=nil, interface=nil, service=nil, path=nil)
+      rule = build_signal_rule(signal_name, interface, service, path)
+      return nil unless @rules.has_key?(rule)
+      @rules[rule].remove(handler_proc)
+      DBus::Binding::bus_remove_match(@conn, rule)
+    end
+
+    # Generate a match rule for a signal with the specified arguments. If any of
+    # the method arguments is +nil+, its processing (below) is skipped.
+    #
+    # - The rule "type" is set to "signal"
+    # - The rule "interface" is set to the value of the +interface+ argument
+    # - The rule "sender" is set as follows: If the given +service+ argument does not
+    #   start with ":", and is not "org.freedesktop.DBus", the "sender" value
+    #   is set to the owner of the supplied +service+ argument (determined with
+    #   a +GetServiceOwner+ call), otherwise, the +service+ value is used
+    # - The "path" parameter is set to the value of the +path+ argument
+    # - The "member" parameter is set to the value of the +signal_name+ argument
+    # 
+    def build_signal_rule(signal_name, interface, service, path)
+      rule = "type='signal'"
+      if interface
+        rule += ",interface='%s'" % interface
+      end
+      if service
+        if service[0,1] != ":" && service != "org.freedesktop.DBus"
+          bus_service = get_service("org.freedesktop.DBus")
+          bus_object = bus_service.get_object("/org/freedesktop/DBus",
+                                              "org.freedesktop.DBus")
+          service = bus_object.GetServiceOwner(service)
+        end
+        rule += ",sender='%s'" % service
+      end
+      if path
+        rule += ",path='%s'" % path
+      end
+      if signal_name
+        rule += ",member='%s'" % signal_name
+      end
+      rule
+    end
+
+    protected
+    def signal_dispatcher(connection, message)
+      return HANDLER_RESULT_NOT_YET_HANDLED unless message.get_type == MESSAGE_TYPE_SIGNAL
+      interface = message.get_interface
+      service = message.get_sender
+      path = message.get_path
+      member = message.get_member
+      rule = build_signal_rule(member, interface, service, path)
+      if @rules.has_key?(rule)
+        args = [interface, member, service, path, message]
+        @rules[rule].each {|f| f.call(*args)}
+      end
+      HANDLER_RESULT_HANDLED
+    end
+  end
+
+  # The system-wide message bus
+  class SystemBus < Bus
+    def initialize(glib_mainloop=true)
+      super(Bus::TYPE_SYSTEM, glib_mainloop)
+    end
+  end
+
+  # The session (current login) message bus
+  class SessionBus < Bus
+    def initialize(glib_mainloop=true)
+      super(Bus::TYPE_SESSION, glib_mainloop)
+    end
+  end
+
+  # The bus that activated this process (if
+  # this process was launched by DBus activation)
+  class ActivationBus < Bus
+    def initialize(glib_mainloop=true)
+      super(Bus::TYPE_ACTIVATION, glib_mainloop)
+    end
+  end
+
+  # Represents a remote object.
+  #
+  # A RemoteObject is provided by a RemoteService on a particular Bus. RemoteObjects
+  # have member functions, and can be called like normal Ruby objects.
+  class RemoteObject
+    def initialize(service, object_path, interface)
+      @service = service
+      @object_path = object_path
+      @interface = interface
+    end
+
+    # Connect the signal +signal_name+ on this remote object to the
+    # supplied handler proc +handler_proc+.
+    def connect_to_signal(signal_name, handler_proc)
+      @service.get_bus.add_signal_receiver(handler_proc,
+                                           signal_name,
+                                           @interface,
+                                           @service.get_service_name,
+                                           @object_path)
+    end
+
+    # Implements magic remote method calls
+    def method_missing(sym, *args)
+      name = sym.id2name
+      message = DBus::Binding::DBusMessage.new_method_call(@service.get_service_name,
+                                                           @object_path,
+                                                           @interface,
+                                                           name)
+      iter = message.get_iter
+      args.each{|a| iter.append(a)}
+      reply = @service.get_bus.get_connection.send_with_reply_and_block(message, 5000)
+      reply_args = reply.to_a
+      return nil if reply_args.empty?
+      return reply_args[0] if reply_args.length == 1
+      return reply_args
+    end
+  end
+
+  # Base class for exporting your own Services across the Bus
+  #
+  # Just inherit from Service, providing the name of your service
+  # (e.g. org.designfu.SampleService)
+  class Service
+    def initialize(name, bus=nil)
+      @name = name
+      @bus = bus
+      @bus = Bus.new if @bus.nil?
+      DBus::Binding::bus_acquire_service(@bus.get_connection, @name)
+    end
+
+    # The name of this service
+    def get_name
+      @name
+    end
+
+    # The bus this service is defined on
+    def get_bus
+      @bus
+    end
+  end
+
+  # Base class for objects that support D-BUS invocation messages
+  class DBusCallable
+    # Create a new DBusCallable instance on the specified +connection+.
+    # +dbus_methods+ is an Array containing a list of symbols for the
+    # methods which may be invoked remotely.
+    def initialize(connection, dbus_methods=[])
+      @connection = connection
+      @dbus_methods = dbus_methods
+    end
+
+    # Process the method invocation message given in +message+. Returns
+    # the reply message.
+    def dispatch_message(message)
+      dispatch(message.get_member, message.to_a, message)
+    end
+
+    # Invoke the method +name+, with arguments +args+, and source invocation
+    # request message +source_message+, returning the reply message.
+    def dispatch(name, args, source_message)
+      unless @dbus_methods.include?(name.to_sym)
+        return new_error_reply(source_message, "Method '#{name}' not in allowed list")
+      end
+      unless self.respond_to?(name)
+        return new_error_reply(source_message, "No such method '#{name}'")
+      end
+      ret = nil
+      begin
+        args = [source_message, *args]
+        ret = self.send(name, *args)
+      rescue
+        return new_error_reply(source_message, $!.to_s)
+      end
+      reply = DBus::Binding::DBusMessage.new_method_return(source_message)
+      iter = reply.get_iter
+      iter.append(ret)
+      reply
+    end
+
+    # Generate a new error reply from source message +message+, and error string
+    # +error_message+.
+    def new_error_reply(message, error_message)
+      error_name = self.class.to_s.gsub(/::/, '.')
+      error_name += '.ERROR'
+      DBus::Binding::DBusMessage.new_error(message, error_name, error_message)
+    end
+
+    # Called when this object is unregistered from the connection
+    def on_unregister(connection)
+    end
+
+    # Called when a message arrives on the connection for this object
+    def on_message(connection, message)
+      reply = dispatch_message(message)
+      @connection.send(reply)
+      HANDLER_RESULT_HANDLED
+    end
+  end
+
+  # Base class for exporting your own Objects across the Bus
+  #
+  # Just inherit from Object and provide a list of the symbol names for methods
+  # to share across the bus. These will appear as member functions of your
+  # Service object.
+  class Object < DBusCallable
+    def initialize(object_path, service, dbus_methods=[])
+      @connection = service.get_bus.get_connection
+      super(@connection, dbus_methods)
+      @object_path = object_path
+      @service = service
+      @connection.register_object_path(@object_path, method(:on_unregister), method(:on_message))
+    end
+
+    # Emit the signal +signal_name+ for interface +interface+, and include +args+ in the
+    # signal message. 
+    def emit_signal(interface, signal_name, *args)
+      message = DBus::Binding::DBusMessage.new_signal(@object_path, interface, signal_name)
+      iter = message.get_iter
+      args.each{|a| iter.append(a)}
+      @connection.send(message)
+    end
+  end
+
+  # An object tree allows you to register a handler for a tree of object paths.
+  # This means that literal Ruby objects do not need to be created for each object
+  # over the bus, but you can have a virtual tree of objects handled by a single
+  # Ruby object. There are two ways to handle method calls on virtual objects:
+  #
+  # 1. Pass a list of dbus_methods in to initialize. This works just like
+  #    DBus::Object, except an object_path is passed as the first argument to
+  #    each method, denoting which virtual object the call was made on. If all
+  #    the objects in the tree support the same methods, this is the best
+  #    approach.
+  #
+  # 2. Override object_method_called. This allows you to define the valid
+  #    methods dynamically on an object by object basis. For example, if
+  #    providing an object tree that represented a filesystem heirarchy, you'd
+  #    only want an ls method on directory objects, not file objects.
+  class ObjectTree < DBusCallable
+    def initialize(base_path, service, dbus_methods=[])
+      @connection = service.get_bus.get_connection
+      super(@connection, dbus_methods)
+      @base_path = base_path
+      @service = service
+      @methods = dbus_methods
+      @service.get_bus.get_connection.register_fallback(base_path, method(:on_unregister),
+                                                        method(:on_message))
+    end
+
+    # Create a new absolute +ObjectPath+ for the given relative +path+
+    def relative_path_to_object_path(path)
+      ObjectPath.new(@base_path + path)
+    end
+
+    # Broadcast the signal +signal_name+ for interface +interface+ for
+    # the object identified by +relative_path+
+    def broadcast_signal(interface, signal_name, relative_path)
+      object_path = relative_path_to_object_path(relative_path)
+      message = DBus::Binding::DBusMessage.new_signal(object_path, interface, signal_name)
+      @connection.send(message)
+    end
+
+    def object_method_called
+      raise NotImplementedError, "Not implemented"
+    end
+
+    def on_message(connection, message)
+      target_object_full_path = message.get_path
+      n = @base_path.length
+      unless @base_path == target_object_full_path[0,n]
+        @connection.send(new_error_reply(message, "Invalid target path: #{target_object_full_path}"))
+        return HANDLER_RESULT_HANDLED
+      end
+      target_object_path = target_object_full_path[n..-1]
+      target_method = message.get_member
+      target_args = message.to_a
+      args = [target_object_path, *target_args]
+      @connection.send(dispatch(target_method, args, message))
+      HANDLER_RESULT_HANDLED
+    end
+  end
+
+  # A remote service providing objects.
+  #
+  # A service is typically a process or application that provides
+  # remote objects, but can also be the broadcast service that
+  # receives signals from all applications on the Bus.
+  class RemoteService
+    def initialize(bus, service_name)
+      @bus = bus
+      @service_name = service_name
+    end
+
+    # Bus associated with this service
+    def get_bus
+      @bus
+    end
+
+    # The service name
+    def get_service_name
+      @service_name
+    end
+
+    # Creates an object for the specified +object_path+
+    def get_object(object_path, interface)
+      RemoteObject.new(self, object_path, interface)
+    end
+  end
+
+  class ObjectPath < String; end
+
+end