emdrb 0.1.1 → 0.1.2

data/README.txt

@@ -12,8 +12,9 @@ available in the Ruby standard library.
 
 This is a simple but working DRb server implementation that uses
 EventMachine as its basis, rather than the default implementation that
-uses traditional Ruby sockets.  This should be somewhat more scalable
-than a server using the standard DRb library.
+uses traditional Ruby sockets.  This should at the very least play
+better with other programs that have an EventMachine event loop, and
+hopefully provide somewhat better scalability.
 
 Obviously, this is a quick and dirty release, just to get something
 out there, and of course it has a number of limitations.
@@ -47,6 +48,8 @@ making one with the standard library DRb:
   EMDRb.start_service(URI, TimeServer.new)
   EMDRb.thread.join
 
+It is also possible to create 
+
 == REQUIREMENTS:
 
 * Obviously, EMDRb requires EventMachine.

data/lib/emdrb/emdrb.rb

@@ -4,7 +4,7 @@
 # Homepage:: http://emdrb.rubyforge.org/
 # License:: GNU General Public License / Ruby License
 #
-# $Id: emdrb.rb 17 2008-12-02 03:58:23Z dido $
+# $Id: emdrb.rb 28 2009-01-22 05:13:01Z dido $
 #
 #----------------------------------------------------------------------------
 #
@@ -27,10 +27,78 @@ module EMDRb
   DEFAULT_LOAD_LIMIT = 256 * 102400
   DEFAULT_SAFE_LEVEL = 0
 
+  ##
+  # Common protocol elements for distributed Ruby, used by both the
+  # client and server.
+  #
+  module DRbProtocolCommon
+    ##
+    # This method will dump an object +obj+ using Ruby's marshalling
+    # capabilities.  It will make a proxy to the object instead if
+    # the object is undumpable.  The dumps are basically data produced
+    # by Marshal::dump prefixed by a 32-bit length field in network
+    # byte order.
+    #
+    def dump(obj, error=false)
+      if obj.kind_of? DRb::DRbUndumped
+        obj = make_proxy(obj, error)
+      end
+      begin
+        str = Marshal::dump(obj)
+      rescue
+        str = Marshal::dump(make_proxy(obj, error))
+      end
+      return([str.size].pack("N") + str)
+    end
+
+    ##
+    # Create a proxy for +obj+ that is declared to be undumpable.
+    #
+    def make_proxy(obj, error=false)
+      return(error ? DRb::DRbRemoteError.new(obj) : DRb::DRbObject.new(obj))
+    end
+
+    ##
+    # Receive data from the caller.  This basically receives packets
+    # containing objects marshalled using Ruby's Marshal::dump prefixed
+    # by a length.  These objects are unmarshalled and processed by the
+    # internal object request state machine (DRbServerProtocol#receive_obj
+    # below).  If an error of any kind occurs herein, the exception is
+    # propagated to the caller.
+    def receive_data(data)
+      @msgbuffer << data
+      while @msgbuffer.length > 4
+        length = @msgbuffer.unpack("N")[0]
+        if length > @load_limit
+          raise DRb::DRbConnError, "too large packet #{length}"
+        end
+
+        if @msgbuffer.length < length - 4
+          # not enough data for this length, return to event loop
+          # to wait for more.
+          break
+        end
+        length, message, @msgbuffer = @msgbuffer.unpack("Na#{length}a*")
+        receive_obj(obj_load(message))
+      end
+    end
+
+    ##
+    # Load a serialized object.
+    def obj_load(message)
+      begin
+        return(Marshal::load(message))
+      rescue NameError, ArgumentError
+        return(DRb::DRbUnknown.new($!, message))
+      end
+    end
+  end
+
   ##
   # EventMachine server module for DRb.
   #
   module DRbServerProtocol
+    include DRbProtocolCommon
     ##
     # The front object for this server connection.
     attr_accessor :front
@@ -80,69 +148,15 @@ module EMDRb
       @server = @argv = @argc = nil
     end
 
