resilient_socket 0.0.2 → 0.1.0

data/lib/resilient_socket/tcp_client.rb

@@ -35,13 +35,15 @@ module ResilientSocket
     # due to a failed connection to the server
     attr_accessor :user_data
 
-    # [String] Name of the server currently connected to or being connected to
-    # including the port number
+    # Returns [String] Name of the server connected to including the port number
     #
     # Example:
-    #   "localhost:2000"
+    #   localhost:2000
     attr_reader :server
 
+    # Returns [TrueClass|FalseClass] Whether send buffering is enabled for this connection
+    attr_reader :buffered
+
     # Create a connection, call the supplied block and close the connection on
     # completion of the block
     #
@@ -116,6 +118,14 @@ module ResilientSocket
     #     Number of seconds between connection retry attempts after the first failed attempt
     #     Default: 0.5
     #
+    #   :on_connect [Proc]
+    #     Directly after a connection is established and before it is made available
+    #     for use this Block is invoked.
+    #     Typical Use Cases:
+    #     - Initialize per connection session sequence numbers
+    #     - Pass any authentication information to the server
+    #     - Perform a handshake with the server
+    #
     # Example
     #   client = ResilientSocket::TCPClient.new(
     #     :server                 => 'server:3300',
@@ -127,7 +137,9 @@ module ResilientSocket
     #     client.send('Update the database')
     #   end
     #
+    #   # Read upto 20 characters from the server
     #   response = client.read(20)
+    #
     #   puts "Received: #{response}"
     #   client.close
     def initialize(parameters={})
@@ -138,8 +150,9 @@ module ResilientSocket
       @buffered = buffered.nil? ? true : buffered
       @connect_retry_count = params.delete(:connect_retry_count) || 10
       @connect_retry_interval = (params.delete(:connect_retry_interval) || 0.5).to_f
+      @on_connect = params.delete(:on_connect)
 
-      unless @servers = params[:servers]
+      unless @servers = params.delete(:servers)
         raise "Missing mandatory :server or :servers" unless server = params.delete(:server)
         @servers = [ server ]
       end
@@ -168,47 +181,27 @@ module ResilientSocket
     #    Timed out after 5 seconds trying to connect to the server
     #    Usually means server is busy or the remote server disappeared off the network recently
     #    No retry, just raise a ConnectionTimeout
+    #
+    # Note: When multiple servers are supplied it will only try to connect to
+    #       the subsequent servers once the retry count has been exceeded
+    #
     def connect
-      retries = 0
-      @logger.benchmark_info "Connected to server" do
-        begin
-          # TODO Implement failover to second server if connect fails
-          @server = @servers.first
-
-          host_name, port = @server.split(":")
-          port = port.to_i
-          address = Socket.getaddrinfo('localhost', nil, Socket::AF_INET)
-
-          socket = Socket.new(Socket.const_get(address[0][0]), Socket::SOCK_STREAM, 0)
-          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) unless @buffered
-
-          # http://stackoverflow.com/questions/231647/how-do-i-set-the-socket-timeout-in-ruby
+      if @servers.size > 0
+        # Try each server in sequence
+        @servers.each_with_index do |server, server_id|
           begin
-            socket_address = Socket.pack_sockaddr_in(port, address[0][3])
-            socket.connect_nonblock(socket_address)
-          rescue Errno::EINPROGRESS
-            resp = IO.select(nil, [socket], nil, @connect_timeout)
-            raise(ConnectionTimeout.new("Timedout after #{@connect_timeout} seconds trying to connect to #{host_name}:#{port}")) unless resp
-            begin
-              socket_address = Socket.pack_sockaddr_in(port, address[0][3])
-              socket.connect_nonblock(socket_address)
-            rescue Errno::EISCONN
-            end
-          end
-          @socket = socket
-
-        rescue SystemCallError => exception
-          if retries < @connect_retry_count
-            retries += 1
-            @logger.warn "Connection failure: #{exception.class}: #{exception.message}. Retry: #{retries}"
-            sleep @connect_retry_interval
-            retry
+            @socket = 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)
           end
-          @logger.error "Connection failure: #{exception.class}: #{exception.message}. Giving up after #{retries} retries"
-          raise ConnectionFailure.new("After #{retries} attempts: #{exception.class}: #{exception.message}")
         end
+      else
+        @socket = connect_to_server(@servers.first)
       end
-      self.user_data = nil
+
+      # Invoke user supplied Block every time a new connection has been established
+      @on_connect.call(self) if @on_connect
       true
     end
 
@@ -232,54 +225,6 @@ module ResilientSocket
       end
     end
 
