net_tcp_client 2.0.1 → 2.2.1

data/lib/net/tcp_client/tcp_client.rb

@@ -38,9 +38,8 @@ module Net
     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
+                  :connect_retry_count, :connect_retry_interval, :retry_count,
+                  :policy, :close_on_error, :buffered, :ssl, :proxy_server, :keepalive
     attr_reader :servers, :address, :socket, :ssl_handshake_timeout
 
     # Supports embedding user supplied data along with this connection
@@ -48,7 +47,7 @@ module Net
     # Not used or modified by TCPClient
     attr_accessor :user_data
 
-    @@reconnect_on_errors = [
+    @reconnect_on_errors = [
       Errno::ECONNABORTED,
       Errno::ECONNREFUSED,
       Errno::ECONNRESET,
@@ -66,8 +65,8 @@ module Net
     # Return the array of errors that will result in an automatic connection retry
     #  To add any additional errors to the standard list:
     #    Net::TCPClient.reconnect_on_errors << Errno::EPROTO
-    def self.reconnect_on_errors
-      @@reconnect_on_errors
+    class << self
+      attr_reader :reconnect_on_errors
     end
 
     # Create a connection, call the supplied block and close the connection on
@@ -82,19 +81,17 @@ module Net
     #     connect_retry_count:    5
     #   ) do |client|
     #     client.retry_on_connection_failure do
-    #       client.send('Update the database')
+    #       client.write('Update the database')
     #     end
     #     response = client.read(20)
     #     puts "Received: #{response}"
     #   end
     #
-    def self.connect(params={})
-      begin
-        connection = self.new(params)
-        yield(connection)
-      ensure
-        connection.close if connection
-      end
+    def self.connect(params = {})
+      connection = new(params)
+      yield(connection)
+    ensure
+      connection&.close
     end
 
     # Create a new TCP Client connection
@@ -129,7 +126,7 @@ module Net
     #     Can be overridden by supplying a timeout in the write call
     #     Default: 60
     #
-    #   :buffered [Boolean]
+    #   :buffered [true|false]
     #     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
@@ -139,7 +136,12 @@ module Net
     #     internal buffering.
     #     Default: true
     #
-    #   :connect_retry_count [Fixnum]
+    #   :keepalive [true|false]
+    #     Makes the OS check connections even when not in use, so that failed connections fail immediately
+    #     upon use instead of possibly taking considerable time to fail.
+    #     Default: true
+    #
+    #   :connect_retry_count [Integer]
     #     Number of times to retry connecting when a connection fails
     #     Default: 10
     #
@@ -147,7 +149,7 @@ module Net
     #     Number of seconds between connection retry attempts after the first failed attempt
     #     Default: 0.5
     #
-    #   :retry_count [Fixnum]
+    #   :retry_count [Integer]
     #     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
@@ -216,7 +218,7 @@ module Net
     #   )
     #
     #   client.retry_on_connection_failure do
-    #     client.send('Update the database')
+    #     client.write('Update the database')
     #   end
     #
     #   # Read upto 20 characters from the server
@@ -242,40 +244,32 @@ module Net
     #       verify_mode: OpenSSL::SSL::VERIFY_NONE
     #     }
     #   )
-    def initialize(parameters={})
-      params                  = parameters.dup
-      @read_timeout           = (params.delete(:read_timeout) || 60.0).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)
-      @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?
-      if @ssl = params.delete(:ssl)
-        @ssl                   = {} if @ssl == true
+    def initialize(server: nil, servers: nil,
+                   policy: :ordered, buffered: true, keepalive: true,
+                   connect_timeout: 10.0, read_timeout: 60.0, write_timeout: 60.0,
+                   connect_retry_count: 10, retry_count: 3, connect_retry_interval: 0.5, close_on_error: true,
+                   on_connect: nil, proxy_server: nil, ssl: nil)
+      @read_timeout           = read_timeout.to_f
+      @write_timeout          = write_timeout.to_f
+      @connect_timeout        = connect_timeout.to_f
+      @buffered               = buffered
+      @keepalive              = keepalive
+      @connect_retry_count    = connect_retry_count
+      @retry_count            = retry_count
+      @connect_retry_interval = connect_retry_interval.to_f
+      @on_connect             = on_connect
+      @proxy_server           = proxy_server
+      @policy                 = policy
+      @close_on_error         = close_on_error
+      if ssl
+        @ssl                   = ssl == true ? {} : ssl
         @ssl_handshake_timeout = (@ssl.delete(:handshake_timeout) || @connect_timeout).to_f
       end
+      @servers = [server] if server
+      @servers = servers if servers
 
-      if server = params.delete(:server)
-        @servers = [server]
-      end
-      if servers = params.delete(:servers)
-        @servers = servers
-      end
-      raise(ArgumentError, 'Missing mandatory :server or :servers') unless @servers
-
-      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
+      raise(ArgumentError, "Missing mandatory :server or :servers") unless @servers
 
-      # Connect to the Server
       connect
     end
 
@@ -312,27 +306,29 @@ module Net
       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
+      rescue ConnectionFailure, ConnectionTimeout => e
+        cause = e.is_a?(ConnectionTimeout) ? e : e.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)
+          if respond_to?(:logger)
+            logger.warn "#connect Failed to connect to any of #{servers.join(',')}. Sleeping:#{connect_retry_interval}s. Retry: #{retries}"
+          end
           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)
+          message = "#connect Failed to connect to any of #{servers.join(',')} after #{retries} retries. #{e.class}: #{e.message}"
+          logger.benchmark_error(message, exception: e, 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
+    # Write data to the server
     #
-    # Use #with_retry to add resilience to the #send method
+    # Use #with_retry to add resilience to the #write method
     #
-    # Raises Net::TCPClient::ConnectionFailure whenever the send fails
+    # Raises Net::TCPClient::ConnectionFailure whenever the write fails
     #        For a description of the errors, see Socket#write
     #
     # Parameters
@@ -345,7 +341,7 @@ module Net
     #
     #  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
+    #        If the application no longer wants 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
@@ -355,15 +351,15 @@ module Net
         payload        = {timeout: timeout}
         # With trace level also log the sent data
         payload[:data] = data if logger.trace?
-        logger.benchmark_debug('#write', payload: payload) do
+        logger.benchmark_debug("#write", payload: payload) do
           payload[:bytes] = socket_write(data, timeout)
         end
       else
         socket_write(data, timeout)
       end
-    rescue Exception => exc
+    rescue Exception => e
       close if close_on_error
-      raise exc
+      raise e
     end
 
     # Returns a response from the server
@@ -378,10 +374,10 @@ module Net
     #        requested number of bytes from the server
     #        Partial data will not be returned
     #        Connection is _not_ closed and #read can be called again later
-    #        to read the respnse from the connection
+    #        to read the response from the connection
     #
     # Parameters
-    #   length [Fixnum]
+    #   length [Integer]
     #     The number of bytes to return
     #     #read will not return until 'length' bytes have been received from
     #     the server
@@ -398,14 +394,14 @@ module Net
     #
     #  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
+    #        If the application no longer wants 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)
       if respond_to?(:logger)
         payload = {bytes: length, timeout: timeout}
-        logger.benchmark_debug('#read', payload: payload) do
+        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?
@@ -414,12 +410,12 @@ module Net
       else
         socket_read(length, buffer, timeout)
       end
-    rescue Exception => exc
+    rescue Exception => e
       close if close_on_error
-      raise exc
+      raise e
     end
 
-    # Send and/or receive data with automatic retry on connection failure
+    # Write and/or receive data with automatic retry on connection failure
     #
     # On a connection failure, it will create a new connection and retry the block.
     # Returns immediately on exception Net::TCPClient::ReadTimeout
@@ -428,34 +424,34 @@ module Net
     # 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
+    #    Wrap both the write and the read with #retry_on_connection_failure
+    #    since it is safe to write the same data twice to the server
     #
-    #    # Since the send can be sent many times it is safe to also put the receive
+    #    # Since the write 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.write("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
+    #    Wrap _only_ the write 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
+    #    not retry the write 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
+    #    # Only the write is within the retry block since we cannot re-write once
+    #    # the write was successful since the server may have made the change
     #    client.retry_on_connection_failure do
-    #      client.send("SETVALUE:#{count}\n")
+    #      client.write("SETVALUE:#{count}\n")
     #    end
-    #    # Server returns "SAVED" if the call was successfull
+    #    # Server returns "SAVED" if the call was successful
     #    result = client.read(20).strip
     #
     # Error handling is implemented as follows:
-    #    If a network failure occurrs during the block invocation the block
+    #    If a network failure occurs 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
@@ -465,20 +461,22 @@ module Net
       begin
         connect if closed?
         yield(self)
-      rescue ConnectionFailure => exception
-        exc_str = exception.cause ? "#{exception.cause.class}: #{exception.cause.message}" : exception.message
+      rescue ConnectionFailure => e
+        exc_str = e.cause ? "#{e.cause.class}: #{e.cause.message}" : e.message
         # Re-raise exceptions that should not be retried
-        if !self.class.reconnect_on_errors.include?(exception.cause.class)
+        if !self.class.reconnect_on_errors.include?(e.cause.class)
           logger.info "#retry_on_connection_failure not configured to retry: #{exc_str}" if respond_to?(:logger)
-          raise exception
+          raise e
         elsif retries < @retry_count
           retries += 1
-          logger.warn "#retry_on_connection_failure retry #{retries} due to #{exception.class}: #{exception.message}" if respond_to?(:logger)
+          logger.warn "#retry_on_connection_failure retry #{retries} due to #{e.class}: #{e.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" if respond_to?(:logger)
-        raise ConnectionFailure.new("After #{retries} retries to host '#{server}': #{exc_str}", server, exception.cause)
+        if respond_to?(:logger)
+          logger.error "#retry_on_connection_failure Connection failure: #{e.class}: #{e.message}. Giving up after #{retries} retries"
+        end
+        raise ConnectionFailure.new("After #{retries} retries to any of #{servers.join(',')}': #{exc_str}", servers, e.cause)
       end
     end
 
@@ -490,14 +488,15 @@ module Net
       @socket  = nil
       @address = nil
       true
-    rescue IOError => exception
-      logger.warn "IOError when attempting to close socket: #{exception.class}: #{exception.message}" if respond_to?(:logger)
+    rescue IOError => e
+      logger.warn "IOError when attempting to close socket: #{e.class}: #{e.message}" if respond_to?(:logger)
       false
     end
 
     def flush
       return unless socket
-      respond_to?(:logger) ? logger.benchmark_debug('#flush') { socket.flush } : socket.flush
+
+      respond_to?(:logger) ? logger.benchmark_debug("#flush") { socket.flush } : socket.flush
     end
 
     def closed?
@@ -525,7 +524,11 @@ module Net
       return false if socket.nil? || closed?
 
       if IO.select([socket], nil, nil, 0)
-        !socket.eof? rescue false
+        begin
+          !socket.eof?
+        rescue StandardError
+          false
+        end
       else
         true
       end
@@ -547,8 +550,8 @@ module Net
       Policy::Base.factory(policy, servers).each do |address|
         begin
           return connect_to_address(address)
-        rescue ConnectionTimeout, ConnectionFailure => exception
-          last_exception = exception
+        rescue ConnectionTimeout, ConnectionFailure => e
+          last_exception = e
         end
       end
 
@@ -572,14 +575,15 @@ module Net
         socket.sync = true
         socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
       end
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) if keepalive
 
       socket_connect(socket, address, connect_timeout)
 
