tcp-client 0.5.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3222937127a374a29b4f69d84a1e45d78ccc74bffee2ed05d849782385c5402
-  data.tar.gz: 8a56cb5574794f4bbf0f5fcb1f91fbbdc033120eefc86604f881322ddfeedf44
+  metadata.gz: 14f787ad4e8e06910bfebf67755ae7142183df4c4fb090edce84aae7d497a2b6
+  data.tar.gz: 6349bea2eac6bac053c724e0c6a162b1fe99502e94cf1c6734854d97f194f37a
 SHA512:
-  metadata.gz: a096f6f5d41be9f63e5018f014aced375ab5e4574a7ea165bd006be23a9246264fcf77269f6be4335ee6f930794b1ef3332e08ccd580d54601eef2468bdf282d
-  data.tar.gz: ee8edc735c7de68b28688043c8bf6d2715f177941c4e14f4bb742a91c1fc8edf4d47d3c5273379d4f0ec029418506dc3e52f3bbacfbff6cc4466fe7d22bf40f5
+  metadata.gz: b53fafbf091a67a329832663c058b4e8243b36a779f8bc52cc7f37de556ad0aa016245e0a059489b972e6afaccfea7d26a63a735686d5f50d88036a2f4ecaca1
+  data.tar.gz: 4a6ff368e221073c5addfab51e31df1b094ee3f69e09ebe3f38d6d552ebc761b14c552a1a2cd90dcfd148b1ba34ebb1b2e3abfcea9622ded8413870f21a60285

data/README.md

@@ -11,20 +11,22 @@ This Gem implements a TCP client with (optional) SSL support. It is an easy to u
 ```ruby
 require 'tcp-client'
 
-TCPClient.configure do |cfg|
-  cfg.connect_timeout = 1 # limit connect time the server to 1 second
-  cfg.ssl_params = { ssl_version: :TLSv1_2 } # use TLS 1.2
-end
-
-TCPClient.open('www.google.com:443') do |client|
-  # next sequence should not last longer than 0.5 seconds
-  client.with_deadline(0.5) do
-    # simple HTTP get request
-    pp client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
-
-    # read "HTTP/1.1 " + 3 byte HTTP status code
-    pp client.read(12)
-  end
+# create a configuration:
+# - don't use internal buffering
+# - use TLS 1.2 or TLS 1.3
+cfg = TCPClient::Configuration.create(
+  buffered: false,
+  ssl_params: {min_version: :TLS1_2, max_version: :TLS1_3}
+)
+
+# request to Google.com:
+# - limit all network interactions to 1.5 seconds
+# - use the Configuration cfg
+# - send a simple HTTP get request
+# - read 12 byte: "HTTP/1.1 " + 3 byte HTTP status code
+TCPClient.with_deadline(1.5, 'www.google.com:443', cfg) do |client|
+  client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n") # >= 40
+  client.read(12) # => "HTTP/1.1 200"
 end
 ```
 
@@ -41,13 +43,13 @@ gem 'tcp-client'
 and install it by running Bundler:
 
 ```bash
-$ bundle
+bundle
 ```
 
 To install the gem globally use:
 
 ```bash
-$ gem install tcp-client
+gem install tcp-client
 ```
 
 After that you need only a single line of code in your project to have all tools on board:

data/lib/tcp-client/address.rb

@@ -25,12 +25,16 @@ class TCPClient
       "#{@hostname}:#{@addrinfo.ip_port}"
     end
 
-    def to_h
+    def to_hash
       { host: @hostname, port: @addrinfo.ip_port }
     end
 
+    def to_h(*args)
+      args.empty? ? to_hash : to_hash.slice(*args)
+    end
+
     def ==(other)
-      to_h == other.to_h
+      to_hash == other.to_hash
     end
     alias eql? ==
 

data/lib/tcp-client/configuration.rb

@@ -13,6 +13,7 @@ class TCPClient
     attr_reader :buffered,
                 :keep_alive,
                 :reverse_lookup,
+                :normalize_network_errors,
                 :connect_timeout,
                 :read_timeout,
                 :write_timeout,
@@ -27,6 +28,7 @@ class TCPClient
       @connect_timeout_error = ConnectTimeoutError
       @read_timeout_error = ReadTimeoutError
       @write_timeout_error = WriteTimeoutError
+      @normalize_network_errors = false
       options.each_pair { |attribute, value| set(attribute, value) }
     end
 
@@ -37,7 +39,7 @@ class TCPClient
 
     def initialize_copy(_org)
       super
