tcp-client 0.1.3 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc62bca2078a00db24dc861aa876a6e2acac79dd1f2eb0cafbd29840d5169704
-  data.tar.gz: c784e00a152bcf7ac5c1246517483a39f55beb3f7591881be58a4edeb847097e
+  metadata.gz: 2791642003fb16623a27988401ff3bb532194032a5bbd4f62b853aae94790055
+  data.tar.gz: 030a2b3ebecf1334dea84e2c8f18aecd3b900c7c467c10c624c1354429a66195
 SHA512:
-  metadata.gz: 77ff9adf39b16aab0ca83cd77c01f688a77efd675c287095e5b67c1b52f89cf0528ddbc0a1c206330703cf430c4f457ddbdcb369f5a0a8f57a6c143ee5266f7e
-  data.tar.gz: 27df4b59116a68cf8232f471214e305d74f650b4e1be6cbd59302660f8d2998beef1fd7c382079311f9139c3465bda20981f3ff0993659f74807c00bb3942959
+  metadata.gz: e4ef14d49cd323a418190e62bc190af01fcc9be1b7008b7fd27c8fa7b8779ae29947045a660080e9403ba1d932e1318a6f98c819006d816f91eb093caf6d7873
+  data.tar.gz: 29617e860ad0b419638b54a8258541ccf3c668530a38aa2e629badcb373b94df71c33e538d54faf12d732ffd51670e1ad57cc8fabcaac11bb2d4de3d28cd29b1

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,50 +20,88 @@ class TCPClient
   attr_reader :address
 
   def initialize
-    @socket = @address = @write_timeout = @read_timeout = nil
+    @socket = @address = @deadline = @cfg = nil
   end
 
   def to_s
     @address ? @address.to_s : ''
   end
 
-  def connect(addr, configuration)
+  def connect(addr, configuration, exception: nil)
     close
     NoOpenSSL.raise! if configuration.ssl? && !defined?(SSLSocket)
     @address = Address.new(addr)
-    @socket = TCPSocket.new(@address, configuration, ConnectTimeoutError)
-    configuration.ssl? &&
-      @socket =
-        SSLSocket.new(@socket, @address, configuration, ConnectTimeoutError)
-    @write_timeout = configuration.write_timeout
-    @read_timeout = configuration.read_timeout
+    @cfg = configuration.dup
+    exception ||= configuration.connect_timeout_error
+    @socket = TCPSocket.new(@address, @cfg, exception)
+    @cfg.ssl? &&
+      @socket = SSLSocket.new(@socket, @address, configuration, exception)
     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)
+    previous_deadline = @deadline
+    NoBlockGiven.raise! unless block_given?
+    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: nil)
+    NotConnected.raise! if closed?
+    timeout.nil? && @deadline and
+      return read_with_deadline(nbytes, @deadline, exception)
+    timeout = (timeout || @cfg.read_timeout).to_f
+    return @socket.read(nbytes) unless timeout.positive?
+    read_with_deadline(nbytes, Time.now + timeout, exception)
   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: nil)
+    NotConnected.raise! if closed?
+    timeout.nil? && @deadline and
+      return write_with_deadline(msg, @deadline, exception)
+    timeout = (timeout || @cfg.write_timeout).to_f
+    return @socket.write(*msg) unless timeout.positive?
+    write_with_deadline(msg, Time.now + timeout, exception)
   end
 
   def flush
     @socket.flush unless closed?
     self
   end
+
+  private
+
+  def read_with_deadline(nbytes, deadline, exception)
+    @socket.read_with_deadline(
+      nbytes,
+      deadline,
+      exception || @cfg.read_timeout_error
+    )
+  end
+
+  def write_with_deadline(msg, deadline, exception)
+    exception ||= @cfg.write_timeout_error
+    result = 0
+    msg.each do |chunk|
+      result += @socket.write_with_deadline(chunk.b, deadline, exception)
+    end
+    result
+  end
 end

data/lib/tcp-client/address.rb

@@ -26,7 +26,7 @@ class TCPClient
     end
 
     def to_h
-      {host: @hostname, port: @addrinfo.ip_port}
+      { host: @hostname, port: @addrinfo.ip_port }
     end
 
     def ==(other)

data/lib/tcp-client/configuration.rb

@@ -1,3 +1,5 @@
+require_relative 'errors'
+
 class TCPClient
   class Configuration
     def self.create(options = {})
