brb 0.2.0

data/CHANGELOG.rdoc

@@ -0,0 +1,7 @@
+0.2.0 (Apr 16, 2010)
+
+* Releasing gem and wiki
+
+0.1.0 (Feb 01, 2009)
+
+* Initial release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Guillaume Luccisano - g-mai|: guillaume.luccisano
+
+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/README.rdoc

@@ -0,0 +1,49 @@
+= BrB - Easy and Fast distributed ruby
+
+BrB is a simple and extremely fast interface for doing simple distributed ruby.
+The main power of the architecture is provided by EventMachine (Fast and reliable IO event library).
+
+BrB was build in order to achieve these 4 main goals :
+* Simple and fast message passing between distant ruby process.
+* Message passing with handling of return value when needed.
+* Being extremely fast in order to handle more than a few thousand messages per seconds.
+* Being completely transparent for developer.
+
+The principle is simple and inspired from Drb (Original distributed ruby library) :
+A process want to expose an object on the network, and want other ruby processes calling directly method on it.
+BrB handle all that part, it's fully transparent in the ruby code.
+
+BrB only support message passing with Marshable dumpable object : String, symbol, Array, hash, Number, Object etc...
+That mean you can not send file descriptor, Thread or another funky things like that :)
+
+== Main Functionalities
+
+* Unlimited objects exposed
+* Processes can expose object and be client to exposed object too at the same time
+* Do not wait for return by default : just do simple message passing
+* Wait for return if needed by simply adding <em>_block</em> at the end of the function name
+* Transmission of Exception when blocking call
+* Thread safe if used correctly with Event Machine
+
+== How it works
+
+First of all, a process declare himself as a sever and expose any object on a given address and port.
+Then, any number of distant processes can create a <em>Tunnel</em> with that server and can expose an object in exchange too.
+After connection are ready, just call method on the tunnel. It will just act like normal method calling on the exposed object !
+
+== What BrB is usable for ?
+
+* Doing Simple message passing between ruby process.
+* Connecting hundred of ruby process transparently.
+* Building a real-time scalable (game) server
+* Taking important load on a server easily just by distributing the load on multiple BrB instance.
+* Taking advantage of multi-core and multi-threaded systems.
+
+==  TODO
+* Better README and Wiki
+* Writing more examples
+* Publish Benchmarks VS drb
+* Improve logging mechanism
+* Clean up
+
+Copyright (c) 2009-2010 Guillaume Luccisano - g-mai|: guillaume.luccisano, released under the MIT license

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'rake'
+require 'spec/rake/spectask'
+
+spec_files = Rake::FileList["spec/**/*_spec.rb"]
+
+desc "Run specs for current Rails version"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = spec_files
+  t.spec_opts = ["-c"]
+end
+
+task :default => :spec
+
+desc "Run simple core"
+task :simple_core_example do
+  require 'examples/simple_core'
+end
+
+desc "Run simple client (call simple_core_before)"
+task :simple_client_example do
+  require 'examples/simple_client'
+end

data/examples/simple_client.rb

@@ -0,0 +1,37 @@
+require 'lib/brb'
+
+port = 5555
+host = 'localhost'
+
+EM::run do
+  EM::set_quantum(20)
+  # Connecting to the core server, retrieving its interface object : core
+  # We do not want to expose an object, so the first parameter is nil
+  core = BrB::Tunnel.create(nil, "brb://#{host}:#{port}", :silent => false)
+
+  # Create thread here, as you can not block the EventMachine::run block
+  Thread.new do
+
+    # Calling 10 times an non blocking method on the distant core server
+    10.times do
+      core.simple_api_method # Do not wait for response
+    end
+    
+    # Calling 10 times again long treatment time distant methods
+    10.times do
+      core.simple_long_api_method # Do not wait for response
+    end
+
+    # Calling a blocking method with _block on the distant core server :
+    puts " >> Calling 1s call, and wait for response..."
+    r = core.simple_api_method_block
+    puts " > Api response : #{r}"
+    
+    puts " >> Calling long call, and wait for response..."
+    r = core.simple_long_api_method_block
+    puts " > Api long response : #{r}"
+
+    # Our job is over, close
+    EM.stop
+  end
+end

data/examples/simple_core.rb

@@ -0,0 +1,31 @@
+require 'lib/brb'
+
+class ExposedCoreObject
+  
+  def simple_api_method
+    puts "#{Thread.current} > In simple api method, now sleeping"
+    sleep 1
+    puts "#{Thread.current} > Done sleeping in simple api method, return"
+    return 'OK'
+  end
+  
+  def simple_long_api_method
+    puts "#{Thread.current} > In simple long api method, now sleeping"
+    sleep 10
+    puts "#{Thread.current} > Done sleeping in long api method, return"
+    return 'OK LONG'
+  end
+  
+end
+
+Thread.abort_on_exception = true
+
+port = 5555
+host = 'localhost'
+
+EM::run do
+  EM::set_quantum(20)
+
+  puts " > Starting the core on brb://#{host}:#{port}"
+  BrB::Service.instance.start_service(:object => ExposedCoreObject.new, :silent => false, :host => host, :port => port)
+end

data/init.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), 'lib', 'brb.rb')

data/lib/brb.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), 'brb', 'exception.rb')
+require File.join(File.dirname(__FILE__), 'brb', 'event_machine.rb')
+require File.join(File.dirname(__FILE__), 'brb', 'tunnel.rb')
+require 'singleton'
+
+#
+# Brb Main class used to do basic distributed ruby, Simple but fast
+# Use two distinct canal, one for the command reception, and the other one for send return value
+#
+module BrB
+  class Service
+    attr_reader :silent
+    attr_reader :uri
+
+    include Singleton
+
+    # Start a server hosted on the object given,
+    # If an uri is given, automatcilay connect to the distant brb object
+    def start_service(opts = {}, &block)
+      return if @em_signature
+      
+      @silent = opts[:silent]
+
+      addr = "brb://#{opts[:host] || 'localhost'}:#{opts[:port] || 6200}"
+
+      tputs " [BrB] Start service on #{addr} ..."
+      @uri, @em_signature = BrBProtocol.open_server(addr, BrB::Tunnel::Handler, opts.merge(:block => block))
+      tputs " [BrB] Service started on #{@uri}"
+    end
+
+private
+    def tputs(s)
+      puts s if !@silent
+    end
+
+public
+    # Stop the Brb Service
+    def stop_service
+      return if !@em_signature
+      
+      tputs ' [BrB] Stop service'
+      EM::stop_server(@em_signature)
+      @em_signature = nil
+      @uri = nil
+    end
+
+  end
+end

data/lib/brb/event_machine.rb

@@ -0,0 +1,44 @@
+require 'eventmachine'
+
+# Define a BrBProtocol using event machine
+class BrBEventMachine
+
+  def self.parse_uri(uri)
+    if /^brb:\/\/(.+):([0-9]+)$/ =~ uri 
+      [$1, $2.to_i]
+    else
+      raise "Bad tcp BrB url: '#{uri}'"
+    end
+  end
+
+  def self.open(uri, klass, opts = {})
+    host, port = parse_uri(uri)
+    begin
+      socket = EventMachine::connect host, port, klass, opts.merge(:uri => "brb://#{host}:#{port}")
+
+    rescue Exception => e
+      puts e.backtrace.join("\n")
+      raise "#{e} - #{uri}"
+    end
+    return socket
+  end
+
+  def self.open_server(uri, klass, opts = {})
+    host, port = parse_uri(uri)
+    max = 80
+    begin
+      #EventMachine::epoll
+      uri = "brb://#{host}:#{port}"
+      return uri, EventMachine::start_server(host, port, klass, opts.merge(:uri => uri))
+    rescue Exception => e
+      max -= 1
+      port += 1
+      retry if max > 0
+      puts e.backtrace.join("\n")
+      raise "#{e} - BrB Tcp Event machine Can not bind on #{host}:#{port}"
+    end
+  end
+end
+
+class BrBProtocol < BrBEventMachine
+end

data/lib/brb/request.rb

@@ -0,0 +1,81 @@
+module BrB
+  module Request
+
+    def is_brb_request_blocking?(meth)
+      if m = meth.to_s and m.rindex('_block') == (m.size - 6)
+        return true
+      end
+      nil
+    end
+
+    # Execute a request on a distant object
+    def new_brb_out_request(meth, *args)
+      Thread.current[:brb_nb_out] ||= 0
+      Thread.current[:brb_nb_out] += 1
+
+      block = is_brb_request_blocking?(meth) ? Thread.current.to_s.to_sym : nil
+      if block
+        args << block 
+        args << Thread.current[:brb_nb_out]
+      end
+
+      args.size > 0 ? brb_send([:s, meth, args]) : brb_send([:s, meth])
+
+      # Block jusqu'au retour de la requete
+      if block
+        #TimeMonitor.instance.watch_thread!(@timeout_rcv_value || 45)
+        begin
+          r = recv(block, Thread.current[:brb_nb_out])
+        rescue Exception => e
+          #@object.log_error(e, "Error sending out request #{meth}(#{args.inspect})")
+          raise e
+        ensure
+          #TimeMonitor.instance.remove_thread!
+        end
+        if r.kind_of? Exception
+          raise r
+        end
+        return r
+      end
+
+      nil
+    end
+
+    # Execute a request on the local object
+    def new_brb_in_request(meth, *args)
+
+      if is_brb_request_blocking?(meth)
+
+        m = meth.to_s
+        m = m[0, m.size - 6].to_sym
+
+        idrequest = args.pop
+        thread = args.pop
+        begin
+          #TimeMonitor.instance.watch_thread!(25)
+          r = ((args.size > 0) ? @object.send(m, *args) : @object.send(m))
+          brb_send([:r, r, thread, idrequest])
+        rescue Exception => e
+          brb_send([:r, e, thread, idrequest])
+          tputs e.to_s
+          tputs e.backtrace.join("\n")
+          #raise e
+        ensure
+          #TimeMonitor.instance.remove_thread!
+        end
+      else
+
+        begin
+          (args.size > 0) ? @object.send(meth, *args) : @object.send(meth)
+        rescue Exception => e
+          tputs "#{e.to_s} => By calling #{meth} on #{@object.class} with args : #{args.inspect}"
+          tputs e.backtrace.join("\n")
+          raise e
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/brb/tunnel.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+require 'eventmachine'
+require File.join(File.dirname(__FILE__), 'request.rb')
+require File.join(File.dirname(__FILE__), 'tunnel', 'shared.rb')
+
+module BrB
+  module Tunnel
+
+    def self.create(object, uri = nil, opts = {}, &block)
+      BrBProtocol.open(uri, BrB::Tunnel::Handler, opts.merge(:object => object, :block => block))
+    end
+
+    # Brb interface Handler for Tunnel over Event machine
+    class Handler < EventMachine::Connection
+      attr_reader :uri
+
+      include BrB::Request
+      include BrB::Tunnel::Shared
+
+      def initialize(opts = {})
+        super
+        @object = opts[:object]
+        @silent = opts[:silent]
+        @timeout_rcv_value = opts[:timeout] || 30
+        @close_after_timeout = opts[:close_after_timeout] || false
+        @uri = opts[:uri]
+        @closed = nil
+        @replock = Mutex.new
+        @responses = {}
+        @block = opts[:block]
+        @mu = Mutex.new
+        
+        @queue = Queue.new
+        @buffer = ''
+      end
+
+      def post_init
+        tputs " [BrB] Tunnel initialized on #{@uri}"
+        @active = true
+        if @block
+          EventMachine.defer do
+            @block.call(:register, self)
+          end
+        end
+      end
+      
+      def close_connection(after_writing = false)
+        @active = false
+        super
+      end
+
+      def unbind
+        tputs ' [BrB] Tunnel service closed'
+        @active = false
+        if @block
+          EventMachine.defer do
+            @block.call(:unregister, self)
+          end
+        end
+      end
+      
+      def stop_service
+        tputs ' [BrB] Stop Tunnel service'
+        @active = false
+        EM.schedule do
+          close_connection
+        end
+      end
+
+      def active?
+        @active
+      end
+
+      def method_missing(meth, *args)
+        return nil if !@active
+        new_brb_out_request(meth, *args)
+      end
+    end
+  end
+
+end

data/lib/brb/tunnel/shared.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+module BrB
+  module Tunnel
+    module Shared
+      def tputs(s)
+        puts s if !@silent
+      end
+
+      def make_proxy(r)
+        if r.is_a?(Array)
+          t = []
+          r.each do |obj|
+            t << if obj.is_a? Array
+              make_proxy(obj)
+            elsif !obj.is_a?(Symbol) and !obj.is_a?(String) and obj and !(Marshal::dump(obj) rescue nil)
+              #puts "  - > Make proxy for : #{obj.class}"
+              obj.to_s.to_sym
+            else
+              obj
+            end
+          end
+          return t
+        else
+          return r.to_s
+        end
+      end
+
+      def brb_send(r)
+        return nil if !@active
+        s = Marshal::dump(r) rescue Marshal::dump(make_proxy(r))
+
+        s = [s.size].pack('N') + s
+        EM.schedule do
+          send_data s
+        end
+      end
+
+      SizeOfPackedInt = [1].pack('N').size
+
+      def load_request
+        return nil if @buffer.size < SizeOfPackedInt
+        len = @buffer.unpack('N').first + SizeOfPackedInt
+        if @buffer.size < len
+          return nil
+        end
+
+        obj =  Marshal::load(@buffer[SizeOfPackedInt, len])
+        @buffer.slice!(0,len)
+        return obj
+      end
+
+      def receive_data(data)
+        @buffer << data
+        
+        while obj = load_request
+          if obj[0] == :r
+            @replock.lock
+            @responses[obj[2]] ||= Queue.new
+            @replock.unlock
+            @responses[obj[2]] << [obj[1], obj[3]]
+          else
+
+            @queue << obj
+
+            EventMachine.defer do
+              treat_request(@queue.pop)
+            end
+            
+          end
+        end
+      end
+
+      def treat_request(obj)
+        if obj.size == 2
+          new_brb_in_request(obj[1])
+        else
+          new_brb_in_request(obj[1], *(obj.last))
+        end
+      end
+
+      def recv(key, nb_out)
+        begin
+          @replock.lock
+          r = @responses[key] ||= Queue.new
+          @replock.unlock
+          while rep = r.pop
+            if rep[1] == nb_out # On check ke c'est bien la réponse que l'on attend
+              return rep[0]
+            end
+            #Error.create(:backtrace => "Error in Brb receiving in thread #{Thread.current}. Try to get #{nb_out} request id, but get #{rep[1]}", :type => 'BrBRecvBadId', :url => "#{@object.class}-#{@uri}")
+            if rep[1] > nb_out
+              return nil
+            end
+          end
+        rescue Exception => e
+          if @close_after_timeout == true
+            #Error.create(:backtrace => "Error in Rcv in thread #{Thread.current}. Try to get #{nb_out} => Stop service #{e.class.to_s}\n\n#{e.backtrace.join("\n")}", :type => e.to_s, :url => "#{@object.class}-#{@uri}")
+            stop_service
+            sleep 1
+            raise e
+          else
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/spec/brb/brb_massive_usage_spec.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe :brb_service do
+  before(:all) do
+    @brb = BrB::Service.instance
+    @brb.stop_service
+    @brb_test = BrBTest.new
+    open_service(@brb_test)
+    @clients = []
+    20.times do
+      @clients << connect_to_the_service(self, @brb.uri) do |type, tunnel|
+      end
+    end
+  end
+  
+  # Start the service
+  it "should the service be started" do
+     @clients.each do |cl|
+       cl.should_not be_nil
+       cl.active?.should be_true
+       cl.uri.should == @brb.uri
+     end
+  end
+  
+  it "should works with massive simple messaging" do
+    nb_call_before = @brb_test.nb_call || 0
+    nb_call_to_do = 500
+
+    @clients.each do |cl|
+      nb_call_to_do.times do
+        cl.noarg
+      end
+    end
+
+    sleep 6
+    # Wait a little in order to be sure all the stack is processed
+    @brb_test.last_call.should == :noarg
+    @brb_test.nb_call.should == (nb_call_to_do * @clients.size) + nb_call_before
+  end
+
+  it "should works with massive simple messaging including blocking messaging" do
+    nb_call_before = @brb_test.nb_call || 0
+    nb_call_to_do = 500
+    nb_call_blocking_to_do = 50
+
+    t = Thread.new do
+      @clients.each do |cl|
+        nb_call_blocking_to_do.times do
+          val = Time.now.to_f
+          cl.return_same_value_block(val).should == val
+        end
+      end      
+    end
+
+    @clients.each do |cl|
+      nb_call_to_do.times do
+        cl.noarg
+      end
+    end
+
+    sleep 6
+    t.join
+    # Wait a little in order to be sure all the stack is processed
+    @brb_test.nb_call.should == (nb_call_to_do * @clients.size + nb_call_blocking_to_do * @clients.size) + nb_call_before
+  end
+
+  # Finally, stop the service
+  it "should stop the service after usage" do
+    @brb.stop_service
+    @brb.uri.should be_nil
+  end
+end

data/spec/brb/brb_service_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe :brb_service do
+  before(:all) do
+    @brb = BrB::Service.instance
+    @brb.stop_service
+    @brb_test = BrBTest.new
+    open_service(self)
+  end
+  
+  # Start the service
+  it "should open a service on localhost:6200" do
+    @brb.uri.should_not be_nil
+  end
+
+  # Finally, stop the service
+  it "should stop the service" do
+    @brb.stop_service
+    @brb.uri.should be_nil
+  end
+
+  it "should start again the service after a stop" do
+    open_service(self)
+    @brb.stop_service
+    open_service(self)
+    @brb.uri.should_not be_nil
+  end
+end
+

data/spec/brb/brb_tunnel_spec.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+$last_unregistered = nil
+$last_registered = nil
+
+describe :brb_service do
+  before(:all) do
+    @brb = BrB::Service.instance
+    @brb.stop_service
+    @brb_test = BrBTest.new
+    open_service(@brb_test)
+    @client = connect_to_the_service(self, @brb.uri) do |type, tunnel|
+      if type == :unregister
+        $last_unregistered = tunnel
+      elsif type == :register
+        $last_registered = tunnel
+      end
+    end
+  end
+  
+  # Start the service
+  it "should the service be started" do
+    @client.should_not be_nil
+    @client.active?.should be_true
+    @client.uri.should == @brb.uri
+  end
+  
+  it "should have get the register message" do
+    sleep 0.2 # Be sure to get the message
+    $last_registered.class.should == @client.class
+  end
+  
+  it "should correctly call simple distant method without args and without return" do
+    @client.noarg
+    sleep 0.2
+    # Wait a little in order to be sure the method is called
+    @brb_test.last_call.should == :noarg
+  end
+
+  it "should correctly call simple distant method without args and without return multipe times" do
+    nb_call_before = @brb_test.nb_call
+    nb_call_to_do = 50
+    
+    nb_call_to_do.times do
+      @client.noarg
+    end
+    sleep 0.2
+    # Wait a little in order to be sure the method is called
+    @brb_test.last_call.should == :noarg
+    @brb_test.nb_call.should == nb_call_to_do + nb_call_before
+  end
+  
+  it "should correctly call distant method with one argument" do
+    @client.very_long(:hello)
+    sleep 0.2
+    # Wait a little in order to be sure the method is called
+    @brb_test.last_args.should == [:hello]
+  end
+  
+  it "should correctly call distant method with multiple arguments" do
+    args = [:one, :two, 3, "four"]
+    @client.fourargs(*args)
+    sleep 0.2
+    # Wait a little in order to be sure the method is called
+    @brb_test.last_args.should == args
+  end
+
+  it "should correctly return arguments symbol value" do
+    @client.one_arg_with_return_block(:hello).should == :hello
+  end
+
+  it "should correctly return arguments string value" do
+    @client.one_arg_with_return_block('hello').should == 'hello'
+  end
+  
+  it "should correctly return arguments Fixnum value" do
+    @client.one_arg_with_return_block(42).should == 42
+  end
+  
+  it "should correctly return arguments Float value" do
+    @client.one_arg_with_return_block(42.42).should == 42.42
+  end
+  
+  it "should correctly return arguments Table value" do
+    @client.one_arg_with_return_block([:one, :two, 3, "four"]).should == [:one, :two, 3, "four"]
+  end
+  
+  it "should correctly return arguments Hash value" do
+    h = {:yoyo => :titi, "salut" => 45}
+    @client.one_arg_with_return_block(h).should == h
+  end
+  
+  it "should dump to symbol undumpable value by using the proxy" do
+    @client.return_same_value_block(Thread.current).class.should == Symbol
+    @client.return_same_value_block(Thread.current).should == Thread.current.to_s.to_sym
+  end
+
+  it "should transmit with success exception when blocking" do
+    e = nil
+    begin
+      @client.notavalidmeth_block
+    rescue Exception => e
+    end
+    e.should be_a NameError
+  end
+
+  # Finally, stop the service
+  it "should stop the service after usage" do
+    @brb.stop_service
+    @brb.uri.should be_nil
+  end
+
+  # Finally, stop the service
+  it "should stop the tunnel after usage" do
+    @client.stop_service
+    @client.active?.should_not be_true
+  end
+
+  it "should have get the unregister message" do
+    sleep 0.2 # Be sure to get the message
+    $last_unregistered.class.should == @client.class
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'spec'
+
+Thread.abort_on_exception = true
+
+require File.dirname(__FILE__) + '/../init.rb'
+
+def open_service(object, host = 'localhost', port = 6200)
+  if !EM::reactor_running?
+    # Launch event machine reactor
+    Thread.new do
+      EM::run do
+        EM::set_quantum(20)
+      end
+    end
+    sleep 0.05
+  end
+  r = nil
+  EM.schedule do
+    r = BrB::Service.instance.start_service(:object => object, :silent => true, :host => host, :port => port)
+  end
+  sleep 0.1
+  return r
+end
+
+def connect_to_the_service(object_exposed, uri, &block)
+  r = nil
+  EM.schedule do
+    r = BrB::Tunnel.create(object_exposed, uri, :silent => true, &block)
+  end
+  sleep 0.1
+  return r
+end
+
+class BrBTest
+  attr_reader :last_call
+  attr_reader :last_args
+  attr_reader :nb_call
+  
+  def increment_nb_call(call_name, *args)
+    @last_call = call_name
+    @last_args = args
+    @nb_call ||= 0
+    @nb_call += 1
+  end
+  
+  def very_long(ar)
+    increment_nb_call(:very_long, ar)
+  end
+
+  def fourargs(arg1, arg2, arg3, arg4)
+    increment_nb_call(:fourargs, arg1, arg2, arg3, arg4)
+  end
+
+  def noarg
+    increment_nb_call(:noarg)
+  end
+
+  def one_arg_with_return(ar)
+    increment_nb_call(:one_arg_with_return)
+    return ar
+  end
+  
+  def return_same_value(val)
+    increment_nb_call(:return_same_value)
+    return val
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: brb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Guillaume Luccisano
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-16 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: BrB is a simple and extremely fast interface for doing simple distributed ruby and message passing
+email: guillaume.luccisano@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- examples/simple_client.rb
+- examples/simple_core.rb
+- lib/brb/event_machine.rb
+- lib/brb/exception.rb
+- lib/brb/request.rb
+- lib/brb/tunnel/shared.rb
+- lib/brb/tunnel.rb
+- lib/brb.rb
+- spec/brb/brb_massive_usage_spec.rb
+- spec/brb/brb_service_spec.rb
+- spec/brb/brb_tunnel_spec.rb
+- spec/spec_helper.rb
+- CHANGELOG.rdoc
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- init.rb
+has_rdoc: true
+homepage: http://github.com/kwi/BrB
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 4
+      version: 1.3.4
+requirements: 
+- eventmachine
+rubyforge_project: brb
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: BrB is a simple and extremely fast interface for doing simple distributed ruby
+test_files: []
+