pangdudu-ruby-dbus 0.2.3 → 0.2.4

data/examples/gdbus/launch.sh

@@ -1,4 +0,0 @@
-#!/bin/sh
-set -e
-# for the lazy typer
-ruby -w -I ../../lib gdbus

data/examples/no-introspect/nm-test.rb

@@ -1,21 +0,0 @@
-#!/usr/bin/ruby
-#
-# Trivial network interface lister using NetworkManager.
-# NetworkManager does not support introspection, so the api is not that sexy.
-
-require 'dbus'
-
-bus = DBus::SystemBus.instance
-
-nm_service = bus.service("org.freedesktop.NetworkManager")
-nm_manager = nm_service.object("/org/freedesktop/NetworkManager")
-poi = DBus::ProxyObjectInterface.new(nm_manager, "org.freedesktop.NetworkManager")
-begin
-  poi.define_method("getDevices", "") # NM 0.6
-  p poi.getDevices
-rescue Exception
-  poi.define_method("GetDevices", "") # NM 0.7
-  p poi.GetDevices
-end
-
-

data/examples/no-introspect/tracker-test.rb

@@ -1,16 +0,0 @@
-#!/usr/bin/ruby
-#
-# Trivial network interface lister using NetworkManager.
-# NetworkManager does not support introspection, so the api is not that sexy.
-
-require 'dbus'
-
-bus = DBus::SessionBus.instance
-
-tracker_service = bus.service("org.freedesktop.Tracker")
-tracker_manager = tracker_service.object("/org/freedesktop/tracker")
-poi = DBus::ProxyObjectInterface.new(tracker_manager, "org.freedesktop.Tracker.Files")
-poi.define_method("GetMetadataForFilesInFolder", "in live_query_id:i, in uri:s, in fields:as, out values:aas")
-p poi.GetMetadataForFilesInFolder(-1, ENV['HOME'] + "/Desktop", ["File:Name", "File:Size"])
-
-

data/examples/rhythmbox/playpause.rb

@@ -1,25 +0,0 @@
-#!/usr/bin/ruby
-
-require 'dbus'
-bus = DBus::SessionBus.instance
-# get a rb object
-proxy = bus.introspect("org.gnome.Rhythmbox", "/org/gnome/Rhythmbox/Player")
-proxyi = proxy["org.gnome.Rhythmbox.Player"]
-
-# register for signals
-
-mr = DBus::MatchRule.new
-mr.type = "signal"
-mr.interface = "org.gnome.Rhythmbox.Player"
-mr.path = "/org/gnome/Rhythmbox/Player"
-bus.add_match(mr) do |msg, first_param|
-  print msg.member + " "
-  puts first_param
-end
-
-proxyi.playPause(true)
-
-main = DBus::Main.new
-main << bus
-main.run
-

data/examples/service/call_service.rb

@@ -1,25 +0,0 @@
-#!/usr/bin/ruby
-
-require "dbus"
-
-session_bus = DBus::SessionBus.instance
-
-ruby_srv = session_bus.service("org.ruby.service")
-
-# Get the object from this service
-player = ruby_srv.object("/org/ruby/MyInstance")
-
-# Introspect it
-puts player.introspect
-player.default_iface = "org.ruby.SampleInterface"
-player.test_variant(["s", "coucou"])
-player.on_signal("SomethingJustHappened") do |u, v|
-  puts "SomethingJustHappened: #{u} #{v}"
-end
-player.hello("8=======D", "(_._)")
-p player["org.ruby.AnotherInterface"].Reverse("Hello world!")
-
-main = DBus::Main.new
-main << session_bus
-main.run
-

data/examples/service/service_newapi.rb

