rbus 0.1.0

data/lib/rbus/mainloop/observers.rb

@@ -0,0 +1,149 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+require 'monitor'
+module RBus
+#  module Message
+  
+    # Waits for Signals in the message loop.
+    class SignalObserver
+      include Message::MessageTypes
+      
+      def initialize(observable, rules, callback)
+        @observable = observable
+        @rules = rules
+        @callback = callback
+        @observable.add_observer(self)
+      end
+      
+      def update(message)
+        #Log.debug(message)
+        @rules.each do |key,value|
+          Log.debug("#{key}: #{value}")
+          case key.to_s
+            when 'sender'
+              return unless value == message.sender
+            when 'interface'
+              return unless value == message.interface
+            when 'member'
+              return unless value == message.member
+            when 'path'
+              return unless value == message.object_path
+            when 'destination'
+              return unless value == message.destination
+            when 'type'
+              type = case value
+                       when 'signal': SIGNAL
+                       when 'method_call': METHOD_CALL
+                       when 'method_return': METHOD_RETURN
+                       when 'error': ERROR
+                     end
+                Log.debug("#{type} == #{message.type}")
+                return unless type == message.type
+            when /^arg(\d+)/
+              return unless value == message.arguments[$1]
+          end
+        end 
+        @callback.call(message.arguments)
+      end
+    end
+    
+    # Waits for asynchronous replies in the message loop.
+    class AsyncObserver
+      def initialize(observable, serial, callback)
+        @observable = observable
+        @serial = serial
+        @callback = callback
+        @observable.add_observer(self)
+      end
+      
+      def update(message)
+        Log.debug('AsyncObserver got message serial: ' + message.serial.to_s)
+        Log.debug('AsyncObserver wanted message serial: ' + @serial.to_s)
+        if message.serial == @serial
+          @observable.delete_observer(self)
+          @callback.call(message.arguments)
+        end
+      end
+    end
+    
+  # Waits for synchronous replies in the message loop.
+  # Only used by threaded.
+  class SyncObserver
+    attr_reader :message
+    
+    def initialize(observable, serial)
+      @observable = observable
+      @serial = serial
+      @observable.add_observer(self)
+      @message = nil
+    end
+    
+    def update(message)
+      Log.debug('SyncObserver got message serial: ' + message.serial.to_s)
+      Thread.critical = true
+      if message.serial == @serial
+        @message = message
+        @observable.delete_observer(self)
+      end
+      Thread.critical = false
+    end
+  end
+  
+=begin Old, better(?) implementation?
+
+  # Waits for synchronous replies in the message loop.
+  class SyncObserver
+    include MonitorMixin
+    def initialize(observable, serial)
+      super()
+      @observable = observable
+      @serial = serial
+      @observable.add_observer(self)
+      @message = nil
+      @lock = new_cond
+    end
+    
+    def wait
+      synchronize do
+        @lock.wait_while {@message.nil?}
+        @observable.delete_observer(self)
+        return @message.arguments
+      end
+    end
+    
+    def update(message)
+      Log.debug('SyncObserver got message serial: ' + message.serial.to_s)
+      synchronize do
+        if message.serial == @serial
+          @message = message
+          @lock.signal
+        end
+      end
+    end
+
+
+
+=end
+  
+end

data/lib/rbus/mainloop/thread.rb

@@ -0,0 +1,78 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+require File.dirname(__FILE__) + '/mainloop'
+require File.dirname(__FILE__) + '/observers'
+module RBus
+  class Mainloop
+
+    def setup
+      @loop = Thread.new do
+        loop do
+          #IO.select([@transport.socket], nil, nil, nil)
+          message = @reader.read_message
+          handle_incoming(message)
+        end
+      end
+    end
+    
+    # Threaded version of observable's method with same name.
+    def notify_observers(*arg) # :nodoc:
+      if defined? @observer_state and @observer_state
+        if defined? @observer_peers
+          for i in @observer_peers.dup
+            Thread.new{i.update(*arg)}
+          end
+        end
+        @observer_state = false
+      end
+    end
+    
+    def send_message(message, callback = nil)    
+      # TODO: if message has no_reply, use dummy observer
+      if message.member == 'AddMatch'
+        observer = SignalObserver.new(self, message.arguments[0], callback)
+        message.arguments = message.arguments[0].map{|key,value|"#{key}='#{value}'"}.join(',')
+      elsif callback
+        observer = AsyncObserver.new(self, message.serial, callback)
+      else
+        observer = SyncObserver.new(self, message.serial)
+      end
+      
+      handle_outgoing(message)
+      
+      if observer.instance_of?(SyncObserver)
+        while observer.message.nil?
+          #Thread.pass
+        end
+        return observer.message.arguments
+      end
+    end    
+
+    
+  end
+
+  def self.mainloop # :nodoc:
+    Thread.stop
+  end
+end

data/lib/rbus/message/constants.rb

@@ -0,0 +1,51 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+module RBus
+  module Message
+    module MessageTypes
+      INVALID = 0
+      METHOD_CALL = 1
+      METHOD_RETURN = 2
+      ERROR = 3
+      SIGNAL = 4
+    end
+        
+    module HeaderFields
+      PATH = 1
+      INTERFACE = 2
+      MEMBER = 3
+      ERROR_NAME = 4
+      REPLY_SERIAL = 5
+      DESTINATION = 6
+      SENDER = 7
+      SIGNATURE = 8
+    end
+        
+    module Flags
+      EMPTY = 0
+      NO_REPLY_EXPECTED = 1
+      NO_AUTO_START = 2
+    end
+  end
+end

data/lib/rbus/message/marshal.rb

