tcp-client 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb5546419b47d6680b576f39d8c4b382c39d74f07ca43f6e782160122b6ba524
-  data.tar.gz: 3e563cd2db3efc765e491ece2fc37a784cb55ef05f6390eb23d1322a926be49e
+  metadata.gz: 4738c2c07c1163d9a991fa08978d148ebdee182193a90103ecba277cd783f4b3
+  data.tar.gz: a69ecf05054b5260ab9a324226d5d0a592e337a09a68865c4702e37f4a948a4a
 SHA512:
-  metadata.gz: 712f24a4dc3427cf37126681ba50d53f0aefc9f839920283f611ef22e923f65f53f09fc83ca66cb45930536ca3c13d630dc7b0c5a5f40c6fc6f91f82bf123c3c
-  data.tar.gz: e97e52fc2aa1ad3cc548d2f561df97678e00c0e7e617c08afdbb9c6537709fc2743a07f26679cc8007124348cb32f1e8481d6417b7d3e28d247b504fcc951805
+  metadata.gz: 8c348cb8696ab9fec32321499b4fa62f169ce5b62e4d703df009a7762cd40e9c6e9cbe22c52affce4a493f4d473907f6b051a74e2a46e9de9ff5fc13d24bdd24
+  data.tar.gz: 40d45b9e44f4f7d6fd8e9514ae0e507c39e7177df8cca986b13f461753d00de579bae04578db49a0b5a67b86e6d9527e35cc8db87eb5ff4646b972c9ac4a6b90

data/README.md

@@ -12,22 +12,18 @@ require 'tcp-client'
 
 TCPClient.configure do |cfg|
   cfg.connect_timeout = 1 # second to connect the server
-  cfg.write_timeout = 0.25 # seconds to write a single data junk
-  cfg.read_timeout = 0.5 # seconds to read some bytes
   cfg.ssl_params = { ssl_version: :TLSv1_2 } # use TLS 1.2
 end
 
-# the following request sequence is not allowed to last longer than 2 seconds:
-# 1 second to connect (incl. SSL handshake etc.)
-# + 0.25 seconds to write data
-# + 0.5 seconds to read a response
-
 TCPClient.open('www.google.com:443') do |client|