-    # Send data with retry logic
-    #
-    # On a connection failure, it will close the connection and retry the block
-    # Returns immediately on exception ReadTimeout
-    #
-    # Note this method should only wrap a single standalone call to the server
-    #      since it will automatically retry the entire block every time a
-    #      connection failure is experienced
-    #
-    # Error handling is implemented as follows:
-    #    Network failure during send of either the header or the body
-    #    Since the entire message was not sent it is assumed that it will not be processed
-    #    Close socket
-    #    Retry 1 time using a new connection before raising a ConnectionFailure
-    #
-    # Example of a resilient request that could _modify_ data at the server:
-    #
-    # # Only the send is within the retry block since we cannot re-send once
-    # # the send was successful
-    #
-    # Example of a resilient _read-only_ request:
-    #
-    # # Since the send can be sent many times it is safe to also put the receive
-    # # inside the retry block
-    #
-    def retry_on_connection_failure
-      retries = 0
-      begin
-        connect if closed?
-        yield(self)
-      rescue ConnectionFailure => exception
-        close
-        if retries < 3
-          retries += 1
-          @logger.warn "#retry_on_connection_failure Connection failure: #{exception.message}. Retry: #{retries}"
-          connect
-          retry
-        end
-        @logger.error "#retry_on_connection_failure Connection failure: #{exception.class}: #{exception.message}. Giving up after #{retries} retries"
-        raise ConnectionFailure.new("After #{retries} retry_on_connection_failure attempts: #{exception.class}: #{exception.message}")
-      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
-
     # 4. TCP receive timeout:
     #    Send was successful but receive timed out after X seconds (for example 10 seconds)
     #    No data or partial data received ( for example header but no body )
@@ -327,6 +272,88 @@ module ResilientSocket
       buffer
     end
 
+    # Send and/or receive data with automatic retry on connection failure
+    #
+    # On a connection failure, it will close the connection and retry the block
+    # Returns immediately on exception ReadTimeout
+    #
+    # 1. Example of a resilient _readonly_ request:
+    #
+    #    When reading data from a server that does not change state on the server
+    #    Wrap both the send and the read with #retry_on_connection_failure
+    #    since it is safe to send the same data twice to the server
+    #
+    #    # Since the send can be sent many times it is safe to also put the receive
+    #    # inside the retry block
+    #    value = client.retry_on_connection_failure do
+    #      client.send("GETVALUE:count\n")
+    #      client.read(20).strip.to_i
+    #    end
+    #
+    # 2. Example of a resilient request that _modifies_ data on the server:
+    #
+    #    When changing state on the server, for example when updating a value
+    #    Wrap _only_ the send with #retry_on_connection_failure
+    #    The read must be outside the #retry_on_connection_failure since we must
+    #    not retry the send if the connection fails during the #read
+    #
+    #    value = 45
+    #    # Only the send is within the retry block since we cannot re-send once
+    #    # the send was successful since the server may have made the change
+    #    client.retry_on_connection_failure do
+    #      client.send("SETVALUE:#{count}\n")
+    #    end
+    #    # Server returns "SAVED" if the call was successfull
+    #    result = client.read(20).strip
+    #
+    # 3. Example of a resilient request that _modifies_ data on the server:
+    #
+    #    When changing state on the server, for example when updating a value
+    #    Wrap _only_ the send with #retry_on_connection_failure
+    #    The read must be outside the #retry_on_connection_failure since we must
+    #    not retry the send if the connection fails during the #read
+    #
+    #    value = 45
+    #    # Only the send is within the retry block since we cannot re-send once
+    #    # the send was successful since the server may have made the change
+    #    client.retry_on_connection_failure do
+    #      client.send("SETVALUE:#{count}\n")
+    #    end
+    #    # Server returns "SAVED" if the call was successfull
+    #    saved = (client.read(20).strip == 'SAVED')
+    #
+    #
+    # Error handling is implemented as follows:
+    #    If a network failure occurrs during the block invocation the block
+    #    will be called again with a new connection to the server.
+    #    It will only be retried up to 3 times
+    #    The re-connect will independently retry and timeout using all the
+    #    rules of #connect
+    #
+    #
+    def retry_on_connection_failure
+      retries = 0
+      begin
+        connect if closed?
+        yield(self)
+      rescue ConnectionFailure => exception
+        close
+        if retries < 3
+          retries += 1
+          @logger.warn "#retry_on_connection_failure Connection failure: #{exception.message}. Retry: #{retries}"
+          connect
+          retry
+        end
+        @logger.error "#retry_on_connection_failure Connection failure: #{exception.class}: #{exception.message}. Giving up after #{retries} retries"
+        raise ConnectionFailure.new("After #{retries} retry_on_connection_failure attempts: #{exception.class}: #{exception.message}")
+      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
+
     # Close the socket
     #
     # Logs a warning if an error occurs trying to close the socket
@@ -346,6 +373,54 @@ module ResilientSocket
       @socket.setsockopt(level, optname, optval)
     end
 
-  end
+    #############################################
+    protected
+
+    # Try connecting to a single server
+    # Returns the connected socket
+    #
+    # Raises ConnectionTimeout when the connection timeout has been exceeded
+    # Raises ConnectionFailure
+    def connect_to_server(server)
+      socket = nil
+      retries = 0
+      @logger.benchmark_info "Connecting to server #{server}" do
+        begin
+          host_name, port = server.split(":")
+          port = port.to_i
+          address = Socket.getaddrinfo('localhost', nil, Socket::AF_INET)
+
+          socket = Socket.new(Socket.const_get(address[0][0]), Socket::SOCK_STREAM, 0)
+          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) unless buffered
+
+          # http://stackoverflow.com/questions/231647/how-do-i-set-the-socket-timeout-in-ruby
+          begin
+            socket_address = Socket.pack_sockaddr_in(port, address[0][3])
+            socket.connect_nonblock(socket_address)
+          rescue Errno::EINPROGRESS
+            resp = IO.select(nil, [socket], nil, @connect_timeout)
+            raise(ConnectionTimeout.new("Timedout after #{@connect_timeout} seconds trying to connect to #{host_name}:#{port}")) unless resp
+            begin
+              socket_address = Socket.pack_sockaddr_in(port, address[0][3])
+              socket.connect_nonblock(socket_address)
+            rescue Errno::EISCONN
+            end
+          end
+          break
+        rescue SystemCallError => exception
+          if retries < @connect_retry_count
+            retries += 1
+            @logger.warn "Connection failure: #{exception.class}: #{exception.message}. Retry: #{retries}"
+            sleep @connect_retry_interval
+            retry
+          end
+          @logger.error "Connection failure: #{exception.class}: #{exception.message}. Giving up after #{retries} retries"
+          raise ConnectionFailure.new("After #{retries} attempts: #{exception.class}: #{exception.message}")
+        end
+      end
+      @server = server
+      socket
+    end
 
+  end
 end

data/lib/resilient_socket/version.rb

@@ -1,3 +1,3 @@
 module ResilientSocket #:nodoc
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/nbproject/private/private.properties

@@ -1,2 +1,3 @@
 file.reference.resilient_socket-lib=/Users/rmorrison/Sandbox/resilient_socket/lib
 file.reference.resilient_socket-test=/Users/rmorrison/Sandbox/resilient_socket/test
+platform.active=Ruby_0

data/nbproject/project.properties

@@ -1,5 +1,6 @@
 file.reference.resilient_socket-lib=lib
 file.reference.resilient_socket-test=test
+javac.classpath=
 main.file=
 platform.active=Ruby
 source.encoding=UTF-8

data/test/tcp_client_test.rb

@@ -95,6 +95,44 @@ class TCPClientTest < Test::Unit::TestCase
         end
 
       end
+
+      context "without client connection" do
+        should "connect to second server when first is down" do
+          client = ResilientSocket::TCPClient.new(
+            :servers         => ['localhost:1999', @server_name],
+            :read_timeout    => 3
+          )
+          assert_equal @server_name, client.server
+
+          request = { 'action' => 'test1' }
+          client.send(BSON.serialize(request))
+          reply = read_bson_document(client)
+          assert_equal 'test1', reply['result']
+
+          client.close
+        end
+
+        should "call on_connect after connection" do
+          client = ResilientSocket::TCPClient.new(
+            :server          => @server_name,
+            :read_timeout    => 3,
+            :on_connect      => Proc.new do |socket|
+              # Reset user_data on each connection
+              socket.user_data = { :sequence => 1 }
+            end
+          )
+          assert_equal @server_name, client.server
+          assert_equal 1, client.user_data[:sequence]
+
+          request = { 'action' => 'test1' }
+          client.send(BSON.serialize(request))
+          reply = read_bson_document(client)
+          assert_equal 'test1', reply['result']
+
+          client.close
+        end
+      end
+
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resilient_socket
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-01 00:00:00.000000000 Z
+date: 2012-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -39,6 +39,7 @@ files:
 - lib/resilient_socket/version.rb
 - lib/resilient_socket.rb
 - LICENSE.txt
+- nbproject/private/config.properties
 - nbproject/private/private.properties
 - nbproject/private/rake-d.txt
 - nbproject/project.properties
@@ -46,6 +47,7 @@ files:
 - Rakefile
 - README.md
 - resilient_socket-0.0.1.gem
+- resilient_socket-0.0.2.gem
 - test/simple_tcp_server.rb
 - test/tcp_client_test.rb
 - test.log