ruby-dbus 0.10.0 → 0.11.0

data/lib/dbus/error.rb

@@ -34,8 +34,10 @@ module DBus
     end
   end # class Error
 
-  # raise DBus.error, "message"
-  # raise DBus.error("org.example.Error.SeatOccupied"), "Seat #{n} is occupied"
+  # @example raise a generic error
+  #   raise DBus.error, "message"
+  # @example raise a specific error
+  #   raise DBus.error("org.example.Error.SeatOccupied"), "Seat #{n} is occupied"
   def error(name = "org.freedesktop.DBus.Error.Failed")
     # message will be set by Kernel.raise
     DBus::Error.new(nil, name)

data/lib/dbus/export.rb

@@ -64,9 +64,10 @@ module DBus
             reply.add_param(rsig.type, rdata)
           end
         rescue => ex
-          reply = ErrorMessage.from_exception(ex).reply_to(msg)
+          dbus_msg_exc = msg.annotate_exception(ex)
+          reply = ErrorMessage.from_exception(dbus_msg_exc).reply_to(msg)
         end
-        @service.bus.send(reply.marshall)
+        @service.bus.message_queue.push(reply)
       end
     end
 

data/lib/dbus/introspect.rb

@@ -215,299 +215,5 @@ module DBus
       xml
     end
   end # class Signal