-      @ssl_params = @ssl_params.dup
+      @ssl_params = Hash[@ssl_params] if @ssl_params
       self
     end
 
@@ -47,8 +49,8 @@ class TCPClient
 
     def ssl=(value)
       @ssl_params =
-        if Hash === value
-          value.dup
+        if value.respond_to?(:to_hash)
+          Hash[value.to_hash]
         else
           value ? {} : nil
         end
@@ -66,6 +68,10 @@ class TCPClient
       @reverse_lookup = value ? true : false
     end
 
+    def normalize_network_errors=(value)
+      @normalize_network_errors = value ? true : false
+    end
+
     def timeout=(seconds)
       @connect_timeout = @write_timeout = @read_timeout = seconds(seconds)
     end
@@ -83,43 +89,47 @@ class TCPClient
     end
 
     def timeout_error=(exception)
-      raise(NotAnException, exception) unless exception_class?(exception)
+      raise(NotAnExceptionError, exception) unless exception_class?(exception)
       @connect_timeout_error =
         @read_timeout_error = @write_timeout_error = exception
     end
 
     def connect_timeout_error=(exception)
-      raise(NotAnException, exception) unless exception_class?(exception)
+      raise(NotAnExceptionError, exception) unless exception_class?(exception)
       @connect_timeout_error = exception
     end
 
     def read_timeout_error=(exception)
-      raise(NotAnException, exception) unless exception_class?(exception)
+      raise(NotAnExceptionError, exception) unless exception_class?(exception)
       @read_timeout_error = exception
     end
 
     def write_timeout_error=(exception)
-      raise(NotAnException, exception) unless exception_class?(exception)
+      raise(NotAnExceptionError, exception) unless exception_class?(exception)
       @write_timeout_error = exception
     end
 
-    def to_h
+    def to_hash
       {
         buffered: @buffered,
         keep_alive: @keep_alive,
         reverse_lookup: @reverse_lookup,
         connect_timeout: @connect_timeout,
-        read_timeout: @read_timeout,
-        write_timeout: @write_timeout,
         connect_timeout_error: @connect_timeout_error,
+        read_timeout: @read_timeout,
         read_timeout_error: @read_timeout_error,
+        write_timeout: @write_timeout,
         write_timeout_error: @write_timeout_error,
         ssl_params: @ssl_params
       }
     end
 
+    def to_h(*args)
+      args.empty? ? to_hash : to_hash.slice(*args)
+    end
+
     def ==(other)
-      to_h == other.to_h
+      to_hash == other.to_hash
     end
     alias eql? ==
 
@@ -136,7 +146,7 @@ class TCPClient
     def set(attribute, value)
       public_send("#{attribute}=", value)
     rescue NoMethodError
-      raise(UnknownAttribute, attribute)
+      raise(UnknownAttributeError, attribute)
     end
 
     def seconds(value)

data/lib/tcp-client/deadline.rb

@@ -29,4 +29,6 @@ class TCPClient
       end
     end
   end
+
+  private_constant(:Deadline)
 end

data/lib/tcp-client/errors.rb

@@ -1,43 +1,45 @@
 # frozen_string_literal: true
 
 class TCPClient
-  class NoOpenSSL < RuntimeError
+  class NoOpenSSLError < RuntimeError
     def initialize
       super('OpenSSL is not available')
     end
   end
 
-  class NoBlockGiven < ArgumentError
+  class NoBlockGivenError < ArgumentError
     def initialize
       super('no block given')
     end
   end
 
-  class InvalidDeadLine < ArgumentError
+  class InvalidDeadLineError < ArgumentError
     def initialize(timeout)
       super("invalid deadline - #{timeout}")
     end
   end
 
-  class UnknownAttribute < ArgumentError
+  class UnknownAttributeError < ArgumentError
     def initialize(attribute)
       super("unknown attribute - #{attribute}")
     end
   end
 
-  class NotAnException < TypeError
+  class NotAnExceptionError < TypeError
     def initialize(object)
       super("exception class required - #{object.inspect}")
     end
   end
 
-  class NotConnected < IOError
+  NetworkError = Class.new(StandardError)
+
+  class NotConnectedError < NetworkError
     def initialize
       super('client not connected')
     end
   end
 
-  class TimeoutError < IOError
+  class TimeoutError < NetworkError
     def initialize(message = nil)
       super(message || "unable to #{action} in time")
     end
@@ -65,6 +67,18 @@ class TCPClient
     end
   end
 
