net_tcp_client 1.0.2 → 2.0.0

data/lib/net/tcp_client/policy/base.rb

@@ -0,0 +1,36 @@
+module Net
+  class TCPClient
+    module Policy
+      # Policy for connecting to servers in the order specified
+      class Base
+        attr_reader :addresses
+
+        # Returns a policy instance for the supplied policy type
+        def self.factory(policy, server_names)
+          case policy
+          when :ordered
+            # Policy for connecting to servers in the order specified
+            Ordered.new(server_names)
+          when :random
+            Random.new(server_names)
+          when Proc
+            Custom.new(server_names, policy)
+          else
+            raise(ArgumentError, "Invalid policy: #{policy.inspect}")
+          end
+        end
+
+        def initialize(server_names)
+          # Collect Addresses for the supplied server_names
+          @addresses = Array(server_names).collect { |name| Address.addresses_for_server_name(name) }.flatten
+        end
+
+        # Calls the block once for each server, with the addresses in order
+        def each(&block)
+          raise NotImplementedError
+        end
+
+      end
+    end
+  end
+end

data/lib/net/tcp_client/policy/custom.rb

@@ -0,0 +1,39 @@
+module Net
+  class TCPClient
+    module Policy
+      # Policy for connecting to servers in the order specified
+      class Custom < Base
+        def initialize(server_names, proc)
+          super(server_names)
+          @proc = proc
+        end
+
+        # Calls the block once for each server, with the addresses in the order returned
+        # by the supplied proc.
+        # The block must return a Net::TCPClient::Address instance,
+        # or nil to stop trying to connect to servers
+        #
+        # Note:
+        #   If every address fails the block will be called constantly until it returns nil.
+        #
+        # Example:
+        #   # Returns addresses in random order but without checking if a host name has been used before
+        #   policy.each_proc do |addresses, count|
+        #     # Return nil after the last address has been tried so that retry logic can take over
+        #     if count <= address.size
+        #       addresses.sample
+        #     end
+        #   end
+        def each(&block)
+          count = 1
+          while address = @proc.call(addresses, count)
+            raise(ArgumentError, 'Proc must return Net::TCPClient::Address, or nil') unless address.is_a?(Net::TCPClient::Address) || address.nil?
+            block.call(address)
+            count += 1
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/net/tcp_client/policy/ordered.rb

@@ -0,0 +1,14 @@
+module Net
+  class TCPClient
+    module Policy
+      # Policy for connecting to servers in the order specified
+      class Ordered < Base
+        # Calls the block once for each server, with the addresses in order
+        def each(&block)
+          addresses.each {|address| block.call(address)}
+        end
+
+      end
+    end
+  end
+end

data/lib/net/tcp_client/policy/random.rb

@@ -0,0 +1,14 @@
+module Net
+  class TCPClient
+    module Policy
+      # Policy for connecting to servers in the order specified
+      class Random < Base
+        # Calls the block once for each server, with the addresses in random order
+        def each(&block)
+          addresses.shuffle.each {|address| block.call(address)}
+        end
+
+      end
+    end
+  end
+end

data/lib/net/tcp_client/tcp_client.rb

@@ -35,25 +35,19 @@ module Net
   #   has to be completely destroyed and recreated after a connection failure
   #
   class TCPClient
+    include SemanticLogger::Loggable if defined?(SemanticLogger::Loggable)
+
+    attr_accessor :connect_timeout, :read_timeout, :write_timeout,
+      :connect_retry_count, :connect_retry_interval, :retry_count,
+      :policy, :close_on_error, :buffered, :ssl, :buffered,
+      :proxy_server
+    attr_reader :servers, :address, :socket, :ssl_handshake_timeout
+
     # Supports embedding user supplied data along with this connection
     # such as sequence number and other connection specific information
+    # Not used or modified by TCPClient
     attr_accessor :user_data
 
-    # Returns [String] Name of the server connected to including the port number
-    #
-    # Example:
-    #   localhost:2000
-    attr_reader :server
-
-    attr_accessor :read_timeout, :connect_timeout, :connect_retry_count,
-      :retry_count, :connect_retry_interval, :server_selector, :close_on_error
-
-    # Returns [true|false] Whether send buffering is enabled for this connection
-    attr_reader :buffered
-
-    # Returns the logger being used by the TCPClient instance
-    attr_reader :logger
-
     @@reconnect_on_errors = [
       Errno::ECONNABORTED,
       Errno::ECONNREFUSED,
@@ -65,6 +59,7 @@ module Net
       Errno::EPIPE,
       Errno::ETIMEDOUT,
       EOFError,
+      Net::TCPClient::ConnectionTimeout
     ]
 
     # Return the array of errors that will result in an automatic connection retry
@@ -107,6 +102,7 @@ module Net
     #   :server [String]
     #     URL of the server to connect to with port number
     #     'localhost:2000'
+    #     '192.168.1.10:80'
     #
     #   :servers [Array of String]
     #     Array of URL's of servers to connect to with port numbers
@@ -117,34 +113,29 @@ module Net
     #     A read failure or timeout will not result in switching to the second
     #     server, only a connection failure or during an automatic reconnect
     #
-    #   :read_timeout [Float]
-    #     Time in seconds to timeout on read
-    #     Can be overridden by supplying a timeout in the read call
-    #     Default: 60
-    #
     #   :connect_timeout [Float]
     #     Time in seconds to timeout when trying to connect to the server
     #     A value of -1 will cause the connect wait time to be infinite
-    #     Default: Half of the :read_timeout ( 30 seconds )
+    #     Default: 10 seconds
     #
-    #   :logger [Logger]
-    #     Set the logger to which to write log messages to
-    #     Note: Additional methods will be mixed into this logger to make it
-    #           compatible with the SematicLogger extensions if it is not already
-    #           a SemanticLogger logger instance
+    #   :read_timeout [Float]
+    #     Time in seconds to timeout on read
+    #     Can be overridden by supplying a timeout in the read call
+    #     Default: 60
     #
-    #   :log_level [Symbol]
-    #     Set the logging level for the TCPClient
-    #     Any valid SemanticLogger log level:
-    #       :trace, :debug, :info, :warn, :error, :fatal
-    #     Default: SemanticLogger.default_level
+    #   :write_timeout [Float]
+    #     Time in seconds to timeout on write
+    #     Can be overridden by supplying a timeout in the write call
+    #     Default: 60
     #
     #   :buffered [Boolean]
     #     Whether to use Nagle's Buffering algorithm (http://en.wikipedia.org/wiki/Nagle's_algorithm)
     #     Recommend disabling for RPC style invocations where we don't want to wait for an
     #     ACK from the server before sending the last partial segment
     #     Buffering is recommended in a browser or file transfer style environment
-    #     where multiple sends are expected during a single response
+    #     where multiple sends are expected during a single response.
+    #     Also sets sync to true if buffered is false so that all data is sent immediately without
+    #     internal buffering.
     #     Default: true
     #
     #   :connect_retry_count [Fixnum]
@@ -159,20 +150,19 @@ module Net
     #     Number of times to retry when calling #retry_on_connection_failure
     #     This is independent of :connect_retry_count which still applies with
     #     connection failures. This retry controls upto how many times to retry the
-    #     supplied block should a connection failure occurr during the block
+    #     supplied block should a connection failure occur during the block
     #     Default: 3
     #
     #   :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
+    #     - Initialize per connection session sequence numbers.
+    #     - Pass 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
+    #   :policy [Symbol|Proc]
+    #     Specify the policy to use when connecting to servers.
     #       :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
@@ -180,20 +170,14 @@ module Net
     #       :random
     #         Randomly select a server from the list every time a connection
     #         is established, including during automatic connection recovery.
-    #       :nearest
-    #         FUTURE - Not implemented yet
-    #         The server with an IP address that most closely matches the
-    #         local ip address will be attempted first
-    #         This will result in connections to servers on the localhost
-    #         first prior to looking at remote servers
     #       :ping_time
-    #         FUTURE - Not implemented yet
-    #         The server with the lowest ping time will be selected first
+    #         FUTURE - Not implemented yet - Pull request anyone?
+    #         The server with the lowest ping time will be tried first
     #       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|
+    #             :policy => Proc.new do |servers|
     #               servers.last
     #             end
     #       Default: :ordered
@@ -204,7 +188,26 @@ module Net
     #     This includes a Read Timeout
     #     Default: true
     #
-    # Example
+    #   :proxy_server [String]
+    #     The host name and port in the form of 'host_name:1234' to forward
+    #     socket connections though.
+    #     Default: nil ( none )
+    #
+    #   SSL Options
+    #   :ssl [true|false|Hash]
+    #      true:  SSL is enabled using the SSL context defaults.
+    #      false: SSL is not used.
+    #      Hash:
+    #        Keys from OpenSSL::SSL::SSLContext:
+    #          ca_file, ca_path, cert, cert_store, ciphers, key, ssl_timeout, ssl_version
+    #          verify_callback, verify_depth, verify_mode
+    #        handshake_timeout: [Float]
+    #          The number of seconds to timeout the SSL Handshake.
+    #          Default: connect_timeout
+    #      Default: false.
+    #        See OpenSSL::SSL::SSLContext::DEFAULT_PARAMS for the defaults.
+    #
+    # Example:
     #   client = Net::TCPClient.new(
     #     server:                 'server:3300',
     #     connect_retry_interval: 0.1,
@@ -220,20 +223,43 @@ module Net
     #
     #   puts "Received: #{response}"
     #   client.close
+    #
+    # SSL Example:
+    #   client = Net::TCPClient.new(
+    #     server:                 'server:3300',
+    #     connect_retry_interval: 0.1,
+    #     connect_retry_count:    5,
+    #     ssl:                    true
+    #   )
+    #
+    # SSL with options Example:
+    #   client = Net::TCPClient.new(
+    #     server:                 'server:3300',
+    #     connect_retry_interval: 0.1,
+    #     connect_retry_count:    5,
+    #     ssl:                    {
+    #       verify_mode: OpenSSL::SSL::VERIFY_NONE
+    #     }
+    #   )
     def initialize(parameters={})
       params                  = parameters.dup
       @read_timeout           = (params.delete(:read_timeout) || 60.0).to_f
-      @connect_timeout        = (params.delete(:connect_timeout) || (@read_timeout/2)).to_f
+      @write_timeout          = (params.delete(:write_timeout) || 60.0).to_f
+      @connect_timeout        = (params.delete(:connect_timeout) || 10).to_f
       buffered                = params.delete(:buffered)
       @buffered               = buffered.nil? ? true : buffered
       @connect_retry_count    = params.delete(:connect_retry_count) || 10
       @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
+      @proxy_server           = params.delete(:proxy_server)
+      @policy                 = params.delete(:policy) || :ordered
       @close_on_error         = params.delete(:close_on_error)
       @close_on_error         = true if @close_on_error.nil?
-      @logger                 = params.delete(:logger)
+      if @ssl = params.delete(:ssl)
+        @ssl                   = {} if @ssl == true
+        @ssl_handshake_timeout = (@ssl.delete(:handshake_timeout) || @connect_timeout).to_f
+      end
 
       if server = params.delete(:server)
         @servers = [server]
@@ -243,9 +269,9 @@ module Net
       end
       raise(ArgumentError, 'Missing mandatory :server or :servers') unless @servers
 
-      # If a logger is supplied then extend it with the SemanticLogger API
-      @logger = Logging.new_logger(logger, "#{self.class.name} #{@servers.inspect}", params.delete(:log_level))
-
+      if params.delete(:logger)
+        warn '[Deprecated] :logger option is no longer offered. Add semantic_logger gem to enable logging.' if $VERBOSE
+      end
       raise(ArgumentError, "Invalid options: #{params.inspect}") if params.size > 0
 
       # Connect to the Server