-  # simple HTTP get request
-  pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
-
-  # read "HTTP/1.1 " + 3 byte HTTP status code
-  pp client.read(12)
+  # query 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: google.com\r\n\r\n")
+
+    # read "HTTP/1.1 " + 3 byte HTTP status code
+    pp client.read(12)
+  end
 end
 ```
 

data/lib/tcp-client.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'tcp-client/errors'
 require_relative 'tcp-client/address'
 require_relative 'tcp-client/tcp_socket'
 require_relative 'tcp-client/ssl_socket'
@@ -8,30 +9,9 @@ require_relative 'tcp-client/default_configuration'
 require_relative 'tcp-client/version'
 
 class TCPClient
-  class NoOpenSSL < RuntimeError
-    def self.raise!
-      raise(self, 'OpenSSL is not avail', caller(1))
-    end
-  end
-
-  class NotConnected < SocketError
-    def self.raise!(reason)
-      raise(self, "client not connected - #{reason}", caller(1))
-    end
-  end
-
-  TimeoutError = Class.new(IOError)
-  ConnectTimeoutError = Class.new(TimeoutError)
-  ReadTimeoutError = Class.new(TimeoutError)
-  WriteTimeoutError = Class.new(TimeoutError)
-
-  Timeout = TimeoutError # backward compatibility
-  deprecate_constant(:Timeout)
-
   def self.open(addr, configuration = Configuration.default)
-    addr = Address.new(addr)
     client = new
-    client.connect(addr, configuration)
+    client.connect(Address.new(addr), configuration)
     block_given? ? yield(client) : client
   ensure
     client&.close if block_given?
@@ -40,46 +20,73 @@ class TCPClient
   attr_reader :address
 
   def initialize
-    @socket = @address = @write_timeout = @read_timeout = nil
+    @socket = @address = @write_timeout = @read_timeout = @deadline = nil
   end
 
   def to_s
     @address ? @address.to_s : ''
   end
 
-  def connect(addr, configuration)
+  def connect(addr, configuration, exception: ConnectTimeoutError)
     close
     NoOpenSSL.raise! if configuration.ssl? && !defined?(SSLSocket)
     @address = Address.new(addr)
-    @socket = TCPSocket.new(@address, configuration, ConnectTimeoutError)
+    @socket = TCPSocket.new(@address, configuration, exception)
     configuration.ssl? &&
-      @socket =
-        SSLSocket.new(@socket, @address, configuration, ConnectTimeoutError)
+      @socket = SSLSocket.new(@socket, @address, configuration, exception)
     @write_timeout = configuration.write_timeout
     @read_timeout = configuration.read_timeout
     self
   end
 
   def close
-    socket, @socket = @socket, nil
-    socket&.close
+    @socket&.close
     self
   rescue IOError
     self
+  ensure
+    @socket = @deadline = nil
   end
 
   def closed?
     @socket.nil? || @socket.closed?
   end
 
-  def read(nbytes, timeout: @read_timeout)
-    NotConnected.raise!(self) if closed?
-    @socket.read(nbytes, timeout: timeout, exception: ReadTimeoutError)
+  def with_deadline(timeout)
+    NoBlockGiven.raise! unless block_given?
+    previous_deadline = @deadline
+    tm = timeout&.to_f
+    InvalidDeadLine.raise! unless tm&.positive?
+    @deadline = Time.now + tm
+    yield(self)
+  ensure
+    @deadline = previous_deadline
+  end
+
+  def read(nbytes, timeout: nil, exception: ReadTimeoutError)
+    NotConnected.raise! if closed?
+    if timeout.nil? && @deadline
+      return @socket.read_with_deadline(nbytes, @deadline, exception)
+    end
+    timeout = (timeout || @read_timeout).to_f
+    if timeout.positive?
+      @socket.read_with_deadline(nbytes, Time.now + timeout, exception)
+    else
+      @socket.read(nbytes)
+    end
   end
 
-  def write(*msg, timeout: @write_timeout)
-    NotConnected.raise!(self) if closed?
-    @socket.write(*msg, timeout: timeout, exception: WriteTimeoutError)
+  def write(*msg, timeout: nil, exception: WriteTimeoutError)
+    NotConnected.raise! if closed?
+    if timeout.nil? && @deadline
+      return @socket.write_with_deadline(msg.join.b, @deadline, exception)
+    end
+    timeout = (timeout || @read_timeout).to_f
+    if timeout.positive?
+      @socket.write_with_deadline(msg.join.b, Time.now + timeout, exception)
+    else
+      @socket.write(*msg)
+    end
   end
 
   def flush

data/lib/tcp-client/address.rb

@@ -25,6 +25,19 @@ class TCPClient
       "#{@hostname}:#{@addrinfo.ip_port}"
     end
 
+    def to_h
+      { host: @hostname, port: @addrinfo.ip_port }
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+    alias eql? ==
+
+    def equal?(other)
+      self.class == other.class && self == other
+    end
+
     private
 
     def init_from_selfclass(address)
@@ -44,7 +57,7 @@ class TCPClient
     end
 
     def from_string(str)
-      return nil, str.to_i unless idx = str.rindex(':')
+      idx = str.rindex(':') or return nil, str.to_i
       name = str[0, idx]
       name = name[1, name.size - 2] if name[0] == '[' && name[-1] == ']'
       [name, str[idx + 1, str.size - idx].to_i]

data/lib/tcp-client/configuration.rb

@@ -6,7 +6,7 @@ class TCPClient
       ret
     end
 
-    attr_reader :buffered, :keep_alive, :reverse_lookup
+    attr_reader :buffered, :keep_alive, :reverse_lookup, :timeout
     attr_accessor :ssl_params
 
     def initialize(options = {})
@@ -19,22 +19,22 @@ class TCPClient
       @ssl_params ? true : false
     end
 
-    def ssl=(yn)
-      return @ssl_params = nil unless yn
-      return @ssl_params = yn if Hash === yn
+    def ssl=(value)
+      return @ssl_params = nil unless value
+      return @ssl_params = value.dup if Hash === value
       @ssl_params ||= {}
     end
 
-    def buffered=(yn)
-      @buffered = yn ? true : false
+    def buffered=(value)
+      @buffered = value ? true : false
     end
 
-    def keep_alive=(yn)
-      @keep_alive = yn ? true : false
+    def keep_alive=(value)
+      @keep_alive = value ? true : false
     end
 
-    def reverse_lookup=(yn)
-      @reverse_lookup = yn ? true : false
+    def reverse_lookup=(value)
+      @reverse_lookup = value ? true : false
     end
 
     def timeout=(seconds)
@@ -66,6 +66,28 @@ class TCPClient
       @read_timeout = seconds(seconds)
     end
 
+    def to_h
+      {
+        buffered: @buffered,
+        keep_alive: @keep_alive,
+        reverse_lookup: @reverse_lookup,
+        timeout: @timeout,
+        connect_timeout: @connect_timeout,
+        read_timeout: @read_timeout,
+        write_timeout: @write_timeout,
+        ssl_params: @ssl_params
+      }
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+    alias eql? ==
+
+    def equal?(other)
+      self.class == other.class && self == other
+    end
+
     private
 
     def set(attribute, value)
@@ -75,7 +97,7 @@ class TCPClient
     end
 
     def seconds(value)
-      value&.positive? ? value : nil
+      value&.to_f&.positive? ? value : nil
     end
   end
 end

data/lib/tcp-client/errors.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+class TCPClient
+  class NoOpenSSL < RuntimeError
+    def self.raise!
+      raise(self, 'OpenSSL is not avail', caller(1))
+    end
+  end
+
+  class NoBlockGiven < RuntimeError
+    def self.raise!
+      raise(self, 'no block given', caller(1))
+    end
+  end
+
+  class InvalidDeadLine < ArgumentError
+    def self.raise!(timeout)
+      raise(self, "invalid deadline - #{timeout}", caller(1))
+    end
+  end
+
+  class NotConnected < SocketError
+    def self.raise!
+      raise(self, 'client not connected', caller(1))
+    end
+  end
+
+  TimeoutError = Class.new(IOError)
+  ConnectTimeoutError = Class.new(TimeoutError)
+  ReadTimeoutError = Class.new(TimeoutError)
+  WriteTimeoutError = Class.new(TimeoutError)
+
+  Timeout = TimeoutError # backward compatibility
+  deprecate_constant(:Timeout)
+end

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

@@ -1,3 +1,7 @@
+# I keep this file for backward compatibility.
+# This may be removed in one of the next versions.
+# Let me know if you like to use it elsewhere...
+
 IOTimeoutError = Class.new(IOError) unless defined?(IOTimeoutError)
 
 module IOTimeoutMixin
@@ -10,6 +14,24 @@ module IOTimeoutMixin
     end
   end
 
+  def read_with_deadline(nbytes, deadline, exception)
+    result = ''.b
+    return result if nbytes.zero?
+    loop do
+      junk_size = nbytes - result.bytesize
+      read =
+        with_deadline(deadline, exception) do
+          read_nonblock(junk_size, exception: false)
+        end
+      unless read
+        close
+        return result
+      end
+      result += read
+      return result if result.bytesize >= nbytes
+    end
+  end
+
   def read(nbytes, timeout: nil, exception: IOTimeoutError)
     timeout = timeout.to_f
     return read_all(nbytes) { |junk_size| super(junk_size) } if timeout <= 0
@@ -35,8 +57,8 @@ module IOTimeoutMixin
   private
 
   def read_all(nbytes)
-    return '' if nbytes.zero?
-    result = ''
+    return ''.b if nbytes.zero?
+    result = ''.b
     loop do
       unless read = yield(nbytes - result.bytesize)
         close
@@ -59,9 +81,7 @@ module IOTimeoutMixin
   end
 
   module DeadlineMethods
-    private
-
-    def with_deadline(deadline, exclass)
+    private def with_deadline(deadline, exclass)
       loop do
         case ret = yield
         when :wait_writable
@@ -78,9 +98,7 @@ module IOTimeoutMixin
   end
 
   module DeadlineIO
-    private
-
-    def with_deadline(deadline, exclass)
+    private def with_deadline(deadline, exclass)
       loop do
         case ret = yield
         when :wait_writable

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

@@ -0,0 +1,79 @@
+module IOWithDeadlineMixin
+  def self.included(mod)
+    im = mod.instance_methods
+    if im.index(:wait_writable) && im.index(:wait_readable)
+      mod.include(ViaWaitMethod)
+    else
+      mod.include(ViaSelect)
+    end
+  end
+
+  def read_with_deadline(nbytes, deadline, exclass)
+    raise(exclass) if Time.now > deadline
+    result = ''.b
+    return result if nbytes.zero?
+    loop do
+      read =
+        with_deadline(deadline, exclass) do
+          read_nonblock(nbytes - result.bytesize, exception: false)
+        end
+      unless read
+        close
+        return result
+      end
+      result += read
+      return result if result.bytesize >= nbytes
+    end
+  end
+
+  def write_with_deadline(data, deadline, exclass)
+    raise(exclass) if Time.now > deadline
+    return 0 if (size = data.bytesize).zero?
+    result = 0
+    loop do
+      written =
+        with_deadline(deadline, exclass) do
+          write_nonblock(data, exception: false)
+        end
+      result += written
+      return result if result >= size
+      data = data.byteslice(written, data.bytesize - written)
+    end
+  end
+
+  module ViaWaitMethod
+    private def with_deadline(deadline, exclass)
+      loop do
+        case ret = yield
+        when :wait_writable
+          raise(exclass) if (remaining_time = deadline - Time.now) <= 0
+          raise(exclass) if wait_writable(remaining_time).nil?
+        when :wait_readable
+          raise(exclass) if (remaining_time = deadline - Time.now) <= 0
+          raise(exclass) if wait_readable(remaining_time).nil?
+        else
+          return ret
+        end
+      end
+    end
+  end
+
+  module ViaSelect
+    private def with_deadline(deadline, exclass)
+      loop do
+        case ret = yield
+        when :wait_writable
+          raise(exclass) if (remaining_time = deadline - Time.now) <= 0
+          raise(exclass) if ::IO.select(nil, [self], nil, remaining_time).nil?
+        when :wait_readable
+          raise(exclass) if (remaining_time = deadline - Time.now) <= 0
+          raise(exclass) if ::IO.select([self], nil, nil, remaining_time).nil?
+        else
+          return ret
+        end
+      end
+    end
+  end
+
+  private_constant(:ViaWaitMethod, :ViaSelect)
+end

data/lib/tcp-client/ssl_socket.rb

@@ -4,11 +4,11 @@ rescue LoadError
   return
 end
 
-require_relative 'mixin/io_timeout'
+require_relative 'mixin/io_with_deadline'
 
 class TCPClient
   class SSLSocket < ::OpenSSL::SSL::SSLSocket
-    include IOTimeoutMixin
+    include IOWithDeadlineMixin
 
     def initialize(socket, address, configuration, exception)
       ssl_params = Hash[configuration.ssl_params]
@@ -31,12 +31,13 @@ class TCPClient
 
     def connect_to(address, check, timeout, exception)
       self.hostname = address.hostname
-      if timeout
+      timeout = timeout.to_f
+      if timeout.zero?
+        connect
+      else
         with_deadline(Time.now + timeout, exception) do
           connect_nonblock(exception: false)
         end
-      else
-        connect
       end
       post_connection_check(address.hostname) if check
     end

data/lib/tcp-client/tcp_socket.rb

@@ -1,9 +1,9 @@
 require 'socket'
-require_relative 'mixin/io_timeout'
+require_relative 'mixin/io_with_deadline'
 
 class TCPClient
   class TCPSocket < ::Socket
-    include IOTimeoutMixin
+    include IOWithDeadlineMixin
 
     def initialize(address, configuration, exception)
       super(address.addrinfo.ipv6? ? :INET6 : :INET, :STREAM)
@@ -19,7 +19,8 @@ class TCPClient
           address.addrinfo.ip_port,
           address.addrinfo.ip_address
         )
-      return connect(addr) unless timeout
+      timeout = timeout.to_f
+      return connect(addr) if timeout.zero?
       with_deadline(Time.now + timeout, exception) do
         connect_nonblock(addr, exception: false)
       end

data/lib/tcp-client/version.rb

@@ -1,3 +1,3 @@
 class TCPClient
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/rakefile.rb

@@ -4,7 +4,9 @@ require 'rake/clean'
 require 'rake/testtask'
 require 'bundler/gem_tasks'
 
-STDOUT.sync = STDERR.sync = true
+$stdout.sync = $stderr.sync = true
+
+task(:default) { exec('rake --tasks') }
 
 CLOBBER << 'prj'
 
@@ -13,7 +15,3 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = true
   t.test_files = FileList['test/**/*_test.rb']
 end
-
-task :default do
-  exec("#{$PROGRAM_NAME} --tasks")
-end

data/sample/google_ssl.rb

@@ -2,20 +2,16 @@ require_relative '../lib/tcp-client'
 
 TCPClient.configure do |cfg|
   cfg.connect_timeout = 1 # second to connect the server
-  cfg.write_timeout = 0.25 # seconds to write a single data junk
-  cfg.read_timeout = 0.5 # seconds to read some bytes
   cfg.ssl_params = { ssl_version: :TLSv1_2 } # use TLS 1.2
 end
 
-# the following request sequence is not allowed to last longer than 2 seconds:
-# 1 second to connect (incl. SSL handshake etc.)
-# + 0.25 seconds to write data
-# + 0.5 seconds to read a response
-
 TCPClient.open('www.google.com:443') do |client|
-  # simple HTTP get request
-  pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
+  # query 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: google.com\r\n\r\n")
 
-  # read "HTTP/1.1 " + 3 byte HTTP status code
-  pp client.read(12)
+    # read "HTTP/1.1 " + 3 byte HTTP status code
+    pp client.read(12)
+  end
 end

data/tcp-client.gemspec

@@ -5,6 +5,10 @@ require_relative './lib/tcp-client/version'
 GemSpec = Gem::Specification.new do |spec|
   spec.name = 'tcp-client'
   spec.version = TCPClient::VERSION
+  spec.author = 'Mike Blumtritt'
+
+  spec.required_ruby_version = '>= 2.7.0'
+
   spec.summary = 'A TCP client implementation with working timeout support.'
   spec.description = <<~DESCRIPTION
     This gem implements a TCP client with (optional) SSL support. The
@@ -13,27 +17,17 @@ GemSpec = Gem::Specification.new do |spec|
     other implementations this client respects given/configurable time
     limits for each method (`connect`, `read`, `write`).
   DESCRIPTION
-  spec.author = 'Mike Blumtritt'
-  spec.email = 'mike.blumtritt@pm.me'
   spec.homepage = 'https://github.com/mblumtritt/tcp-client'
-  spec.metadata = {
-    'source_code_uri' => 'https://github.com/mblumtritt/tcp-client',
-    'bug_tracker_uri' => 'https://github.com/mblumtritt/tcp-client/issues'
-  }
-  spec.rubyforge_project = spec.name
+
+  spec.metadata['source_code_uri'] = 'https://github.com/mblumtritt/tcp-client'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/mblumtritt/tcp-client/issues'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'minitest'
   spec.add_development_dependency 'rake'
 
-  spec.platform = Gem::Platform::RUBY
-  spec.required_ruby_version = '>= 2.5.0'
-  spec.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
-
-  spec.require_paths = %w[lib]
-
-  all_files = %x(git ls-files -z).split(0.chr)
-  spec.test_files = all_files.grep(%r{^(spec|test)/})
+  all_files = Dir.chdir(__dir__) { `git ls-files -z`.split(0.chr) }
+  spec.test_files = all_files.grep(%r{^test/})
   spec.files = all_files - spec.test_files
 
   spec.extra_rdoc_files = %w[README.md]

data/test/tcp-client/address_test.rb

@@ -13,7 +13,7 @@ class AddressTest < MiniTest::Test
   end
 
   def test_create_from_addrinfo
-    addrinfo = Addrinfo.tcp('google.com', 42)
+    addrinfo = Addrinfo.tcp('localhost', 42)
     subject = TCPClient::Address.new(addrinfo)
     assert_equal(addrinfo.getnameinfo[0], subject.hostname)
     assert_equal(addrinfo, subject.addrinfo)
@@ -54,4 +54,12 @@ class AddressTest < MiniTest::Test
     assert(subject.addrinfo.ip?)
     assert(subject.addrinfo.ipv6?)
   end
+
+  def test_compare
+    a = TCPClient::Address.new('localhost:42')
+    b = TCPClient::Address.new('localhost:42')
+    assert_equal(a, b)
+    assert(a == b)
+    assert(a === b)
+  end
 end

data/test/tcp-client/configuration_test.rb

@@ -87,4 +87,12 @@ class ConfigurationTest < MiniTest::Test
     assert_same(42, subject.read_timeout)
     assert_same(42, subject.write_timeout)
   end
+
+  def test_compare
+    a = TCPClient::Configuration.new
+    b = TCPClient::Configuration.new
+    assert_equal(a, b)
+    assert(a == b)
+    assert(a === b)
+  end
 end

data/test/tcp_client_test.rb

@@ -3,6 +3,8 @@ require_relative 'test_helper'
 class TCPClientTest < MiniTest::Test
   parallelize_me!
 
+  HUGE_AMOUNT_OF_DATA = Array.new(2024, '?' * 1024).freeze
+
   attr_reader :config
 
   def setup
@@ -22,9 +24,9 @@ class TCPClientTest < MiniTest::Test
   def create_nonconnected_client
     client = TCPClient.new
     client.connect('', config)
+    client
   rescue Errno::EADDRNOTAVAIL
-  ensure
-    return client
+    client
   end
 
   def test_failed_state
@@ -41,7 +43,7 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_connected_state
-    TCPClient.open('localhost:1234') do |subject|
+    TCPClient.open('localhost:1234', config) do |subject|
       refute(subject.closed?)
       assert_equal('localhost:1234', subject.to_s)
       refute_nil(subject.address)
@@ -65,7 +67,7 @@ class TCPClientTest < MiniTest::Test
         start_time = Time.now
         subject.read(42, timeout: timeout)
       end
-      assert_in_delta(timeout, Time.now - start_time, 0.02)
+      assert_in_delta(timeout, Time.now - start_time, 0.11)
     end
   end
 
@@ -81,27 +83,63 @@ class TCPClientTest < MiniTest::Test
       start_time = nil
       assert_raises(TCPClient::WriteTimeoutError) do
         start_time = Time.now
-
-        # send 1MB to avoid any TCP stack buffering
-        args = Array.new(2024, '?' * 1024)
-        subject.write(*args, timeout: timeout)
+        subject.write(*HUGE_AMOUNT_OF_DATA, timeout: timeout)
       end
-      assert_in_delta(timeout, Time.now - start_time, 0.02)
+      assert_in_delta(timeout, Time.now - start_time, 0.11)
     end
   end
 
   def test_write_timeout
-    check_write_timeout(0.1)
+    check_write_timeout(0.01)
     check_write_timeout(0.25)
   end
 
+  def test_write_deadline
+    TCPClient.open('localhost:1234', config) do |subject|
+      refute(subject.closed?)
+      assert_raises(TCPClient::WriteTimeoutError) do
+        subject.with_deadline(0.25) do |*args|
+          assert_equal([subject], args)
+          loop { subject.write('some data here') }
+        end
+      end
+    end
+  end
+
+  def test_read_deadline
+    TCPClient.open('localhost:1234', config) do |subject|
+      refute(subject.closed?)
+      assert_raises(TCPClient::ReadTimeoutError) do
+        subject.with_deadline(0.25) do |*args|
+          assert_equal([subject], args)
+          loop { subject.read(0) }
+        end
+      end
+    end
+  end
+
+  def xtest_read_write_deadline
+    TCPClient.open('localhost:1234', config) do |subject|
+      refute(subject.closed?)
+      assert_raises(TCPClient::TimeoutError) do
+        subject.with_deadline(0.25) do |*args|
+          assert_equal([subject], args)
+          loop do
+            subject.write('HUGE_AMOUNT_OF_DATA')
+            subject.read(0)
+          end
+        end
+      end
+    end
+  end
+
   def check_connect_timeout(ssl_config)
     start_time = nil
     assert_raises(TCPClient::ConnectTimeoutError) do
       start_time = Time.now
       TCPClient.new.connect('localhost:1234', ssl_config)
     end
-    assert_in_delta(ssl_config.connect_timeout, Time.now - start_time, 0.02)
+    assert_in_delta(ssl_config.connect_timeout, Time.now - start_time, 0.11)
   end
 
   def test_connect_ssl_timeout

data/test/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'minitest/parallel'
 require_relative '../lib/tcp-client'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-11 00:00:00.000000000 Z
+date: 2021-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,7 +58,7 @@ description: |
   easy to use client which can handle time limits correctly. Unlike
   other implementations this client respects given/configurable time
   limits for each method (`connect`, `read`, `write`).
-email: mike.blumtritt@pm.me
+email:
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -71,7 +71,9 @@ files:
 - lib/tcp-client/address.rb
 - lib/tcp-client/configuration.rb
 - lib/tcp-client/default_configuration.rb
+- lib/tcp-client/errors.rb
 - lib/tcp-client/mixin/io_timeout.rb
+- lib/tcp-client/mixin/io_with_deadline.rb
 - lib/tcp-client/ssl_socket.rb
 - lib/tcp-client/tcp_socket.rb
 - lib/tcp-client/version.rb
@@ -99,12 +101,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: '0'
 requirements: []
 rubygems_version: 3.2.9
 signing_key: