marilyn-rpc 0.0.1

data/benchmark/client.rb

@@ -0,0 +1,26 @@
+$:.push('../lib')
+require "marilyn-rpc"
+client1 = MarilynRPC::NativeClient.connect_tcp('localhost', 8483)
+TestService1 = client1.for(:test)
+client2 = MarilynRPC::NativeClient.connect_unix("tmp.socket")
+TestService2 = client2.for(:test)
+
+require "benchmark"
+n = 10000
+Benchmark.bm(10) do |b|
+  b.report("tcp add") do 
+    n.times { TestService1.add(1, 2) }
+  end
+  b.report("tcp time") do
+    n.times { TestService1.time.to_f }
+  end
+  b.report("unix add") do 
+    n.times { TestService2.add(1, 2) }
+  end
+  b.report("unix time") do
+    n.times { TestService2.time.to_f }
+  end
+end
+
+client1.disconnect
+client2.disconnect

data/benchmark/server.rb

@@ -0,0 +1,22 @@
+require "rubygems"
+$:.push('../lib')
+require "marilyn-rpc"
+require "eventmachine"
+
+class TestService < MarilynRPC::Service
+  register :test
+  
+  def time
+    Time.now
+  end
+  
+  def add(a, b)
+    a + b
+  end
+end
+
+
+EM.run {
+  EM.start_server "localhost", 8483, MarilynRPC::Server
+  EM.start_unix_domain_server("tmp.socket", MarilynRPC::Server)
+}

data/lib/marilyn-rpc.rb

@@ -0,0 +1,4 @@
+%w(version gentleman envelope mails service 
+   server service_cache client).each do |file|
+  require File.join(File.dirname(__FILE__), "marilyn-rpc", file)
+end

data/lib/marilyn-rpc/client.rb

@@ -0,0 +1,81 @@
+require 'socket'
+
+module MarilynRPC
+  class NativeClientProxy
+    # Creates a new Native client proxy, were the calls get send to the remote
+    # side.
+    # @param [Object] path the path that is used to identify the service
+    # @param [Socekt] socket the socket to use for communication
+    def initialize(path, socket)
+      @path, @socket = path, socket
+    end
+
+    # Handler for calls to the remote system
+    def method_missing(method, *args, &block)
+      # since this client can't multiplex, we set the tag to nil
+      @socket.write(MarilynRPC::MailFactory.build_call(nil, @path, method, args))
+
+      # read the answer of the server back in
+      answer = MarilynRPC::Envelope.new
+      # read the header to have the size
+      answer.parse!(@socket.read(4))
+      # so now that we know the site, read the rest of the envelope
+      answer.parse!(@socket.read(answer.size))
+
+      # returns the result part of the mail or raise the exception if there is 
+      # one
+      mail = MarilynRPC::MailFactory.unpack(answer)
+      if mail.is_a? MarilynRPC::CallResponseMail
+        mail.result
+      else
+        raise mail.exception
+      end
+    end
+  end
+
+  # The client that will handle the socket to the remote. The native client is
+  # written in pure ruby.
+  # @example Using the native client
+  #   require "marilyn-rpc"
+  #   client = MarilynRPC::NativeClient.connect_tcp('localhost', 8483)
+  #   TestService = client.for(:test)
+  #   TestService.add(1, 2)
+  #   TestService.time.to_f
+  #
+  class NativeClient
+    # Create a native client for the socket.
+    # @param [Socket] socket the socket to manage
+    def initialize(socket)
+      @socket = socket
+    end
+
+    # Disconnect the client from the remote.
+    def disconnect
+      @socket.close
+    end
+
+    # Creates a new Proxy Object for the connection.
+    # @param [Object] path the path were the service is registered on the remote
+    #   site
+    # @return [MarilynRPC::NativeClientProxy] the proxy obejct that will serve
+    #   all calls
+    def for(path)
+      NativeClientProxy.new(path, @socket)
+    end
+    
+    # Connect to a unix domain socket.
+    # @param [String] path the path to the socket file.
+    # @return [MarilynRPC::NativeClient] the cónnected client
+    def self.connect_unix(path)
+      new(UNIXSocket.new(path))
+    end
+    
+    # Connect to a tcp socket.
+    # @param [String] host the host to cennect to (e.g. 'localhost')
+    # @param [Integer] port the port to connect to (e.g. 8000)
+    # @return [MarilynRPC::NativeClient] the cónnected client
+    def self.connect_tcp(host, port)
+      new(TCPSocket.open(host, port))
+    end
+  end
+end