@@ -277,23 +303,28 @@ module Net
     # Note: Calling #connect on an open connection will close the current connection
     #       and create a new connection
     def connect
-      @socket.close if @socket && !@socket.closed?
-      case
-      when @servers.size == 1
-        connect_to_server(@servers.first)
-      when @server_selector.is_a?(Proc)
-        connect_to_server(@server_selector.call(@servers))
-      when @server_selector == :ordered
-        connect_to_servers_in_order(@servers)
-      when @server_selector == :random
-        connect_to_servers_in_order(@servers.sample(@servers.size))
-      else
-        raise ArgumentError.new("Invalid or unknown value for parameter :server_selector => #{@server_selector}")
-      end
+      start_time = Time.now
+      retries    = 0
+      close
 
-      # Invoke user supplied Block every time a new connection has been established
-      @on_connect.call(self) if @on_connect
-      true
+      # Number of times to try
+      begin
+        connect_to_server(servers, policy)
+        logger.info(message: "Connected to #{address}", duration: (Time.now - start_time) * 1000) if respond_to?(:logger)
+      rescue ConnectionFailure, ConnectionTimeout => exception
+        cause = exception.is_a?(ConnectionTimeout) ? exception : exception.cause
+        # Retry-able?
+        if self.class.reconnect_on_errors.include?(cause.class) && (retries < connect_retry_count.to_i)
+          retries += 1
+          logger.warn "#connect Failed to connect to any of #{servers.join(',')}. Sleeping:#{connect_retry_interval}s. Retry: #{retries}" if respond_to?(:logger)
+          sleep(connect_retry_interval)
+          retry
+        else
+          message = "#connect Failed to connect to any of #{servers.join(',')} after #{retries} retries. #{exception.class}: #{exception.message}"
+          logger.benchmark_error(message, exception: exception, duration: (Time.now - start_time)) if respond_to?(:logger)
+          raise ConnectionFailure.new(message, address.to_s, cause)
+        end
+      end
     end
 
     # Send data to the server
@@ -303,24 +334,35 @@ module Net
     # Raises Net::TCPClient::ConnectionFailure whenever the send fails
     #        For a description of the errors, see Socket#write
     #
-    def write(data)
+    # Parameters
+    #   timeout [Float]
+    #     Optional: Override the default write timeout for this write
+    #     Number of seconds before raising Net::TCPClient::WriteTimeout when no data has
+    #     been written.
+    #     A value of -1 will wait forever
+    #     Default: :write_timeout supplied to #initialize
+    #
+    #  Note: After a Net::TCPClient::ReadTimeout #read can be called again on
+    #        the same socket to read the response later.
+    #        If the application no longers want the connection after a
+    #        Net::TCPClient::ReadTimeout, then the #close method _must_ be called
+    #        before calling _connect_ or _retry_on_connection_failure_ to create
+    #        a new connection
+    def write(data, timeout = write_timeout)
       data = data.to_s
-      logger.trace('#write ==> sending', data)
-      stats = {}
-      logger.benchmark_debug('#write ==> complete', stats) do
-        begin
-          stats[:bytes_sent] = @socket.write(data)
-        rescue SystemCallError => exception
-          logger.warn "#write Connection failure: #{exception.class}: #{exception.message}"
-          close if close_on_error
-          raise Net::TCPClient::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
+      if respond_to?(:logger)
+        payload        = {timeout: timeout}
+        # With trace level also log the sent data
+        payload[:data] = data if logger.trace?
+        logger.benchmark_debug('#write', payload: payload) do
+          payload[:bytes] = socket_write(data, timeout)
         end
+      else
+        socket_write(data, timeout)
       end
+    rescue Exception => exc
+      close if close_on_error
+      raise exc
     end
 
     # Returns a response from the server
@@ -340,9 +382,12 @@ module Net
     # Parameters
     #   length [Fixnum]
     #     The number of bytes to return
