ione-rpc 1.0.0.pre3 → 1.0.0.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98f7be7547ebdcd263f54d286682869bd629dfdc
-  data.tar.gz: 6d331deff1f746ce7c69f3914f9527f115701d08
+  metadata.gz: 2219fec79fa845ec467d80462b2b25b521649afe
+  data.tar.gz: 0a505a71f3c16bba88a160925c9f4d6d511b51cf
 SHA512:
-  metadata.gz: 4ecab7afd0cc50ecfcd9475d8f2b04da77aac64b063e022b29498556241e0bddd64329291fb2c64299cc670d22c9368203c4cb66c5ab5113d4aeb2bac035bc2f
-  data.tar.gz: 33a712ea45a402f0f5fd501fc3b4eb14af603c56c1496424512252e2c387f9801a0fc8a6b2d91e45dc25e45f6c70a50939bf60222ad16211b1e4f44c59695854
+  metadata.gz: 2e7f795882099bbc4753f0295085962ddb6c05af8cfd4ae67dc4cdcabb854e5a16816acaf147a7ba43860ea37249e61f06270de638cd47bb2c2cc64bc4930709
+  data.tar.gz: 89b9886afc1ff2b7fda147ed7fda063489a60052204b5a2ab9a5e334571aefc51520f432ece8aa6e1d2266814f9c944d2cf1403add28bf7623a32442227ed526

data/lib/ione/rpc/peer.rb

@@ -37,6 +37,8 @@ module Ione
           handle_message(@current_message, channel)
           @current_message = nil
         end
+      rescue => e
+        @connection.close(e)
       end
 
       def handle_message(message, channel)

data/lib/ione/rpc/server.rb

@@ -6,7 +6,8 @@ module Ione
     #
     # To implement a server you need to create a subclass of this class and
     # implement {#handle_request}. You can also optionally implement
-    # {#handle_connection} to do initialization when a new client connects.
+    # {#handle_connection} to do initialization when a new client connects, and
+    # {#handle_error} to handle errors that occur during the request handling.
     class Server
       attr_reader :port
 
@@ -41,8 +42,6 @@ module Ione
         @io_reactor.stop.map(self)
       end
 
-      protected
-
       # Override this method to do work when a new client connects.
       #
       # This method may be called concurrently.
@@ -51,6 +50,27 @@ module Ione
       def handle_connection(connection)
       end
 
+      # Override this method to handle errors raised or returned by
+      # {#handle_request} or any other part of the request handling (for example
+      # the response encoding).
+      #
+      # When this method raises an error or returns a failed future there will be
+      # no response for the request. Unless you use a custom client this means
+      # that you lock up one of the connection's channels forever, and depending
+      # on the client implementation it may lock up resources. Make sure that
+      # you always return a future that will resolve to something that will be
+      # encodeable.
+      #
+      # Should this method fail a message will be logged at the `error` level
+      # with the error message and class. The full backtrace will also be logged
+      # at the `debug` level.
+      #
+      # @return [Ione::Future<Object>] a future that will resolve to an alternate
+      #   response for this request.
+      def handle_error(error, request, connection)
+        Ione::Future.failed(error)
+      end
+
       # Override this method to handle requests.
       #
       # You must respond to all requests, otherwise the client will eventually
@@ -58,6 +78,9 @@ module Ione
       #
       # This method may be called concurrently.
       #
+      # When this method raises an error, or returns a failed future, {#handle_error}
+      # will be called with the error.
+      #
       # @param [Object] message a (decoded) message from a client
       # @param [#host, #port, #on_closed] connection the client connection that
       #   received the message
@@ -66,6 +89,20 @@ module Ione
         Future.resolved
       end
 
+      # @private
+      def guarded_handle_error(error, request, connection)
+        handle_error(error, request, connection)
+      rescue => e
+        Ione::Future.failed(e)
+      end
+
+      # @private
+      def guarded_handle_request(message, connection)
+        handle_request(message, connection)
+      rescue => e
+        Ione::Future.failed(e)
+      end
+
       private
 
       def setup_server
@@ -73,7 +110,7 @@ module Ione
           @logger.info('Server listening for connections on %s:%d' % [@bind_address, @port]) if @logger
           acceptor.on_accept do |connection|
             @logger.info('Connection from %s:%d accepted' % [connection.host, connection.port]) if @logger
-            peer = ServerPeer.new(connection, @codec, self)
+            peer = ServerPeer.new(connection, @codec, self, @logger)
             peer.on_closed do
               @logger.info('Connection from %s:%d closed' % [connection.host, connection.port]) if @logger
             end
@@ -84,15 +121,31 @@ module Ione
 
       # @private
       class ServerPeer < Peer
-        def initialize(connection, codec, server)
+        def initialize(connection, codec, server, logger)
           super(connection, codec)
           @server = server
+          @logger = logger
         end
 
         def handle_message(message, channel)
-          f = @server.handle_request(message, self)
-          f.on_value do |response|
-            @connection.write(@codec.encode(response, channel))
+          f = @server.guarded_handle_request(message, self)
+          send_response(f, message, channel, true)
+        end
+
+        def send_response(f, message, channel, try_again)
+          f = f.map do |response|
+            encoded_response = @codec.encode(response, channel)
+            @connection.write(encoded_response)
+            nil
+          end
+          f.fallback do |error|
+            if try_again
+              ff = @server.guarded_handle_error(error, message, self)
+              send_response(ff, message, channel, false)
+            else
+              @logger.error('Unhandled error: %s (%s)' % [error.message, error.class.name])
+              error.backtrace && @logger.debug(error.backtrace.join("#{$/}\t"))
+            end
           end
         end
       end

data/lib/ione/rpc/version.rb

@@ -2,6 +2,6 @@
 
 module Ione
   module Rpc
-    VERSION = '1.0.0.pre3'.freeze
+    VERSION = '1.0.0.pre4'.freeze
   end
 end

data/spec/ione/rpc/peer_common.rb

@@ -66,6 +66,15 @@ shared_examples 'peers' do
       connection.data_listener.call('FOOBARBAZ')
       peer.messages.should have(3).items
     end
+
+    it 'closes the connection when there is an error decoding a frame' do
+      error = nil
+      peer.on_closed { |e| error = e }
+      codec.stub(:decode).with(Ione::ByteBuffer.new('FOOBARBAZ'), anything).and_raise(Ione::Rpc::CodecError.new('Bork'))
+      connection.data_listener.call('FOOBARBAZ')
+      error.should be_a(Ione::Rpc::CodecError)
+      error.message.should == 'Bork'
+    end
   end
 
   context 'when sending data' do
@@ -123,6 +132,10 @@ module RpcSpec
       @written_bytes = ''
     end
 
+    def close(cause=nil)
+      @closed_listener.call(cause) if @closed_listener
+    end
+
     def write(bytes)
       @written_bytes << bytes
     end

data/spec/ione/rpc/server_spec.rb

@@ -15,7 +15,7 @@ module Ione
       end
 
       let :logger do
-        double(:logger)
+        double(:logger, debug: nil, info: nil, warn: nil, error: nil)
       end
 
       let :acceptor do
@@ -43,10 +43,6 @@ module Ione
         codec.stub(:encode) { |msg, _| msg }
       end
 
-      before do
-        logger.stub(:info)
-      end
-
       describe '#port' do
         it 'returns the port the server is listening on' do
           server.port.should == 4321
@@ -182,7 +178,133 @@ module Ione
           raw_connection.should have_received(:write).with('42BAZFOO')
         end
 