data/lib/marilyn-rpc/envelope.rb

@@ -0,0 +1,62 @@
+# This class handles the envelope parsing and encoding which will be used by the
+# server to handle multiple writes into the envelope.
+class MarilynRPC::Envelope
+  # size of the envelope content
+  attr_reader :size
+  
+  # create a new envelope instance
+  # @param [String] content the content of the new envelope
+  def initialize(content = nil)
+    self.content = content
+  end
+  
+  # parses the passed data
+  # @param [String] data parses the parsed data
+  # @return [String,nil] returns data that is not part of this string 
+  #   (in case the) parser gets more data than the length of the envelope. 
+  #   In case there are no data it will return nil.
+  def parse!(data)
+    @buffer += data
+    overhang = nil
+
+    # parse the length field of the 
+    if @size.nil? && @buffer.size >= 4 
+      # extract 4 bytes length header
+      @size = @buffer.slice!(0...4).unpack("N").first
+    end
+    
+    # envelope is complete and contains overhang
+    if !@size.nil? && @buffer.size > @size
+      overhang = @buffer.slice!(@size, @buffer.size)
+    end
+    
+    overhang
+  end
+  
+  # returns the content of the envelope
+  # @note should only be requested when the message if {finished?}.
+  # @return [String] the content of the envelope
+  def content
+    @buffer
+  end
+  
+  # sets the content of the envelope. If `nil` was passed an empty string will
+  # be set.
+  # @param [String] data the new content
+  def content=(content)
+    @buffer = content || ""
+    @size = content.nil? ? nil : content.size
+  end
+  
+  # encodes the envelope to be send over the wire
+  # @return [String] encoded envelope
+  def encode
+    [@size].pack("N") + @buffer
+  end
+
+  # checks if the complete envelope was allready parsed
+  # @return [Boolean] `true` if the message was parsed
+  def finished?
+    @buffer.size == @size
+  end
+end

data/lib/marilyn-rpc/gentleman.rb

@@ -0,0 +1,64 @@
+# The gentleman is a proxy onject that should help to create async responses on 
+# the server (service) side. There are two ways to use the gentleman. See the
+# examples.
+# 
+# @example Use the gentleman als passed block
+#   MarilynRPC::Gentleman.proxy do |helper|
+#     EM.system('ls', &helper)
+#   
+#     lambda do |output,status|
+#       output if status.exitstatus == 0 
+#     end
+#   end
+#
+# @example Use the gentleman for responses that are objects
+#   conn = EM::Protocols::HttpClient2.connect 'google.com', 80
+#   req = conn.get('/')
+#   MarilynRPC::Gentleman.new(conn) do |response|
+#     response.content
+#   end
+#
+# The Gentleman has to be returned by the service method.
+#
+# @attr [Object] connection the connection where the response should be send
+# @attr [Proc] callback the callback that will be called when the deferable 
+#   was successful
+# @attr [Object] tag the tag that should be used for the response
+class MarilynRPC::Gentleman
+  attr_accessor :connection, :callback, :tag
+  
+  # create a new proxy object using a deferable or the passed block.
+  # @param [EventMachine::Deferrable] deferable
+  def initialize(deferable = nil, &callback)
+    @callback = callback
+    if deferable
+      unless deferable.respond_to? :callback
+        raise ArgumentError.new("Wrong type, expected object that responds to #callback!")
+      end
+      gentleman = self
+      deferable.callback { |*args| gentleman.handle(*args) }
+    end
+  end
+  
+  # Creates a anonymous Gentleman proxy where the helper is exposed to, be able
+  # to use the Gentleman in situations where only a callback can be passed.
+  def self.proxy(&block)
+    gentleman = MarilynRPC::Gentleman.new
+    gentleman.callback = block.call(gentleman.helper)
+    gentleman
+  end
+  
+  # The handler that will send the response to the remote system
+  # @param [Object] args the arguments that should be handled by the callback,
+  #   the reponse of the callback will be send as result
+  def handle(*args)
+    mail = MarilynRPC::CallResponseMail.new(self.tag, self.callback.call(*args))
+    connection.send_mail(mail)
+  end
+  
+  # The helper that will be called by the deferable to call {handle} later
+  def helper
+    gentleman = self
+    lambda { |*args| gentleman.handle(*args) }
+  end
+end