-    #     #read will not return unitl 'length' bytes have been received from
+    #     #read will not return until 'length' bytes have been received from
     #     the server
     #
+    #   buffer [String]
+    #    Optional buffer into which to write the data that is read.
+    #
     #   timeout [Float]
     #     Optional: Override the default read timeout for this read
     #     Number of seconds before raising Net::TCPClient::ReadTimeout when no data has
@@ -350,41 +395,27 @@ module Net
     #     A value of -1 will wait forever for a response on the socket
     #     Default: :read_timeout supplied to #initialize
     #
-    #  Note: After a ResilientSocket::Net::TCPClient::ReadTimeout #read can be called again on
+    #  Note: After a Net::TCPClient::ReadTimeout #read can be called again on
     #        the same socket to read the response later.
     #        If the application no longers want the connection after a
     #        Net::TCPClient::ReadTimeout, then the #close method _must_ be called
     #        before calling _connect_ or _retry_on_connection_failure_ to create
     #        a new connection
-    #
     def read(length, buffer = nil, timeout = read_timeout)
-      result = nil
-      logger.benchmark_debug("#read <== read #{length} bytes") do
-        wait_for_data(timeout)
-
-        # Read data from socket
-        begin
-          result = buffer.nil? ? @socket.read(length) : @socket.read(length, buffer)
-          logger.trace('#read <== received', result)
-
-          # EOF before all the data was returned
-          if result.nil? || (result.length < length)
-            close if close_on_error
-            logger.warn "#read server closed the connection before #{length} bytes were returned"
-            raise Net::TCPClient::ConnectionFailure.new('Connection lost while reading data', @server, EOFError.new('end of file reached'))
-          end
-        rescue SystemCallError, IOError => exception
-          close if close_on_error
-          logger.warn "#read Connection failure while reading data: #{exception.class}: #{exception.message}"
-          raise Net::TCPClient::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
+      if respond_to?(:logger)
+        payload = {bytes: length, timeout: timeout}
+        logger.benchmark_debug('#read', payload: payload) do
+          data           = socket_read(length, buffer, timeout)
+          # With trace level also log the received data
+          payload[:data] = data if logger.trace?
+          data
         end
+      else
+        socket_read(length, buffer, timeout)
       end
-      result
+    rescue Exception => exc
+      close if close_on_error
+      raise exc
     end
 
     # Send and/or receive data with automatic retry on connection failure
@@ -433,20 +464,20 @@ module Net
       begin
         connect if closed?
         yield(self)
-      rescue Net::TCPClient::ConnectionFailure => exception
+      rescue ConnectionFailure => exception
         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)
-          logger.warn "#retry_on_connection_failure not configured to retry: #{exc_str}"
+          logger.info "#retry_on_connection_failure not configured to retry: #{exc_str}" if respond_to?(:logger)
           raise exception
         elsif retries < @retry_count
           retries += 1
-          logger.warn "#retry_on_connection_failure retry #{retries} due to #{exception.class}: #{exception.message}"
+          logger.warn "#retry_on_connection_failure retry #{retries} due to #{exception.class}: #{exception.message}" if respond_to?(:logger)
           connect
           retry
         end
-        logger.error "#retry_on_connection_failure Connection failure: #{exception.class}: #{exception.message}. Giving up after #{retries} retries"
-        raise Net::TCPClient::ConnectionFailure.new("After #{retries} retries to host '#{server}': #{exc_str}", @server, exception.cause)
+        logger.error "#retry_on_connection_failure Connection failure: #{exception.class}: #{exception.message}. Giving up after #{retries} retries" if respond_to?(:logger)
+        raise ConnectionFailure.new("After #{retries} retries to host '#{server}': #{exc_str}", server, exception.cause)
       end
     end
 
@@ -454,14 +485,26 @@ module Net
     #
     # Logs a warning if an error occurs trying to close the socket
     def close