-        it 'handles that the server fails to process the request'
+        context 'and there is an error' do
+          before do
+            codec.stub(:encode).with('BAZFOO', 42).and_return('42BAZFOO')
+          end
+
+          it 'calls #handle_error when #handle_request raises an error' do
+            server.override_handle_request { raise 'Borkzor' }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            server.errors.first.message.should == 'Borkzor'
+          end
+
+          it 'calls #handle_error when #handle_request returns a failed future' do
+            server.override_handle_request { Ione::Future.failed(StandardError.new('Borkzor')) }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            server.errors.should == [StandardError.new('Borkzor')]
+          end
+
+          it 'calls #handle_error with the error, the request and the connection' do
+            error, request, connection = nil, nil, nil
+            server.override_handle_request { Ione::Future.failed(StandardError.new('Borkzor')) }
+            server.override_handle_error { |e, r, c| error = e; request = r; connection = c }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            error.should be_a(StandardError)
+            error.message.should == 'Borkzor'
+            request.should == 'FOOBAZ'
+            connection.should == peer
+          end
+
+          it 'responds with the message returned by #handle_error' do
+            server.override_handle_request { Ione::Future.failed(StandardError.new('Borkzor')) }
+            server.override_handle_error { |e| Ione::Future.resolved("OH NOES: #{e.message}") }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            raw_connection.should have_received(:write).with('OH NOES: Borkzor')
+          end
+
+          it 'does not respond at all by default' do
+            server.override_handle_request { Ione::Future.failed(StandardError.new('Borkzor')) }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            raw_connection.should_not have_received(:write)
+          end
+
+          it 'does not respond when #handle_error raises an error' do
+            server.override_handle_request { Ione::Future.failed(StandardError.new('Borkzor')) }
+            server.override_handle_error { |e| raise "OH NOES: #{e.message}" }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            raw_connection.should_not have_received(:write)
+          end
+
+          it 'does not respond when #handle_error returns a failed future' do
+            server.override_handle_request { Ione::Future.failed(StandardError.new('Borkzor')) }
+            server.override_handle_error { |e| Ione::Future.failed(StandardError.new("OH NOES: #{e.message}")) }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            raw_connection.should_not have_received(:write)
+          end
+
+          it 'logs unhandled errors' do
+            server.override_handle_request { raise StandardError, 'Borkzor' }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            logger.should have_received(:error).with(/^Unhandled error: Borkzor \(StandardError\)/i)
+            logger.should have_received(:debug).with(/\d+:in/)
+          end
+
+          it 'logs when #handle_error raises an error' do
+            server.override_handle_request { Ione::Future.failed(StandardError.new('Borkzor')) }
+            server.override_handle_error { |e| raise StandardError, "OH NOES: #{e.message}" }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            logger.should have_received(:error).with(/^Unhandled error: OH NOES: Borkzor \(StandardError\)/i)
+          end
+
+          it 'logs when #handle_error returns a failed future' do
+            server.override_handle_request { Ione::Future.failed(StandardError.new('Borkzor')) }
+            server.override_handle_error { |e| Ione::Future.failed(StandardError.new("OH NOES: #{e.message}")) }
+            peer = server.connections.first
+            peer.handle_message('FOOBAZ', 42)
+            logger.should have_received(:error).with(/^Unhandled error: OH NOES: Borkzor \(StandardError\)/i)
+          end
+
+          context 'when the codec fails to encode the response' do
+            it 'calls #handle_error' do
+              server.override_handle_request { Ione::Future.resolved('OK') }
+              codec.stub(:encode).with('OK', 42).and_raise(CodecError.new('Borkzor'))
+              peer = server.connections.first
+              peer.handle_message('FOOBAZ', 42)
+              server.errors.first.should be_a(CodecError)
+              server.errors.first.message.should == 'Borkzor'
+            end
+
+            it 'responds with what #handle_error responds with' do
+              server.override_handle_request { Ione::Future.resolved('OK') }
+              server.override_handle_error { |e| Ione::Future.resolved("ERROR: #{e.message}") }
+              codec.stub(:encode).with('OK', 42).and_raise(CodecError.new('Borkzor'))
+              peer = server.connections.first
+              peer.handle_message('FOOBAZ', 42)
+              raw_connection.should have_received(:write).with('ERROR: Borkzor')
+            end
+
+            it 'does not respond when the codec cannot encode the response returned by #handle_error' do
+              server.override_handle_request { Ione::Future.resolved('OK') }
+              server.override_handle_error { |e| Ione::Future.resolved("ERROR: #{e.message}") }
+              codec.stub(:encode).with('OK', 42).and_raise(CodecError.new('Borkzor'))
+              codec.stub(:encode).with('ERROR: Borkzor', 42).and_raise(CodecError.new('Buzzfuzz'))
+              peer = server.connections.first
+              peer.handle_message('FOOBAZ', 42)
+              raw_connection.should_not have_received(:write)
+              server.errors.should have(1).item
+            end
+
+            it 'logs when the codec cannot encode the response returned by #handle_error' do
+              server.override_handle_request { Ione::Future.resolved('OK') }
+              server.override_handle_error { |e| Ione::Future.resolved("ERROR: #{e.message}") }
+              codec.stub(:encode).with('OK', 42).and_raise(CodecError.new('Borkzor'))
+              codec.stub(:encode).with('ERROR: Borkzor', 42).and_raise(CodecError.new('Buzzfuzz'))
+              peer = server.connections.first
+              peer.handle_message('FOOBAZ', 42)
+              logger.should have_received(:error).with(/^Unhandled error: Buzzfuzz \(Ione::Rpc::CodecError\)/i)
+            end
+          end
+        end
       end
     end
   end
@@ -190,22 +312,36 @@ end
 
 module ServerSpec
   class TestServer < Ione::Rpc::Server
-    attr_reader :connections, :received_messages
+    attr_reader :connections, :received_messages, :errors
 
     def initialize(*)
       super
       @connections = []
       @received_messages = []
+      @errors = []
     end
 
     def handle_connection(peer)
       @connections << peer
     end
 
+    def override_handle_error(&handler)
+      @error_handler = handler
+    end
+
     def override_handle_request(&handler)
       @request_handler = handler
     end
 
+    def handle_error(error, request, connection)
+      @errors << error
+      if @error_handler
+        @error_handler.call(error, request, connection)
+      else
+        super
+      end
+    end
+
     def handle_request(request, peer)
       @received_messages << [request, peer]
       if @request_handler

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ione-rpc
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre3
+  version: 1.0.0.pre4
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-21 00:00:00.000000000 Z
+date: 2014-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione