emrpc 0.1

data/README

@@ -0,0 +1,48 @@
+EMRPC is a EventMachine-based remote procedure call library.
+It looks like DRb, but is much more efficient and provides
+asynchronous interface along with blocking synchronous interface. 
+
+Author: Oleg Andreev <oleganza@gmail.com>
+
+HELLO WORLD
+
+  class HelloWorld
+    def action
+      "Hello!"
+    end
+  end
+    
+  server = EMRPC::Server.new(:host => '0.0.0.0', 
+                             :port => 9000, 
+                             :object => HelloWorld.new)
+  
+  EM::run do
+    server.run
+  end
+  
+  client = EMRPC::Client.new(:host => "localhost", :port => 9000)
+  client.action == "Hello!" #=> true
+
+  
+THE MIT LICENSE
+
+Copyright (c) 2008, Oleg Andreev <oleganza@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,96 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "rake/testtask"
+require "spec/rake/spectask"
+require "fileutils"
+
+def __DIR__
+  File.dirname(__FILE__)
+end
+
+include FileUtils
+
+require "lib/emrpc/version"
+
+def sudo
+  ENV['EMRPC_SUDO'] ||= "sudo"
+  sudo = windows? ? "" : ENV['EMRPC_SUDO']
+end
+
+def windows?
+  (PLATFORM =~ /win32|cygwin/) rescue nil
+end
+
+def install_home
+  ENV['GEM_HOME'] ? "-i #{ENV['GEM_HOME']}" : ""
+end
+
+##############################################################################
+# Packaging & Installation
+##############################################################################
+CLEAN.include ["**/.*.sw?", "pkg", "lib/*.bundle", "*.gem", "doc/rdoc", ".config", "coverage", "cache"]
+
+desc "Run the specs."
+task :default => :specs
+
+task :emrpc => [:clean, :rdoc, :package]
+
+RUBY_FORGE_PROJECT  = "emrpc"
+PROJECT_URL         = "http://strokedb.com"
+PROJECT_SUMMARY     = "Efficient RPC library with evented and blocking APIs. In all ways better than DRb."
+PROJECT_DESCRIPTION = PROJECT_SUMMARY
+
+AUTHOR = "Oleg Andreev"
+EMAIL  = "oleganza@gmail.com"
+
+GEM_NAME    = "emrpc"
+PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+GEM_VERSION = EMRPC::VERSION + PKG_BUILD
+
+RELEASE_NAME    = "REL #{GEM_VERSION}"
+
+require "extlib/tasks/release"
+
+spec = Gem::Specification.new do |s|
+  s.name         = GEM_NAME
+  s.version      = GEM_VERSION
+  s.platform     = Gem::Platform::RUBY
+  s.author       = AUTHOR
+  s.email        = EMAIL
+  s.homepage     = PROJECT_URL
+  s.summary      = PROJECT_SUMMARY
+  s.bindir       = "bin"
+  s.description  = s.summary
+  s.executables  = %w( )
+  s.require_path = "lib"
+  s.files        = %w( README Rakefile TODO ) + Dir["{docs,bin,spec,lib,examples,script}/**/*"]
+
+  # rdoc
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w( README TODO )
+  #s.rdoc_options     += RDOC_OPTS + ["--exclude", "^(app|uploads)"]
+
+  # Dependencies
+  s.add_dependency "eventmachine"
+  s.add_dependency "rake"
+  s.add_dependency "rspec"
+  # Requirements
+  s.requirements << "You need to install the json (or json_pure), yaml, rack gems to use related features."
+  s.required_ruby_version = ">= 1.8.4"
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+end
+
+desc "Run :package and install the resulting .gem"
+task :install => :package do
+  sh %{#{sudo} gem install #{install_home} --local pkg/#{NAME}-#{EMRPC::VERSION}.gem --no-rdoc --no-ri}
+end
+
+desc "Run :clean and uninstall the .gem"
+task :uninstall => :clean do
+  sh %{#{sudo} gem uninstall #{NAME}}
+end

data/TODO

@@ -0,0 +1,8 @@
+reconnecting client
+rack http server & http client
+object serialization:
+  self (special case, return reference to the running )
+  other
+unix sockets interface
+resource discovery
+ring/chord protocol

data/lib/emrpc/client.rb

@@ -0,0 +1,28 @@
+module EMRPC
+  class Client
+    DEFAULT_TIMEOUT     = 5 # 5 sec.
+    DEFAULT_PROTOCOL    = :ClientProtocol # Default EventMachine connection protocol
+    DEFAULT_CONNECTIONS = 10 # 10 threads can operate concurrently, others will wait.
+    
+    attr_reader :host, :port, :protocol, :timeout, :connections
+    # Create a regular object holding configuration, 
+    # but returns a method proxy.
+    def self.new(*args, &blk)
+      client = super(*args)
+      backend = MultithreadedClient.new(:backends => client.connections, 
+                                        :timeout => client.timeout)
+      MethodProxy.new(backend)
+    end
+    
+    def initialize(options = {})
+      @host     = options[:host] or raise ":host required!"
+      @port     = options[:port] or raise ":port required!"
+      @timeout  = options[:timeout] || DEFAULT_TIMEOUT
+      @protocol = options[:protocol] || DEFAULT_PROTOCOL 
+      @connections = Array.new(options.delete(:connections) || DEFAULT_CONNECTIONS) do 
+        ClientConnection.new(options)
+      end
+    end
+  
+  end
+end

data/lib/emrpc/em_connection.rb

@@ -0,0 +1,19 @@
+module EMRPC
+  module EmConnection
+    # Connection initialization hook,
+    def post_init
+    end
+    
+    # Connection being safely established (post_init was already called).
+    def connection_completed
+    end
+    
+    # Connection was closed.
+    def unbind
+    end
+    
+    # Raw receive data callback.
+    def receive_data(data)
+    end
+  end
+end

data/lib/emrpc/fast_message_protocol.rb

@@ -0,0 +1,111 @@
+module EMRPC
+  # Receives data with a 4-byte integer size prefix (network byte order).
+  # Underlying protocol must implement #send_data and invoke #receive_data.
+  # User's protocol must call #send_fast_message and listen to #receive_fast_message callback.
+  module FastMessageProtocol
+    def post_init
+      @fmp_size = 0         # if 0, we're waiting for a new message,
+                            # else - accumulating data.
+      @fmp_size_chunk = ""  # we store a part of size chunk here
+      @fmp_data = ""
+      super
+    end
+
+    LENGTH_FORMAT = "N".freeze
+    LENGTH_FORMAT_LENGTH = 4
+    
+    def send_fast_message(data)
+      size = data.size
+      packed_size = [size].pack(LENGTH_FORMAT)
+      send_data packed_size
+      send_data data
+    end
+
+    def receive_data(next_chunk)
+      while true # helps fight deep recursion when receiving many messages in a single buffer.
+        data = next_chunk
+        # accumulate data
+        if @fmp_size > 0
+          left = @fmp_size - @fmp_data.size
+          now  = data.size
+          log { "Need more #{left} bytes, got #{now} for now." }
+
+          if left > now
+            @fmp_data << data
+            break
+          elsif left == now
+            @fmp_data << data
+            data = @fmp_data
+            @fmp_data = ""
+            @fmp_size = 0
+            @fmp_size_chunk = ""
+            receive_fast_message(data)
+            break
+          else
+            # Received more, than expected.
+            # 1. Forward expected part
+            # 2. Put unexpected part into receive_data
+            @fmp_data << data[0, left]
+            next_chunk = data[left, now]
+            data = @fmp_data
+            @fmp_data = ""
+            @fmp_size = 0
+            @fmp_size_chunk = ""
+            log { "Returning #{data.size} bytes (#{data[0..32]})"  }
+            receive_fast_message(data)
+            # (see while true: processing next chunk without recursive calls)
+          end
+
+        # get message size prefix
+        else
+          left = LENGTH_FORMAT_LENGTH - @fmp_size_chunk.size
+          now  = data.size
+          log { "Need more #{left} bytes for size_chunk, got #{now} for now." }
+
+          if left > now
+            @fmp_size_chunk << data
+            break
+          elsif left == now
+            @fmp_size_chunk << data
+            @fmp_size = @fmp_size_chunk.unpack(LENGTH_FORMAT)[0]
+            log { "Ready to receive #{@fmp_size} bytes."}
+            break
+          else
+            # Received more, than expected.
+            # 1. Pick only expected part for length
+            # 2. Pass unexpected part into receive_data
+            @fmp_size_chunk << data[0, left]
+            next_chunk = data[left, now]
+            @fmp_size = @fmp_size_chunk.unpack(LENGTH_FORMAT)[0]
+            log { "Ready to receive #{@fmp_size} bytes."}
+            # (see while true) receive_data(next_chunk) # process next chunk
+          end # if
+        end # if 
+      end # while true
+    end # def receive_data
+    
+    def err
+      STDERR.write("FastMessageProtocol: #{yield}\n")
+    end
+    def log
+      puts("FastMessageProtocol: #{yield}")
+    end
+    # Switch logging off when not in debug mode.
+    unless $DEBUG || ENV['DEBUG']
+      def log
+      end
+    end
+  end # module FastMessageProtocol
+  
+  # Allows to use send_message/receive_message without 
+  # a knowledge of the particular messaging protocol.
+  module FastMessageProtocolAdapter
+    def send_message(msg)
+      send_fast_message(msg)
+    end
+    def receive_fast_message(msg)
+      receive_message(msg)
+    end
+  end
+  
+end # EMRPC

data/lib/emrpc/marshal_protocol.rb

@@ -0,0 +1,30 @@
+module EMRPC
+  module MarshalProtocol
+    # Creates new protocol using specified dump/load interface.
+    # Note: interface must be a constant! See examples below.
+    # Examples:
+    #  1. include MarshalProtocol.new(Marshal)
+    #  2. include MarshalProtocol.new(YAML)
+    #  3. include MarshalProtocol.new(JSON)
+    def self.new(marshal_const)
+      const_name = marshal_const.name
+      mod = Module.new
+      mod.class_eval <<-EOF, __FILE__, __LINE__
+        def send_marshalled_message(msg)
+          send_message(#{const_name}.dump(msg))
+        end
+        def receive_message(msg)
+          receive_marshalled_message(#{const_name}.load(msg))
+        rescue => e
+          rescue_marshal_error(e)
+        end
+      EOF
+      mod
+    end
+    
+    # Prevent direct inclusion by accident.
+    def self.included(base)
+      raise "#{self} cannot be included directly! Create a module using #{self}.new(marshal_const)."
+    end
+  end
+end

data/lib/emrpc/method_proxy.rb

@@ -0,0 +1,38 @@
+require 'thread'
+module EMRPC
+  # Sends all the messages to a specified backend
+  # FIXME: deal with Object's methods gracefully.
+  class MethodProxy
+    EMPTY_ARGS = [ ].freeze
+    attr_reader :__emrpc_backend
+    def initialize(backend)
+      @__emrpc_backend = backend
+    end
+    
+    def method_missing(meth, *args, &blk)
+      @__emrpc_backend.send_message(meth, args, blk)
+    end
+    
+    def id
+      @__emrpc_backend.send_message(:id, EMPTY_ARGS, nil)
+    end
+    
+    def to_s
+      @__emrpc_backend.send_message(:to_s, EMPTY_ARGS, nil)
+    end
+    
+    def to_str
+      @__emrpc_backend.send_message(:to_str, EMPTY_ARGS, nil)
+    end
+    
+    alias :__class__ :class
+    def class
+      @__emrpc_backend.send_message(:class, EMPTY_ARGS, nil)
+    end
+    
+    def inspect
+      "#<#{self.__class__.name}:0x#{__id__.to_s(16)} remote:#{@__emrpc_backend.send_message(:inspect, EMPTY_ARGS, nil)}>"
+    end
+    
+  end
+end

data/lib/emrpc/multithreaded_client.rb

@@ -0,0 +1,40 @@
+require 'thread'
+module EMRPC
+  class PoolTimeout < StandardError; end
+  class MultithreadedClient
+    attr_reader :pool, :backends, :timeout
+    def initialize(options)
+      @backends = options[:backends] or raise "No backends supplied!"
+      @pool     = options[:queue] || ::Queue.new
+      @timeout  = options[:timeout] || 5
+      @timeout_thread = Thread.new { timer_action! }
+      @backends.each do |backend|
+        @pool.push(backend)
+      end
+    end
+    
+    def send_message(meth, args, blk)
+      start = Time.now
+      # wait for the available connections here
+      while :timeout == (backend = @pool.pop)
+        seconds = Time.now - start
+        if seconds > @timeout
+          raise PoolTimeout, "Thread #{Thread.current} waited #{seconds} seconds for backend connection in a pool. Pool size is #{@backends.size}. Maybe too many threads are running concurrently. Increase the pool size or decrease the number of threads."
+        end
+      end
+      begin
+        backend.send_message(meth, args, blk)
+      ensure # Always push backend to a pool after using it!
+        @pool.push(backend)
+      end
+    end
+    
+    # Pushes :timeout message to a queue for all 
+    # the threads in a backlog every @timeout seconds.
+    def timer_action!
+      sleep @timeout
+      @pool.num_waiting.times { @pool.push(:timeout) }
+    end
+    
+  end
+end

data/lib/emrpc/reconnecting_client.rb

@@ -0,0 +1,46 @@
+module EMRPC
+  # Reconnects when needed.
+  class ReconnectingClient
+    attr_reader :host, :port, :protocol
+    def initialize(options)
+      @host     = options[:host]
+      @port     = options[:port]
+      @protocol = options[:protocol]
+      @timeout  = options[:timeout]
+      
+      @connection = nil # diconnected at the start
+    end
+    
+    def connection
+      return @connection if @connection
+      
+    end
+    
+    def send_data(data)
+      connection.send_data
+    end
+    
+    def close_connection(after_writing = false)
+      
+    end
+    
+    module ReconnectingCallbacks
+      attr_accessor :reconnecting_client
+      
+      def receive_data(data)
+        
+      end
+      
+      def connection_completed
+        @reconnecting_client.connection_completed
+      end
+      
+      def unbind
+        @reconnecting_client.unbind
+      end
+    end
+  end # ReconnectingClient
+  
+  # Raised when reconnection timeout is over.
+  class ReconnectionTimeout < StandardError; end
+end

data/lib/emrpc/server.rb

@@ -0,0 +1,18 @@
+module EMRPC
+  class Server
+    attr_accessor :host, :port, :object, :protocol
+    def initialize(options = {})
+      @host   = options[:host]
+      @port   = options[:port]
+      @object = options[:object]
+      @protocol = options[:protocol] || ServerProtocol
+    end
+    
+    def run
+      EventMachine.start_server(@host, @port, @protocol) do |conn|
+        conn.__served_object = @object
+      end
+    end
+    
+  end
+end

data/lib/emrpc/singlethreaded_client.rb

@@ -0,0 +1,16 @@
+require 'thread'
+module EMRPC
+  class ConnectionTimeout < StandardError; end
+  class SinglethreadedClient
+    def initialize(options)
+      
+    end
+    
+    def send_message(meth, args, blk)
+      start = Time.now
+      # TODO...
+      
+    end
+    
+  end
+end

data/lib/emrpc/version.rb

@@ -0,0 +1,3 @@
+module EMRPC
+  VERSION = "0.1"
+end

data/lib/emrpc.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'eventmachine'
+
+$LOAD_PATH.unshift( File.expand_path(File.join(File.dirname(__FILE__))))
+
+require 'emrpc/version'
+require 'emrpc/fast_message_protocol'
+require 'emrpc/marshal_protocol'
+require 'emrpc/server'
+require 'emrpc/method_proxy'
+require 'emrpc/multithreaded_client'
+require 'emrpc/singlethreaded_client'
+require 'emrpc/client'

data/spec/fast_message_protocol_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe FastMessageProtocol do
+  before(:each) do
+    @peer_class = Class.new do
+      def initialize
+        post_init
+      end
+      def post_init
+      end
+    end
+    @oleganza = Class.new(@peer_class) do
+      include FastMessageProtocol
+    end
+    @yrashk = Class.new(@peer_class) do
+      include FastMessageProtocol
+    end
+    @oleganza.class_eval do
+      attr_accessor :messages
+      def post_init
+        @messages = []
+        super
+      end
+      def receive_fast_message(msg)
+        @messages << msg
+      end
+    end
+    @yrashk.class_eval do
+      attr_accessor :peer
+      def post_init
+        @buffer = ""
+        super
+      end
+      def send_data(data)
+        @buffer << data
+        flush_buffer if @buffer.size > (rand(300) + 1)
+      end
+      def flush_buffer
+        @peer.receive_data(@buffer.dup)
+        @buffer = ""
+      end
+    end
+  end
+  
+  it "should receive all messages" do
+    messages = Array.new(1000) {|i| (i*(rand(100)+1)).to_s*(1+rand(100))  }
+    oleg = @oleganza.new
+    yr = @yrashk.new
+    yr.peer = oleg
+    messages.each {|m| yr.send_fast_message(m) }
+    yr.flush_buffer
+    
+    oleg.messages.should == messages
+  end
+  
+  it "should handle protocol errors" do
+    pending "Add message size limit!"
+  end
+  
+end

data/spec/marshal_protocol_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'json'
+require 'yaml'
+
+def create_marshal_protocol_instance(interface)
+  mod = MarshalProtocol.new(interface)
+  
+  spec_module = Module.new do
+    def send_message(data)
+      data
+    end
+    def receive_marshalled_message(data)
+      data
+    end
+    def rescue_marshal_error(e)
+      [:error, e]
+    end
+  end
+  
+  Class.new do
+    include mod
+    include spec_module
+  end.new
+end
+
+describe "Generic MarshalProtocol", :shared => true do
+  it "should pass data in and out" do
+    encoded = @instance.send_marshalled_message(@msg)
+    decoded = @instance.receive_message(encoded)
+    decoded.should == @msg
+  end
+  
+  it "should report error when format is wrong" do
+    encoded = @instance.send_marshalled_message(@msg)
+    decoded = @instance.receive_message("blah-blah"+encoded)
+    decoded.first.should == :error
+  end
+end
+
+[Marshal, JSON, YAML].each do |interface|
+  describe MarshalProtocol, "with #{interface}" do
+    before(:each) do
+      # FIXME: fixture containing 3.1415 may cause floating point issues.
+      @msg = ["Hello", {"a" => "b", "arr" => [true, false, nil]}, 1, 3.1415]
+      @instance = create_marshal_protocol_instance(interface)
+    end
+    it_should_behave_like "Generic MarshalProtocol"
+  end
+end

data/spec/method_proxy_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MethodProxy do
+  before(:each) do
+    @backend = [ 1, 2, 3 ]
+    class <<@backend
+      def send_message(meth, args, blk)
+        send(meth, *args, &blk)
+      end
+      def id
+        object_id
+      end
+    end
+    @proxy = MethodProxy.new(@backend)
+  end
+  
+  it "should proxy regular methods" do
+    @proxy.size.should == @backend.size
+    (@proxy*2).should == (@backend*2)
+    @proxy.join(':').should == @backend.join(':')
+  end 
+  
+  it "should proxy Object's methods" do
+    @proxy.to_s.should   == @backend.to_s
+    lambda { @proxy.to_str.should == @backend.to_str }.should raise_error(NoMethodError) # to_str is undefined
+    @proxy.class.should  == @backend.class
+    @proxy.id.should     == @backend.id
+  end
+  
+  it "should inspect" do
+    @proxy.inspect == %{#<#{MethodProxy}:0x#{@proxy.__id__.to_s(16)} remote:#{@backend.inspect}>}
+  end
+end

data/spec/multithreaded_client_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MultithreadedClient, " with no timeouts" do
+  include ThreadHelpers
+  before(:each) do
+    @mod = Module.new do
+      def send_message(meth, args, blk)
+        send(meth, *args, &blk)
+      end
+    end
+    @backends = [ [ 1 ], [ 2 ], [ 3 ] ]
+    @backends.each{|b| b.extend(@mod) }
+    
+    @client = MultithreadedClient.new(:backends => @backends, :timeout => 1)
+  end
+  it "should work with all backends" do
+    ts = create_threads(10) do 
+      loop { @client.send_message(:[], [ 0 ], nil) }
+    end
+    sleep 3
+    ts.each {|t| t.kill}
+  end
+end
+
+describe MultithreadedClient, " with PoolTimeout" do
+  include ThreadHelpers
+  before(:each) do
+    @long_backend = Object.new
+    class <<@long_backend
+      def send_message(meth, args, blk)
+        sleep 0.5
+      end
+    end
+    @long_client = MultithreadedClient.new(:backends => [ @long_backend ], :timeout => 1)
+  end
+  
+  it "should raise ThreadTimeout" do
+    ts = create_threads(50) do # some of them will die
+      @long_client.send_message(:some_meth, nil, nil)
+    end
+    create_threads(10, true) do 
+      lambda {
+        @long_client.send_message(:some_meth, nil, nil)
+      }.should raise_error(PoolTimeout)
+    end
+    sleep 3
+    ts.each {|t| t.kill}
+  end
+end

data/spec/singlethreaded_client_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe SinglethreadedClient do
+  include ThreadHelpers
+  before(:each) do
+    @backend= [1, 2, 3]
+    class <<@backend
+      def send_message(meth, args, blk)
+        send(meth, *args, &blk)
+      end
+    end
+    @client = SinglethreadedClient.new(:backend => @backend, :timeout => 1)
+  end
+  
+  it "should work without errors with regular methods" do
+    @client.send_message(:size, nil, nil).should == 3
+    @client.send_message(:join, [":"], nil).should == "1:2:3"
+    @client.send_message(:map, nil, proc{|e| e.to_s}).should == %w[1 2 3]
+  end
+
+  
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,64 @@
+$LOAD_PATH.unshift( File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')) )
+
+require 'emrpc'
+include EMRPC
+
+EM_HOST =  ENV['EM_HOST'] || "127.0.0.1"
+EM_PORT = (ENV['EM_PORT'] || 4567).to_i
+
+module Fixtures
+  class Person
+    attr_accessor :name
+    def initialize(options = {})
+      @name = options[:name]
+    end
+  end
+
+  class Paris
+    attr_accessor :people, :options
+  
+    def initialize(ppl, options = {})
+      @options = options
+      @people = Array.new(ppl){ Person.new }
+      @name = "Paris"
+    end
+  
+    def translate(english_word)
+      "le #{english_word}" # :-)
+    end
+  
+    def visit(person)
+      people << person
+      people.size
+    end
+    
+    def run_exception
+      raise SomeException, "paris message"
+    end
+    class SomeException < Exception; end
+  end
+end
+
+module ThreadHelpers
+  def create_threads(n, abort_on_exception = false, &blk)
+    Array.new(n) do 
+      t = Thread.new(&blk)
+      t.abort_on_exception = abort_on_exception
+      t
+    end
+  end
+end
+
+# Runs eventmachine reactor in a child thread,
+# waits 0.5 sec. in a current thread.
+# Returns child thread.
+#
+module EventMachine
+  def self.run_in_thread(delay = 0.5, &blk)
+    t = Thread.new do
+      EventMachine.run(&blk) 
+    end
+    sleep delay
+    t
+  end
+end

data/spec/sync_client_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Sync client" do
+  
+  # Run server
+  before(:all) do
+    @em_thread = EM.run_in_thread do
+      paris = Fixtures::Paris.new(4, :cafes => ["quai-quai", "2 moulins"])
+      EMRPC::Server.new(:host => EM_HOST, :port => EM_PORT, :object => paris).run
+    end
+  end
+  after(:all) do
+    begin
+      EM.stop_event_loop
+      @em_thread.kill
+    rescue => e
+      puts "Exception after specs:"
+      puts e.inspect
+    end
+  end
+  
+  # Run client
+  before(:each) do
+    @paris  = EMRPC::Client.new(:host => EM_HOST, :port => EM_PORT)
+    # wrong port
+    @berlin = EMRPC::Client.new(:host => EM_HOST, :port => EM_PORT + 1)
+    # wrong host
+    @prague = EMRPC::Client.new(:host => "192.254.254.254", :port => EM_PORT)
+  end
+  
+  it "should get serialized data" do
+    @paris.options.should == { :cafes => ["quai-quai", "2 moulins"] }
+  end
+  
+  it "should issue connection error" do
+    lambda { @berlin.options }.should raise_error(EMRPC::ConnectionError)
+  end
+  
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: emrpc
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Oleg Andreev
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-18 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Efficient RPC library with evented and blocking APIs. In all ways better than DRb.
+email: oleganza@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- TODO
+files: 
+- README
+- Rakefile
+- TODO
+- spec/fast_message_protocol_spec.rb
+- spec/marshal_protocol_spec.rb
+- spec/method_proxy_spec.rb
+- spec/multithreaded_client_spec.rb
+- spec/singlethreaded_client_spec.rb
+- spec/spec_helper.rb
+- spec/sync_client_spec.rb
+- lib/emrpc
+- lib/emrpc/client.rb
+- lib/emrpc/em_connection.rb
+- lib/emrpc/fast_message_protocol.rb
+- lib/emrpc/marshal_protocol.rb
+- lib/emrpc/method_proxy.rb
+- lib/emrpc/multithreaded_client.rb
+- lib/emrpc/reconnecting_client.rb
+- lib/emrpc/server.rb
+- lib/emrpc/singlethreaded_client.rb
+- lib/emrpc/version.rb
+- lib/emrpc.rb
+has_rdoc: true
+homepage: http://strokedb.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.4
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- You need to install the json (or json_pure), yaml, rack gems to use related features.
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Efficient RPC library with evented and blocking APIs. In all ways better than DRb.
+test_files: []
+