-      @socket.close unless @socket.closed?
+      socket.close if socket && !socket.closed?
+      @socket  = nil
+      @address = nil
+      true
     rescue IOError => exception
-      logger.warn "IOError when attempting to close socket: #{exception.class}: #{exception.message}"
+      logger.warn "IOError when attempting to close socket: #{exception.class}: #{exception.message}" if respond_to?(:logger)
+      false
+    end
+
+    def flush
+      return unless socket
+      respond_to?(:logger) ? logger.benchmark_debug('#flush') { socket.flush } : socket.flush
     end
 
-    # Returns whether the socket is closed
     def closed?
-      @socket.closed?
+      socket.nil? || socket.closed?
+    end
+
+    def eof?
+      socket.nil? || socket.eof?
     end
 
     # Returns whether the connection to the server is alive
@@ -478,10 +521,10 @@ module Net
     # make about 120,000 calls per second against an active connection.
     # I.e. About 8.3 micro seconds per call
     def alive?
-      return false if @socket.closed?
+      return false if socket.nil? || closed?
 
-      if IO.select([@socket], nil, nil, 0)
-        !@socket.eof? rescue false
+      if IO.select([socket], nil, nil, 0)
+        !socket.eof? rescue false
       else
         true
       end
@@ -489,109 +532,189 @@ module Net
       false
     end
 
-    # See: Socket#setsockopt
-    def setsockopt(level, optname, optval)
-      @socket.setsockopt(level, optname, optval)
+    def setsockopt(*args)
+      socket.nil? || socket.setsockopt(*args)
     end
 
-    #############################################
-    protected
+    private
 
-    # Try connecting to a single server
-    # Returns the connected socket
+    # Connect to one of the servers in the list, per the current policy
+    # Returns [Socket] the socket connected to or an Exception
+    def connect_to_server(servers, policy)
+      # Iterate over each server address until it successfully connects to a host
+      last_exception = nil
+      Policy::Base.factory(policy, servers).each do |address|
+        begin
+          return connect_to_address(address)
+        rescue ConnectionTimeout, ConnectionFailure => exception
+          last_exception = exception
+        end
+      end
+
+      # Raise Exception once it has failed to connect to any server
+      last_exception ? raise(last_exception) : raise(ArgumentError, "No servers supplied to connect to: #{servers.join(',')}")
+    end
+
+    # Returns [Socket] connected to supplied address
+    #   address [Net::TCPClient::Address]
+    #     Host name, ip address and port of server to connect to
+    # Connect to the server at the supplied address
+    # Returns the socket connection
+    def connect_to_address(address)
+      socket =
+        if proxy_server
+          ::SOCKSSocket.new("#{address.ip_address}:#{address.port}", proxy_server)
+        else
+          ::Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        end
+      unless buffered
+        socket.sync = true
+        socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
+      end
+
+      socket_connect(socket, address, connect_timeout)
+
+      @socket = ssl ? ssl_connect(socket, address, ssl_handshake_timeout) : socket
+      @address = address
+
+      # Invoke user supplied Block every time a new connection has been established
+      @on_connect.call(self) if @on_connect
+    end
+
+    # Connect to server
     #
     # Raises Net::TCPClient::ConnectionTimeout when the connection timeout has been exceeded
     # Raises Net::TCPClient::ConnectionFailure
-    def connect_to_server(server)
-      # Have to use Socket internally instead of TCPSocket since TCPSocket
-      # does not offer async connect API amongst others:
-      # :accept, :accept_nonblock, :bind, :connect, :connect_nonblock, :getpeereid,
-      # :ipv6only!, :listen, :recvfrom_nonblock, :sysaccept
-      retries = 0
-      logger.benchmark_info "Connected to #{server}" do
-        host_name, port = server.split(":")
-        port            = port.to_i
+    def socket_connect(socket, address, timeout)
+      socket_address = Socket.pack_sockaddr_in(address.port, address.ip_address)
 