-  Timeout = TimeoutError # backward compatibility
-  deprecate_constant(:Timeout)
+  NoOpenSSL = NoOpenSSLError
+  NoBlockGiven = NoBlockGivenError
+  InvalidDeadLine = InvalidDeadLineError
+  UnknownAttribute = UnknownAttributeError
+  NotAnException = NotAnExceptionError
+  NotConnected = NotConnectedError
+  deprecate_constant(
+    :NoOpenSSL,
+    :NoBlockGiven,
+    :InvalidDeadLine,
+    :UnknownAttribute,
+    :NotAnException,
+    :NotConnected
+  )
 end

data/lib/tcp-client/mixin/io_with_deadline.rb

@@ -5,6 +5,8 @@ module IOWithDeadlineMixin
     methods = mod.instance_methods
     if methods.index(:wait_writable) && methods.index(:wait_readable)
       mod.include(ViaWaitMethod)
+    elsif methods.index(:to_io)
+      mod.include(ViaIOWaitMethod)
     else
       mod.include(ViaSelect)
     end
@@ -12,6 +14,13 @@ module IOWithDeadlineMixin
 
   def read_with_deadline(bytes_to_read, deadline, exception)
     raise(exception) unless deadline.remaining_time
+    if bytes_to_read.nil?
+      return(
+        with_deadline(deadline, exception) do
+          read_nonblock(65_536, exception: false)
+        end
+      )
+    end
     result = ''.b
     while result.bytesize < bytes_to_read
       read =
@@ -59,6 +68,25 @@ module IOWithDeadlineMixin
     end
   end
 
+  module ViaIOWaitMethod
+    private def with_deadline(deadline, exception)
+      loop do
+        case ret = yield
+        when :wait_writable
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) if to_io.wait_writable(remaining_time).nil?
+        when :wait_readable
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) if to_io.wait_readable(remaining_time).nil?
+        else
+          return ret
+        end
+      end
+    rescue Errno::ETIMEDOUT
+      raise(exception)
+    end
+  end
+
   module ViaSelect
     private def with_deadline(deadline, exception)
       loop do
@@ -78,5 +106,5 @@ module IOWithDeadlineMixin
     end
   end
 
-  private_constant(:ViaWaitMethod, :ViaSelect)
+  private_constant(:ViaWaitMethod, :ViaIOWaitMethod, :ViaSelect)
 end

data/lib/tcp-client/ssl_socket.rb

@@ -18,6 +18,7 @@ class TCPClient
       super(socket, create_context(ssl_params))
       self.sync_close = true
       self.hostname = address.hostname
+      check_new_session if @new_session
       deadline.valid? ? connect_with_deadline(deadline, exception) : connect
       post_connection_check(address.hostname) if should_verify?(ssl_params)
     end
@@ -25,7 +26,19 @@ class TCPClient
     private
 
     def create_context(ssl_params)
-      OpenSSL::SSL::SSLContext.new.tap { |ctx| ctx.set_params(ssl_params) }
+      @new_session = nil
+      ::OpenSSL::SSL::SSLContext.new.tap do |ctx|
+        ctx.set_params(ssl_params)
+        ctx.session_cache_mode = CONTEXT_CACHE_MODE
+        ctx.session_new_cb = proc { |_, sess| @new_session = sess }
+      end
+    end
+
+    def check_new_session
+      time = @new_session.time.to_f + @new_session.timeout
+      if Process.clock_gettime(Process::CLOCK_REALTIME) < time
+        self.session = @new_session
+      end
     end
 
     def connect_with_deadline(deadline, exception)
@@ -33,8 +46,13 @@ class TCPClient
     end
 
     def should_verify?(ssl_params)
-      ssl_params[:verify_mode] != OpenSSL::SSL::VERIFY_NONE
+      ssl_params[:verify_mode] != ::OpenSSL::SSL::VERIFY_NONE &&
+        context.verify_hostname
     end
+
+    CONTEXT_CACHE_MODE =
+      ::OpenSSL::SSL::SSLContext::SESSION_CACHE_CLIENT |
+        ::OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_INTERNAL_STORE
   end
 
   private_constant(:SSLSocket)

data/lib/tcp-client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class TCPClient
-  VERSION = '0.5.0'
+  VERSION = '0.8.0'
 end

data/lib/tcp-client.rb

@@ -10,40 +10,45 @@ require_relative 'tcp-client/default_configuration'
 require_relative 'tcp-client/version'
 
 class TCPClient
-  def self.open(address, configuration = Configuration.default)
+  def self.open(address, configuration = nil)
     client = new
     client.connect(Address.new(address), configuration)
-    return client unless block_given?
-    begin
-      yield(client)
-    ensure
-      client.close
+    block_given? ? yield(client) : client
+  ensure
+    client.close if block_given?
+  end
+
+  def self.with_deadline(timeout, address, configuration = nil)
+    client = nil
+    raise(NoBlockGivenError) unless block_given?
+    address = Address.new(address)
+    client = new
+    client.with_deadline(timeout) do
+      yield(client.connect(address, configuration))
     end
+  ensure
+    client&.close
   end
 
   attr_reader :address, :configuration
 
-  def initialize
-    @socket = @address = @deadline = @configuration = nil
-  end
-
   def to_s
     @address&.to_s || ''
   end
 
-  def connect(address, configuration, exception: nil)
-    raise(NoOpenSSL) if configuration.ssl? && !defined?(SSLSocket)
-    close
+  def connect(address, configuration = nil, timeout: nil, exception: nil)
+    close if @socket
+    raise(NoOpenSSLError) if configuration.ssl? && !defined?(SSLSocket)
     @address = Address.new(address)
-    @configuration = configuration.dup.freeze
-    @socket = create_socket(exception)
+    @configuration = (configuration || Configuration.default).dup
+    @socket = create_socket(timeout, exception)
     self
   end
 
   def close
     @socket&.close
     self
-  rescue IOError
+  rescue *NETWORK_ERRORS
     self
   ensure
     @socket = @deadline = nil
@@ -55,66 +60,77 @@ class TCPClient
 
   def with_deadline(timeout)
     previous_deadline = @deadline
-    raise(NoBlockGiven) unless block_given?
+    raise(NoBlockGivenError) unless block_given?
     @deadline = Deadline.new(timeout)
-    raise(InvalidDeadLine, timeout) unless @deadline.valid?
+    raise(InvalidDeadLineError, timeout) unless @deadline.valid?
     yield(self)
   ensure
     @deadline = previous_deadline
   end
 
-  def read(nbytes, timeout: nil, exception: nil)
-    raise(NotConnected) if closed?
-    timeout.nil? && @deadline and
-      return read_with_deadline(nbytes, @deadline, exception)
-    deadline = Deadline.new(timeout || @configuration.read_timeout)
-    return @socket.read(nbytes) unless deadline.valid?
-    read_with_deadline(nbytes, deadline, exception)
+  def read(nbytes = nil, timeout: nil, exception: nil)
+    raise(NotConnectedError) if closed?
+    deadline = create_deadline(timeout, configuration.read_timeout)
+    return stem_errors { @socket.read(nbytes) } unless deadline.valid?
+    exception ||= configuration.read_timeout_error
+    stem_errors(exception) do
+      @socket.read_with_deadline(nbytes, deadline, exception)
+    end
   end
 
   def write(*msg, timeout: nil, exception: nil)
-    raise(NotConnected) if closed?
-    timeout.nil? && @deadline and
-      return write_with_deadline(msg, @deadline, exception)
-    deadline = Deadline.new(timeout || @configuration.read_timeout)
-    return @socket.write(*msg) unless deadline.valid?
-    write_with_deadline(msg, deadline, exception)
+    raise(NotConnectedError) if closed?
+    deadline = create_deadline(timeout, configuration.write_timeout)
+    return stem_errors { @socket.write(*msg) } unless deadline.valid?
+    exception ||= configuration.write_timeout_error
+    stem_errors(exception) do
+      msg.sum do |chunk|
+        @socket.write_with_deadline(chunk.b, deadline, exception)
+      end
+    end
   end
 
   def flush
-    @socket.flush unless closed?
+    stem_errors { @socket&.flush }
     self
   end
 
   private
 
-  def create_socket(exception)
-    exception ||= @configuration.connect_timeout_error
-    deadline = Deadline.new(@configuration.connect_timeout)
-    socket = TCPSocket.new(@address, @configuration, deadline, exception)
-    @configuration.ssl? ? as_ssl_socket(socket, deadline, exception) : socket
+  def create_deadline(timeout, default)
+    timeout.nil? && @deadline ? @deadline : Deadline.new(timeout || default)
   end
 
-  def as_ssl_socket(socket, deadline, exception)
-    SSLSocket.new(socket, @address, @configuration, deadline, exception)
-  rescue StandardError => e
-    begin
-      socket.close
-    rescue IOError
-      # ignore!
+  def create_socket(timeout, exception)
+    deadline = create_deadline(timeout, configuration.connect_timeout)
+    exception ||= configuration.connect_timeout_error
+    stem_errors(exception) do
+      @socket = TCPSocket.new(address, configuration, deadline, exception)
+      return @socket unless configuration.ssl?
+      SSLSocket.new(@socket, address, configuration, deadline, exception)
     end
-    raise(e, cause: e.cause)
   end
 
-  def read_with_deadline(nbytes, deadline, exception)
-    exception ||= @configuration.read_timeout_error
-    @socket.read_with_deadline(nbytes, deadline, exception)
+  def stem_errors(except = nil)
+    yield
+  rescue *NETWORK_ERRORS => e
+    raise unless configuration.normalize_network_errors
+    (except && e.is_a?(except)) ? raise : raise(NetworkError, e)
   end
 
-  def write_with_deadline(msg, deadline, exception)
-    exception ||= @configuration.write_timeout_error
-    msg.sum do |chunk|
-      @socket.write_with_deadline(chunk.b, deadline, exception)
-    end
-  end
+  NETWORK_ERRORS =
+    [
+      Errno::EADDRNOTAVAIL,
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::EINVAL,
+      Errno::ENETUNREACH,
+      Errno::EPIPE,
+      IOError,
+      SocketError
+    ].tap do |errors|
+      errors << ::OpenSSL::SSL::SSLError if defined?(::OpenSSL::SSL::SSLError)
+    end.freeze
 end

data/rakefile.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require 'rake/clean'
-require 'rake/testtask'
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 $stdout.sync = $stderr.sync = true
 
@@ -10,7 +10,4 @@ CLOBBER << 'prj'
 
 task(:default) { exec('rake --tasks') }
 
-Rake::TestTask.new(:test) do |task|
-  task.pattern = 'test/**/*_test.rb'
-  task.warning = task.verbose = true
-end
+RSpec::Core::RakeTask.new { |task| task.ruby_opts = %w[-w] }

data/sample/google.rb

@@ -2,21 +2,20 @@
 
 require_relative '../lib/tcp-client'
 
-TCPClient.configure(
-  connect_timeout: 0.5, # seconds to connect the server
-  write_timeout: 0.25, # seconds to write a single data junk
-  read_timeout: 0.5 # seconds to read some bytes
-)
-
-# the following sequence is not allowed to last longer than 1.25 seconds:
-#   0.5 seconds to connect
-# + 0.25 seconds to write data
-# + 0.5 seconds to read a response
+# global configuration.
+# - 0.5 seconds to connect the server
+# - 0.25 seconds to write a single data junk
+# - 0.25 seconds to read some bytes
+TCPClient.configure do |cfg|
+  cfg.connect_timeout = 0.5
+  cfg.write_timeout = 0.25
+  cfg.read_timeout = 0.25
+end
 
+# request to Google:
+# - send a simple HTTP get request
+# - read 12 byte: "HTTP/1.1 " + 3 byte HTTP status code
 TCPClient.open('www.google.com:80') do |client|
-  # simple HTTP get request
-  pp client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
-
-  # read "HTTP/1.1 " + 3 byte HTTP status code
-  pp client.read(12)
+  p client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
+  p client.read(12)
 end

data/sample/google_ssl.rb

@@ -2,18 +2,24 @@
 
 require_relative '../lib/tcp-client'
 
-TCPClient.configure do |cfg|
-  cfg.connect_timeout = 1 # limit connect time the server to 1 second
-  cfg.ssl_params = { ssl_version: :TLSv1_2 } # use TLS 1.2
-end
-
-TCPClient.open('www.google.com:443') do |client|
-  # next sequence should not last longer than 0.5 seconds
-  client.with_deadline(0.5) do
-    # simple HTTP get request
-    pp client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
+# create a configuration:
+# - don't use internal buffering
+# - use TLS 1.2 or TLS 1.3
+cfg =
+  TCPClient::Configuration.create(
+    buffered: false,
+    ssl_params: {
+      min_version: :TLS1_2,
+      max_version: :TLS1_3
+    }
+  )
 
-    # read "HTTP/1.1 " + 3 byte HTTP status code
-    pp client.read(12)
-  end
+# request to Google.com:
+# - limit all network interactions to 1.5 seconds
+# - use the Configuration cfg
+# - send a simple HTTP get request
+# - read 12 byte: "HTTP/1.1 " + 3 byte HTTP status code
+TCPClient.with_deadline(1.5, 'www.google.com:443', cfg) do |client|
+  p client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
+  p client.read(12)
 end

data/spec/helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rspec/core'
+require_relative '../lib/tcp-client'
+
+$stdout.sync = $stderr.sync = true
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.warnings = true
+  config.order = :random
+end