emdrb 0.1.2 → 0.2.0

data/History.txt

@@ -1,7 +1,17 @@
-== 0.1.0 / 2008-10-23
+== 0.2.0 / 2009-01-23
 
-* First public release
+* DRb client implementation, including asynchronous calls.
+* Changes so that DRb functionality is as untouched as possible.
+
+== 0.1.2 / 2009-01-21
+
+* Maintenance release
 
 == 0.1.1 / 2008-12-02
 
 * Basic unit tests
+
+== 0.1.0 / 2008-10-23
+
+* First public release
+

data/LEGAL

@@ -1,7 +1,7 @@
 LEGAL NOTICE INFORMATION
 ------------------------
 
-EMDRb is Copyright (C) 2008 by Rafael Sevilla.
+EMDRb is Copyright © 2008, 2009 by Rafael Sevilla.
 
 EMDRb is copyrighted software owned by Rafael Sevilla (dido
 ... imperium.ph).  You may redistribute and/or modify this software as

data/Manifest.txt

@@ -7,6 +7,11 @@ Rakefile
 lib/emdrb.rb
 lib/emdrb/emdrb.rb
 lib/emdrb/version.rb
+spec/client_spec.rb
+spec/drbserver.rb
+spec/server_spec.rb
+spec/spec_common.rb
+spec/spec_helper.rb
 tasks/ann.rake
 tasks/bones.rake
 tasks/gem.rake
@@ -20,4 +25,3 @@ tasks/setup.rb
 tasks/spec.rake
 tasks/svn.rake
 tasks/test.rake
-test/test_emdrb.rb

data/README.txt

@@ -10,20 +10,19 @@ available in the Ruby standard library.
 
 == FEATURES/PROBLEMS:
 
-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 at the very least play
-better with other programs that have an EventMachine event loop, and
-hopefully provide somewhat better scalability.
+This is a simple but working DRb client/server implementation that
+uses EventMachine as its basis, rather than the default implementation
+that 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.
+out there, and of course it has a number of limitations:
 
-* We still don't have a DRb client.  We use the client implementation
-  of the standard DRb.
 * No SSL support.
 * No support for ACLs.
-* No unit tests so it probably still has a lot of bugs.
+* No support for DRb over Unix domain sockets.
+* RSpec tests are very basic, and need a lot more comprehensive work.
 * Many standard configuration options for DRb still unsupported
 
 These and many other problems are scheduled to be addressed in the
@@ -31,8 +30,11 @@ next release.
 
 == SYNOPSIS:
 
-Creating a server using EMDRb has been made as close as possible to
-making one with the standard library DRb:
+EMDRb basically reopens several classes and adds methods and overrides
+some methods in the basic distributed Ruby implementation to make it
+use EventMachine's infrastructure instead of the normal networking
+layer.  One could do the following, which is practically identical to
+one of the examples for distributed Ruby:
 
   require 'emdrb'
 
@@ -45,10 +47,35 @@ making one with the standard library DRb:
   end
 
   $SAFE=1
-  EMDRb.start_service(URI, TimeServer.new)
-  EMDRb.thread.join
+  DRb.start_service(URI, TimeServer.new)
+  DRb.thread.join
 
-It is also possible to create 
+The corresponding client code could be made nearly identical:
+
+  require 'emdrb'
+
+  SERVER_URI="druby://localhost:8787"
+
+  DRb.start_service
+   
+  timeserver = DRbObject.new_with_uri(SERVER_URI)
+  puts timeserver.get_current_time 
+
+Or it could be written to use of asynchronous calls:
+
+  require 'emdrb'
+
+  SERVER_URI="druby://localhost:8787"
+
+  DRb.start_service
+   
+  timeserver = DRbObject.new_with_uri(SERVER_URI)
+
+  EventMachine::next_tick do
+    timeserver.async_call(:get_current_time).callback do |res|
+      puts res
+    end
+  end
 
 == REQUIREMENTS:
 
@@ -58,11 +85,16 @@ It is also possible to create
 
 * Standard gem installation: 'sudo gem install' ought to do the trick.
 
-== LICENSE:
+Note that you will need the daemons gem ('sudo gem install daemons')
+if you would like to run the rspec tests that are included with
+EMDRb.  Daemons is not required to use EMDRb otherwise, and as such it
+is not listed as a hard dependency in the gem install.
 
-Copyright (c) 2008 Rafael R. Sevilla.  You can redistribute it and/or
-modify it under the same terms as Ruby.  Please see the file COPYING for
-more details.
+== LICENSE:
 
+Copyright © 2008, 2009 Rafael R. Sevilla.  You can redistribute it
+and/or modify it under the same terms as Ruby.  Please see the file
+COPYING for more details.
 
+$Id: README.txt 63 2009-01-23 09:15:55Z dido $
 

data/Rakefile

@@ -1,12 +1,31 @@
 #  -*- Ruby -*-
-# $Id: Rakefile 18 2008-12-02 03:58:53Z dido $
+#
+# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
+# Copyright:: Copyright © 2008, 2009 Rafael R. Sevilla
+# Homepage:: http://emdrb.rubyforge.org/
+# License:: GNU General Public License / Ruby License
+#
+# $Id: Rakefile 61 2009-01-23 09:11:43Z dido $
+#
+#----------------------------------------------------------------------------
+#
+# Copyright © 2008, 2009 Rafael Sevilla
+# This file is part of EMDRb
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#----------------------------------------------------------------------------
 #
 load 'tasks/setup.rb'
 
 ensure_in_path 'lib'
 require 'emdrb/version'
 
-task :default => 'test:run'
+task :default => 'spec:run'
 
 PROJ.name = 'emdrb'
 PROJ.authors = 'dido@imperium.ph'
@@ -15,7 +34,6 @@ PROJ.url = 'http://emdrb.rubyforge.org'
 PROJ.rubyforge.name = 'emdrb'
 PROJ.version = EMDRb::Version::STRING
 PROJ.dependencies = ["eventmachine"]
-PROJ.rcov.opts += ["-Ilib"] # Why is this necessary?
 
 PROJ.spec.opts << '--color'
 

data/lib/emdrb/emdrb.rb

@@ -1,14 +1,14 @@
 #
 # Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
-# Copyright:: Copyright (c) 2008 Rafael R. Sevilla
+# Copyright:: Copyright © 2008, 2009 Rafael R. Sevilla
 # Homepage:: http://emdrb.rubyforge.org/
 # License:: GNU General Public License / Ruby License
 #
-# $Id: emdrb.rb 28 2009-01-22 05:13:01Z dido $
+# $Id: emdrb.rb 49 2009-01-23 08:51:47Z dido $
 #
 #----------------------------------------------------------------------------
 #
-# Copyright (C) 2008 Rafael Sevilla
+# Copyright © 2008, 2009 Rafael Sevilla
 # This file is part of EMDRb
 #
 # This program is free software; you can redistribute it and/or modify
@@ -20,9 +20,10 @@
 #----------------------------------------------------------------------------
 #
 require 'eventmachine'
+require 'thread'
 require 'drb'
 
-module EMDRb
+module DRb
   DEFAULT_ARGC_LIMIT = 256
   DEFAULT_LOAD_LIMIT = 256 * 102400
   DEFAULT_SAFE_LEVEL = 0
@@ -40,7 +41,7 @@ module EMDRb
     # byte order.
     #
     def dump(obj, error=false)
-      if obj.kind_of? DRb::DRbUndumped
+      if obj.kind_of? DRbUndumped
         obj = make_proxy(obj, error)
       end
       begin
@@ -55,22 +56,21 @@ module EMDRb
     # 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))
+      return(error ? DRbRemoteError.new(obj) : 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)
+    # internal object request state machine which should be represented by
+    # a receive_obj method from within the mixin.
+    def receive_data_raw(data)
       @msgbuffer << data
       while @msgbuffer.length > 4
         length = @msgbuffer.unpack("N")[0]
         if length > @load_limit
-          raise DRb::DRbConnError, "too large packet #{length}"
+          raise DRbConnError, "too large packet #{length}"
         end
 
         if @msgbuffer.length < length - 4
@@ -89,7 +89,7 @@ module EMDRb
       begin
         return(Marshal::load(message))
       rescue NameError, ArgumentError
-        return(DRb::DRbUnknown.new($!, message))
+        return(DRbUnknown.new($!, message))
       end
     end
   end
@@ -161,79 +161,111 @@ module EMDRb
 
     ##
     # This method will perform a method action if a block is not specified.
-    #
+    # For symmetry with perform_with_block, this method returns a deferrable
+    # instead of the actual value or exception as the case may be.  It will
+    # also further execute the method call in its own independent thread
+    # and safe level invocations are also taken care of herein.
     def perform_without_block
-      if Proc == @front && @request[:msg] == :__drb_yield
-        ary = (@request[:argv].size == 1) ? @request[:argv] : [@request[:argv]]
-        return(ary.collect(&@front)[0])
+      df = EventMachine::DefaultDeferrable.new
+      info = Thread.current['DRb']
+      req = @request
+      Thread.new do
+        Thread.current['DRb'] = info
+        if $SAFE < @safe_level
+          $SAFE = @safe_level
+        end
+        begin
+          if Proc == req[:ro] && req[:msg] == :__drb_yield
+            ary = (req[:argv].size == 1) ? req[:argv] :
+              [req[:argv]]
+            EventMachine::next_tick do
+              df.set_deferred_status(:succeeded, ary.collect(&@front)[0])
+            end
+          else
+            r = req[:ro].__send__(req[:msg], *req[:argv])
+            EventMachine::next_tick do
+              df.set_deferred_status(:succeeded, r)
+            end
+          end
+        rescue
+          p $!
+          EventMachine::next_tick do
+            df.set_deferred_status(:failed, $!)
+          end
+        end
       end
-      return(@front.__send__(@request[:msg], *@request[:argv]))
+      return(df)
     end
 
     ##
     # block_yield method lifted almost verbatim from InvokeMethod18Mixin
     # from the standard distributed Ruby.  Obviously, since EventMachine
     # doesn't work with Ruby 1.6.x, we don't care about the 1.6 version...
-    #
-    def block_yield(x)
+    # Since this performs a synchronous DRb call, we need to execute this
+    # within a thread of its own.
+    def block_yield(req, x)
       if x.size == 1 && x[0].class == Array
-        x[0] = DRb::DRbArray.new(x[0])
+        x[0] = DRbArray.new(x[0])
       end
-      block_value = @request[:block].call(*x)
+      block_value = req[:block].call(*x)
+      return(block_value)
     end
 
     ##
-    # Perform with a method action with a specified block.
-    #
+    # Perform with a method action with a specified block.  We have to
+    # do the action within a thread of its own in order to avoid deadlock
+    # due to the call in block_yield above, which uses synchronous calls.
+    # I suppose there must be a way to do it without using threads (possibly
+    # by using call/cc perhaps?), but I suppose this should be okay.
     def perform_with_block
-      @front.__send__(@request[:msg], *@request[:argv]) do |*x|
-        jump_error = nil
-        begin
-          block_value = block_yield(x)
-        rescue LocalJumpError
-          jump_error = $!
+      df = EventMachine::DefaultDeferrable.new
+      info = Thread.current['DRb']
+      req = @request
+      Thread.new do
+        Thread.current['DRb'] = info
+        if $SAFE < @safe_level
+          $SAFE = @safe_level
         end
-        if jump_error
-          case jump_error.reason
-          when :retry
-            retry
-          when :break
-            break(jump_error.exit_value)
-          else
-            raise jump_error
+        begin
+          r = req[:ro].__send__(req[:msg], *req[:argv]) { |*x|
+            jump_error = nil
+            block_value = nil
+            begin
+              block_value = block_yield(req, x)
+            rescue LocalJumpError
+              jump_error = $!
+            end
+            if jump_error
+              case jump_error.reason
+              when :retry
+                retry
+              when :break
+                break(jump_error.exit_value)
+              else
+                raise jump_error
+              end
+            end
+            block_value
+          }
+          EventMachine::next_tick { df.set_deferred_status(:succeeded, r) }
+        rescue Exception => e
+          EventMachine::next_tick do
+            df.set_deferred_status(:failed, e)
           end
         end