data/lib/marilyn-rpc/mails.rb

@@ -0,0 +1,101 @@
+module MarilynRPC
+  # Helper that gets mixed into the mail classes to make common things easyer
+  module MailHelper
+    # generate a new serialize id which can be used in a mail
+    # @param [Integer] a number between 0 and 254
+    # @param [String] returns an 1 byte string as type id
+    def self.type(nr)
+      [nr].pack("c")
+    end
+    
+    # extracts the real data and ignores the type information
+    # @param [String] data the data to extract the mail from
+    # @return [String] the extracted data
+    def only_data(data)
+      data.slice(1, data.size)
+    end
+    
+    # serialize the data using marilyns default serializer
+    # @param [Object] data the data to encode
+    # @param [String] the serialized data
+    def serialize(data)
+      Marshal.dump(data)
+    end
+    
+    # deserializes the passed data to the original objects
+    # @param [String] data the serialized data
+    # @return [Object] the deserialized object
+    def deserialize(data)
+      Marshal.load(data)
+    end
+  end
+  
+  class CallRequestMail < Struct.new(:tag, :path, :method, :args)
+    include MarilynRPC::MailHelper
+    TYPE = MarilynRPC::MailHelper.type(1)
+    
+    def encode
+      TYPE + serialize([self.tag, self.path, self.method, self.args])
+    end
+    
+    def decode(data)
+      self.tag, self.path, self.method, self.args = deserialize(only_data(data))
+    end
+  end
+  
+  class CallResponseMail < Struct.new(:tag, :result)
+    include MarilynRPC::MailHelper
+    TYPE = MarilynRPC::MailHelper.type(2)
+    
+    def encode
+      TYPE + serialize([self.tag, self.result])
+    end
+    
+    def decode(data)
+      self.tag, self.result = deserialize(only_data(data))
+    end
+  end
+  
+  class ExceptionMail < Struct.new(:exception)
+    include MarilynRPC::MailHelper
+    TYPE = MarilynRPC::MailHelper.type(3)
+    
+    def encode
+      TYPE + serialize(self.exception)
+    end
+    
+    def decode(data)
+      self.exception = deserialize(only_data(data))
+    end
+  end
+  
+  # Helper to destiguish between the different mails
+  module MailFactory
+    # Parses the envelop and generate the correct mail.
+    # @param [MarilynRPC::Envelope] envelope the envelope which contains a mail
+    # @return [MarilynRPC::CallRequestMail, MarilynRPC::CallResponseMail,
+    #          MarilynRPC::ExceptionMail] the mail object that was extracted
+    def self.unpack(envelope)
+      data = envelope.content
+      type = data.slice(0, 1)
+      case type
+        when MarilynRPC::CallRequestMail::TYPE
+          mail = MarilynRPC::CallRequestMail.new
+        when MarilynRPC::CallResponseMail::TYPE
+          mail = MarilynRPC::CallResponseMail.new
+        when MarilynRPC::ExceptionMail::TYPE
+          mail = MarilynRPC::ExceptionMail.new
+        else
+          raise ArgumentError.new("The passed type #{type.inspect} is unknown!")
+      end  
+      mail.decode(data)
+      mail
+    end
+    
+    # builds the binary data for a method call
+    def self.build_call(tag, path, method_name, args)
+      mail = MarilynRPC::CallRequestMail.new(tag, path, method_name, args)
+      MarilynRPC::Envelope.new(mail.encode).encode
+    end
+  end
+end

