resilient_socket 0.2.0 → 0.3.0

data/lib/resilient_socket/tcp_client.rb

@@ -42,14 +42,17 @@ module ResilientSocket
   #
   class TCPClient
     # Supports embedding user supplied data along with this connection
-    # such as sequence number, etc.
+    # such as sequence number and other connection specific information
     attr_accessor :user_data
 
     # Returns [String] Name of the server connected to including the port number
     #
     # Example:
     #   localhost:2000
-    attr_reader :server
+    attr_reader :server, :buffered
+
+    attr_accessor :read_timeout, :connect_timeout, :connect_retry_count,
+      :retry_count, :connect_retry_interval, :server_selector, :close_on_error
 
     # Returns [TrueClass|FalseClass] Whether send buffering is enabled for this connection
     attr_reader :buffered
@@ -163,6 +166,31 @@ module ResilientSocket
     #     - Pass any authentication information to the server
     #     - Perform a handshake with the server
     #
+    #   :server_selector [Symbol|Proc]
+    #     When multiple servers are supplied using :servers, this option will
+    #     determine which server is selected from the list
+    #       :ordered
+    #         Select a server in the order supplied in the array, with the first
+    #         having the highest priority. The second server will only be connected
+    #         to if the first server is unreachable
+    #       :random
+    #         Randomly select a server from the list every time a connection
+    #         is established, including during automatic connection recovery.
+    #       Proc:
+    #         When a Proc is supplied, it will be called passing in the list
+    #         of servers. The Proc must return one server name
+    #           Example:
+    #             :server_selector => Proc.new do |servers|
+    #               servers.last
+    #             end
+    #       Default: :ordered
+    #
+    #   :close_on_error [True|False]
+    #     To prevent the connection from going into an inconsistent state
+    #     automatically close the connection if an error occurs
+    #     This includes a Read Timeout
+    #     Default: true
+    #
     # Example
     #   client = ResilientSocket::TCPClient.new(
     #     :server                 => 'server:3300',
@@ -189,6 +217,9 @@ module ResilientSocket
       @retry_count = params.delete(:retry_count) || 3
       @connect_retry_interval = (params.delete(:connect_retry_interval) || 0.5).to_f
       @on_connect = params.delete(:on_connect)
+      @server_selector = params.delete(:server_selector) || :ordered
+      @close_on_error = params.delete(:close_on_error)
+      @close_on_error = true if @close_on_error.nil?
 
       unless @servers = params.delete(:servers)
         raise "Missing mandatory :server or :servers" unless server = params.delete(:server)
@@ -228,14 +259,46 @@ module ResilientSocket
     def connect
       @socket.close if @socket && !@socket.closed?
       if @servers.size > 1
-        # Try each server in sequence
-        @servers.each_with_index do |server, server_id|
-          begin
-            connect_to_server(server)
-          rescue ConnectionFailure => exc
-            # Raise Exception once it has also failed to connect to the last server
-            raise(exc) if @servers.size <= (server_id + 1)
+        case
+        when @server_selector.is_a?(Proc)
+          connect_to_server(@server_selector.call(@servers))
+
+        when @server_selector == :ordered
+          # Try each server in sequence
+          exception = nil
+          @servers.find do |server|
+            begin
+              connect_to_server(server)
+              exception = nil
+              true
+            rescue ConnectionFailure => exc
+              exception = exc
+              false
+            end
+          end
+          # Raise Exception once it has also failed to connect to all servers
+          raise(exception) if exception
+
+        when @server_selector == :random
+          # Pick each server randomly, trying each server until one can be connected to
+          # If no server can be connected to a ConnectionFailure is raised
+          servers_to_try = @servers.uniq
+          exception = nil
+          servers_to_try.size.times do |i|
+            server = servers_to_try[rand(servers_to_try.size)]
+            servers_to_try.delete(server)
+            begin
+              connect_to_server(server)
+              exception = nil
+            rescue ConnectionFailure => exc
+              exception = exc
+            end
           end
+          # Raise Exception once it has also failed to connect to all servers
+          raise(exception) if exception
+
+        else
+          raise ArgumentError.new("Invalid or unknown value for parameter :server_selector => #{@server_selector}")
         end
       else
         connect_to_server(@servers.first)
@@ -260,8 +323,13 @@ module ResilientSocket
           @socket.write(data)
         rescue SystemCallError => exception
           @logger.warn "#write Connection failure: #{exception.class}: #{exception.message}"
-          close
+          close if close_on_error
           raise ConnectionFailure.new("Send Connection failure: #{exception.class}: #{exception.message}", @server, exception)
+        rescue Exception
+          # Close the connection on any other exception since the connection
+          # will now be in an inconsistent state
+          close if close_on_error
+          raise
         end
       end
     end
@@ -290,6 +358,7 @@ module ResilientSocket
     #     Optional: Override the default read timeout for this read
     #     Number of seconds before raising ReadTimeout when no data has
     #     been returned
+    #     A value of -1 will wait forever for a response on the socket
     #     Default: :read_timeout supplied to #initialize
     #
     #  Note: After a ResilientSocket::ReadTimeout #read can be called again on
@@ -302,17 +371,25 @@ module ResilientSocket
     def read(length, buffer=nil, timeout=nil)
       result = nil
       @logger.benchmark_debug("#read <== read #{length} bytes") do
-        # Block on data to read for @read_timeout seconds
-        begin
-          ready = IO.select([@socket], nil, [@socket], timeout || @read_timeout)
+        if timeout != -1
+          # Block on data to read for @read_timeout seconds
+          ready = begin
+            ready = IO.select([@socket], nil, [@socket], timeout || @read_timeout)
+          rescue IOError => exception
+            @logger.warn "#read Connection failure while waiting for data: #{exception.class}: #{exception.message}"
+            close if close_on_error
+            raise ConnectionFailure.new("#{exception.class}: #{exception.message}", @server, exception)
+          rescue Exception
+            # Close the connection on any other exception since the connection
+            # will now be in an inconsistent state
+            close if close_on_error
+            raise
+          end
           unless ready
+            close if close_on_error
             @logger.warn "#read Timeout waiting for server to reply"
             raise ReadTimeout.new("Timedout after #{timeout || @read_timeout} seconds trying to read from #{@server}")
           end
-        rescue IOError => exception
-          @logger.warn "#read Connection failure while waiting for data: #{exception.class}: #{exception.message}"
-          close
-          raise ConnectionFailure.new("#{exception.class}: #{exception.message}", @server, exception)
         end
 
         # Read data from socket
@@ -322,14 +399,19 @@ module ResilientSocket
 
           # EOF before all the data was returned
           if result.nil? || (result.length < length)
-            close
+            close if close_on_error
             @logger.warn "#read server closed the connection before #{length} bytes were returned"
             raise ConnectionFailure.new("Connection lost while reading data", @server, EOFError.new("end of file reached"))
           end
         rescue SystemCallError, IOError => exception
-          close
+          close if close_on_error
           @logger.warn "#read Connection failure while reading data: #{exception.class}: #{exception.message}"
           raise ConnectionFailure.new("#{exception.class}: #{exception.message}", @server, exception)
+        rescue Exception
+          # Close the connection on any other exception since the connection
+          # will now be in an inconsistent state
+          close if close_on_error
+          raise
         end
       end
       result
@@ -337,8 +419,9 @@ module ResilientSocket
 
     # Send and/or receive data with automatic retry on connection failure
     #
-    # On a connection failure, it will close the connection and retry the block
+    # On a connection failure, it will create a new connection and retry the block.
     # Returns immediately on exception ReadTimeout
+    # The connection is always closed on ConnectionFailure regardless of close_on_error
     #
     # 1. Example of a resilient _readonly_ request:
     #
@@ -381,10 +464,6 @@ module ResilientSocket
         connect if closed?
         yield(self)
       rescue ConnectionFailure => exception
-        # Connection no longer usable. The next call to #retry_on_connection_failure
-        # will create a new connection since this one is now closed
-        close
-
         exc_str = exception.cause ? "#{exception.cause.class}: #{exception.cause.message}" : exception.message
         # Re-raise exceptions that should not be retried
         if !self.class.reconnect_on_errors.include?(exception.cause.class)
@@ -398,11 +477,6 @@ module ResilientSocket
         end
         @logger.error "#retry_on_connection_failure Connection failure: #{exception.class}: #{exception.message}. Giving up after #{retries} retries"
         raise ConnectionFailure.new("After #{retries} retries to host '#{server}': #{exc_str}", @server, exception.cause)
-      rescue Exception => exc
-        # With any other exception we have to close the connection since the connection
-        # is now in an unknown state
-        close
-        raise exc
       end
     end
 

data/lib/resilient_socket/version.rb

@@ -1,3 +1,3 @@
 module ResilientSocket #:nodoc
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/test/tcp_client_test.rb

@@ -51,6 +51,32 @@ class TCPClientTest < Test::Unit::TestCase
       #  assert_match /Timedout after/, exception.message
       #end
 
+      context "without client connection" do
+        should "timeout on first receive and then successfully read the response" do
+          @read_timeout = 3.0
+          # Need a custom client that does not auto close on error:
+          @client = ResilientSocket::TCPClient.new(
+            :server          => @server_name,
+            :read_timeout    => @read_timeout,
+            :close_on_error  => false
+          )
+
+          request = { 'action' => 'sleep', 'duration' => @read_timeout + 0.5}
+          @client.write(BSON.serialize(request))
+
+          exception = assert_raise ResilientSocket::ReadTimeout do
+            # Read 4 bytes from server
+            @client.read(4)
+          end
+          assert_equal false, @client.close_on_error
+          assert @client.alive?, "The client connection is not alive after the read timed out with :close_on_error => false"
+          assert_match /Timedout after #{@read_timeout} seconds trying to read from #{@server_name}/, exception.message
+          reply = read_bson_document(@client)
+          assert_equal 'sleep', reply['result']
+          @client.close
+        end
+      end
+
       context "with client connection" do
         setup do
           @read_timeout = 3.0
@@ -59,6 +85,7 @@ class TCPClientTest < Test::Unit::TestCase
             :read_timeout    => @read_timeout
           )
           assert @client.alive?
+          assert_equal true, @client.close_on_error
         end
 
         def teardown
@@ -83,24 +110,12 @@ class TCPClientTest < Test::Unit::TestCase
             # Read 4 bytes from server
             @client.read(4)
           end
-          assert @client.alive?
+          # Due to :close_on_error => true, a timeout will close the connection
+          # to prevent use of a socket connection in an inconsistent state
+          assert_equal false, @client.alive?
           assert_match /Timedout after #{@read_timeout} seconds trying to read from #{@server_name}/, exception.message
         end
 
-        should "timeout on first receive and then successfully read the response" do
-          request = { 'action' => 'sleep', 'duration' => @read_timeout + 0.5}
-          @client.write(BSON.serialize(request))
-
-          exception = assert_raise ResilientSocket::ReadTimeout do
-            # Read 4 bytes from server
-            @client.read(4)
-          end
-          assert @client.alive?
-          assert_match /Timedout after #{@read_timeout} seconds trying to read from #{@server_name}/, exception.message
-          reply = read_bson_document(@client)
-          assert_equal 'sleep', reply['result']
-        end
-
         should "retry on connection failure" do
           attempt = 0
           reply = @client.retry_on_connection_failure do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resilient_socket
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-15 00:00:00.000000000 Z
+date: 2012-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -47,6 +47,8 @@ files:
 - nbproject/project.xml
 - Rakefile
 - README.md
+- resilient_socket-0.2.0.gem
+- resilient_socket-0.2.1.gem
 - test/simple_tcp_server.rb
 - test/tcp_client_test.rb
 - test.log