rubarb 0.2.0 → 0.2.11

data/README.md

@@ -0,0 +1,89 @@
+# 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
+
+
+## Compilation
+
+    rake build
+
+## Installation
+
+    gem install rubarb
+
+## 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
+
+## Building
+	gem install jeweller
+	rake build
+	

data/examples/client.rb

@@ -12,7 +12,7 @@ class ClientApi
 end
 
 EM::run do
-  connection = Rubarb::Connection.new("127.0.0.1", 9441, ClientApi.new(ARGV[0]))
+  connection = Rubarb::Connection.new("127.0.0.1", 9447, ClientApi.new(ARGV[0]))
   connection.errback do |error|
     puts ("Connection Error:  #{error}")
   end
@@ -22,6 +22,8 @@ EM::run do
       puts "Server Said it is:  #{response.strftime("%D")}"
     end
 
+    connection.keep_alive_time=2
+
     EventMachine.add_timer(20) do
       puts "stopping"
       connection.stop

data/examples/server.rb

@@ -12,7 +12,7 @@ class ServerApi
 end
 
 EM.run do
-  server = Rubarb::Server.new("127.0.0.1", 9441, ServerApi.new)
+  server = Rubarb::Server.new("127.0.0.1", 9447, ServerApi.new, Rubarb::Default::INSECURE_METHODS, 2)
 
   connections = {}
 

data/lib/rubarb/connection.rb

@@ -13,8 +13,8 @@ module Rubarb
     attr_accessor :id
     attr_accessor :on_connection
     attr_accessor :api
-    attr_accessor :errbacks
     attr_accessor :insecure_methods
+    attr_accessor :parent
 
     def post_init
       @buffer = ""
@@ -24,6 +24,7 @@ module Rubarb
       Rubarb::FastMessageProtocol.install(self)
       send_data("5")
       send_data(@id)
+      @parent.connection_completed(self) if @parent
     end
 
     def receive_message message
@@ -36,13 +37,11 @@ module Rubarb
     end
 
     def unbind
-      call_errbacks(ConnectionError.new)
+      @parent.connection_closed(self)
     end
 
     def call_errbacks(message)
-      @errbacks.each do |e|
-        e.call(message)
-      end
+      @parent.call_errbacks(message)
     end
 
   end
@@ -54,10 +53,11 @@ module Rubarb
     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
+    attr_accessor :parent
+    attr_accessor :keep_alive_time
 
     def post_init
       @buffer = ""
@@ -65,6 +65,7 @@ module Rubarb
 
     def connection_completed
       send_data("4")
+      @parent.connection_completed(self) if @parent
     end
 
     def receive_data data
@@ -75,17 +76,12 @@ module Rubarb
     end
 
     def unbind
-      if @incoming_connection
-        EM.next_tick { @incoming_connection.close_connection }
-      else
-        call_errbacks(ConnectionError.new)
-      end
+      cancel_keep_alive
+      @parent.connection_closed(self)
     end
 
     def call_errbacks(message)
-      @errbacks.each do |e|
-        e.call(message)
-      end
+      @parent.call_errbacks(message)
     end
 
     private
@@ -98,25 +94,65 @@ module Rubarb
           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
+          incoming_connection.parent = @parent
         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)
+    def remote_connection
+      @outgoing_connection
+    end
+
+    def initialize(host, port, api, insecure_methods=Default::INSECURE_METHODS, keep_alive_time = 0)
       @host = host
       @port = port
       @api = api
       @msg_id_generator = Id.new
       @errbacks = []
       @insecure_methods = insecure_methods
+      @connections = []
+      @keep_alive_time = keep_alive_time
+    end
+
+    def keep_alive_time=(keep_alive_time_seconds)
+      @keep_alive_time = keep_alive_time_seconds
+      if @outgoing_connection
+        EventMachine::schedule do
+          @outgoing_connection.keep_alive_time = @keep_alive_time
+          @outgoing_connection.reset_keep_alive
+        end
+      end
+    end
+
+    def close_connections
+      EM.next_tick do
+        @connections.each { |conn| conn.close_connection_after_writing }
+      end
+    end
+
+    def connection_closed(connection)
+      @connections.delete(connection)
+      if !@connections.empty?
+        close_connections
+      else
+        call_errbacks(ConnectionError.new)
+      end
+    end
+
+    def connection_completed(connection)
+      @connections << connection
+    end
+
+    def call_errbacks(message)
+      @errbacks.each do |e|
+        e.call(message)
+      end
     end
 
     def errback & block
@@ -131,10 +167,11 @@ module Rubarb
             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
+            connection.parent = self
+            connection.keep_alive_time = @keep_alive_time
+            @outgoing_connection = connection
           end
         rescue Exception => e
           @errbacks.each do |errback|
@@ -147,18 +184,18 @@ module Rubarb
     def method_missing(method, * args, & block)
       EventMachine::schedule do
         begin
-          @remote_connection.remote_call(method, args, & block)
+          @outgoing_connection.remote_call(method, args, & block)
         rescue Exception => e
-          @remote_connection.call_errbacks(e)
+          call_errbacks(e)
         end
       end
     end
 
     def stop(& callback)
       EventMachine::schedule do
-        if @remote_connection
+        if @outgoing_connection
           EventMachine::next_tick do
-            @remote_connection.close_connection
+            @outgoing_connection.close_connection_after_writing
             callback.call(true) if callback
           end
         else

data/lib/rubarb/incoming_connection.rb

@@ -9,10 +9,11 @@ module Rubarb
 
     def receive_message(message)
       id, method, args = unmarshal_call(message)
+      return unless method
       responder = Responder.new(self, id)
       begin
         raise Rubarb::InsecureMethodCallError.new(method) if @insecure_methods.include?(method)
-        api.send(method, *[responder, *args]);
+        api.send(method, *[responder, *args])
       rescue Exception => e
         reply("0", e)
       end
@@ -20,6 +21,13 @@ module Rubarb
 
     def reply(id, *args)
       send_message(marshal_call(args.unshift(id)))
+    end
+
+	def reset_keep_alive
+	end
+
+    def cancel_keep_alive
+
     end
   end
 end

data/lib/rubarb/outgoing_connection.rb

@@ -17,11 +17,26 @@ module Rubarb
     end
 
     def remote_call(method, *args, &block)
+      reset_keep_alive
       id = @msg_id_generator.next
       @callback ||= {}
       @callback[id] = block
       send_message(marshal_call(id, method, *args))
     end
 
+    def cancel_keep_alive
+      EventMachine::cancel_timer(@keep_alive_timer) if @keep_alive_timer
+    end
+
+    def reset_keep_alive
+      cancel_keep_alive
+      return if @keep_alive_time.to_i == 0
+
+      @keep_alive_timer = EventMachine::add_timer(@keep_alive_time) do
+        send_message(marshal_call(""))
+        reset_keep_alive
+      end
+    end
+
   end
 end

data/lib/rubarb/server.rb

@@ -34,8 +34,8 @@ module Rubarb
 
     def stop
       EventMachine::next_tick do
-        @remote_connection.close_connection
-      end
+        @remote_connection.close_connection_after_writing
+      end if @remote_connection
     end
   end
 
@@ -47,7 +47,7 @@ module Rubarb
     attr_reader :insecure_methods
     attr_accessor :external_protocol
 
-    def initialize(host, port, api, insecure_methods=Default::INSECURE_METHODS)
+    def initialize(host, port, api, insecure_methods=Default::INSECURE_METHODS, keep_alive_time = 0)
       @host = host
       @port = port
       @api = api
@@ -58,6 +58,16 @@ module Rubarb
       @conn_id_generator = Id.new
       @msg_id_generator = Id.new
       @insecure_methods = insecure_methods
+      @keep_alive_time = keep_alive_time
+    end
+
+    def keep_alive_time=(keep_alive_seconds)
+      EventMachine::schedule do
+        @connections.each do |c|
+          c.keep_alive_time = @keep_alive_time = keep_alive_seconds
+          c.reset_keep_alive
+        end
+      end
     end
 
     def start(& callback)
@@ -72,6 +82,7 @@ module Rubarb
             connection.unbindback = @unbind_block
             connection.insecure_methods = @insecure_methods
             connection.external_protocol = @external_protocol
+            connection.keep_alive_time = @keep_alive_time
             @connections << connection
           end
         rescue Exception => e
@@ -97,7 +108,7 @@ module Rubarb
     private #################################################################################
     def close_all_connections
       @connections.each do |connection|
-        connection.close_connection
+        connection.close_connection_after_writing
       end
     end
 
@@ -126,6 +137,7 @@ module Rubarb
     attr_accessor :unbindback
     attr_accessor :insecure_methods
     attr_accessor :external_protocol
+    attr_accessor :keep_alive_time
 
     include ConnectionId
 
@@ -138,7 +150,12 @@ module Rubarb
       handshake(@buffer) if @conn_id.nil?
     end
 
+    def cancel_keep_alive
+      #will be replaced by later included modules
+    end
+
     def unbind
+      cancel_keep_alive
       call_errbacks(ConnectionError.new)
       @unbindback.call(self) if @unbindback
     end

data/spec/rubarb/connection_failure_spec.rb

@@ -5,14 +5,6 @@ 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"))
 

data/spec/rubarb/connection_spec.rb

@@ -8,14 +8,6 @@ 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
@@ -49,6 +41,10 @@ describe Rubarb::Connection do
       @connection = connect(Rubarb::Connection.new("127.0.0.1", 9441, mock("client")))
     end
 
+    after(:each) do
+      sync_stop(@server)
+    end
+
     it "sets an instance of Rubarb::Id to remote_connection" do
       @connection.remote_connection.msg_id_generator.class.should == Rubarb::Id
     end
@@ -144,6 +140,10 @@ describe Rubarb::OutgoingHandler do
     remote_call(:foo, "bary")
     @sent_msg.should == marshal_call("00000001", :foo, "bary")
   end
+
+  it "should receive empty message" do
+    proc {receive_data("")}.should_not raise_error
+  end
 end
 
 describe Rubarb::IncomingHandler do
@@ -177,11 +177,16 @@ describe Rubarb::IncomingHandler do
 
   it "should errback if ids do not match" do
     errback_msg = false
-    @errbacks = [Proc.new { |error| errback_msg = error.message }]
+    @parent = mock("parent")
+    @parent.should_receive(:call_errbacks) do |error|
+      error.message.should == "Handshake Failure"
+    end
+
+    @parent.should_receive(:connection_completed).with(self)
+
     @id = "00000001"
 
     connection_completed
     receive_message("00000004")
-    errback_msg.should == "Handshake Failure"
   end
 end