-        block_value
       end
+      return(df)
     end
 
     ##
-    # Perform a method action.  This handles the safe level invocations.
+    # Perform a method action.  This returns a deferrable that gets
+    # posted to succeeded or failed depending on whether the method
+    # call did not raise or raised an exception while it was being
+    # executed.
     #
     def perform
-      result = nil
-      succ = false
-      begin
-        @server.check_insecure_method(@front, @request[:msg])
-        if $SAFE < @safe_level
-          info = Thread.current['DRb']
-          result = Thread.new {
-            Thread.current['DRb'] = info
-            $SAFE = @safe_level
-            (@request[:block]) ? perform_with_block : perform_without_block
-          }.value
-        else
-          result = (@request[:block]) ? perform_with_block :
-            perform_without_block
-          succ = true
-          if @request[:msg] == :to_ary && result.class == Array
-            result = DRb::DRbArray.new(result)
-          end
-        end
-      rescue StandardError, ScriptError, Interrupt
-        result = $!
-      end
-      return([succ, result])
+      @server.check_insecure_method(@request[:ro], @request[:msg])
+      return((@request[:block]) ? perform_with_block : perform_without_block)
     end
 
     def to_obj(ref)
@@ -283,7 +315,16 @@ module EMDRb
       when :block
         @request[:argv] = @argv
         @state = :ref
-        send_reply(*perform)
+        df = perform
+        df.callback do |result|
+          if @request[:msg] == :to_ary && result.class == Array
+            result = DRb::DRbArray.new(result)
+          end
+          send_reply(true, result)
+        end
+        df.errback do |error|
+          send_reply(false, error)
+        end
         @request = {}
         @argc = @argv = nil
       else
@@ -291,6 +332,18 @@ module EMDRb
       end
     end
 
+    ##
+    # This version of receive_data will propagate any exceptions thrown
+    # by receive_data_raw back to the caller.  This includes load limit
+    # errors and other miscellanea.
+    def receive_data(data)
+      begin
+        return(receive_data_raw(data))
+      rescue Exception => e
+        return(send_reply(false, e))
+      end
+    end
+
   end
 
   ##
@@ -298,7 +351,7 @@ module EMDRb
   # 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
+  class DRbServer
     def initialize(uri=nil, front=nil, config_or_acl=nil)
       if Hash === config_or_acl
 	config = config_or_acl.dup
@@ -314,6 +367,9 @@ module EMDRb
       @front = front
       @idconv = @config[:idconv]
       @safe_level = @config[:safe_level]
+      EventMachine::next_tick do
+        @thread = Thread.current
+      end
     end
 
     private
@@ -348,11 +404,11 @@ module EMDRb
     #
     def start_drb_server
       @thread = Thread.current
-      host, port, opt = EMDRb::parse_uri(@uri)
+      host, port, opt = DRb::parse_uri_drb(@uri)
       if host.size == 0
         host = self.class.host_inaddr_any
       end
-      EventMachine::start_server(host, port, DRbServerProtocol) do |conn|
+      r = EventMachine::start_server(host, port, DRbServerProtocol) do |conn|
         Thread.current['DRb'] = { 'client' => conn, 'server' => self }
         conn.front = @front
         conn.load_limit = @config[:load_limit]
@@ -361,11 +417,18 @@ module EMDRb
         conn.server = self
         conn.safe_level = self.safe_level
       end
+      # NOTE: This is an undocumented method in EventMachine.  Revise
+      # as necessary when we receive feedback from the EventMachine
+      # developers on the canonical way to determine the real port number
+      # if port 0 was specified in start_server.
+      addr = Socket.unpack_sockaddr_in(EventMachine.get_sockname(r))
+      port = addr[0] if port == 0
+      @uri = "druby://#{host}:#{port}"
     end
 
   end
 
-  def parse_uri(uri)
+  def parse_uri_drb(uri)
     if uri =~ /^druby:\/\/(.*?):(\d+)(\?(.*))?$/
       host = $1
       port = $2.to_i
@@ -378,9 +441,8 @@ module EMDRb
       raise DRb::DRbBadURI.new('can\'t parse uri:' + uri)
     end
   end
-  module_function :parse_uri
+  module_function :parse_uri_drb
 
-  @primary_server = nil
   @eventloop = nil
 
   ##
@@ -411,52 +473,11 @@ module EMDRb
     end
     serv = queue.shift
     @primary_server = serv
-    EMDRb.regist_server(serv)
+    DRb.regist_server(serv)
     return(serv)
   end
   module_function :start_service
 
-  attr_accessor :primary_server
-  module_function :primary_server=, :primary_server
-
-  @server = {}
-  def regist_server(server)
-    @server[server.uri] = server
-    Thread.exclusive do
-      @primary_server = server unless @primary_server
-    end
-  end
-  module_function :regist_server
-
-  ##
-  # Get the 'current' server.
-  #
-  # In the context of execution taking place within the main
-  # thread of a dRuby server (typically, as a result of a remote
-  # call on the server or one of its objects), the current
-  # server is that server.  Otherwise, the current server is
-  # the primary server.
-  #
-  # If the above rule fails to find a server, a DRbServerNotFound
-  # error is raised.
-  def current_server
-    drb = Thread.current['DRb'] 
-    server = (drb && drb['server']) ? drb['server'] : @primary_server 
-    raise DRb::DRbServerNotFound unless server
-    return server
-  end
-  module_function :current_server
-
-  ##
-  # Get the thread of the primary server.
-  #
-  # This returns nil if there is no primary server.  See #primary_server.
-  def thread
-    @primary_server ? @primary_server.thread : nil
-  end
-  module_function :thread
-
-
   ##
   # Client protocol module 
   module DRbClientProtocol
@@ -470,7 +491,7 @@ module EMDRb
 
     def post_init
       @msgbuffer = ""
-      @idconv = DRb::DRbIdConv.new
+      @idconv = DRbIdConv.new
       @load_limit = DEFAULT_LOAD_LIMIT
     end
 
@@ -506,6 +527,10 @@ module EMDRb
         close_connection
       end
     end
+
+    def receive_data(data)
+      return(receive_data_raw(data))
+    end
   end
 
   ##
@@ -513,7 +538,7 @@ module EMDRb
   #
   # Method calls on this object are relayed to the remote object
   # that this object is a stub for.
-  class DRbObject < DRb::DRbObject
+  class DRbObject
     def initialize(obj, uri=nil)
       @uri = nil
       @ref = nil
@@ -521,18 +546,22 @@ module EMDRb
 	return if uri.nil?
         @uri = uri
         ref = nil
-        @host, @port, @opt = EMDRb::parse_uri(@uri)
+        @host, @port, @opt = DRb::parse_uri_drb(@uri)
       else
-        @ref = obj
+	@uri = uri ? uri : (DRb.uri rescue nil)
+        @ref = obj ? DRb.to_id(obj) : nil
       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
+    # be used from within the event loop.  It returns a deferrable to which
     # callbacks can be attached.
     def send_async(msg_id, *a, &b)
       df = EventMachine::DefaultDeferrable.new
+      if @host.nil? || @port.nil?
+        @host, @port, @opt = DRb::parse_uri_drb(@uri)
+      end
       EventMachine.connect(@host, @port, DRbClientProtocol) do |c|
         c.ref = self
         c.msg_id = msg_id
@@ -543,6 +572,37 @@ module EMDRb
       return(df)
     end
 
+    ##
+    # Route method calls to the referenced object.  This synchronizes
+    # an asynchronous call by using a Queue to synchronize the DRb
+    # event thread with the calling thread, so use of this mechanism,
+    # to make method calls within an event loop will thus result in a
+    # threading deadlock!  Use the send_async method if you want to
+    # use EMDRb from within an event loop.
+    def method_missing(msg_id, *a, &b)
+      if DRb.here?(@uri)
+	obj = DRb.to_obj(@ref)
+	DRb.current_server.check_insecure_method(obj, msg_id)
+	return obj.__send__(msg_id, *a, &b) 
+      end
+
+      q = Queue.new
+      EventMachine::next_tick do
+        df = self.send_async(msg_id, *a, &b)
+        df.callback { |data| q << data }
+      end
+      succ, result = q.shift
+      if succ
+        return result
+      elsif DRbUnknown === result
+        raise result
+      else
+        bt = self.class.prepare_backtrace(@uri, result)
+	result.set_backtrace(bt + caller)
+        raise result
+      end
+    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 26 2009-01-22 04:48:43Z dido $
+# $Id: version.rb 57 2009-01-23 09:07:54Z dido $
 #
 #----------------------------------------------------------------------------
 #
@@ -25,8 +25,8 @@ module EMDRb
   module Version
 
     MAJOR = 0
-    MINOR = 1
-    TINY = 2
+    MINOR = 2
+    TINY = 0
 
     # The version of EMDRb in use.
     STRING = [ MAJOR, MINOR, TINY ].join(".")

data/spec/client_spec.rb

@@ -0,0 +1,61 @@
+#
+# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
+# Copyright:: Copyright © 2008, 2009 Rafael R. Sevilla
+# Homepage:: http://emdrb.rubyforge.org/
+# License:: GNU General Public License / Ruby License
+#
+# $Id: client_spec.rb 50 2009-01-23 08:52:21Z dido $
+#
+#----------------------------------------------------------------------------
+#
+# Copyright © 2008, 2009 Rafael Sevilla
+# This file is part of EMDRb
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#----------------------------------------------------------------------------
+#
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+require File.join(File.dirname(__FILE__), %w[spec_common])
+
+Thread.abort_on_exception = true
+
+describe EMDRb, "Client" do
+  it_should_behave_like "DRb basics"
+
+  before(:all) do
+    system(File.join(File.dirname(__FILE__), "drbserver.rb drb"))
+    DRb.start_service
+    @obj = DRb::DRbObject.new(nil, "druby://localhost:12345")
+  end
+
+  after(:all) do
+    pid = File.open(File.join(File.dirname(__FILE__), "drbserver.pid")) { |fp| fp.read.to_i }
+    Process.kill("SIGTERM", pid)
+  end
+
+  it "should be able to perform asynchronous method calls" do
+    EventMachine::next_tick do
+      @obj.send_async(:identity, 1).callback do |data|
+        data[0].should be_true
+        data[1].should == 1
+      end
+    end
+  end
+
+  it "should be able to perform asynchronous method calls with a passed block" do
+    EventMachine::next_tick do
+      val = 1
+      df = @obj.send_async(:blockyield, 1,2,3,4,5,6,7) { |x| val *= x; val }
+      df.callback do |data|
+        data[0].should be_true
+        val.should == 5040
+      end
+    end
+  end
+
+end

data/spec/drbserver.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
+# Copyright:: Copyright © 2008, 2009 Rafael R. Sevilla
+# Homepage:: http://emdrb.rubyforge.org/
+# License:: GNU General Public License / Ruby License
+#
+# $Id: drbserver.rb 46 2009-01-23 08:10:42Z dido $
+#
+#----------------------------------------------------------------------------
+#
+# Copyright © 2008, 2009 Rafael Sevilla
+# This file is part of EMDRb
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#----------------------------------------------------------------------------
+#
+# This is the DRb server that should be run by the specs, and can execute
+# using either the standard DRb or EMDRb depending on what is being tested.
+#
+require 'daemons'
+Thread.abort_on_exception = true
+if ARGV[0] == "emdrb"
+  $LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+  require 'emdrb'
+elsif ARGV[0] == "drb"
+  require 'drb'
+else
+  raise "specify emdrb or drb on the command line"
+end
+
+if ARGV[1].nil?
+  pidfile = File.expand_path(File.join(File.dirname(__FILE__), "drbserver.pid"))
+  if File.exist?(pidfile)
+    exit(0)
+  end
+#  logfile = File.expand_path(File.join(File.dirname(__FILE__), "drbserver.log"))
+  Daemonize.daemonize
+  pid = Process.pid
+  File.open(pidfile, "w") { |fp| fp.write(pid.to_s) }
+
+  handler = lambda do
+    File.delete(pidfile)
+    exit(0)
+  end
+
+  trap("SIGTERM", handler)
+  trap("SIGINT", handler)
+end
+
+class TestServer
+  def identity(x)
+    return(x)
+  end
+
+  def addtwo(x, y)
+    return(x+y)
+  end
+
+  def sum(*vals)
+    return(vals.inject(0) { |x,y| x + y })
+  end
+
+  def blockyield(*vals)
+    vals.each do |x|
+      yield x
+    end
+  end
+end
+
+
+
+DRb.start_service("druby://:12345", TestServer.new)
+DRb.thread.join

data/spec/server_spec.rb

@@ -0,0 +1,51 @@
+#
+# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
+# Copyright:: Copyright © 2008, 2009 Rafael R. Sevilla
+# Homepage:: http://emdrb.rubyforge.org/
+# License:: GNU General Public License / Ruby License
+#
+# $Id: server_spec.rb 48 2009-01-23 08:48:43Z dido $
+#
+#----------------------------------------------------------------------------
+#
+# Copyright © 2008, 2009 Rafael Sevilla
+# This file is part of EMDRb
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#----------------------------------------------------------------------------
+#
+# This tests the EMDRb server implementation against the standard DRb
+# client.
+#
+#require File.join(File.dirname(__FILE__), %w[spec_helper])
+require File.join(File.dirname(__FILE__), %w[spec_common])
+require 'drb'       # yes, that's right, we use the STANDARD DRb here!
+require 'thread'
+
+Thread.abort_on_exception = true
+
+describe "EMDRb Server" do
+  it_should_behave_like "DRb basics"
+
+  before(:all) do
+    # but we start the *server* with EMDRb
+    system(File.join(File.dirname(__FILE__), "drbserver.rb emdrb"))
+    DRb.start_service
+    @obj = DRbObject.new_with_uri("druby://localhost:12345")
+  end
+
+  after(:all) do
+    pid = File.open(File.join(File.dirname(__FILE__), "drbserver.pid")) { |fp| fp.read.to_i }
+    Process.kill("SIGTERM", pid)
+  end
+
+  it "should work with variadic methods" do
+    @obj.sum(1,2,3,4,5).should == 15
+  end
+
+end

data/spec/spec_common.rb

@@ -0,0 +1,34 @@
+#
+# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
+# Copyright:: Copyright © 2008, 2009 Rafael R. Sevilla
+# Homepage:: http://emdrb.rubyforge.org/
+# License:: GNU General Public License / Ruby License
+#
+# $Id: spec_common.rb 44 2009-01-23 06:40:54Z dido $
+#
+#----------------------------------------------------------------------------
+#
+# Copyright © 2008, 2009 Rafael Sevilla
+# This file is part of EMDRb
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#----------------------------------------------------------------------------
+#
+describe "DRb basics", :shared => true do
+  it "should be able to perform simple synchronous method calls" do
+    @obj.identity(1).should == 1
+    @obj.addtwo(1, 2).should == 3
+  end
+
+  it "should be able to perform synchronous method calls with a block" do
+    val = 1
+    @obj.blockyield(1,2,3,4,5,6,7) { |x| val *= x }
+    val.should == 5040
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+#
+# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
+# Copyright:: Copyright © 2008, 2009 Rafael R. Sevilla
+# Homepage:: http://emdrb.rubyforge.org/
+# License:: GNU General Public License / Ruby License
+#
+# $Id: spec_helper.rb 60 2009-01-23 09:11:11Z dido $
+#
+#----------------------------------------------------------------------------
+#
+# Copyright © 2008, 2009 Rafael Sevilla
+# This file is part of EMDRb
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#----------------------------------------------------------------------------
+#
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib emdrb]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

data/tasks/ann.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: ann.rake 59 2009-01-23 09:10:01Z dido $
 
 begin
   require 'bones/smtp_tls'

data/tasks/bones.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: bones.rake 59 2009-01-23 09:10:01Z dido $
 
 if HAVE_BONES
 