@@ -1,51 +0,0 @@
-#!/usr/bin/ruby
-
-require 'dbus'
-require 'thread'
-Thread.abort_on_exception = true
-
-class Test < DBus::Object
-  # Create an interface aggregating all upcoming dbus_method defines.
-  dbus_interface "org.ruby.SampleInterface" do
-    dbus_method :hello, "in name:s, in name2:s" do |name, name2|
-      puts "hello(#{name}, #{name2})"
-    end
-
-    dbus_method :test_variant, "in stuff:v" do |variant|
-      p variant
-    end
-
-    dbus_signal :SomethingJustHappened, "toto:s, tutu:u"
-  end
-
-  dbus_interface "org.ruby.AnotherInterface" do
-    dbus_method :ThatsALongMethodNameIThink do
-      puts "ThatsALongMethodNameIThink"
-    end
-    dbus_method :Reverse, "in instr:s, out outstr:s" do |instr|
-      outstr = instr.split(//).reverse.join
-      puts "got: #{instr}, replying: #{outstr}"
-      [outstr]
-    end
-  end
-end
-
-bus = DBus::SessionBus.instance
-service = bus.request_service("org.ruby.service")
-myobj = Test.new("/org/ruby/MyInstance")
-service.export(myobj)
-
-Thread.new do
-  i = 0
-  loop do 
-    # Signal emission
-    myobj.SomethingJustHappened("hey", i += 1)
-    sleep(0.5)
-  end
-end
-
-puts "listening"
-main = DBus::Main.new
-main << bus
-main.run
-

data/examples/simple/call_introspect.rb

@@ -1,34 +0,0 @@
-#!/usr/bin/ruby
-
-require "dbus"
-
-session_bus = DBus::SessionBus.instance
-
-# Get the Rhythmbox service
-rhythmbox = session_bus.service("org.gnome.Rhythmbox")
-
-# Get the object from this service
-player = rhythmbox.object("/org/gnome/Rhythmbox/Player")
-
-# Introspect it
-player.introspect
-if player.has_iface? "org.gnome.Rhythmbox.Player"
-  puts "We have Rhythmbox Player interface"
-end
-
-player_with_iface = player["org.gnome.Rhythmbox.Player"]
-p player_with_iface.getPlayingUri
-
-# Maybe support default_iface=(iface_str) on an ProxyObject, so
-# that this is possible?
-player.default_iface = "org.gnome.Rhythmbox.Player"
-puts "default_iface test:"
-p player.getPlayingUri
-player.on_signal("elapsedChanged") do |u|
-  puts "elapsedChanged: #{u}"
-end
-
-main = DBus::Main.new
-main << session_bus
-main.run
-

data/examples/utils/listnames.rb

@@ -1,11 +0,0 @@
-#!/usr/bin/ruby
-
-require 'dbus'
-
-d = if ARGV.member?("--system")
-  DBus::SystemBus.instance
-else
-  DBus::SessionBus.instance
-end
-d.proxy.ListNames[0].each{ |n| puts "\t#{n}" }
-

data/examples/utils/notify.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/ruby
-
-require 'dbus'
-
-if ARGV.size < 2
-  puts "Usage:"
-  puts "notify.rb \"title\" \"body\""
-  exit
-end
-
-d = DBus::SessionBus.instance
-o = d.service("org.freedesktop.Notifications").object("/org/freedesktop/Notifications")
-o.introspect
-
-i = o["org.freedesktop.Notifications"]
-
-i.Notify('notify.rb', 0, 'info', ARGV[0], ARGV[1], [], {}, 2000) do |ret, param|
-end
-

data/lib/dbus/connection.rb

@@ -1,468 +0,0 @@
- require 'dbus/bus'
- require 'dbus/auth'
-
-# = D-Bus main module
-#
-# Module containing all the D-Bus modules and classes.
-module DBus 
-  # D-Bus main connection class
-  #
-  # Main class that maintains a connection to a bus and can handle incoming
-  # and outgoing messages.
-  class Connection
-    # The unique name (by specification) of the message.
-    attr_reader :unique_name
-    # The socket that is used to connect with the bus.
-    attr_reader :socket
-
-    # Create a new connection to the bus for a given connect _path_. _path_
-    # format is described in the D-Bus specification:
-      # http://dbus.freedesktop.org/doc/dbus-specification.html#addresses
-    # and is something like:
-    # "transport1:key1=value1,key2=value2;transport2:key1=value1,key2=value2"
-    # e.g. "unix:path=/tmp/dbus-test"
-    #
-    # Current implementation of ruby-dbus supports only a single server
-    # address and only "unix:path=...,guid=..." and
-    # "unix:abstract=...,guid=..." forms
-    def initialize(path)
-      @path = path
-      @unique_name = nil
-      @buffer = ""
-      @method_call_replies = Hash.new
-      @method_call_msgs = Hash.new
-      @signal_matchrules = Array.new
-      @proxy = nil
-      # FIXME: can be TCP or any stream, let's do it.
-      @socket = Socket.new(Socket::Constants::PF_UNIX,Socket::Constants::SOCK_STREAM, 0)
-      @object_root = Node.new("/")
-    end
-
-    # Connect to the bus and initialize the connection.
-    def connect
-      connect_to_unix_abstract
-    end
-
-    # Connect to the bus and initialize the connection.
-    def connect_to_unix_abstract
-      parse_session_string
-      if @transport == "unix" and @type == "abstract"
-        if HOST_END == LIL_END
-          sockaddr = "\1\0\0#{@unix_abstract}"
-        else
-          sockaddr = "\0\1\0#{@unix_abstract}"
-        end
-      elsif @transport == "unix" and @type == "path"
-        sockaddr = Socket.pack_sockaddr_un(@unix)
-      end
-      @socket.connect(sockaddr)
-      init_connection
-    end
-
-    # Send the buffer _buf_ to the bus using Connection#writel.
-    def send(buf)
-      @socket.write(buf)
-    end
-
-    # Tell a bus to register itself on the glib main loop
-    def glibize
-      puts "dbus/bus.rb-221: Entered glibize."
-      require 'glib2'
-      # Circumvent a ruby-glib bug
-      @channels ||= Array.new
-
-      gio = GLib::IOChannel.new(@socket.fileno)
-      @channels << gio
-      gio.add_watch(GLib::IOChannel::IN) do |c, ch|
-        update_buffer
-        messages.each do |msg|
-          process(msg)
-        end
-        true
-      end
-    end
-
-    # FIXME: describe the following names, flags and constants.
-    # See DBus spec for definition
-    NAME_FLAG_ALLOW_REPLACEMENT = 0x1
-    NAME_FLAG_REPLACE_EXISTING = 0x2
-    NAME_FLAG_DO_NOT_QUEUE = 0x4
-
-    REQUEST_NAME_REPLY_PRIMARY_OWNER = 0x1
-    REQUEST_NAME_REPLY_IN_QUEUE = 0x2
-    REQUEST_NAME_REPLY_EXISTS = 0x3
-    REQUEST_NAME_REPLY_ALREADY_OWNER = 0x4
-
-    DBUSXMLINTRO = '<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
-"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
-<node>
-  <interface name="org.freedesktop.DBus.Introspectable">
-    <method name="Introspect">
-      <arg name="data" direction="out" type="s"/>
-    </method>
-  </interface>
-  <interface name="org.freedesktop.DBus">
-    <method name="RequestName">
-      <arg direction="in" type="s"/>
-      <arg direction="in" type="u"/>
-      <arg direction="out" type="u"/>
-    </method>
-    <method name="ReleaseName">
-      <arg direction="in" type="s"/>
-      <arg direction="out" type="u"/>
-    </method>
-    <method name="StartServiceByName">
-      <arg direction="in" type="s"/>
-      <arg direction="in" type="u"/>
-      <arg direction="out" type="u"/>
-    </method>
-    <method name="Hello">
-      <arg direction="out" type="s"/>
-    </method>
-    <method name="NameHasOwner">
-      <arg direction="in" type="s"/>
-      <arg direction="out" type="b"/>
-    </method>
-    <method name="ListNames">
-      <arg direction="out" type="as"/>
-    </method>
-    <method name="ListActivatableNames">
-      <arg direction="out" type="as"/>
-    </method>
-    <method name="AddMatch">
-      <arg direction="in" type="s"/>
-    </method>
-    <method name="RemoveMatch">
-      <arg direction="in" type="s"/>
-    </method>
-    <method name="GetNameOwner">
-      <arg direction="in" type="s"/>
-      <arg direction="out" type="s"/>
-    </method>
-    <method name="ListQueuedOwners">
-      <arg direction="in" type="s"/>
-      <arg direction="out" type="as"/>
-    </method>
-    <method name="GetConnectionUnixUser">
-      <arg direction="in" type="s"/>
-      <arg direction="out" type="u"/>
-    </method>
-    <method name="GetConnectionUnixProcessID">
-      <arg direction="in" type="s"/>
-      <arg direction="out" type="u"/>
-    </method>
-    <method name="GetConnectionSELinuxSecurityContext">
-      <arg direction="in" type="s"/>
-      <arg direction="out" type="ay"/>
-    </method>
-    <method name="ReloadConfig">
-    </method>
-    <signal name="NameOwnerChanged">
-      <arg type="s"/>
-      <arg type="s"/>
-      <arg type="s"/>
-    </signal>
-    <signal name="NameLost">
-      <arg type="s"/>
-    </signal>
-    <signal name="NameAcquired">
-      <arg type="s"/>
-    </signal>
-  </interface>
-</node>
-'
-
-    def introspect_data(dest, path)
-      m = DBus::Message.new(DBus::Message::METHOD_CALL)
-      m.path = path
-      m.interface = "org.freedesktop.DBus.Introspectable"
-      m.destination = dest
-      m.member = "Introspect"
-      m.sender = unique_name
-      if not block_given?
-        # introspect in synchronous !
-        send_sync(m) do |rmsg|
-          if rmsg.is_a?(Error)
-            raise rmsg
-          else
-            return rmsg.params[0]
-          end
-        end
-      else
-        send(m.marshall)
-        on_return(m) do |rmsg|
-          if rmsg.is_a?(Error)
-            yield rmsg
-          else
-            yield rmsg.params[0]
-          end
-        end
-      end
-      nil
-    end
-
-    # Issues a call to the org.freedesktop.DBus.Introspectable.Introspect method
-    # _dest_ is the service and _path_ the object path you want to introspect
-    # If a code block is given, the introspect call in asynchronous. If not
-    # data is returned
-    #
-    # FIXME: link to ProxyObject data definition
-    # The returned object is a ProxyObject that has methods you can call to
-    # issue somme METHOD_CALL messages, and to setup to receive METHOD_RETURN
-    def introspect(dest, path)
-      if not block_given?
-        # introspect in synchronous !
-        data = introspect_data(dest, path)
-        pof = DBus::ProxyObjectFactory.new(data, self, dest, path)
-        return pof.build
-      else
-        introspect_data(dest, path) do |data|
-          yield(DBus::ProxyObjectFactory.new(data, self, dest, path).build)
-        end
-      end
-    end
-
-    # Exception raised when a service name is requested that is not available.
-    class NameRequestError < Exception
-    end
-
-    # Attempt to request a service _name_.
-    def request_service(name)
-      r = proxy.RequestName(name, NAME_FLAG_REPLACE_EXISTING)
-      raise NameRequestError if r[0] != REQUEST_NAME_REPLY_PRIMARY_OWNER
-      @service = Service.new(name, self)
-      @service
-    end
-
-    # Set up a ProxyObject for the bus itself, since the bus is introspectable.
-    # Returns the object.
-    def proxy
-      if @proxy == nil
-        path = "/org/freedesktop/DBus"
-        dest = "org.freedesktop.DBus"
-        pof = DBus::ProxyObjectFactory.new(DBUSXMLINTRO, self, dest, path)
-        @proxy = pof.build["org.freedesktop.DBus"]
-      end
-      @proxy
-    end
-
-    # Fill (append) the buffer from data that might be available on the
-    # socket.
-    def update_buffer
-      @buffer += @socket.read_nonblock(MSG_BUF_SIZE)
-    end
-
-    # Get one message from the bus and remove it from the buffer.
-    # Return the message.
-    def pop_message
-      ret = nil
-      begin
-        ret, size = Message.new.unmarshall_buffer(@buffer)
-        @buffer.slice!(0, size)
-      rescue IncompleteBufferException => e
-        # fall through, let ret be null
-      end
-      ret
-    end
-
-    # Retrieve all the messages that are currently in the buffer.
-    def messages
-      ret = Array.new
-      while msg = pop_message
-        ret << msg
-      end
-      ret
-    end
-
-    # The buffer size for messages.
-    MSG_BUF_SIZE = 4096
-
-    # Update the buffer and retrieve all messages using Connection#messages.
-    # Return the messages.
-    def poll_messages
-      ret = nil
-      r, d, d = IO.select([@socket], nil, nil, 0)
-      if r and r.size > 0
-        update_buffer
-      end
-      messages
-    end
-
-    # Wait for a message to arrive. Return it once it is available.
-    def wait_for_message
-      ret = pop_message
-      while ret == nil
-        r, d, d = IO.select([@socket])
-        if r and r[0] == @socket
-          update_buffer
-          ret = pop_message
-        end
-      end
-      ret
-    end
-
-    # Send a message _m_ on to the bus. This is done synchronously, thus
-    # the call will block until a reply message arrives.
-    def send_sync(m, &retc) # :yields: reply/return message
-      send(m.marshall)
-      @method_call_msgs[m.serial] = m
-      @method_call_replies[m.serial] = retc
-
-      retm = wait_for_message
-      process(retm)
-      until [DBus::Message::ERROR,
-          DBus::Message::METHOD_RETURN].include?(retm.message_type) and
-          retm.reply_serial == m.serial
-        retm = wait_for_message
-        process(retm)
-      end
-    end
-
-    # Specify a code block that has to be executed when a reply for
-    # message _m_ is received.
-    def on_return(m, &retc)
-      # Have a better exception here
-      if m.message_type != Message::METHOD_CALL
-        raise "on_return should only get method_calls"
-      end
-      @method_call_msgs[m.serial] = m
-      @method_call_replies[m.serial] = retc
-    end
-
-    # Asks bus to send us messages matching mr, and execute slot when
-    # received
-    def add_match(mr, &slot)
-      # check this is a signal.
-      @signal_matchrules << [mr, slot]
-      self.proxy.AddMatch(mr.to_s)
-    end
-
-    # Process a message _m_ based on its type.
-    # method call:: FIXME...
-    # method call return value:: FIXME...
-    # signal:: FIXME...
-    # error:: FIXME...
-    def process(m)
-      case m.message_type
-      when Message::ERROR, Message::METHOD_RETURN
-        raise InvalidPacketException if m.reply_serial == nil
-        mcs = @method_call_replies[m.reply_serial]
-        if not mcs
-          puts "no return code for #{mcs.inspect} (#{m.inspect})" if $DEBUG
-        else
-          if m.message_type == Message::ERROR
-            mcs.call(Error.new(m))
-          else
-            mcs.call(m)
-          end
-          @method_call_replies.delete(m.reply_serial)
-          @method_call_msgs.delete(m.reply_serial)
-        end
-      when DBus::Message::METHOD_CALL
-        if m.path == "/org/freedesktop/DBus"
-          puts "Got method call on /org/freedesktop/DBus" if $DEBUG
-        end
-        # handle introspectable as an exception:
-        if m.interface == "org.freedesktop.DBus.Introspectable" and
-            m.member == "Introspect"
-          reply = Message.new(Message::METHOD_RETURN).reply_to(m)
-          reply.sender = @unique_name
-          node = @service.get_node(m.path)
-          raise NotImplementedError if not node
-          reply.sender = @unique_name
-          reply.add_param(Type::STRING, @service.get_node(m.path).to_xml)
-          send(reply.marshall)
-        else
-          node = @service.get_node(m.path)
-          return if node.nil?
-          obj = node.object
-          return if obj.nil?
-          obj.dispatch(m) if obj
-        end
-      when DBus::Message::SIGNAL
-        @signal_matchrules.each do |elem|
-          mr, slot = elem
-          if mr.match(m)
-            slot.call(m)
-            return
-          end
-        end
-      else
-        puts "Unknown message type: #{m.message_type}" if $DEBUG
-      end
-    end
-
-    # Retrieves the service with the given _name_.
-    def service(name)
-      # The service might not exist at this time so we cannot really check
-      # anything
-      Service.new(name, self)
-    end
-    alias :[] :service
-
-    # Emit a signal event for the given _service_, object _obj_, interface
-    # _intf_ and signal _sig_ with arguments _args_.
-    def emit(service, obj, intf, sig, *args)
-      m = Message.new(DBus::Message::SIGNAL)
-      m.path = obj.path
-      m.interface = intf.name
-      m.member = sig.name
-      m.sender = service.name
-      i = 0
-      sig.params.each do |par|
-        m.add_param(par[1], args[i])
-        i += 1
-      end
-      send(m.marshall)
-    end
-
-    ###########################################################################
-    private
-
-    # Send a hello messages to the bus to let it know we are here.
-    def send_hello
-      m = Message.new(DBus::Message::METHOD_CALL)
-      m.path = "/org/freedesktop/DBus"
-      m.destination = "org.freedesktop.DBus"
-      m.interface = "org.freedesktop.DBus"
-      m.member = "Hello"
-      send_sync(m) do |rmsg|
-        @unique_name = rmsg.destination
-        puts "Got hello reply. Our unique_name is #{@unique_name}" if $DEBUG
-      end
-    end
-
-    # Parse the session string (socket address).
-    def parse_session_string
-      path_parsed = /^([^:]*):([^;]*)$/.match(@path)
-      @transport = path_parsed[1]
-      adr = path_parsed[2]
-      if @transport == "unix"
-        adr.split(",").each do |eqstr|
-          idx, val = eqstr.split("=")
-          case idx
-          when "path"
-            @type = idx
-            @unix = val
-          when "abstract"
-            @type = idx
-            @unix_abstract = val
-          when "guid"
-            @guid = val
-          end
-        end
-      end
-    end
-
-    # Initialize the connection to the bus.
-    def init_connection
-      @client = Client.new(@socket)
-      @client.authenticate
-      # TODO: code some real stuff here
-      #writel("AUTH EXTERNAL 31303030")
-      #s = readl
-      # parse OK ?
-      #writel("BEGIN")
-    end
-  end # class Connection
-end # module DBus