rubarb 0.2.0

data/.gitignore

@@ -0,0 +1,7 @@
+dkbrpc.i*
+rubarb.i*
+pkg
+.idea
+*.iml
+.rakeTasks
+*.gemspec

data/README

@@ -0,0 +1,77 @@
+rubaRb
+A Bidirectional Event Machine Based Remote Procedure Call Library for Ruby
+
+This library uses two socket connections between a client and a server.
+One is used for request / replies from the client to the server.
+The other is used for remote calls made from the server to the client.
+
+Each end publishes a single object on which methods can be called by the remote end.
+All calls to the remote objects are asyncronous.  Do not make any blocking calls in
+the published object.  Responses are return by calling the "reply method on the responder object.
+
+Server and Connection object may be created and started outside of EM::run,
+but the Eventmachine reactor must be started somewhere in your application
+
+################################# Server Example #####################################################################
+
+class ServerApi
+  def time(responder)
+    puts "Server received time request"
+    responder.reply(Time.now)
+  end
+end
+
+EM.run do
+  server = Rubarb::Server.new("127.0.0.1", 9441, ServerApi.new)
+
+  connections = {}
+
+  server.start do |client|
+    puts "Connection Made:  #{client}"
+    client.name do |name|
+      connections[name] = client
+      client.errback do
+        puts "Connection Lost:  #{name}"
+        connections.delete(name)
+      end
+
+    end
+
+  end
+
+  EventMachine.add_periodic_timer(1) { puts "Connections:  #{connections.keys.inspect}" }
+
+end
+######################################################################################################################
+
+
+################################# Client Example #####################################################################
+class ClientApi
+  def initialize(name)
+    @name = name
+  end
+  def name(responder)
+    responder.reply(@name)
+  end
+end
+
+EM::run do
+  connection = Rubarb::Connection.new("127.0.0.1", 9441, ClientApi.new(ARGV[0]))
+  connection.errback do |error|
+    puts ("Connection Error:  #{error}")
+  end
+
+  connection.start do
+    connection.time do |response|
+      puts "Server Said it is:  #{response.strftime("%D")}"
+    end
+
+    EventMachine.add_timer(20) do
+      puts "stopping"
+      connection.stop
+      EM::stop
+    end
+  end
+
+end
+######################################################################################################################

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rubarb"
+    gem.summary = %Q{A Bidirectional Event Machine Based Remote Procedure Call Library for Ruby}
+    gem.description = %Q{This library uses two socket connections between a client and a server. One is used for request / replies from the
+client to the server.  The other is used for remote calls made from the server to the client.
+
+Each end publishes a single object on which
+methods can be called by the remote end.  All calls to the remote objects are asyncronous.  Do not make any blocking
+calls in the published object.  Responses are return by calling the "reply method on the responder object.}
+    
+    gem.email = "doug@8thlight.com"
+    gem.homepage = "http://github.com/dougbradbury/rubarb"
+    gem.authors = ["doug bradbury"]
+    gem.add_development_dependency "rspec", ">= 1.3.0"
+    gem.add_dependency "eventmachine", ">= 0.12.11"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rubarb-gem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/examples/client.rb

@@ -0,0 +1,32 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'rubygems'
+require 'rubarb'
+
+class ClientApi
+  def initialize(name)
+    @name = name
+  end
+  def name(responder)
+    responder.reply(@name)
+  end
+end
+
+EM::run do
+  connection = Rubarb::Connection.new("127.0.0.1", 9441, ClientApi.new(ARGV[0]))
+  connection.errback do |error|
+    puts ("Connection Error:  #{error}")
+  end
+
+  connection.start do
+    connection.time do |response|
+      puts "Server Said it is:  #{response.strftime("%D")}"
+    end
+
+    EventMachine.add_timer(20) do
+      puts "stopping"
+      connection.stop
+      EM::stop
+    end
+  end
+
+end

data/examples/server.rb

@@ -0,0 +1,34 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+#$DEBUG = true
+require 'rubygems'
+require 'rubarb'
+
+
+class ServerApi
+  def time(responder)
+    puts "Server received time request"
+    responder.reply(Time.now)
+  end
+end
+
+EM.run do
+  server = Rubarb::Server.new("127.0.0.1", 9441, ServerApi.new)
+
+  connections = {}
+
+  server.start do |client|
+    puts "Connection Made:  #{client}"
+    client.name do |name|
+      connections[name] = client
+      client.errback do
+        puts "Connection Lost:  #{name}"
+        connections.delete(name)
+      end
+
+    end
+
+  end
+
+  EventMachine.add_periodic_timer(1) { puts "Connections:  #{connections.keys.inspect}" }
+
+end

data/lib/dkbrpc.rb

@@ -0,0 +1,4 @@
+#provided for backwards compatiblity with old name of gem
+require "rubarb/connection"
+require "rubarb/server"
+Dkbrpc = Rubarb

data/lib/rubarb.rb

@@ -0,0 +1,2 @@
+require "rubarb/connection"
+require "rubarb/server"

data/lib/rubarb/connection.rb

@@ -0,0 +1,170 @@
+require "rubarb/connection_id"
+require "rubarb/fast_message_protocol"
+require "rubarb/remote_call"
+require 'rubarb/outgoing_connection'
+require 'rubarb/incoming_connection'
+require 'rubarb/connection_error'
+require 'rubarb/default'
+
+module Rubarb
+  module IncomingHandler
+    include ConnectionId
+
+    attr_accessor :id
+    attr_accessor :on_connection
+    attr_accessor :api
+    attr_accessor :errbacks
+    attr_accessor :insecure_methods
+
+    def post_init
+      @buffer = ""
+    end
+
+    def connection_completed
+      Rubarb::FastMessageProtocol.install(self)
+      send_data("5")
+      send_data(@id)
+    end
+
+    def receive_message message
+      if (message == @id)
+        self.extend(Rubarb::IncomingConnection)
+        @on_connection.call if @on_connection
+      else
+        call_errbacks(ConnectionError.new("Handshake Failure"))
+      end
+    end
+
+    def unbind
+      call_errbacks(ConnectionError.new)
+    end
+
+    def call_errbacks(message)
+      @errbacks.each do |e|
+        e.call(message)
+      end
+    end
+
+  end
+
+  module OutgoingHandler
+    include ConnectionId
+    include OutgoingConnection
+    attr_accessor :host
+    attr_accessor :port
+    attr_accessor :on_connection
+    attr_accessor :api
+    attr_accessor :errbacks
+    attr_accessor :callback
+    attr_accessor :msg_id_generator
+    attr_accessor :insecure_methods
+
+    def post_init
+      @buffer = ""
+    end
+
+    def connection_completed
+      send_data("4")
+    end
+
+    def receive_data data
+      @buffer << data
+      if @id.nil?
+        handshake(@buffer)
+      end
+    end
+
+    def unbind
+      if @incoming_connection
+        EM.next_tick { @incoming_connection.close_connection }
+      else
+        call_errbacks(ConnectionError.new)
+      end
+    end
+
+    def call_errbacks(message)
+      @errbacks.each do |e|
+        e.call(message)
+      end
+    end
+
+    private
+
+    def handshake(buffer)
+      if complete_id?(buffer)
+        Rubarb::FastMessageProtocol.install(self)
+        EventMachine::connect(@host, @port, IncomingHandler) do |incoming_connection|
+          @id = extract_id(buffer)
+          incoming_connection.id = @id
+          incoming_connection.on_connection = @on_connection
+          incoming_connection.api = @api
+          incoming_connection.errbacks = @errbacks
+          incoming_connection.insecure_methods = @insecure_methods
+          @incoming_connection = incoming_connection
+        end
+      end
+    end
+  end
+
+  class Connection
+    attr_reader :remote_connection
+    attr_reader :msg_id_generator
+
+    def initialize(host, port, api, insecure_methods=Default::INSECURE_METHODS)
+      @host = host
+      @port = port
+      @api = api
+      @msg_id_generator = Id.new
+      @errbacks = []
+      @insecure_methods = insecure_methods
+    end
+
+    def errback & block
+      @errbacks << block if block
+    end
+
+    def start & block
+      EventMachine::schedule do
+        begin
+          EventMachine::connect(@host, @port, OutgoingHandler) do |connection|
+            connection.host = @host
+            connection.port = @port
+            connection.on_connection = block
+            connection.api = @api
+            connection.errbacks = @errbacks
+            connection.msg_id_generator = @msg_id_generator
+            connection.insecure_methods = @insecure_methods
+            @remote_connection = connection
+          end
+        rescue Exception => e
+          @errbacks.each do |errback|
+            errback.call(e)
+          end
+        end
+      end
+    end
+
+    def method_missing(method, * args, & block)
+      EventMachine::schedule do
+        begin
+          @remote_connection.remote_call(method, args, & block)
+        rescue Exception => e
+          @remote_connection.call_errbacks(e)
+        end
+      end
+    end
+
+    def stop(& callback)
+      EventMachine::schedule do
+        if @remote_connection
+          EventMachine::next_tick do
+            @remote_connection.close_connection
+            callback.call(true) if callback
+          end
+        else
+          callback.call(false) if callback
+        end
+      end
+    end
+  end
+end

data/lib/rubarb/connection_error.rb

@@ -0,0 +1,11 @@
+module Rubarb
+  class ConnectionError < StandardError
+    def initialize(message = "Connection Failure")
+      @message = message
+    end
+    
+    def message
+      @message
+    end
+  end
+end

data/lib/rubarb/connection_id.rb

@@ -0,0 +1,11 @@
+module ConnectionId
+  def complete_id?(data)
+    return false if data.size < 8
+    return true
+  end
+
+  def extract_id(data)
+    return data[0..7]        
+  end
+
+end

data/lib/rubarb/default.rb

@@ -0,0 +1,15 @@
+module Rubarb
+  module Default
+    INSECURE_METHODS = [:==, :===, :=~, :__drbref, :__drburi, :__id__, :__send__, :_dump,
+    :class, :clone, :display, :dup, :enum_for, :eql?, :equal?, :extend, :freeze,
+    :frozen?, :hash, :id, :inspect, :instance_eval, :instance_exec, :instance_of?, :instance_variable_defined?,
+    :instance_variable_get, :instance_variable_set, :is_a?, :kind_of?, :method, :method_missing,
+    :methods, :nil?, :object_id, :pretty_print, :pretty_print_cycle, :private_methods,
+    :protected_methods, :public_methods, :respond_to?, :send, :singleton_methods,
+    :taint, :tainted?, :tap, :to_enum, :type, :untaint,
+    :add_options, :args_and_options, :as_null_object, :com, :config, :config=, :context, :dclone, :debugger,
+    :handle_different_imports, :hash, :include_class, :java, :java_kind_of?, :javax, :log, :null_object?, :org,
+    :received_message?, :taguri, :taguri=, :taint, :tainted?, :tap, :timeout, :to_a, :to_channel, :to_inputstream,
+    :to_outputstream, :to_s, :to_yaml, :to_yaml_properties, :to_yaml_style]
+  end
+end

data/lib/rubarb/fast_message_protocol.rb

@@ -0,0 +1,109 @@
+module Rubarb
+  # 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_message and listen to #receive_message callback.
+  module FastMessageProtocol
+
+    def self.install(object)
+      object.extend Rubarb::FastMessageProtocol
+      object.post_init
+    end
+
+    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 = ""
+    end
+
+    LENGTH_FORMAT = "N".freeze
+    LENGTH_FORMAT_LENGTH = 4
+
+    def send_message(data)
+      size = data.size
+      packed_size = [size].pack(LENGTH_FORMAT)
+      send_data packed_size
+      send_data data
+    end
+
+    def receive_data(next_chunk)
+      log {"fmp rx:  #{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_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_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']) && !($NO_FMP_DEBUG || ENV['NO_FMP_DEBUG'])
+      def log
+      end
+    end
+  end # module FastMessageProtocol
+end # EMRPC