-    ##
-    # Receive data from the caller.  This basically receives packets
-    # containing objects marshalled using Ruby's Marshal::dump prefixed
-    # by a length.  These objects are unmarshalled and processed by the
-    # internal object request state machine.  If an error of any kind
-    # occurs herein, the exception is propagated to the caller.
-    def receive_data(data)
-      begin
-        @msgbuffer << data
-        while @msgbuffer.length > 4
-          length = @msgbuffer.unpack("N")[0]
-          if length > @load_limit
-            raise DRb::DRbConnError, "too large packet #{length}"
-          end
-          
-          if @msgbuffer.length < length - 4
-            # not enough data for this length, return to event loop
-            # to wait for more.
-            break
-          end
-          length, message, @msgbuffer = @msgbuffer.unpack("Na#{length}a*")
-          add_obj(obj_load(message))
-        end
-      rescue Exception => e
-        send_reply(false, e)
-      end
-    end
-
     private
 
-    ##
-    # This method will dump an object +obj+ using Ruby's marshalling
-    # capabilities.  It will make a proxy to the object instead if
-    # the object is undumpable.  The dumps are basically data produced
-    # by Marshal::dump prefixed by a 32-bit length field in network
-    # byte order.
-    #
-    def dump(obj, error=false)
-      if obj.kind_of? DRb::DRbUndumped
-        obj = make_proxy(obj, error)
-      end
-      begin
-        str = Marshal::dump(obj)
-      rescue
-        str = Marshal::dump(make_proxy(obj, error))
-      end
-      return([str.size].pack("N") + str)
-    end
-
-    ##
-    # Create a proxy for +obj+ that is declared to be undumpable.
-    #
-    def make_proxy(obj, error=false)
-      return(error ? Drb::DRbRemoteError.new(obj) : DRb::DRbObject.new(obj))
-    end
-
     ##
     # Send a reply to the caller.  The return value for distributed Ruby
     # over the wire is the success as a boolean true or false value, followed
     # by a dump of the data.
     #
     def send_reply(succ, result)
-      send_data(dump(succ) + dump(result, !succ))        
+      send_data(dump(succ) + dump(result, !succ))
     end
 
     ##
@@ -229,7 +243,22 @@ module EMDRb
       return(@idconv.to_obj(ref))
     end
 
-    def add_obj(obj)
+    ##
+    # This is the main state machine that processes distributed Ruby calls.
+    # A DRb client basically sends several pieces of data in sequence, each
+    # of which corresponds to a state of this machine.
+    #
+    # 1. :ref - this gives a reference to a DRb server running on the
+    #    caller, mainly used to provide a mechanism for accessing undumpable
+    #    objects on the caller.
+    # 2. :msg - a symbol giving the method to be called on this server.
+    # 3. :argc - an integer count of the number of arguments on the caller.
+    # 4. :argv - repeats an :argc number of times, the actual arguments
+    #    sent by the caller.
+    # 5. :block - the block passed by the caller (generally a DRbObject
+    #    wrapping a Proc object).
+    #
+    def receive_obj(obj)
       @request[@state] = obj
       case @state
       when :ref
@@ -252,7 +281,7 @@ module EMDRb
           @state = :block
         end
       when :block
-        @request[:argv] = @argv        
+        @request[:argv] = @argv
         @state = :ref
         send_reply(*perform)
         @request = {}
@@ -262,18 +291,13 @@ module EMDRb
       end
     end
 
-    ##
-    # Load a serialized object.
-    def obj_load(message)
-      begin
-        return(Marshal::load(message))
-      rescue NameError, ArgumentError
-        return(DRb::DRbUnknown.new($!, message))
-      end
-    end
-
   end
 
+  ##
+  # Class representing a drb server instance.  This subclasses DRb::DRbServer
+  # for brevity.  DRbServer instances are normally created indirectly using
+  # either EMDRb.start service (which emulates DRb.start_service) or via
+  # EMDRb.start_drbserver (designed to be called from within an event loop).
   class DRbServer < DRb::DRbServer
     def initialize(uri=nil, front=nil, config_or_acl=nil)
       if Hash === config_or_acl