-      @socket = ssl ? ssl_connect(socket, address, ssl_handshake_timeout) : socket
+      @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
+      @on_connect&.call(self)
     end
 
     # Connect to server
@@ -598,36 +602,48 @@ module Net
       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}"
+        raise ConnectionTimeout, "Timed out after #{timeout} seconds trying to connect to #{address}"
+      rescue SystemCallError, IOError => e
+        message = "#connect Connection failure connecting to '#{address}': #{e.class}: #{e.message}"
         logger.error message if respond_to?(:logger)
-        raise ConnectionFailure.new(message, address.to_s, exception)
+        raise ConnectionFailure.new(message, address.to_s, e)
       end
     end
 
     # Write to the socket
     def socket_write(data, timeout)
-      if timeout < 0
+      if timeout.negative?
         socket.write(data)
       else
-        deadline = Time.now.utc + timeout
+        deadline    = Time.now.utc + timeout
+        length      = data.bytesize
+        total_count = 0
         non_blocking(socket, deadline) do
-          socket.write_nonblock(data)
+          loop do
+            begin
+              count = socket.write_nonblock(data)
+            rescue Errno::EWOULDBLOCK
+              retry
+            end
+            total_count += count
+            return total_count if total_count >= length
+
+            data = data.byteslice(count..-1)
+          end
         end
       end
     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}"
+      raise WriteTimeout, "Timed out after #{timeout} seconds trying to write to #{address}"
+    rescue SystemCallError, IOError => e
+      message = "#write Connection failure while writing to '#{address}': #{e.class}: #{e.message}"
       logger.error message if respond_to?(:logger)
-      raise ConnectionFailure.new(message, address.to_s, exception)
+      raise ConnectionFailure.new(message, address.to_s, e)
     end
 
     def socket_read(length, buffer, timeout)
       result =
-        if timeout < 0
+        if timeout.negative?
           buffer.nil? ? socket.read(length) : socket.read(length, buffer)
         else
           deadline = Time.now.utc + timeout