@@ -6,15 +8,38 @@ class TCPClient
       ret
     end
 
-    attr_reader :buffered, :keep_alive, :reverse_lookup, :timeout
+    attr_reader :buffered,
+                :keep_alive,
+                :reverse_lookup,
+                :timeout,
+                :connect_timeout,
+                :read_timeout,
+                :write_timeout,
+                :connect_timeout_error,
+                :read_timeout_error,
+                :write_timeout_error
     attr_accessor :ssl_params
 
     def initialize(options = {})
       @buffered = @keep_alive = @reverse_lookup = true
       self.timeout = @ssl_params = nil
+      @connect_timeout_error = ConnectTimeoutError
+      @read_timeout_error = ReadTimeoutError
+      @write_timeout_error = WriteTimeoutError
       options.each_pair { |attribute, value| set(attribute, value) }
     end
 
+    def freeze
+      @ssl_params.freeze
+      super
+    end
+
+    def initialize_copy(_org)
+      super
+      @ssl_params = @ssl_params.dup
+      self
+    end
+
     def ssl?
       @ssl_params ? true : false
     end
@@ -38,32 +63,41 @@ class TCPClient
     end
 
     def timeout=(seconds)
-      @timeout = seconds(seconds)
-      @connect_timeout = @write_timeout = @read_timeout = nil
-    end
-
-    def connect_timeout
-      @connect_timeout || @timeout
+      @timeout =
+        @connect_timeout = @write_timeout = @read_timeout = seconds(seconds)
     end
 
     def connect_timeout=(seconds)
       @connect_timeout = seconds(seconds)
     end
 
-    def write_timeout
-      @write_timeout || @timeout
+    def read_timeout=(seconds)
+      @read_timeout = seconds(seconds)
     end
 
     def write_timeout=(seconds)
       @write_timeout = seconds(seconds)
     end
 
-    def read_timeout
-      @read_timeout || @timeout
+    def timeout_error=(exception)
+      NotAnException.raise!(exception) unless exception_class?(exception)
+      @connect_timeout_error =
+        @read_timeout_error = @write_timeout_error = exception
     end
 
-    def read_timeout=(seconds)
-      @read_timeout = seconds(seconds)
+    def connect_timeout_error=(exception)
+      NotAnException.raise!(exception) unless exception_class?(exception)
+      @connect_timeout_error = exception
+    end
+
+    def read_timeout_error=(exception)
+      NotAnException.raise!(exception) unless exception_class?(exception)
+      @read_timeout_error = exception
+    end
+
+    def write_timeout_error=(exception)
+      NotAnException.raise!(exception) unless exception_class?(exception)
+      @write_timeout_error = exception
     end
 
     def to_h
@@ -75,6 +109,9 @@ class TCPClient
         connect_timeout: @connect_timeout,
         read_timeout: @read_timeout,
         write_timeout: @write_timeout,
+        connect_timeout_error: @connect_timeout_error,
+        read_timeout_error: @read_timeout_error,
+        write_timeout_error: @write_timeout_error,
         ssl_params: @ssl_params
       }
     end
@@ -90,10 +127,14 @@ class TCPClient
 
     private
 
+    def exception_class?(value)
+      value.is_a?(Class) && value < Exception
+    end
+
     def set(attribute, value)
       public_send("#{attribute}=", value)
     rescue NoMethodError
-      raise(ArgumentError, "unknown attribute - #{attribute}")
+      UnknownAttribute.raise!(attribute)
     end
 
     def seconds(value)

data/lib/tcp-client/default_configuration.rb

@@ -6,10 +6,8 @@ class TCPClient
   class << self
     attr_reader :default_configuration
 
-    def configure(options = {})
-      cfg = Configuration.new(options)
-      yield(cfg) if block_given?
-      @default_configuration = cfg
+    def configure(options = {}, &block)
+      @default_configuration = Configuration.create(options, &block)
     end
   end
 

data/lib/tcp-client/errors.rb

@@ -0,0 +1,49 @@
+# 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 UnknownAttribute < ArgumentError
+    def self.raise!(attribute)
+      raise(self, "unknown attribute - #{attribute}", caller(1))
+    end
+  end
+
+  class NotAnException < TypeError
+    def self.raise!(object)
+      raise(self, "not a valid exception class - #{object.inspect}", 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

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

@@ -0,0 +1,83 @@
+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
+    rescue Errno::ETIMEDOUT
+      raise(exclass)
+    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
+    rescue Errno::ETIMEDOUT
+      raise(exclass)
+    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.3'.freeze
+  VERSION = '0.2.3'.freeze
 end

data/rakefile.rb

@@ -6,12 +6,12 @@ require 'bundler/gem_tasks'
 
 $stdout.sync = $stderr.sync = true
 
-task(:default) { exec('rake --tasks') }
-
 CLOBBER << 'prj'
 
-Rake::TestTask.new(:test) do |t|
-  t.ruby_opts = %w[-w]
-  t.verbose = true
-  t.test_files = FileList['test/**/*_test.rb']
+task(:default) { exec('rake --tasks') }
+
+Rake::TestTask.new(:test) do |task|
+  task.test_files = FileList['test/**/*_test.rb']
+  task.ruby_opts = %w[-w]
+  task.verbose = true
 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/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)
@@ -62,5 +62,4 @@ class AddressTest < MiniTest::Test
     assert(a == b)
     assert(a === b)
   end
-
 end

data/test/tcp-client/configuration_test.rb

@@ -39,7 +39,8 @@ class ConfigurationTest < MiniTest::Test
         connect_timeout: 1,
         read_timeout: 2,
         write_timeout: 3,
-        ssl: true
+        ssl: true,
+        connect_timeout_error: IOError
       )
     refute(subject.buffered)
     refute(subject.keep_alive)
@@ -48,6 +49,8 @@ class ConfigurationTest < MiniTest::Test
     assert_same(2, subject.read_timeout)
     assert_same(3, subject.write_timeout)
     assert(subject.ssl?)
+    assert_same(IOError, subject.connect_timeout_error)
+    assert_same(TCPClient::ReadTimeoutError, subject.read_timeout_error)
   end
 
   def test_invalid_option
@@ -88,6 +91,18 @@ class ConfigurationTest < MiniTest::Test
     assert_same(42, subject.write_timeout)
   end
 
+  def test_timeout_error_overwrite
+    subject = TCPClient::Configuration.new
+    assert_same(TCPClient::ConnectTimeoutError, subject.connect_timeout_error)
+    assert_same(TCPClient::ReadTimeoutError, subject.read_timeout_error)
+    assert_same(TCPClient::WriteTimeoutError, subject.write_timeout_error)
+
+    subject.timeout_error = IOError
+    assert_same(IOError, subject.connect_timeout_error)
+    assert_same(IOError, subject.read_timeout_error)
+    assert_same(IOError, subject.write_timeout_error)
+  end
+
   def test_compare
     a = TCPClient::Configuration.new
     b = TCPClient::Configuration.new
@@ -95,4 +110,32 @@ class ConfigurationTest < MiniTest::Test
     assert(a == b)
     assert(a === b)
   end
+
+  def test_dup
+    source =
+      TCPClient::Configuration.new(
+        buffered: false,
+        keep_alive: false,
+        reverse_lookup: false,
+        connect_timeout: 1,
+        read_timeout: 2,
+        write_timeout: 3,
+        ssl: {
+          ssl_version: :TLSv1_2
+        }
+      )
+    shadow = source.dup.freeze
+
+    # some changes
+    source.buffered = true
+    source.write_timeout = 5
+    source.ssl_params[:err] = true
+    source.timeout_error = IOError
+
+    refute_equal(source.__id__, shadow.__id__)
+    refute(shadow.buffered)
+    assert_equal(3, shadow.write_timeout)
+    assert_equal({ ssl_version: :TLSv1_2 }, shadow.ssl_params)
+    assert_same(TCPClient::ReadTimeoutError, shadow.read_timeout_error)
+  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
@@ -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.15)
     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.15)
     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

@@ -4,8 +4,6 @@ require 'minitest/autorun'
 require 'minitest/parallel'
 require_relative '../lib/tcp-client'
 
-$stdout.sync = $stderr.sync = true
-
 # this pseudo-server never reads or writes anything
-DummyServer = TCPServer.new('localhost', 1234)
-Minitest.after_run { DummyServer.close }
+PseudoServer = TCPServer.new('localhost', 1234)
+Minitest.after_run { PseudoServer.close }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.3
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-12 00:00:00.000000000 Z
+date: 2021-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -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
@@ -106,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.9
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: A TCP client implementation with working timeout support.