@@ -290,8 +314,6 @@ module EMDRb
       @front = front
       @idconv = @config[:idconv]
       @safe_level = @config[:safe_level]
-      @thread = run
-      EMDRb.regist_server(self)
     end
 
     private
@@ -319,23 +341,25 @@ module EMDRb
       end
     end
 
-    def run
-      Thread.start do
-        host, port, opt = EMDRb::parse_uri(@uri)
-        if host.size == 0
-          host = self.class.host_inaddr_any
-        end
-        EventMachine::run do
-          EventMachine::start_server(host, port, DRbServerProtocol) do |conn|
-            Thread.current['DRb'] = { 'client' => conn, 'server' => self }
-            conn.front = @front
-            conn.load_limit = @config[:load_limit]
-            conn.argc_limit = @config[:argc_limit]
-            conn.idconv = @config[:idconv]
-            conn.server = self
-            conn.safe_level = self.safe_level
-          end
-        end
+    public
+
+    ##
+    # Start a DRb server from within an event loop.
+    #
+    def start_drb_server
+      @thread = Thread.current
+      host, port, opt = EMDRb::parse_uri(@uri)
+      if host.size == 0
+        host = self.class.host_inaddr_any
+      end
+      EventMachine::start_server(host, port, DRbServerProtocol) do |conn|
+        Thread.current['DRb'] = { 'client' => conn, 'server' => self }
+        conn.front = @front
+        conn.load_limit = @config[:load_limit]
+        conn.argc_limit = @config[:argc_limit]
+        conn.idconv = @config[:idconv]
+        conn.server = self
+        conn.safe_level = self.safe_level
       end
     end
 
@@ -357,9 +381,38 @@ module EMDRb
   module_function :parse_uri
 
   @primary_server = nil
+  @eventloop = nil
 
+  ##
+  # This is the 'bare bones' start_service which can be used to
+  # start a DRb service from within an existing event loop.
+  def start_drbserver(uri=nil, front=nil, config=nil)
+    serv = DRbServer.new(uri, front, config)
+    serv.start_drb_server
+    return(serv)
+  end
+  module_function :start_drbserver
+
+  ##
+  # This start_service emulates DRb#start_service.
+  #
   def start_service(uri=nil, front=nil, config=nil)
-    @primary_server = DRbServer.new(uri, front, config)
+    unless EventMachine::reactor_running?
+      @eventloop = Thread.new do
+        EventMachine::run do
+          # Start an empty event loop.  The DRb server(s) will be started
+          # by EM#next_tick calls.
+        end
+      end
+    end
+    queue = Queue.new
+    EventMachine::next_tick do
+      queue << self.start_drbserver(uri, front, config)
+    end
+    serv = queue.shift
+    @primary_server = serv
+    EMDRb.regist_server(serv)
+    return(serv)
   end
   module_function :start_service
 
@@ -403,4 +456,93 @@ module EMDRb
   end
   module_function :thread
 