-        address        = Socket.getaddrinfo(host_name, nil, Socket::AF_INET, Socket::SOCK_STREAM).sample
-        socket_address = Socket.pack_sockaddr_in(port, address[3])
+      # Timeout of -1 means wait forever for a connection
+      return socket.connect(socket_address) if timeout == -1
 
-        begin
-          @socket = Socket.new(Socket.const_get(address[0]), Socket::SOCK_STREAM, 0)
-          @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) unless buffered
-          if @connect_timeout == -1
-            # Timeout of -1 means wait forever for a connection
-            @socket.connect(socket_address)
-          else
-            begin
-              @socket.connect_nonblock(socket_address)
-            rescue Errno::EINPROGRESS
-            end
-            if IO.select(nil, [@socket], nil, @connect_timeout)
-              begin
-                @socket.connect_nonblock(socket_address)
-              rescue Errno::EISCONN
-              end
-            else
-              raise(Net::TCPClient::ConnectionTimeout.new("Timedout after #{@connect_timeout} seconds trying to connect to #{server}"))
-            end
-          end
-          break
-        rescue SystemCallError => exception
-          if retries < @connect_retry_count && self.class.reconnect_on_errors.include?(exception.class)
-            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 Net::TCPClient::ConnectionFailure.new("After #{retries} connection attempts to host '#{server}': #{exception.class}: #{exception.message}", @server, exception)
+      deadline = Time.now.utc + timeout
+      begin
+        non_blocking(socket, deadline) { socket.connect_nonblock(socket_address) }
+      rescue Errno::EISCONN
+        # Connection was successful.
+      rescue NonBlockingTimeout
+        raise ConnectionTimeout.new("Timed out after #{timeout} seconds trying to connect to #{address}")
+      rescue SystemCallError, IOError => exception
+        message = "#connect Connection failure connecting to '#{address.to_s}': #{exception.class}: #{exception.message}"
+        logger.error message if respond_to?(:logger)
+        raise ConnectionFailure.new(message, address.to_s, exception)
+      end
+    end
+
+    # Write to the socket
+    def socket_write(data, timeout)
+      if timeout < 0
+        socket.write(data)
+      else
+        deadline = Time.now.utc + timeout
+        non_blocking(socket, deadline) do
+          socket.write_nonblock(data)
         end
       end
-      @server = server
+    rescue NonBlockingTimeout
+      logger.warn "#write Timeout after #{timeout} seconds" if respond_to?(:logger)
+      raise WriteTimeout.new("Timed out after #{timeout} seconds trying to write to #{address}")
+    rescue SystemCallError, IOError => exception
+      message = "#write Connection failure while writing to '#{address.to_s}': #{exception.class}: #{exception.message}"
+      logger.error message if respond_to?(:logger)
+      raise ConnectionFailure.new(message, address.to_s, exception)
     end
 
-    # Try connecting to each server in the order supplied
-    # The next server is tried if it cannot connect to the current one
-    # After the last server a ConnectionFailure will be raised
-    def connect_to_servers_in_order(servers)
-      exception = nil
-      servers.find do |server|
-        begin
-          connect_to_server(server)
-          exception = nil
-          true
-        rescue Net::TCPClient::ConnectionFailure => exc
-          exception = exc
-          false
+    def socket_read(length, buffer, timeout)
+      result =
+        if timeout < 0
+          buffer.nil? ? socket.read(length) : socket.read(length, buffer)
+        else
+          deadline = Time.now.utc + timeout
+          non_blocking(socket, deadline) do
+            buffer.nil? ? socket.read_nonblock(length) : socket.read_nonblock(length, buffer)
+          end
         end
+
+      # EOF before all the data was returned
+      if result.nil? || (result.length < length)
+        logger.warn "#read server closed the connection before #{length} bytes were returned" if respond_to?(:logger)
+        raise ConnectionFailure.new('Connection lost while reading data', address.to_s, EOFError.new('end of file reached'))
       end