data/lib/marilyn-rpc/server.rb

@@ -0,0 +1,43 @@
+module MarilynRPC::Server
+  # Initialize the first recieving envelope for the connection and create the
+  # service cache since each connection gets it's own service instance.
+  def post_init
+    @envelope = MarilynRPC::Envelope.new
+    @cache = MarilynRPC::ServiceCache.new
+  end
+  
+  # Handler for the incoming data. EventMachine compatible.
+  # @param [String] data the data that should be parsed into envelopes
+  def receive_data(data)
+    overhang = @envelope.parse!(data)
+    
+    # was massage parsed successfully?
+    if @envelope.finished?
+      begin
+        # grep the request
+        answer = @cache.call(MarilynRPC::MailFactory.unpack(@envelope))
+        if answer.is_a? MarilynRPC::CallResponseMail
+          send_mail(answer)
+        else
+          answer.connection = self # pass connection for async responses
+        end
+      rescue => exception
+        send_mail(MarilynRPC::ExceptionMail.new(exception))
+      end
+      
+      # initialize the next envelope
+      @envelope = MarilynRPC::Envelope.new
+      receive_data(overhang) if overhang # reenter the data loop
+    end
+  end
+  
+  # Send a response mail back on the wire of buffer
+  # @param [MarilynRPC::ExceptionMail, MarilynRPC::CallResponseMail] mail the 
+  #   mail that should be send to the client
+  def send_mail(mail)
+    send_data(MarilynRPC::Envelope.new(mail.encode).encode)
+  end
+  
+  # Handler for client disconnect
+  def unbind; end
+end

data/lib/marilyn-rpc/service.rb

@@ -0,0 +1,15 @@
+class MarilynRPC::Service
+  # registers the class where is was called as a service
+  # @param [String] path the path of the service
+  def self.register(path)
+    @@registry ||= {}
+    @@registry[path] = self
+  end
+  
+  # returns all services, that where registered
+  # @return [Hash<String, Object>] all registered services with path as key and
+  #   the registered service as object
+  def self.registry
+    @@registry || {}
+  end
+end

data/lib/marilyn-rpc/service_cache.rb

@@ -0,0 +1,47 @@
+class MarilynRPC::ServiceCache  
+  # creates the service cache
+  def initialize
+    @services = {}
+  end
+  
+  # call a service in the service cache
+  # @param [MarilynRPC::CallRequestMail] mail the mail request object, that
+  #   should be handled
+  # @return [MarilynRPC::CallResponseMail, MarilynRPC::Gentleman] either a 
+  #   Gentleman if the response is async or an direct response.
+  def call(mail)
+    # check if the correct mail object was send
+    unless mail.is_a?(MarilynRPC::CallRequestMail)
+      raise ArgumentError.new("Expected CallRequestMail Object!")
+    end
+    
+    # call the service instance using the argument of the mail
+    # puts "call #{mail.method}@#{mail.path} with #{mail.args.inspect}"
+    result = lookup(mail.path).send(mail.method, *mail.args)
+    # puts "result => #{result.inspect}"
+    
+    # no direct result, register callback
+    if result.is_a? MarilynRPC::Gentleman
+      result.tag = mail.tag # set the correct mail tag for the answer
+      result
+    else
+      # make response
+      MarilynRPC::CallResponseMail.new(mail.tag, result)
+    end
+  end
+  
+  # get the service from the cache or the service registry
+  # @param [Object] path the path to the service (using the regestry)
+  # @return [Object] the service object or raises an ArgumentError
+  def lookup(path)
+    # lookup the service in the cache
+    if service = @services[path]
+      return service
+    # it's not in the cache, so try lookup in the service registry
+    elsif service = MarilynRPC::Service.registry[path]
+      return (@services[path] = service.new)
+    else
+      raise ArgumentError.new("Service #{mail.path} unknown!")
+    end
+  end
+end

data/lib/marilyn-rpc/version.rb

@@ -0,0 +1,3 @@
+module MarilynRPC
+  VERSION = '0.0.1'
+end

data/marilyn-rpc.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+$:.push('lib')
+require "marilyn-rpc/version"
+
+Gem::Specification.new do |s|
+  s.name     = "marilyn-rpc"
+  s.version  = MarilynRPC::VERSION.dup
+  s.date     = "2011-06-04"
+  s.summary  = "Simple, beautiful event-based RPC"
+  s.email    = "vilandgr+github@googlemail.com"
+  s.homepage = "https://github.com/threez/marilyn-rpc"
+  s.authors  = ['Vincent Landgraf']
+  
+  s.description = <<-EOF
+A simple, beautiful event-based (EventMachine) RPC service and client library
+EOF
+  
+  dependencies = [
+    [:runtime,     "eventmachine",  "~> 0.12.10"],
+    [:development, "rspec",         "~> 2.4"],
+  ]
+  
+  s.files         = Dir['**/*']
+  s.test_files    = Dir['test/**/*'] + Dir['spec/**/*']
+  s.executables   = Dir['bin/*'].map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  
+  ## Make sure you can build the gem on older versions of RubyGems too:
+  s.rubygems_version = "1.3.7"
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.specification_version = 3 if s.respond_to? :specification_version
+  
+  dependencies.each do |type, name, version|
+    if s.respond_to?("add_#{type}_dependency")
+      s.send("add_#{type}_dependency", name, version)
+    else
+      s.add_dependency(name, version)
+    end
+  end
+end

data/spec/envelope_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MarilynRPC::Envelope do
+  before(:each) do
+    @envelope = MarilynRPC::Envelope.new
+  end
+  
+  it "should be possible to parse really small envelope pieces" do
+    size = 100
+    content = "X" * size
+    data = [size].pack("N") + content
+    data.each_byte do |byte|
+      overhang = @envelope.parse!(byte.chr)
+      overhang.should == nil
+    end
+    @envelope.finished?.should == true
+    @envelope.content.should == content
+  end
+  
+  it "should be possible to parse complete envelopes" do
+    size = 100
+    content = "X" * size
+    overhang = @envelope.parse!([size].pack("N") + content)
+    overhang.should == nil
+    @envelope.finished?.should == true
+    @envelope.content.should == content
+  end
+  
+  it "shold be possible to parse an empty envelope" do
+    overhang = @envelope.parse!([0].pack("N"))
+    overhang.should == nil
+    @envelope.content.should == ""
+    @envelope.finished?.should == true
+  end
+  
+  it "should be possible to detect overhangs correctly" do
+    content = "X" * 120
+    overhang = @envelope.parse!([100].pack("N") + content)
+    overhang.should == "X" * 20
+    @envelope.finished?.should == true
+    @envelope.content.should == "X" * 100
+  end
+  
+  it "should be possible to lead an envelope from the overhang" do
+    content = ([20].pack("N") + ("X" * 20)) * 2
+    overhang = @envelope.parse!(content)
+    overhang.should == ([20].pack("N") + ("X" * 20))
+    @envelope.finished?.should == true
+    @envelope.content.should == "X" * 20
+    @envelope = MarilynRPC::Envelope.new
+    overhang = @envelope.parse!(overhang)
+    overhang.should == nil
+    @envelope.finished?.should == true
+    @envelope.content.should == "X" * 20
+  end
+  
+  it "should be possible to encode a envelope correctly" do
+    content = "Hallo Welt"
+    @envelope.content = content
+    @envelope.encode.should == [content.size].pack("N") + content
+  end
+  
+  it "should be possible to create a envelope using the initalizer" do
+    size = 100
+    content = "X" * size
+    @envelope = MarilynRPC::Envelope.new(content)
+    @envelope.finished?.should == true
+    @envelope.content.should == content
+  end
+end