+
+  ##
+  # Client protocol module 
+  module DRbClientProtocol
+    include DRbProtocolCommon
+
+    attr_accessor :ref
+    attr_accessor :msg_id
+    attr_accessor :args
+    attr_accessor :block
+    attr_accessor :df
+
+    def post_init
+      @msgbuffer = ""
+      @idconv = DRb::DRbIdConv.new
+      @load_limit = DEFAULT_LOAD_LIMIT
+    end
+
+    def connection_completed
+      @connected = true
+      send_request(@ref, @msg_id, @args, @block)
+      @state = :succ
+      @succ = nil
+      @result = nil
+    end
+
+    def send_request(ref, msgid, arg, block)
+      ary = []
+      ary.push(dump(ref.__drbref))
+      ary.push(dump(msg_id.id2name))
+      ary.push(dump(arg.length))
+      arg.each do |e|
+	ary.push(dump(e))
+      end
+      ary.push(dump(block))
+      send_data(ary.join(''))
+    end
+
+    def receive_obj(obj)
+      if @state == :succ
+        @succ = obj
+        @state = :result
+      else
+        @result = obj
+        @state = :succ
+        @df.set_deferred_status(:succeeded, [@succ, @result])
+        # close the connection after the call succeeds.
+        close_connection
+      end
+    end
+  end
+
+  ##
+  # Object wrapping a reference to a remote drb object.
+  #
+  # Method calls on this object are relayed to the remote object
+  # that this object is a stub for.
+  class DRbObject < DRb::DRbObject
+    def initialize(obj, uri=nil)
+      @uri = nil
+      @ref = nil
+      if obj.nil?
+	return if uri.nil?
+        @uri = uri
+        ref = nil
+        @host, @port, @opt = EMDRb::parse_uri(@uri)
+      else
+        @ref = obj
+      end
+    end
+
+    ##
+    # Perform an asynchronous call to the remote object.  This can only
+    # be used from within an event loop.  It returns a deferrable to which
+    # callbacks can be attached.
+    def send_async(msg_id, *a, &b)
+      df = EventMachine::DefaultDeferrable.new
+      EventMachine.connect(@host, @port, DRbClientProtocol) do |c|
+        c.ref = self
+        c.msg_id = msg_id
+        c.args = a
+        c.block = b
+        c.df = df
+      end
+      return(df)
+    end
+
+  end
+
 end

data/lib/emdrb/version.rb

@@ -4,7 +4,7 @@
 # Homepage:: http://emdrb.rubyforge.org/
 # License:: GNU Lesser General Public License / Ruby License
 #
-# $Id: version.rb 20 2008-12-02 04:00:25Z dido $
+# $Id: version.rb 26 2009-01-22 04:48:43Z dido $
 #
 #----------------------------------------------------------------------------
 #
@@ -26,7 +26,7 @@ module EMDRb
 
     MAJOR = 0
     MINOR = 1
-    TINY = 1
+    TINY = 2
 
     # The version of EMDRb in use.
     STRING = [ MAJOR, MINOR, TINY ].join(".")

data/test/test_emdrb.rb

@@ -4,7 +4,7 @@
 # Homepage:: http://emdrb.rubyforge.org/
 # License:: GNU General Public License / Ruby License
 #
-# $Id: test_emdrb.rb 19 2008-12-02 03:59:14Z dido $
+# $Id: test_emdrb.rb 27 2009-01-22 05:11:56Z dido $
 #
 #----------------------------------------------------------------------------
 #
@@ -46,8 +46,15 @@ class TestServer
 end
 
 class EMDRbTest < Test::Unit::TestCase
-  def test_drb
+  def setup
     EMDRb.start_service("druby://:12345", TestServer.new)
+  end
+
+  def teardown
+    EMDRb.thread.kill
+  end
+
+  def test_server
     o = DRbObject.new_with_uri("druby://localhost:12345")
     DRb.start_service
     assert_equal(1, o.identity(1))
@@ -61,4 +68,29 @@ class EMDRbTest < Test::Unit::TestCase
     assert_equal(5040, val)
   end
 
+  def test_client
+    o = EMDRb::DRbObject.new(nil, "druby://localhost:12345")
+    q = Queue.new
+    EventMachine::next_tick do
+      o.send_async(:identity, 1).callback do |data|
+        assert(data[0])
+        assert_equal(1, data[1])
+        q << data
+      end
+    end
+    q.shift
+
+#    EventMachine::next_tick do
+#      val = 1
+#      df = o.send_async(:blockyield, 1,2,3,4,5,6,7) { |x| val *= x; val }
+#      df.callback do |data|
+#        assert(data[0])
+#        assert_equal(5040, data[1])
+#        q << data
+#      end
+#    end
+#    q.shift
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: emdrb
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - dido@imperium.ph
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-02 00:00:00 +08:00
+date: 2009-01-22 00:00:00 +08:00
 default_executable: 
 dependencies: []