data/tasks/gem.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: gem.rake 59 2009-01-23 09:10:01Z dido $
 
 require 'rake/gempackagetask'
 

data/tasks/git.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: git.rake 59 2009-01-23 09:10:01Z dido $
 
 if HAVE_GIT
 

data/tasks/manifest.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: manifest.rake 59 2009-01-23 09:10:01Z dido $
 
 require 'find'
 

data/tasks/notes.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: notes.rake 59 2009-01-23 09:10:01Z dido $
 
 if HAVE_BONES
 

data/tasks/post_load.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: post_load.rake 59 2009-01-23 09:10:01Z dido $
 
 # This file does not define any rake tasks. It is used to load some project
 # settings if they are not defined by the user.

data/tasks/rdoc.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: rdoc.rake 59 2009-01-23 09:10:01Z dido $
 
 require 'rake/rdoctask'
 

data/tasks/setup.rb

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: setup.rb 59 2009-01-23 09:10:01Z dido $
 
 require 'rubygems'
 require 'rake'

data/tasks/spec.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: spec.rake 59 2009-01-23 09:10:01Z dido $
 
 if HAVE_SPEC_RAKE_SPECTASK
 require 'spec/rake/verify_rcov'

data/tasks/svn.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: svn.rake 59 2009-01-23 09:10:01Z dido $
 
 if HAVE_SVN
 

data/tasks/test.rake

@@ -1,4 +1,4 @@
-# $Id$
+# $Id: test.rake 59 2009-01-23 09:10:01Z dido $
 
 require 'rake/testtask'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: emdrb
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - dido@imperium.ph
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-22 00:00:00 +08:00
+date: 2009-01-23 00:00:00 +08:00
 default_executable: 
 dependencies: []
 
@@ -32,6 +32,11 @@ files:
 - lib/emdrb.rb
 - lib/emdrb/emdrb.rb
 - lib/emdrb/version.rb
+- spec/client_spec.rb
+- spec/drbserver.rb
+- spec/server_spec.rb
+- spec/spec_common.rb
+- spec/spec_helper.rb
 - tasks/ann.rake
 - tasks/bones.rake
 - tasks/gem.rake
@@ -45,7 +50,6 @@ files:
 - tasks/spec.rake
 - tasks/svn.rake
 - tasks/test.rake
-- test/test_emdrb.rb
 has_rdoc: true
 homepage: http://emdrb.rubyforge.org
 post_install_message: 
@@ -73,5 +77,5 @@ rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: This is a distributed Ruby client and server which should work as a drop-in replacement for the standard distributed Ruby implementation available in the Ruby standard library
-test_files: 
-- test/test_emdrb.rb
+test_files: []
+

data/test/test_emdrb.rb

@@ -1,96 +0,0 @@
-#
-# Author:: Rafael R. Sevilla (mailto:dido@imperium.ph)
-# Copyright:: Copyright (c) 2008 Rafael R. Sevilla
-# Homepage:: http://emdrb.rubyforge.org/
-# License:: GNU General Public License / Ruby License
-#
-# $Id: test_emdrb.rb 27 2009-01-22 05:11:56Z dido $
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2008 Rafael Sevilla
-# This file is part of EMDRb
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) 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; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#----------------------------------------------------------------------------
-#
-require 'test/unit'
-require 'emdrb/emdrb'
-require 'drb'
-
-Thread.abort_on_exception = true
-
-class TestServer
-  def identity(x)
-    return(x)
-  end
-
-  def addtwo(x, y)
-    return(x+y)
-  end
-
-  def sum(*vals)
-    return(vals.inject(0) { |x,y| x + y })
-  end
-
-  def blockyield(*vals)
-    vals.each do |x|
-      yield x
-    end
-  end
-end
-
-class EMDRbTest < Test::Unit::TestCase
-  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))
-    assert_equal(3, o.addtwo(1, 2))
-    assert_raises(ArgumentError) do
-      o.addtwo(1)
-    end
-    assert_equal(15, o.sum(1,2,3,4,5))
-    val = 1
-    o.blockyield(1,2,3,4,5,6,7) { |x| val *= x }
-    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