-      # Raise Exception once it has also failed to connect to all servers
-      raise(exception) if exception
+      result
+    rescue NonBlockingTimeout
+      logger.warn "#read Timeout after #{timeout} seconds" if respond_to?(:logger)
+      raise ReadTimeout.new("Timed out after #{timeout} seconds trying to read from #{address}")
+    rescue SystemCallError, IOError => exception
+      message = "#read Connection failure while reading data from '#{address.to_s}': #{exception.class}: #{exception.message}"
+      logger.error message if respond_to?(:logger)
+      raise ConnectionFailure.new(message, address.to_s, exception)
+    end
+
+    class NonBlockingTimeout< ::SocketError
     end
 
-    # Return once data is ready to be ready
-    # Raises Net::TCPClient::ReadTimeout if the timeout is exceeded
-    def wait_for_data(timeout)
-      return if timeout == -1
+    def non_blocking(socket, deadline)
+      yield
+    rescue IO::WaitReadable
+      time_remaining = check_time_remaining(deadline)
+      raise NonBlockingTimeout unless IO.select([socket], nil, nil, time_remaining)
+      retry
+    rescue IO::WaitWritable
+      time_remaining = check_time_remaining(deadline)
+      raise NonBlockingTimeout unless IO.select(nil, [socket], nil, time_remaining)
+      retry
+    end
+
+    def check_time_remaining(deadline)
+      time_remaining = deadline - Time.now.utc
+      raise NonBlockingTimeout if time_remaining < 0
+      time_remaining
+    end
+
+    # Try connecting to a single server
+    # Returns the connected socket
+    #
+    # Raises Net::TCPClient::ConnectionTimeout when the connection timeout has been exceeded
+    # Raises Net::TCPClient::ConnectionFailure
+    def ssl_connect(socket, address, timeout)
+      ssl_context = OpenSSL::SSL::SSLContext.new
+      ssl_context.set_params(ssl.is_a?(Hash) ? ssl : {})
+
+      ssl_socket            = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      ssl_socket.sync_close = true
 
-      ready = false
       begin
-        ready = IO.select([@socket], nil, [@socket], timeout)
-      rescue IOError => exception
-        logger.warn "#read Connection failure while waiting for data: #{exception.class}: #{exception.message}"
-        close if close_on_error
-        raise Net::TCPClient::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
+        if timeout == -1
+          # Timeout of -1 means wait forever for a connection
+          ssl_socket.connect
+        else
+          deadline = Time.now.utc + timeout
+          begin
+            non_blocking(socket, deadline) { ssl_socket.connect_nonblock }
+          rescue Errno::EISCONN
+            # Connection was successful.
+          rescue NonBlockingTimeout
+            raise ConnectionTimeout.new("SSL handshake Timed out after #{timeout} seconds trying to connect to #{address.to_s}")
+          end
+        end
+      rescue SystemCallError, OpenSSL::SSL::SSLError, IOError => exception
+        message = "#connect SSL handshake failure with '#{address.to_s}': #{exception.class}: #{exception.message}"
+        logger.error message if respond_to?(:logger)
+        raise ConnectionFailure.new(message, address.to_s, exception)
       end
 
-      unless ready
-        close if close_on_error
-        logger.warn "#read Timeout after #{timeout} seconds"
-        raise Net::TCPClient::ReadTimeout.new("Timedout after #{timeout} seconds trying to read from #{@server}")
+      # Verify Peer certificate
+      ssl_verify(ssl_socket, address) if ssl_context.verify_mode != OpenSSL::SSL::VERIFY_NONE
+      ssl_socket
+    end
+
+    # Raises Net::TCPClient::ConnectionFailure if the peer certificate does not match its hostname
+    def ssl_verify(ssl_socket, address)
+      unless OpenSSL::SSL.verify_certificate_identity(ssl_socket.peer_cert, address.host_name)
+        ssl_socket.close
+        message = "#connect SSL handshake failed due to a hostname mismatch with '#{address.to_s}'"
+        logger.error message if respond_to?(:logger)
+        raise ConnectionFailure.new(message, address.to_s)
       end
     end