vitobotta-brb 0.3.1

data/CHANGELOG.rdoc

@@ -0,0 +1,22 @@
+0.3.0 (May 21, 2010)
+
+* Added Callback functionality through block
+* Added Callback example
+* Little spec refactoring
+
+0.2.2 (Apr 21, 2010)
+
+* Change silent option to verbose
+
+0.2.1 (Apr 16, 2010)
+
+* Automatically start EM if not started
+* Deprecate the usage of BrB::Service.instance => use BrB::Service instead
+
+0.2.0 (Apr 16, 2010)
+
+* Releasing gem and wiki
+
+0.1.0 (Feb 01, 2009)
+
+* Initial release

data/Gemfile

@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+source 'http://gems.github.com'
+
+gem "rspec", "~> 1.3.2"
+gem "eventmachine"

data/Gemfile.lock

@@ -0,0 +1,13 @@
+GEM
+  remote: http://rubygems.org/
+  remote: http://gems.github.com/
+  specs:
+    eventmachine (0.12.10)
+    rspec (1.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  eventmachine
+  rspec (~> 1.3.2)

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,57 @@
+= BrB - Easy and Fast distributed ruby
+
+BrB is a simple, fully transparent and extremely fast interface for doing simple distributed Ruby.
+The core of the architecture is provided by EventMachine  (a fast and reliable IO event library).
+
+BrB was built in order to achieve these 4 main goals :
+* Simple and fast message passing between distant Ruby processes.
+* Message passing with of return values when needed.
+* Being extremely fast in order to handle more than a few thousand messages per second.
+* Being completely transparent for developer.
+
+The principle is simple and inspired from Drb (standard distributed ruby library) :
+A process exposes an object over the network and any ruby process (after having established a connection tunnel) can directly call a method on the exposed object. BrB handles that part, so 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 :)
+
+For any question, use the Ruby BrB google group: http://groups.google.com/group/ruby-brb
+
+== 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
+* Handle return values without blocking with the usage of a simple block
+* Blocking wait for a return value if needed by simply adding <em>_block</em> at the end of the method 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 designed 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
+* Writing more examples
+* Publish Benchmarks VS drb
+* Improve logging mechanism
+* Clean up
+
+== Contributors
+
+* kwi (Guillaume Luccisano)
+* bwalton (Brian Walton)
+* dpree (Jens Bissinger)
+
+
+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 --format specdoc"]
+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,40 @@
+require File.join(File.dirname(__FILE__), '../init.rb')
+
+port = 5555
+host = 'localhost'
+
+# 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}", :verbose => true)
+
+# 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}"
+
+## Calling method with a callback block for handling the return value
+core.simple_api_method do |r|
+  puts " > Get the callback response : #{r}"
+end
+
+puts " >> Callback method has been called continue .."
+sleep 2
+
+core.stop_service
+
+# Our job is over, close event machine :
+EM.stop

data/examples/simple_core.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), '../init.rb')
+
+class ExposedCoreObject
+  
+  def simple_api_method
+    puts "#{Thread.current} > In simple api method, now sleeping"
+    yield if block_given?
+    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'
+
+puts " > Starting the core on brb://#{host}:#{port}"
+BrB::Service.start_service(:object => ExposedCoreObject.new, :verbose => true, :host => host, :port => port)
+EM.reactor_thread.join

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,5 @@
+require File.join(File.dirname(__FILE__), 'brb', 'logger.rb')
+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', 'service.rb')
+require File.join(File.dirname(__FILE__), 'brb', 'tunnel.rb')

data/lib/brb/event_machine.rb

@@ -0,0 +1,91 @@
+# Define a BrB::Protocol using event machine
+require 'eventmachine'
+
+module BrB
+  class EventMachine
+
+    class << self
+
+    private
+      # If EM::run has not been called yet, start the EM reactor in another thread.
+      def ensure_em_is_started!
+        if !EM::reactor_running?
+          # Launch event machine reactor
+          q = Queue.new
+          Thread.new do
+            EM::run do
+              q << true # Set to the calling thread that the reactor is running
+              #EM::set_quantum(20)
+              #EventMachine::epoll
+            end
+          end
+          # Wait for event machine running :
+          q.pop
+        end
+
+      end
+
+    public
+      def open(uri, klass, opts = {})
+        host, port = parse_uri(uri)
+        begin
+          ensure_em_is_started!
+      
+          q = Queue.new
+          EM.schedule do
+            q << EM::connect(host, port, klass, opts.merge(:uri => "brb://#{host}:#{port}"))
+          end
+          
+          # Wait for socket connection with the q.pop
+          return q.pop
+
+        rescue Exception => e
+          BrB.logger.error e.backtrace.join("\n")
+          raise "#{e} - #{uri}"
+        end
+      end
+
+      def open_server(uri, klass, opts = {})
+        host, port = parse_uri(uri)
+        max = 80 # Nb try before giving up
+        begin
+          uri = "brb://#{host}:#{port}"
+          ensure_em_is_started!
+
+          # Schedule server creation for thread safety
+          q = Queue.new
+          EM.schedule do
+            q << EM::start_server(host, port, klass, opts.merge(:uri => uri))
+          end
+
+          # Wait for server creation with the q.pop
+          return uri, q.pop
+
+        rescue Exception => e
+          max -= 1
+          port += 1
+          retry if max > 0
+          BrB.logger.error e.backtrace.join("\n")
+          raise "#{e} - BrB Tcp Event machine Can not bind on #{host}:#{port}"
+        end
+
+      end
+    end
+  end
+  
+  class Protocol < EventMachine
+
+    class << self
+
+      def parse_uri(uri)
+        if /^brb:\/\/(.+):([0-9]+)$/ =~ uri 
+          [$1, $2.to_i]
+        else
+          raise "Bad tcp BrB url: '#{uri}'"
+        end
+      end
+
+    end
+  end
+end
+

data/lib/brb/exception.rb

@@ -0,0 +1,9 @@
+# Future BrB custom exceptions will come here
+class BrBException < Exception
+end
+
+class BrBCallbackWithBlockingMethodException < BrBException
+  def initialize
+    super('Out request can not be blocking and have a callback at the same time !')
+  end
+end

data/lib/brb/logger.rb

@@ -0,0 +1,35 @@
+require "logger"
+
+module BrB
+  class << self
+    
+    # returns the default logger instance
+    def default_logger
+      Logger.new(STDOUT)
+    end
+    
+    # set a custom logger instance
+    def logger=(custom_logger)
+      @@logger = custom_logger
+    end
+    
+    # returns the logger instance
+    def logger
+      # use default logger if no custom logger is set
+      @@logger = default_logger unless defined? @@logger
+      
+      # this overwrites the original method with a static definition
+      eval %Q{
+        def logger
+          @@logger
+        end
+      }
+      @@logger
+    end
+  end
+  
+  # alias to BrB.logger
+  def logger
+    BrB.logger
+  end
+end

data/lib/brb/request.rb

@@ -0,0 +1,98 @@
+module BrB
+  module Request
+    
+    MessageRequestCode  = :s
+    CallbackRequestCode = :c
+    ReturnCode          = :r
+
+    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, &blck)
+      Thread.current[:brb_nb_out] ||= 0
+      Thread.current[:brb_nb_out] += 1
+
+      raise BrBCallbackWithBlockingMethodException.new if is_brb_request_blocking?(meth) and block_given?
+
+      block = (is_brb_request_blocking?(meth) or block_given?) ? Thread.current.to_s.to_sym : nil
+      if block
+        args << block 
+        args << Thread.current[:brb_nb_out]
+      end
+      
+      if block_given?
+        # Simulate a method with _block in order to make BrB send the answer
+        meth = "#{meth}_block".to_sym
+      end
+
+      args.size > 0 ? brb_send([MessageRequestCode, meth, args]) : brb_send([MessageRequestCode, meth])
+
+      if block_given?
+        # Declare the callback
+        declare_callback(block, Thread.current[:brb_nb_out], &blck)
+
+      elsif block # Block until the request return
+
+        #TimeMonitor.instance.watch_thread!(@timeout_rcv_value || 45)
+        begin
+          r = recv(block, Thread.current[:brb_nb_out], &blck)
+        rescue Exception => e
+          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)
+      client_info =  {
+        :ip_address => @ip_address, 
+        :port       => @port 
+      }
+
+      if is_brb_request_blocking?(meth)
+
+        m = meth.to_s
+        m = m[0, m.size - 6].to_sym
+
+        idrequest = args.pop
+        thread = args.pop
+        
+        args << client_info
+        begin
+          # r = ((args.size > 0) ? @object.send(m, *args) : @object.send(m))
+          r = @object.send(m, *args)
+          brb_send([ReturnCode, r, thread, idrequest])
+        rescue Exception => e
+          brb_send([ReturnCode, e, thread, idrequest])
+          BrB.logger.error e.to_s
+          BrB.logger.error e.backtrace.join("\n")
+          #raise e
+        end
+      else
+        args << client_info
+        
+        begin
+          # (args.size > 0) ? @object.send(meth, *args) : @object.send(meth)
+          @object.send(meth, *args)
+        rescue Exception => e
+          BrB.logger.error "#{e.to_s} => By calling #{meth} on #{@object.class} with args : #{args.inspect}"
+          BrB.logger.error e.backtrace.join("\n")
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/brb/service.rb