data/spec/gentleman_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MarilynRPC::Gentleman do
+  before(:each) do
+    module MarilynRPC
+      def self.serialize(obj)
+        obj
+      end
+    end
+
+    class DeferObjectMock
+      attr_accessor :callback
+
+      def callback(&block)
+        @callback = block
+      end
+
+      def call(*args)
+        @callback.call(*args)
+      end
+    end
+
+    class ConnectionMock
+      attr_accessor :data
+      def send_mail(obj)
+        @data = obj
+      end
+    end
+  end
+  
+  it "should be possible to defer a process to a gentleman" do
+    deferable = DeferObjectMock.new
+    
+    g = MarilynRPC::Gentleman.new(deferable) do |a, b|
+      a + b
+    end
+    g.connection = ConnectionMock.new
+    deferable.call(1, 2)
+    g.connection.data.result.should == 3
+  end
+  
+  it "should be possible to create a gentleman helper" do
+    callback = nil
+    
+    g = MarilynRPC::Gentleman.proxy do |helper|
+      callback = helper
+    
+      lambda do |a, b|
+        a + b
+      end
+    end
+    
+    g.connection = ConnectionMock.new
+    callback.call(1, 2)
+    g.connection.data.result.should == 3
+  end
+end

data/spec/mails_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "MarilynRPC Mails" do
+  describe MarilynRPC::CallRequestMail do
+    it "should be possible to serialize and deserialize a request" do
+      tag = Time.now.to_f
+      mail = MarilynRPC::CallRequestMail.new(
+        tag, "/user", :find_by_name, ["mr.x"])
+      data = mail.encode
+      data.should include("find_by_name")
+      mail = MarilynRPC::CallRequestMail.new()
+      mail.decode(data)
+      mail.tag.should == tag
+      mail.path.should == "/user"
+      mail.method.should == :find_by_name
+      mail.args.should == ["mr.x"]
+    end
+  end
+  
+  describe MarilynRPC::CallResponseMail do
+    before(:each) do
+      class User < Struct.new(:name, :gid, :uid); end
+    end
+    
+    it "should be possible to serialize and deserialize a request" do
+      tag = Time.now.to_f
+      result = [
+        User.new("mr.x", 1, 1),
+        User.new("mr.xxx", 1, 2)
+      ]
+      mail = MarilynRPC::CallResponseMail.new(tag, result)
+      data = mail.encode
+      data.should include("mr.xxx")
+      mail = MarilynRPC::CallResponseMail.new
+      mail.decode(data)
+      mail.tag.should == tag
+      mail.result.should == result
+    end
+  end
+  
+  describe MarilynRPC::ExceptionMail do
+    it "should be possible to serialize and deserialize a request" do
+      exception = nil
+      begin
+        raise Exception.new "TestError"
+      rescue Exception => ex
+        exception = ex
+      end
+      mail = MarilynRPC::ExceptionMail.new(exception)
+      data = mail.encode
+      data.should include("TestError")
+      mail = MarilynRPC::ExceptionMail.new
+      mail.decode(data)
+      mail.exception.message.should == "TestError"
+      mail.exception.backtrace.size.should > 1
+    end
+  end
+  
+  describe MarilynRPC::MailFactory do
+    it "it should be possible to unpack mails encapsulated in envelopes" do
+      tag = Time.now.to_f
+      mail = MarilynRPC::CallRequestMail.new(
+        tag, "/user", :find_by_name, ["mr.x"])
+      envelope = MarilynRPC::Envelope.new(mail.encode)
+      mail = MarilynRPC::MailFactory.unpack(envelope)
+      mail.should be_a(MarilynRPC::CallRequestMail)
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MarilynRPC::Server do
+  before(:each) do
+    class ConnectionStub
+      include MarilynRPC::Server
+      attr_accessor :data
+
+      def initialize()
+        @data = ""
+      end
+
+      def send_data(data)
+        @data += data
+      end
+    end
+
+    @server = ConnectionStub.new
+  end
+  
+  it "should be possible to send multiple letters to the server" do
+    @server.post_init
+    @server.receive_data(MarilynRPC::Envelope.new("Test1").encode)
+    envelope = MarilynRPC::Envelope.new
+    envelope.parse!(@server.data)
+    mail = MarilynRPC::ExceptionMail.new
+    mail.decode(envelope.content)
+    mail.exception.message.should == "The passed type \"T\" is unknown!"
+    @server.receive_data(MarilynRPC::Envelope.new("Test2").encode)
+    @server.receive_data(MarilynRPC::Envelope.new("Test3").encode)
+    @server.unbind
+  end
+end