@@ -0,0 +1,139 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+require 'stringio'
+module RBus
+
+  # Mix in an array of values to gain the +dbus_marshal+ method
+  # Generally, this is used on the arguments of a message, and an
+  # array of header values. See Message::Writer#send_message.
+  module MarshalMixin
+    def dbus_marshal(signature)
+
+      tokens = StringIO.new(signature)        
+      ms = StringIO.new('')
+      
+      skip = lambda {|alignment| ms.write("\0" * (-ms.pos & alignment - 1))}
+      
+      parser = lambda {|element,sig|
+        case sig
+          when 'b'
+            skip.call(4)
+            if element && element != 0 && element != false
+              ms.write([1].pack('I'))
+            else
+              ms.write([0].pack('I'))
+            end
+          when 'y'
+            ms.write([element.to_i].pack('C'))
+          when 'n'
+            skip.call(2)
+            ms.write([element.to_i].pack('s'))
+          when 'q'
+            skip.call(2)
+            ms.write([element.to_i].pack('S'))
+          when 'u'
+            skip.call(4)
+            ms.write([element.to_i].pack('I'))
+          when 'i'
+            skip.call(4)
+            ms.write([element.to_i].pack('i'))
+          when 'd'
+            skip.call(8)
+            ms.write([element.to_f].pack('D'))
+          when 's','o'
+            skip.call(4)
+            str = element.to_s
+            ms.write([str.length,str].pack('Ia*x'))
+          when 'g'
+            str = element.to_s
+            ms.write([str.length,str].pack('Ca*x'))
+          when 'v'
+            parser.call(element.object_signature, 'g')
+            parser.call(element.object, element.object_signature)
+          when 'a'
+            skip.call(4)
+            next_token = tokens.read(1)
+            t_pos = tokens.pos
+            
+            # Postion of array length int
+            a_len_pos = ms.pos
+            # ...which is here
+            ms.write("\0\0\0\0")
+            
+            # Pad already here, to find correct end of padding...
+            case next_token
+              when 's','o','b','i','u'
+                skip.call(4)
+              when '{','(','a','d'
+                skip.call(8)
+              when 'q','n'
+                skip.call(2)
+            end
+            pad_pos = ms.pos
+                          
+            if next_token == '{'
+              skip.call(8)
+              element.each do |key,value|
+                tokens.pos = t_pos
+                parser.call(key,tokens.read(1))
+                parser.call(value,tokens.read(1))
+              end
+              while next_token != '}'
+                next_token = tokens.read(1)
+              end
+            else
+                  
+              element.each do |value|
+                tokens.pos = t_pos
+                parser.call(value,next_token)
+              end
+            end
+                                      
+            # Fill in array length              
+            m_new_pos = ms.pos
+            a_length = ms.pos - pad_pos
+            ms.pos = a_len_pos
+            parser.call(a_length, 'u')
+            ms.pos = m_new_pos
+            
+          when '('
+            skip.call(8)
+            ret_val = ''
+            element.each {|value|
+              next_token = tokens.read(1)
+              break if next_token == ')'
+              parser.call(value, next_token)
+            }
+          else
+            raise NotImplementedError, "can't marshal #{sig}"
+        end
+      }
+      each do |el|
+        parser.call(el,tokens.read(1))
+      end
+
+      ms.string
+    end
+  end
+end

data/lib/rbus/message/message.rb

@@ -0,0 +1,110 @@
+#--
+# 
+# R-Bus is a native Ruby implementation of the D-Bus protocol.
+# Copyright (C) 2007 Kristoffer Lundén (kristoffer.lunden@gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+# MA  02110-1301, USA.  A copy of the GNU General Public License is
+# also available at http://www.gnu.org/copyleft/gpl.html.
+#
+#++
+#
+
+module RBus
+  module Message
+      
+    # Base implementation for the different message types.
+    class Base
+        
+      include MessageTypes
+      include HeaderFields
+      include Flags
+      
+      attr_accessor :destination, :interface
+      attr_accessor :object_path, :member
+      attr_accessor :sender
+      attr_accessor :arguments, :signature
+          
+      attr_accessor :flags, :body
+      
+      attr_accessor :type
+      attr_accessor :serial
+      
+      def initialize
+        @flags ||= EMPTY
+        @body = ''
+        @serial = SerialGenerator.get_unique
+        @type ||= INVALID
+        yield self if block_given?
+      end
+      
+      def no_reply=(bool)
+        if bool
+          @flags |= NO_REPLY_EXPECTED
+        else
+          @flags &= ~ NO_REPLY_EXPECTED
+        end
+        puts "FLAGS: #{@flags}"
+      end
+      
+      def no_auto_start=(bool)
+        if bool
+          @flags |= NO_AUTO_START
+        else
+          @flags &= ~ NO_AUTO_START
+        end
+      end
+
+      def header_fields
+        hf = []
+        @object_path and hf << [PATH,         Variant.new(@object_path, 'o')]
+        @interface   and hf << [INTERFACE,    Variant.new(@interface, 's')]
+        @member      and hf << [MEMBER,       Variant.new(@member, 's')]
+        @destination and hf << [DESTINATION,  Variant.new(@destination, 's')]
+        @signature   and hf << [SIGNATURE,    Variant.new(@signature, 'g')]
+        hf
+      end
+    end  
+  end
+    
+  class MethodCall < Message::Base
+    def initialize
+      @type = METHOD_CALL
+      super
+    end
+  end
+  
+  class MethodReturn < Message::Base
+    def initialize
+      @type = METHOD_RETURN
+      super
+    end
+  end
+
+  class Error < Message::Base
+    def initialize
+      @type = ERROR
+      super
+    end
+  end
+
+  class Signal < Message::Base
+    def initialize
+      @type = SIGNAL
+      super
+    end
+  end
+
+end