-
-  # = D-Bus proxy object interface class
-  #
-  # A class similar to the normal Interface used as a proxy for remote
-  # object interfaces.
-  class ProxyObjectInterface
-    # The proxied methods contained in the interface.
-    attr_accessor :methods
-    # The proxied signals contained in the interface.
-    attr_accessor :signals
-    # The proxy object to which this interface belongs.
-    attr_reader :object
-    # The name of the interface.
-    attr_reader :name
-
-    # Creates a new proxy interface for the given proxy _object_
-    # and the given _name_.
-    def initialize(object, name)
-      @object, @name = object, name
-      @methods, @signals = Hash.new, Hash.new
-    end
-
-    # Returns the string representation of the interface (the name).
-    def to_str
-      @name
-    end
-
-    # Returns the singleton class of the interface.
-    def singleton_class
-      (class << self ; self ; end)
-    end
-
-    # Defines a method on the interface from the Method descriptor _m_.
-    def define_method_from_descriptor(m)
-      m.params.each do |fpar|
-        par = fpar.type
-        # This is the signature validity check
-        Type::Parser.new(par).parse
-      end
-
-      singleton_class.class_eval do
-        define_method m.name do |*args, &reply_handler|
-          if m.params.size != args.size
-            raise ArgumentError, "wrong number of arguments (#{args.size} for #{m.params.size})"
-          end
-
-          msg = Message.new(Message::METHOD_CALL)
-          msg.path = @object.path
-          msg.interface = @name
-          msg.destination = @object.destination
-          msg.member = m.name
-          msg.sender = @object.bus.unique_name
-          m.params.each do |fpar|
-            par = fpar.type
-            msg.add_param(par, args.shift)
-          end
-          @object.bus.send_sync_or_async(msg, &reply_handler)
-        end
-      end
-
-      @methods[m.name] = m
-    end
-
-    # Defines a signal from the descriptor _s_.
-    def define_signal_from_descriptor(s)
-      @signals[s.name] = s
-    end
-
-    # Defines a signal or method based on the descriptor _m_.
-    def define(m)
-      if m.kind_of?(Method)
-        define_method_from_descriptor(m)
-      elsif m.kind_of?(Signal)
-        define_signal_from_descriptor(m)
-      end
-    end
-
-    # Defines a proxied method on the interface.
-    def define_method(methodname, prototype)
-      m = Method.new(methodname)
-      m.from_prototype(prototype)
-      define(m)
-    end
-
-    # @overload on_signal(name, &block)
-    # @overload on_signal(bus, name, &block)
-    # Registers a handler (code block) for a signal with _name_ arriving
-    # over the given _bus_. If no block is given, the signal is unregistered.
-    # Note that specifying _bus_ is discouraged and the option is kept only for
-    # backward compatibility.
-    # @return [void]
-    def on_signal(bus = @object.bus, name, &block)
-      mr = DBus::MatchRule.new.from_signal(self, name)
-      if block.nil?
-        bus.remove_match(mr)
-      else
-        bus.add_match(mr) { |msg| block.call(*msg.params) }
-      end
-    end
-
-    PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties"
-
-    # Read a property.
-    def [](propname)
-      self.object[PROPERTY_INTERFACE].Get(self.name, propname)[0]
-    end
-
-    # Write a property.
-    def []=(propname, value)
-      self.object[PROPERTY_INTERFACE].Set(self.name, propname, value)
-    end
-
-    # Read all properties at once, as a hash.
-    # @return [Hash{String}]
-    def all_properties
-      self.object[PROPERTY_INTERFACE].GetAll(self.name)[0]
-    end
-  end # class ProxyObjectInterface
-
-  # D-Bus proxy object class
-  #
-  # Class representing a remote object in an external application.
-  # Typically, calling a method on an instance of a ProxyObject sends a message
-  # over the bus so that the method is executed remotely on the correctponding
-  # object.
-  class ProxyObject
-    # The names of direct subnodes of the object in the tree.
-    attr_accessor :subnodes
-    # Flag determining whether the object has been introspected.
-    attr_accessor :introspected
-    # The (remote) destination of the object.
-    attr_reader :destination
-    # The path to the object.
-    attr_reader :path
-    # The bus the object is reachable via.
-    attr_reader :bus
-    # @return [String] The name of the default interface of the object.
-    attr_accessor :default_iface
-
-    # Creates a new proxy object living on the given _bus_ at destination _dest_
-    # on the given _path_.
-    def initialize(bus, dest, path)
-      @bus, @destination, @path = bus, dest, path
-      @interfaces = Hash.new
-      @subnodes = Array.new
-    end
-
-    # Returns the interfaces of the object.
-    def interfaces
-      @interfaces.keys
-    end
-
-    # Retrieves an interface of the proxy object
-    # @param [String] intfname
-    # @return [ProxyObjectInterface]
-    def [](intfname)
-      @interfaces[intfname]
-    end
-
-    # Maps the given interface name _intfname_ to the given interface _intf.
-    # @param [String] intfname
-    # @param [ProxyObjectInterface] intf
-    # @return [ProxyObjectInterface]
-    def []=(intfname, intf)
-      @interfaces[intfname] = intf
-    end
-
-    # Introspects the remote object. Allows you to find and select
-    # interfaces on the object.
-    def introspect
-      # Synchronous call here.
-      xml = @bus.introspect_data(@destination, @path)
-      ProxyObjectFactory.introspect_into(self, xml)
-      define_shortcut_methods()
-      xml
-    end
-
-    # For each non duplicated method name in any interface present on the
-    # caller, defines a shortcut method dynamically.
-    # This function is automatically called when a {ProxyObject} is
-    # introspected.
-    def define_shortcut_methods
-      # builds a list of duplicated methods
-      dup_meths, univocal_meths = [],{}
-      @interfaces.each_value do |intf|
-        intf.methods.each_value do |meth|
-          # Module#instance_methods give us an array of symbols or strings,
-          # depending on which version
-          name = if RUBY_VERSION >= "1.9"
-                   meth.name.to_sym
-                 else
-                   meth.name
-                 end
-          # don't overwrite instance methods!
-          if dup_meths.include? name or self.class.instance_methods.include? name
-            next
-          elsif univocal_meths.include? name
-            univocal_meths.delete name
-            dup_meths << name
-          else
-            univocal_meths[name] = intf
-          end
-        end
-      end
-      univocal_meths.each do |name, intf|
-        # creates a shortcut function that forwards each call to the method on
-        # the appropriate intf
-        singleton_class.class_eval do
-          define_method name do |*args, &reply_handler|
-            intf.method(name).call(*args, &reply_handler)
-          end
-        end
-      end
-    end
-
-    # Returns whether the object has an interface with the given _name_.
-    def has_iface?(name)
-      raise "Cannot call has_iface? if not introspected" if not @introspected
-      @interfaces.member?(name)
-    end
-
-    # Registers a handler, the code block, for a signal with the given _name_.
-    # It uses _default_iface_ which must have been set.
-    # @return [void]
-    def on_signal(name, &block)
-      if @default_iface and has_iface?(@default_iface)
-        @interfaces[@default_iface].on_signal(name, &block)
-      else
-        # TODO improve
-        raise NoMethodError
-      end
-    end
-
-    ####################################################
-    private
-
-    # Handles all unkown methods, mostly to route method calls to the
-    # default interface.
-    def method_missing(name, *args, &reply_handler)
-      if @default_iface and has_iface?(@default_iface)
-        begin
-          @interfaces[@default_iface].method(name).call(*args, &reply_handler)
-        rescue NameError => e
-          # interesting, foo.method("unknown")
-          # raises NameError, not NoMethodError
-          raise unless e.to_s =~ /undefined method `#{name}'/
-          # BTW e.exception("...") would preserve the class.
-          raise NoMethodError,"undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
-        end
-      else
-        # TODO distinguish:
-        # - di not specified
-        #TODO
-        # - di is specified but not found in introspection data
-        raise NoMethodError, "undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
-      end
-    end
-
-    # Returns the singleton class of the object.
-    def singleton_class
-      (class << self ; self ; end)
-    end
-  end # class ProxyObject
-
-  # = D-Bus proxy object factory class
-  #
-  # Class that generates and sets up a proxy object based on introspection data.
-  class ProxyObjectFactory
-    # Creates a new proxy object factory for the given introspection XML _xml_,
-    # _bus_, destination _dest_, and _path_.
-    def initialize(xml, bus, dest, path)
-      @xml, @bus, @path, @dest = xml, bus, path, dest
-    end
-
-    # Investigates the sub-nodes of the proxy object _po_ based on the
-    # introspection XML data _xml_ and sets them up recursively.
-    def ProxyObjectFactory.introspect_into(po, xml)
-      intfs, po.subnodes = IntrospectXMLParser.new(xml).parse
-      intfs.each do |i|
-        poi = ProxyObjectInterface.new(po, i.name)
-        i.methods.each_value { |m| poi.define(m) }
-        i.signals.each_value { |s| poi.define(s) }
-        po[i.name] = poi
-      end
-      po.introspected = true
-    end
-
-    # Generates, sets up and returns the proxy object.
-    def build
-      po = ProxyObject.new(@bus, @dest, @path)
-      ProxyObjectFactory.introspect_into(po, @xml)
-      po
-    end
-  end # class ProxyObjectFactory
 end # module DBus
 

data/lib/dbus/marshall.rb

@@ -212,7 +212,7 @@ module DBus
         packet = get_string
       when Type::STRING
         packet = get_string
-        packet.force_encoding('UTF-8') if RUBY_VERSION >= '1.9'
+        packet.force_encoding('UTF-8')
       when Type::SIGNATURE
         packet = get_signature
       when Type::DICT_ENTRY

data/lib/dbus/message.rb

@@ -235,6 +235,14 @@ module DBus
       ret, _ = unmarshall_buffer(buf)
       ret
     end
+
+    # Make a new exception from ex, mark it as being caused by this message
+    # @api private
+    def annotate_exception(ex)
+      new_ex = ex.exception("#{ex}; caused by #{self}")
+      new_ex.set_backtrace(ex.backtrace)
+      new_ex
+    end
   end # class Message
 
   class MethodReturnMessage < Message

data/lib/dbus/message_queue.rb

@@ -0,0 +1,166 @@
+# This file is part of the ruby-dbus project
+# Copyright (C) 2007 Arnaud Cornet and Paul van Tilburg
+# Copyright (C) 2009-2014 Martin Vidner
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License, version 2.1 as published by the Free Software Foundation.
+# See the file "COPYING" for the exact licensing terms.
+
+require "fcntl"
+require "socket"
+
+module DBus
+  class MessageQueue
+    # The socket that is used to connect with the bus.
+    attr_reader :socket
+
+    def initialize(address)
+      @address = address
+      @buffer = ""
+      @is_tcp = false
+      connect
+    end
+
+    # TODO failure modes
+    #
+    # If _non_block_ is true, return nil instead of waiting
+    # EOFError may be raised
+    def pop(non_block = false)
+      buffer_from_socket_nonblock
+      message = message_from_buffer_nonblock
+      unless non_block
+        # we can block
+        while message.nil?
+          r, d, d = IO.select([@socket])
+          if r and r[0] == @socket
+            buffer_from_socket_nonblock
+            message = message_from_buffer_nonblock
+          end
+        end
+      end
+      message
+    end
+
+    def push(message)
+      @socket.write(message.marshall)
+    end
+    alias :<< :push
+
+    private
+
+    # Connect to the bus and initialize the connection.
+    def connect
+      addresses = @address.split ";"
+      # connect to first one that succeeds
+      worked = addresses.find do |a|
+        transport, keyvaluestring = a.split ":"
+        kv_list = keyvaluestring.split ","
+        kv_hash = Hash.new
+        kv_list.each do |kv|
+          key, escaped_value = kv.split "="
+          value = escaped_value.gsub(/%(..)/) {|m| [$1].pack "H2" }
+          kv_hash[key] = value
+        end
+        case transport
+          when "unix"
+          connect_to_unix kv_hash
+          when "tcp"
+          connect_to_tcp kv_hash
+          when "launchd"
+          connect_to_launchd kv_hash
+          else
+          # ignore, report?
+        end
+      end
+      worked
+      # returns the address that worked or nil.
+      # how to report failure?
+    end
+
+    # Connect to a bus over tcp and initialize the connection.
+    def connect_to_tcp(params)
+      #check if the path is sufficient
+      if params.key?("host") and params.key?("port")
+        begin
+          #initialize the tcp socket
+          @socket = TCPSocket.new(params["host"],params["port"].to_i)
+          @socket.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+          init_connection
+          @is_tcp = true
+        rescue Exception => e
+          puts "Oops:", e
+          puts "Error: Could not establish connection to: #{@path}, will now exit."
+          exit(1) #a little harsh
+        end
+      else
+        #Danger, Will Robinson: the specified "path" is not usable
+        puts "Error: supplied path: #{@path}, unusable! sorry."
+      end
+    end
+
+    # Connect to an abstract unix bus and initialize the connection.
+    def connect_to_unix(params)
+      @socket = Socket.new(Socket::Constants::PF_UNIX,Socket::Constants::SOCK_STREAM, 0)
+      @socket.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      if ! params['abstract'].nil?
+        if HOST_END == LIL_END
+          sockaddr = "\1\0\0#{params['abstract']}"
+        else
+          sockaddr = "\0\1\0#{params['abstract']}"
+        end
+      elsif ! params['path'].nil?
+        sockaddr = Socket.pack_sockaddr_un(params['path'])
+      end
+      @socket.connect(sockaddr)
+      init_connection
+    end
+
+    def connect_to_launchd(params)
+      socket_var = params['env']
+      socket = `launchctl getenv #{socket_var}`.chomp
+      connect_to_unix 'path' => socket
+    end
+
+    # Initialize the connection to the bus.
+    def init_connection
+      @client = Client.new(@socket)
+      @client.authenticate
+    end
+
+    public                      # FIXME: fix Main loop instead
+
+    # Get and remove one message from the buffer.
+    # Return the message or nil.
+    def message_from_buffer_nonblock
+      return nil if @buffer.empty?
+      ret = nil
+      begin
+        ret, size = Message.new.unmarshall_buffer(@buffer)
+        @buffer.slice!(0, size)
+      rescue IncompleteBufferException
+        # fall through, let ret be null
+      end
+      ret
+    end
+
+    # The buffer size for messages.
+    MSG_BUF_SIZE = 4096
+
+    # Fill (append) the buffer from data that might be available on the
+    # socket.
+    # EOFError may be raised
+    def buffer_from_socket_nonblock
+      @buffer += @socket.read_nonblock(MSG_BUF_SIZE)
+    rescue EOFError
+      raise                     # the caller expects it
+    rescue Errno::EAGAIN
+      # fine, would block
+    rescue Exception => e
+      puts "Oops:", e
+      raise if @is_tcp          # why?
+      puts "WARNING: read_nonblock failed, falling back to .recv"
+      @buffer += @socket.recv(MSG_BUF_SIZE)
+    end
+  end
+end