data/spec/service_cache.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MarilynRPC::ServiceCache do
+  before(:each) do
+    class DeferObjectMock
+      attr_accessor :callback
+
+      def callback(&block)
+        @callback = block
+      end
+
+      def call(*args)
+        @callback.call(*args)
+      end
+    end
+  
+    class TestService < MarilynRPC::Service
+      register "/test"
+      
+      def sync_method(a, b)
+        a + b
+      end
+      
+      def async_method(a, b)
+        calc = DeferObjectMock.new
+        MarilynRPC::Gentleman.new(calc) { |result| result }
+      end
+    end
+    @cache = MarilynRPC::ServiceCache.new
+  end
+  
+  it "should be possible to call a sync method" do
+    mail = MarilynRPC::CallRequestMail.new(1, "/test", :sync_method, [1, 2])
+    answer = @cache.call(mail)
+    answer.should be_a(MarilynRPC::CallResponseMail)
+    answer.result.should == 3
+  end
+  
+  it "should be possible to call an async method" do
+    mail = MarilynRPC::CallRequestMail.new(1, "/test", :async_method, [1, 2])
+    answer = @cache.call(mail)
+    answer.should be_a(MarilynRPC::Gentleman)
+    answer.tag.should == 1
+  end
+end

data/spec/service_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MarilynRPC::Service do
+  before(:each) do
+    class TestService < MarilynRPC::Service
+      register "/test"
+    end
+    
+    class ExtendedTestService < MarilynRPC::Service
+      register "/test/extended"
+    end
+  end
+  
+  it "should have to registered services" do
+    MarilynRPC::Service.registry.size.should == 2
+    MarilynRPC::Service.registry.should == {
+      "/test/extended" => ExtendedTestService, 
+      "/test" => TestService
+    }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$:.push(File.join(File.dirname(__FILE__), "..", "lib"))
+require "marilyn-rpc"

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: marilyn-rpc
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Vincent Landgraf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-04 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 59
+        segments: 
+        - 0
+        - 12
+        - 10
+        version: 0.12.10
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 4
+        version: "2.4"
+  type: :development
+  version_requirements: *id002
+description: |
+  A simple, beautiful event-based (EventMachine) RPC service and client library
+
+email: vilandgr+github@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- benchmark/client.rb
+- benchmark/server.rb
+- lib/marilyn-rpc/client.rb
+- lib/marilyn-rpc/envelope.rb
+- lib/marilyn-rpc/gentleman.rb
+- lib/marilyn-rpc/mails.rb
+- lib/marilyn-rpc/server.rb
+- lib/marilyn-rpc/service.rb
+- lib/marilyn-rpc/service_cache.rb
+- lib/marilyn-rpc/version.rb
+- lib/marilyn-rpc.rb
+- marilyn-rpc.gemspec
+- spec/envelope_spec.rb
+- spec/gentleman_spec.rb
+- spec/mails_spec.rb
+- spec/server_spec.rb
+- spec/service_cache.rb
+- spec/service_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/threez/marilyn-rpc
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple, beautiful event-based RPC
+test_files: 
+- spec/envelope_spec.rb
+- spec/gentleman_spec.rb
+- spec/mails_spec.rb
+- spec/server_spec.rb
+- spec/service_cache.rb
+- spec/service_spec.rb
+- spec/spec_helper.rb