@@ -639,19 +655,19 @@ module Net
       # 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'))
+        raise ConnectionFailure.new("Connection lost while reading data", address.to_s, EOFError.new("end of file reached"))
       end
       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}"
+      raise ReadTimeout, "Timed out after #{timeout} seconds trying to read from #{address}"
+    rescue SystemCallError, IOError => e
+      message = "#read Connection failure while reading data from '#{address}': #{e.class}: #{e.message}"
       logger.error message if respond_to?(:logger)
-      raise ConnectionFailure.new(message, address.to_s, exception)
+      raise ConnectionFailure.new(message, address.to_s, e)
     end
 
-    class NonBlockingTimeout< ::SocketError
+    class NonBlockingTimeout < ::SocketError
     end
 
     def non_blocking(socket, deadline)
@@ -659,16 +675,19 @@ module Net
     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
+      raise NonBlockingTimeout if time_remaining.negative?
+
       time_remaining
     end
 
@@ -682,6 +701,7 @@ module Net
       ssl_context.set_params(ssl.is_a?(Hash) ? ssl : {})
 
       ssl_socket            = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      ssl_socket.hostname   = address.host_name
       ssl_socket.sync_close = true
 
       begin
@@ -695,13 +715,13 @@ module Net
           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}")
+            raise ConnectionTimeout, "SSL handshake Timed out after #{timeout} seconds trying to connect to #{address}"
           end
         end
-      rescue SystemCallError, OpenSSL::SSL::SSLError, IOError => exception
-        message = "#connect SSL handshake failure with '#{address.to_s}': #{exception.class}: #{exception.message}"
+      rescue SystemCallError, OpenSSL::SSL::SSLError, IOError => e
+        message = "#connect SSL handshake failure with '#{address}': #{e.class}: #{e.message}"
         logger.error message if respond_to?(:logger)
-        raise ConnectionFailure.new(message, address.to_s, exception)
+        raise ConnectionFailure.new(message, address.to_s, e)
       end
 
       # Verify Peer certificate
@@ -711,13 +731,20 @@ module Net
 
     # 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
+      return if OpenSSL::SSL.verify_certificate_identity(ssl_socket.peer_cert, address.host_name)
+
+      domains = extract_domains_from_cert(ssl_socket.peer_cert)
+      ssl_socket.close
+      message = "#connect SSL handshake failed due to a hostname mismatch. Request address was: '#{address}'" \
+                  "  Certificate valid for hostnames: #{domains.map { |d| "'#{d}'" }.join(',')}"
+      logger.error message if respond_to?(:logger)
+      raise ConnectionFailure.new(message, address.to_s)
     end
 
+    def extract_domains_from_cert(cert)
+      cert.subject.to_a.each do |oid, value|
+        return [value] if oid == "CN"
+      end
+    end
   end
 end

data/lib/net/tcp_client/version.rb

@@ -1,5 +1,5 @@
 module Net
-  class TCPClient #:nodoc
-    VERSION = '2.0.1'
+  class TCPClient
+    VERSION = "2.2.1".freeze
   end
 end

data/lib/net/tcp_client.rb

@@ -1,22 +1,22 @@
-require 'socket'
+require "socket"
 # Load SemanticLogger if available
 begin
-  require 'semantic_logger'
+  require "semantic_logger"
 rescue LoadError
 end
-require 'net/tcp_client/version'
-require 'net/tcp_client/address'
-require 'net/tcp_client/exceptions'
-require 'net/tcp_client/tcp_client'
+require "net/tcp_client/version"
+require "net/tcp_client/address"
+require "net/tcp_client/exceptions"
+require "net/tcp_client/tcp_client"
 
 # @formatter:off
 module Net
   class TCPClient
     module Policy
-      autoload :Base,    'net/tcp_client/policy/base.rb'
-      autoload :Custom,  'net/tcp_client/policy/custom.rb'
-      autoload :Ordered, 'net/tcp_client/policy/ordered.rb'
-      autoload :Random,  'net/tcp_client/policy/random.rb'
+      autoload :Base,    "net/tcp_client/policy/base.rb"
+      autoload :Custom,  "net/tcp_client/policy/custom.rb"
+      autoload :Ordered, "net/tcp_client/policy/ordered.rb"
+      autoload :Random,  "net/tcp_client/policy/random.rb"
     end
   end
 end

data/lib/net_tcp_client.rb

@@ -1 +1 @@
-require 'net/tcp_client'
+require "net/tcp_client"