ione-rpc 1.0.1 → 1.1.0.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd2dfbaf504cd8f90db14054c3f1be44a1bf6740
-  data.tar.gz: 4ecca4c71c9d9857c4df03a0caaecf52fb56a973
+  metadata.gz: b76720f1019ef558e761ca6150d3e6417525f7e4
+  data.tar.gz: e0e60b176ac1d29de164124a9db8090be4224e2c
 SHA512:
-  metadata.gz: 005b40b386819c5f9ce87398b6456981b996d7d9a82f03aa13db17f64a18db4de9117474261b7a1c7a2cf30117542db425c00165d8a5f99272441f5413ce5c5a
-  data.tar.gz: 336273d46b03c7cbcd15f59b2c9f3b46ce8da3de9169b583bbb9f867238af9eff73f4dc9cca227f93aa38409ed5342e1c2dd7a413cc05f37937fa712770b6cc8
+  metadata.gz: 843c6352df3a73996b9df2c110e4c9c259f85fa6dec03cda53619f69af220ba519aa17a11ef583aa111523a6dbe3e8fa09bfd987144dc7e3ee4b3809777b5afa
+  data.tar.gz: 1ecb1ef66d1f4f17ca14dccc216cc21a9ecaec02eee64fe1bed4bf32229f44dd56616df562fc0af64fdd09ab79314b6a651cc5a8d1d21f431e5ac12b406c6dd6

data/lib/ione/rpc/server.rb

@@ -52,7 +52,9 @@ module Ione
 
       # 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).
+      # the response encoding). In the event that {#handle_request} completed
+      # successfully, the response will contain that result, otherwise it will
+      # be nil.
       #
       # 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
@@ -65,9 +67,12 @@ module Ione
       # with the error message and class. The full backtrace will also be logged
       # at the `debug` level.
       #
+      # To remain backwards compatible, the method can be overridden to take only
+      # three arguments, in which case the response is omitted.
+      #
       # @return [Ione::Future<Object>] a future that will resolve to an alternate
       #   response for this request.
-      def handle_error(error, request, connection)
+      def handle_error(error, request, response=nil, connection)
         Ione::Future.failed(error)
       end
 
@@ -90,8 +95,12 @@ module Ione
       end
 
       # @private
-      def guarded_handle_error(error, request, connection)
-        handle_error(error, request, connection)
+      def guarded_handle_error(error, request, response, connection)
+        if method(:handle_error).arity == 3
+          handle_error(error, request, connection)
+        else
+          handle_error(error, request, response, connection)
+        end
       rescue => e
         Ione::Future.failed(e)
       end
@@ -112,8 +121,14 @@ module Ione
           @acceptor.on_accept do |connection|
             @logger.info('Connection from %s:%d accepted' % [connection.host, connection.port]) if @logger
             peer = ServerPeer.new(connection, @codec, self, @logger)
-            peer.on_closed do
-              @logger.info('Connection from %s:%d closed' % [connection.host, connection.port]) if @logger
+            if @logger
+              peer.on_closed do |error|
+                if error
+                  @logger.warn(sprintf('Connection from %s:%d closed unexpectedly: %s (%s)', connection.host, connection.port, error.message, error.class.name))
+                else
+                  @logger.info(sprintf('Connection from %s:%d closed', connection.host, connection.port))
+                end
+              end
             end
             handle_connection(peer)
           end
@@ -134,17 +149,19 @@ module Ione
         end
 
         def send_response(f, message, channel, try_again)
-          f = f.map do |response|
+          response = nil
+          f = f.map do |r|
+            response = r
             encoded_response = @codec.encode(response, channel)
             @connection.write(encoded_response)
             nil
           end
-          f.fallback do |error|
+          f.on_failure do |error|
             if try_again
-              ff = @server.guarded_handle_error(error, message, self)
+              ff = @server.guarded_handle_error(error, message, response, self)
               send_response(ff, message, channel, false)
-            else
-              @logger.error('Unhandled error: %s (%s)' % [error.message, error.class.name])
+            elsif @logger
+              @logger.error(sprintf('Unhandled error for %s:%d; %s (%s)', @connection.host, @connection.port, error.message, error.class.name))
               error.backtrace && @logger.debug(error.backtrace.join("#{$/}\t"))
             end
           end

data/lib/ione/rpc/version.rb

@@ -2,6 +2,6 @@
 
 module Ione
   module Rpc
-    VERSION = '1.0.1'.freeze
+    VERSION = '1.1.0.pre0'.freeze
   end
 end

data/spec/ione/rpc/server_spec.rb

@@ -141,6 +141,11 @@ module Ione
           raw_connection.closed_listener.call
           logger.should have_received(:info).with('Connection from client.example.com:34534 closed')
         end
+
+        it 'logs when the client is disconnected unexpectedly' do
+          raw_connection.closed_listener.call(IOError.new('Boork'))
+          logger.should have_received(:warn).with('Connection from client.example.com:34534 closed unexpectedly: Boork (IOError)')
+        end
       end
 
       context 'when a client sends a request' do
@@ -197,16 +202,17 @@ module Ione
             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
+          it 'calls #handle_error with the error, the request, no response, and the connection' do
+            error, request, response, connection = nil, 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 }
+            server.override_handle_error { |e, q, r, c| error = e; request = q; response = 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
+            error.message.should eq('Borkzor')
+            request.should eq('FOOBAZ')
+            response.should be_nil
+            connection.should equal(peer)
           end
 
           it 'responds with the message returned by #handle_error' do
@@ -244,7 +250,7 @@ module Ione
             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(:error).with(/^Unhandled error for client.example.com:34534; Borkzor \(StandardError\)/i)
             logger.should have_received(:debug).with(/\d+:in/)
           end
 
@@ -253,7 +259,7 @@ module Ione
             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)
+            logger.should have_received(:error).with(/^Unhandled error for client.example.com:34534; OH NOES: Borkzor \(StandardError\)/i)
           end
 
           it 'logs when #handle_error returns a failed future' do
@@ -261,7 +267,7 @@ module Ione
             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)
+            logger.should have_received(:error).with(/^Unhandled error for client.example.com:34534; OH NOES: Borkzor \(StandardError\)/i)
           end
 
           context 'when the codec fails to encode the response' do
@@ -274,6 +280,20 @@ module Ione
               server.errors.first.message.should == 'Borkzor'
             end
 
+            it 'calls #handle_error with the error, the request, the response, and the connection' do
+              error, request, response, connection = nil, nil, nil, nil
+              server.override_handle_request { Ione::Future.resolved('OK') }
+              server.override_handle_error { |e, q, r, c| error = e; request = q; response = r; connection = c }
+              codec.stub(:encode).with('OK', 42).and_raise(CodecError.new('Borkzor'))
+              peer = server.connections.first
+              peer.handle_message('FOOBAZ', 42)
+              error.should be_a(CodecError)
+              error.message.should eq('Borkzor')
+              request.should eq('FOOBAZ')
+              response.should eq('OK')
+              connection.should equal(peer)
+            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}") }
@@ -301,7 +321,26 @@ module Ione
               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)
+              logger.should have_received(:error).with(/^Unhandled error for client.example.com:34534; Buzzfuzz \(Ione::Rpc::CodecError\)/i)
+            end
+          end
+
+          context 'with a legacy server subclass' do
+            let :server do
+              ServerSpec::LegacyTestServer.new(4321, codec, io_reactor: io_reactor, logger: logger)
+            end
+
+            it 'calls #handle_error with the error, the request and the connection for legacy servers' do
+              error, request, response, connection = nil, nil, nil, nil
+              server.override_handle_request { Ione::Future.failed(StandardError.new('Borkzor')) }
+              server.override_handle_error { |e, q, r, c| error = e; request = q; response = r; connection = c }
+              peer = server.connections.first
+              peer.handle_message('FOOBAZ', 42)
+              error.should be_a(StandardError)
+              error.message.should eq('Borkzor')
+              request.should eq('FOOBAZ')
+              response.should eq(:legacy)
+              connection.should equal(peer)
             end
           end
         end
@@ -333,10 +372,10 @@ module ServerSpec
       @request_handler = handler
     end
 
-    def handle_error(error, request, connection)
+    def handle_error(error, request, response, connection)
       @errors << error
       if @error_handler
-        @error_handler.call(error, request, connection)
+        @error_handler.call(error, request, response, connection)
       else
         super
       end
@@ -351,4 +390,10 @@ module ServerSpec
       end
     end
   end
+
+  class LegacyTestServer < TestServer
+    def handle_error(error, request, connection)
+      super(error, request, :legacy, connection)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ione-rpc
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0.pre0
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-21 00:00:00.000000000 Z
+date: 2015-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione
@@ -67,9 +67,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.1