@@ -0,0 +1,56 @@
+#
+# 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
+    @@uri = nil
+    @@em_signature = nil
+    @@verbose = false
+    
+    class << self
+
+    public
+
+      # 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
+  
+        @@verbose = opts[:verbose]
+        BrB.logger.level = @@verbose ? Logger::INFO : Logger::WARN
+
+        addr = opts[:uri] || "brb://#{opts[:host] || 'localhost'}:#{opts[:port] || 6200}"
+
+        BrB.logger.info " [BrB] Start service on #{addr} ..."
+        @@uri, @@em_signature = BrB::Protocol::open_server(addr, BrB::Tunnel::Handler, opts.merge(:block => block))
+        BrB.logger.info " [BrB] Service started on #{@@uri}"
+      end
+
+      def uri
+        @@uri
+      end
+
+      # Stop the Brb Service
+      def stop_service
+        return if !@@em_signature or !EM::reactor_running?
+      
+        BrB.logger.info " [BrB] Stop service on #{@@uri}"
+        sign = @@em_signature
+        q = Queue.new # Creation of a Queue for waiting server to stop
+        EM::schedule do
+          q << EM::stop_server(sign)
+        end
+        q.pop
+        @@em_signature = nil
+        @@uri = nil
+      end
+      
+      # Deprecated old method
+      def instance
+        BrB.logger.warn "DEPRECATION WARNING: BrB::Service::instance is deprecated => Just use BrB::Service"
+        self
+      end
+    end
+  end
+end

data/lib/brb/tunnel.rb

@@ -0,0 +1,95 @@
+# 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
+
+    # Create a BrB Tunnel by connecting to a distant BrB service
+    # Pass a block if you want to get register and unregister events
+    # The first parameter object is the object you want to expose in the BrB tunnel
+    def self.create(object, uri = nil, opts = {}, &block)
+      BrB::Protocol.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]
+        @verbose = opts[:verbose]
+        BrB.logger.level = @verbose ? Logger::INFO : Logger::WARN
+        @timeout_rcv_value = opts[:timeout] || 30 # Currently not implemented due to the lack of performance of ruby Timeout
+        @close_after_timeout = opts[:close_after_timeout] || false
+        @uri = opts[:uri]
+        @replock = Mutex.new
+        @responses = {}
+        @block = opts[:block]
+        
+        @queue = Queue.new
+        @buffer = ''
+        
+        # Callbacks handling :
+        @callbacks = {}
+        @callbacks_mutex = Mutex.new
+      end
+
+      # EventMachine Callback, called after connection has been initialized
+      def post_init
+        @port, @ip_address = Socket.unpack_sockaddr_in(get_peername) 
+        
+        BrB.logger.info " [BrB] Tunnel initialized on #{@uri}"
+        @active = true
+        if @block
+          EM.defer do
+            @block.call(:register, self)
+          end
+        end
+      end
+
+      def close_connection(after_writing = false)
+        @active = false
+        super
+      end
+
+      # EventMachine unbind event
+      # The connection has been closed
+      def unbind
+        BrB.logger.info ' [BrB] Tunnel service closed'
+        @active = false
+        if @block
+          EM.defer do
+            @block.call(:unregister, self)
+          end
+        end
+      end
+      
+      # Stop the service
+      def stop_service
+        BrB.logger.info ' [BrB] Stopping Tunnel service...'
+        @active = false
+        EM.schedule do
+          close_connection
+        end
+      end
+
+      # Return true if the tunnel is currently active
+      def active?
+        @active
+      end
+
+      # When no method is found on tunnel interface, create an brb out request
+      def method_missing(meth, *args, &block)
+        return nil if !@active
+        new_brb_out_request(meth, *args, &block)
+      end
+    end
+  end
+
+end

data/lib/brb/tunnel/shared.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+
+module BrB
+  module Tunnel
+    module Shared
+      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)
+              #BrB.logger.debug "  - > 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] == BrB::Request::ReturnCode
+
+            # Return if we have a callback handling the return :
+            next if treat_callback_return(obj[1], obj[2], obj[3])
+
+            # No callback, so blocking thread is waiting :
+            @replock.lock
+            @responses[obj[2]] ||= Queue.new
+            @replock.unlock
+            @responses[obj[2]] << [obj[1], obj[3]]
+          else
+            @queue << obj
+
+            EM.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
+
+      # Declare a new callback to call for a given request
+      # Thread safe code
+      def declare_callback(key, nb_out, &block)
+        @callbacks_mutex.lock
+
+        @callbacks[key] ||= {}
+        @callbacks[key][nb_out] = block
+
+      ensure
+        @callbacks_mutex.unlock
+      end
+      
+      # Return associated callback if present
+      # And if present, delete the associate callback from the table
+      # Thread safe code
+      def get_callback(key, nb_out)
+        @callbacks_mutex.lock
+        
+        if @callbacks[key] and b = @callbacks[key].delete(nb_out)
+          return b
+        end
+
+      ensure
+        @callbacks_mutex.unlock
+      end
+      
+      # Call a callback if present, return true if exists
+      # Non blocking action, use EM.defer
+      def treat_callback_return(ret, key, nb_out)
+
+        if b = get_callback(key, nb_out)
+          EM.defer do
+            # With arity, handle multiple block arguments or no arguments
+            b.arity == 1 ? b.call(ret) : (b.arity == 0 ? b.call : b.call(*ret)) 
+          end
+
+          # A callback has been found and called, return true
+          return true
+        end
+        
+        # No callback, do nothing
+        return nil
+      end
+
+      # Blocking method that wait on the @responses table an answer
+      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
+              
+              # Call the callback
+              if block_given?
+                yield(rep[0])
+              end
+
+              return rep[0]
+            end
+            if rep[1] > nb_out
+              return nil
+            end
+          end
+        rescue Exception => e
+          if @close_after_timeout == true
+            stop_service
+            sleep 1
+            raise e
+          else
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/spec/brb/brb_logger_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+class CustomLogger
+  attr_accessor :level, :history
+  def initialize
+    @history = []
+  end
+  def info(msg)
+    @history << msg
+  end
+  alias :error :info
+  alias :warn :info
+  alias :debug :info
+end
+
+describe :brb_logger do
+  before(:each) do
+    @original_logger = BrB.logger
+  end
+  
+  after(:each) do
+    BrB.logger = @original_logger
+  end
+  
+  it 'should be assigned a default logger' do
+    BrB.logger.should_not be_nil
+    BrB.logger.class.should == Logger
+  end
+  
+  it 'should be possible to use a custom logger' do
+    BrB.logger = CustomLogger.new
+    BrB.logger.info('foo')
+    BrB.logger.history.last.should == 'foo'
+  end
+end

data/spec/brb/brb_massive_usage_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe :brb_massive_usage do
+  before(:all) do
+    @brb = BrB::Service
+    @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
+  
+  def random_client
+    @clients[rand(@clients.size)]
+  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 5
+     # 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 callbacks" do
+    block_called = 0
+    nb_callbacks = 1000
+    nb_callbacks.times do |i|
+      random_client.return_same_value(i) do |callback_return_value|
+        callback_return_value.should == i
+        block_called += 1
+      end
+    end
+
+    sleep 2
+    # Wait a little in order to be sure the method is called
+    @brb_test.last_call.should == :return_same_value
+    block_called.should == nb_callbacks
+  end
+  
+  it "should works with massive simple messaging including blocking messaging and callbacks" 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
+    
+    block_called = 0
+    nb_callbacks = 1000
+    nb_callbacks.times do |i|
+      random_client.return_same_value(i) do |callback_return_value|
+        callback_return_value.should == i
+        block_called += 1
+      end
+    end
+  
+  
+    @clients.each do |cl|
+      nb_call_to_do.times do
+        cl.noarg
+      end
+    end
+  
+    sleep 5
+    block_called.should == nb_callbacks
+    t.join
+    # Wait a little in order to be sure all the stack is processed
+    @brb_test.nb_call.should == nb_callbacks + (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 'spec_helper'
+
+describe :brb_service do
+  before(:all) do
+    @brb = BrB::Service
+    @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,176 @@
+require 'spec_helper'
+
+$last_unregistered = nil
+$last_registered = nil
+
+describe :brb_tunnel do
+  before(:all) do
+    @brb = BrB::Service
+    @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 correctly return multiple values" do
+    r1, r2 = @client.return_same_value_twice_block(:ret, :ret2)
+    r1.should == :ret
+    r2.should == :ret2
+  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
+  
+  it "should use block as non blocking callback with return value" do
+    block_called = nil
+    @client.return_same_value(:arg) do |v|
+      v.should == :arg
+      block_called = true
+    end
+    sleep 0.2
+    # Wait a little in order to be sure the method is called
+    @brb_test.last_call.should == :return_same_value
+    block_called.should == true
+  end
+  
+  it "should correctly handle multiple values return with callbacks" do
+    block_called = nil
+    @client.return_same_value_twice(:ret, :ret2) do |r1, r2|
+      r1.should == :ret
+      r2.should == :ret2
+      block_called = true
+    end
+    sleep 0.2
+    # Wait a little in order to be sure the method is called
+    @brb_test.last_call.should == :return_same_value_twice
+    block_called.should == true
+  end
+  
+  it "should correctly handle no block args return with callbacks" do
+    block_called = nil
+    @client.return_same_value_twice(:ret, :ret2) do
+      block_called = true
+    end
+    sleep 0.2
+    # Wait a little in order to be sure the method is called
+    @brb_test.last_call.should == :return_same_value_twice
+    block_called.should == true
+  end
+  
+  it "should raise an exception when calling a blocking method with a callback" do
+    e = nil
+    begin
+      @client.return_same_value_block(:arg) do |v|
+      end
+    rescue Exception => e
+    end
+    e.should_not be_nil
+  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 client tunnel
+  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,54 @@
+require 'rubygems'
+require 'spec'
+
+Thread.abort_on_exception = true
+
+require File.dirname(__FILE__) + '/../init.rb'
+
+def open_service(object, host = 'localhost', port = 6200)
+  BrB::Service.start_service(:object => object, :verbose => false, :host => host, :port => port)
+end
+
+def connect_to_the_service(object_exposed, uri, &block)
+  BrB::Tunnel.create(object_exposed, uri, :verbose => false, &block)
+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
+  
+  def return_same_value_twice(val, val2)
+    increment_nb_call(:return_same_value_twice)
+    return val, val2
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: vitobotta-brb
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+  prerelease: 
+platform: ruby
+authors:
+- Guillaume Luccisano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-06-26 00:00:00.000000000 +01:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &2156366080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156366080
+description: BrB is a simple, fully transparent 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/logger.rb
+- lib/brb/request.rb
+- lib/brb/service.rb
+- lib/brb/tunnel/shared.rb
+- lib/brb/tunnel.rb
+- lib/brb.rb
+- spec/brb/brb_logger_spec.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
+- Gemfile
+- Gemfile.lock
+- 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
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.4
+requirements:
+- eventmachine
+rubyforge_project: vitobotta-brb
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: BrB is a simple, fully transparent and extremely fast interface for doing
+  simple distributed ruby
+test_files: []