rubarb 0.2.0

data/lib/rubarb/id.rb

@@ -0,0 +1,13 @@
+module Rubarb
+  class Id
+    def initialize
+      @id ||= 1
+    end
+
+    def next
+      id = "%08d" % @id
+      @id = @id == 99999999 ? 1 : @id + 1
+      id
+    end
+  end
+end

data/lib/rubarb/incoming_connection.rb

@@ -0,0 +1,25 @@
+require "rubarb/remote_call"
+require "rubarb/responder"
+require "rubarb/insecure_method_call_error"
+
+module Rubarb
+
+  module IncomingConnection
+    include RemoteCall
+
+    def receive_message(message)
+      id, method, args = unmarshal_call(message)
+      responder = Responder.new(self, id)
+      begin
+        raise Rubarb::InsecureMethodCallError.new(method) if @insecure_methods.include?(method)
+        api.send(method, *[responder, *args]);
+      rescue Exception => e
+        reply("0", e)
+      end
+    end
+
+    def reply(id, *args)
+      send_message(marshal_call(args.unshift(id)))
+    end
+  end
+end

data/lib/rubarb/insecure_method_call_error.rb

@@ -0,0 +1,11 @@
+module Rubarb
+  class InsecureMethodCallError < StandardError
+    def initialize(method="")
+      @method = method
+    end
+
+    def message
+      "Remote client attempts to call method #{@method}, but was denied."
+    end
+  end
+end

data/lib/rubarb/outgoing_connection.rb

@@ -0,0 +1,27 @@
+require "rubarb/remote_call"
+
+module Rubarb
+  module OutgoingConnection
+    include RemoteCall
+
+    def receive_message(message)
+      id, *unmarshaled_message = *unmarshal_call(message)
+      if unmarshaled_message.first.is_a?(Exception)
+        call_errbacks(*unmarshaled_message)
+      else
+        if @callback[id]
+          @callback[id].call(*unmarshaled_message)
+          @callback.delete(id)
+        end
+      end
+    end
+
+    def remote_call(method, *args, &block)
+      id = @msg_id_generator.next
+      @callback ||= {}
+      @callback[id] = block
+      send_message(marshal_call(id, method, *args))
+    end
+
+  end
+end

data/lib/rubarb/remote_call.rb

@@ -0,0 +1,12 @@
+module Rubarb
+  module RemoteCall
+    def marshal_call(*args)
+      Marshal::dump(args)
+    end
+
+    def unmarshal_call(data)
+      return *Marshal::load(data)
+    end
+
+  end
+end

data/lib/rubarb/responder.rb

@@ -0,0 +1,18 @@
+module Rubarb
+  class Responder
+    attr_reader :message_id
+    attr_reader :handler
+    def initialize(handler, message_id)
+      @handler = handler
+      @message_id = message_id
+    end
+
+    def conn_id
+      @handler.conn_id
+    end
+
+    def reply(*args)
+      @handler.reply(@message_id, *args)
+    end
+  end
+end

data/lib/rubarb/server.rb

@@ -0,0 +1,185 @@
+require 'eventmachine'
+require 'rubarb/connection_id'
+require "rubarb/fast_message_protocol"
+require 'rubarb/outgoing_connection'
+require 'rubarb/incoming_connection'
+require 'rubarb/id'
+require 'rubarb/default'
+
+module Rubarb
+  class ClientProxy
+    attr_reader :remote_connection
+    
+    def initialize(outgoing_connection)
+      @remote_connection = outgoing_connection
+    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 errback(& block)
+      @remote_connection.errbacks << block if block
+    end
+
+    def conn_id
+      @remote_connection.conn_id
+    end
+
+    def stop
+      EventMachine::next_tick do
+        @remote_connection.close_connection
+      end
+    end
+  end
+
+  class Server
+    attr_reader :connections
+    attr_reader :conn_id_generator
+    attr_reader :msg_id_generator
+    attr_reader :errback
+    attr_reader :insecure_methods
+    attr_accessor :external_protocol
+
+    def initialize(host, port, api, insecure_methods=Default::INSECURE_METHODS)
+      @host = host
+      @port = port
+      @api = api
+      @connections = []
+      @unbind_block = Proc.new do |connection|
+        @connections.delete(connection)
+      end
+      @conn_id_generator = Id.new
+      @msg_id_generator = Id.new
+      @insecure_methods = insecure_methods
+    end
+
+    def start(& callback)
+      EventMachine::schedule do
+        begin
+          @server_signature = EventMachine::start_server(@host, @port, Listener) do |connection|
+            connection.conn_id_generator = @conn_id_generator
+            connection.msg_id_generator = @msg_id_generator
+            connection.api = @api
+            connection.new_connection_callback = callback
+            connection.errbacks = @errback.nil? ? [] : [@errback]
+            connection.unbindback = @unbind_block
+            connection.insecure_methods = @insecure_methods
+            connection.external_protocol = @external_protocol
+            @connections << connection
+          end
+        rescue Exception => e
+          @errback.call(e) if @errback
+        end
+      end
+    end
+
+
+    def stop(& callback)
+      EventMachine::schedule do
+        EventMachine::next_tick do
+          close_all_connections
+          stop_server(callback)
+        end
+      end
+    end
+
+    def errback(& block)
+      @errback = block
+    end
+
+    private #################################################################################
+    def close_all_connections
+      @connections.each do |connection|
+        connection.close_connection
+      end
+    end
+
+    def stop_server(callback)
+      if @server_signature
+        EventMachine::stop_server(@server_signature)
+        @server_signature = nil
+        callback.call(true) if callback
+      else
+        callback.call(false) if callback
+      end
+    end
+
+  end
+
+  module Listener
+    INCOMING_CONNECTION = "4"[0]
+    OUTGOING_CONNECTION = "5"[0]
+    attr_accessor :conn_id_generator
+    attr_reader :conn_id
+    attr_accessor :msg_id_generator
+    attr_accessor :api
+    attr_accessor :new_connection_callback
+    attr_accessor :callback
+    attr_accessor :errbacks
+    attr_accessor :unbindback
+    attr_accessor :insecure_methods
+    attr_accessor :external_protocol
+
+    include ConnectionId
+
+    def post_init
+      @buffer = ""
+    end
+
+    def receive_data data
+      @buffer << data
+      handshake(@buffer) if @conn_id.nil?
+    end
+
+    def unbind
+      call_errbacks(ConnectionError.new)
+      @unbindback.call(self) if @unbindback
+    end
+
+    def call_errbacks(message)
+      @errbacks.each do |e|
+        e.call(message)
+      end
+    end
+
+    private
+
+    def handle_incoming
+      @conn_id = @conn_id_generator.next
+      self.extend(IncomingConnection)
+      switch_protocol
+      send_data(@conn_id)
+    end
+
+    def handle_outgoing(buffer)
+      if complete_id?(buffer[1..-1])
+        @conn_id = extract_id(buffer[1..-1])
+        self.extend(OutgoingConnection)
+        switch_protocol
+        send_message(@conn_id)
+        @new_connection_callback.call(ClientProxy.new(self)) if @new_connection_callback
+      end
+    end
+
+    def handshake(buffer)
+      if buffer[0] == INCOMING_CONNECTION
+        handle_incoming
+      elsif buffer[0] == OUTGOING_CONNECTION
+        handle_outgoing(buffer)
+      else
+        @external_protocol.handle_connection(buffer, self) if @external_protocol
+      end
+    end
+
+    def switch_protocol
+      Rubarb::FastMessageProtocol.install(self)
+    end
+  end
+end

data/spec/rubarb/connection_failure_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'rubarb/server'
+require 'rubarb/connection'
+
+describe "Connection Failures" do
+
+  before(:each) do
+    @reactor = start_reactor
+  end
+
+  after(:each) do
+    stop_reactor(@reactor)
+  end
+  
+  it "should fail to connect" do
+    @connection = Rubarb::Connection.new("127.0.0.1", 9441, mock("client api"))
+
+    @errback_called = false
+    @connection.errback do |error|
+      @errback_called = true
+      error.class.should == Rubarb::ConnectionError
+      error.message.should == "Connection Failure"
+    end
+
+    @callback_called = false
+    @connection.start do |remote_end|
+      @callback_called = true
+    end
+
+    wait_for {@errback_called}
+
+    @errback_called.should == true
+    @callback_called.should == false
+  end
+
+  it "should fail after it has connected" do
+    @server = Rubarb::Server.new("127.0.0.1", 9441, mock("server"))
+    @connection = Rubarb::Connection.new("127.0.0.1", 9441, mock("client"))
+    @connection2 = Rubarb::Connection.new("127.0.0.1", 9441, mock("client"))
+
+    @server.start
+
+    @errback_called = false
+    @connection.errback do |error|
+      @errback_called = true
+      error.class.should == Rubarb::ConnectionError
+      error.message.should == "Connection Failure"
+    end
+
+    @errback2_called = false
+    @connection2.errback do |error|
+      @errback2_called = true
+      error.class.should == Rubarb::ConnectionError
+      error.message.should == "Connection Failure"
+    end
+
+    @connection.start do
+      @server.stop
+    end
+
+    @connection2.start
+
+    wait_for{@errback_called}
+    @errback_called.should be_true
+
+    wait_for{@errback2_called}
+    @errback2_called.should be_true
+  end
+
+end

data/spec/rubarb/connection_spec.rb

@@ -0,0 +1,187 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'rubarb/server'
+require "rubarb/connection"
+require "rubarb/remote_call"
+require "rubarb/default"
+
+describe Rubarb::Connection do
+  CUSTOM_INSECURE_METHODS = [:==, :===, :=~]
+
+  before(:all) do
+    @reactor = start_reactor
+  end
+
+  after(:all) do
+    stop_reactor(@reactor)
+  end
+
+  it "has an instance of Rubarb::Id" do
+    @connection = Rubarb::Connection.new("host", "port", "api")
+    @connection.msg_id_generator.class.should == Rubarb::Id
+  end
+
+  it "should stop" do
+    @result = "blah"
+    @connection = Rubarb::Connection.new("host", "port", "api")
+    @connection.stop do |result|
+      @result = result
+    end
+
+    wait_for { @result == false }
+    @result.should == false
+  end
+
+  describe "with client and server connected" do
+    
+    def connect(connection)
+      connected = false
+      connection.start do
+        connected = true
+      end
+      wait_for { connected }
+      return connection
+    end
+    
+    before(:all) do
+      @server = Rubarb::Server.new("127.0.0.1", 9441, mock("server"))
+      @server.start
+      @connection = connect(Rubarb::Connection.new("127.0.0.1", 9441, mock("client")))
+    end
+
+    it "sets an instance of Rubarb::Id to remote_connection" do
+      @connection.remote_connection.msg_id_generator.class.should == Rubarb::Id
+    end
+
+    it "sets an instance of insecure_methods to remote_connection" do
+      @connection.remote_connection.insecure_methods.class.should == Array
+    end
+
+    it "has default insecure methods" do
+      @connection.remote_connection.insecure_methods.should == Rubarb::Default::INSECURE_METHODS
+    end
+
+    it "can accept custom insecure methods" do
+      connection = connect(Rubarb::Connection.new("127.0.0.1", 9441, mock("client"), CUSTOM_INSECURE_METHODS))
+      connection.remote_connection.insecure_methods.should == CUSTOM_INSECURE_METHODS
+    end
+
+    it "should stop after it's connected" do
+      connection = connect(Rubarb::Connection.new("127.0.0.1", 9441, mock("client")))
+
+      @result = "boo"
+      connection.stop do |result|
+        @result = result
+      end
+      wait_for{@result == true}
+      @result.should == true
+    end
+
+    it "doesn't exit the reactor loop when an exception occurs in Connection::method_missing" do
+      connection = connect(Rubarb::Connection.new("127.0.0.1", 9441, mock("client")))
+      error = nil
+      connection.errback {|e| error = e}
+      connection.remote_connection.should_receive(:remote_call).and_raise("Blah")
+      
+      connection.foo
+      wait_for{error != nil}
+      
+      error.to_s.should == "Blah"
+      EM.reactor_running?.should == true
+    end
+
+    it "should catch exceptions from connect" do
+      connection = Rubarb::Connection.new("127.0.0.1", 9441, mock("client"))
+      EventMachine.stub!(:connect).and_raise("Internal Java error")
+      errback_called = false
+      connection.errback do |e|
+        e.message.should == "Internal Java error"
+        errback_called = true
+      end
+      connection.start
+
+      wait_for{errback_called}
+      
+    end
+
+  end
+
+end
+
+describe Rubarb::OutgoingHandler do
+  include Rubarb::OutgoingHandler
+  include Rubarb::RemoteCall
+
+  before(:each) do
+    @sent_data = ""
+    self.stub!(:send_data) do |data|
+      @sent_data << data
+    end
+    post_init
+  end
+
+  it "should send type on start" do
+    connection_completed
+    @sent_data.should == "4"
+  end
+
+  it "should open an outgoing connection with connection id" do
+    connection_completed
+    @host = "1.2.3.4"
+    @port = 2321
+    EventMachine.should_receive(:connect).with("1.2.3.4", 2321, Rubarb::IncomingHandler)
+    receive_data("0000")
+    receive_data("0001")
+  end
+
+  it "should send marshaled calls" do
+    @callback = {}
+    @sent_msg = ""
+    id_generator = mock("id")
+    id_generator.stub!(:next).and_return("00000001")
+    @msg_id_generator = id_generator
+    self.stub!(:send_message) { |msg| @sent_msg << msg }
+    remote_call(:foo, "bary")
+    @sent_msg.should == marshal_call("00000001", :foo, "bary")
+  end
+end
+
+describe Rubarb::IncomingHandler do
+  include Rubarb::IncomingHandler
+
+  before(:each) do
+    @sent_data = ""
+    self.stub!(:send_data) do |data|
+      @sent_data << data
+    end
+    post_init
+  end
+
+  it "should send type and id on connection made" do
+    @id = "00000001"
+    connection_completed
+    @sent_data.should == "500000001"
+  end
+
+  it "should call back when finished" do
+    callback = false
+    @on_connection = Proc.new { callback = true }
+    @id = "00000001"
+
+    connection_completed
+    callback.should == false
+
+    receive_message(@id)
+    callback.should == true
+  end
+
+  it "should errback if ids do not match" do
+    errback_msg = false
+    @errbacks = [Proc.new { |error| errback_msg = error.message }]
+    @id = "00000001"
+
+    connection_completed
+    receive_message("00000004")
+    errback_msg.should == "Handshake Failure"
+  end
+end