tcp-client 0.1.5 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1c2652ec394a4f083349a0254f8eeb9432b18a8869b98d39db221cc76dbdd1b
-  data.tar.gz: 0b26e622ae44a45f5e7b7c07fb9d81f6bf2a0f84bccb1ff7f0ab6563fe59b28e
+  metadata.gz: 4b265053761a87007b7de21c3a7a369b778f013ae726bb26220a4fd9aeeaf71c
+  data.tar.gz: 5a71b5dc86ed4ab9ef481e65c24aef0481c5e9d2c868f3f9975b801936d99691
 SHA512:
-  metadata.gz: 7842b8e3d9f53287ed83e6ca9ebd139f33c2ddd6472b474d69db8c0481178b0f74a386dc62b8e0251cc0a2742624976efa22530582d3c3af14ae94231868fc4b
-  data.tar.gz: af08470a96f7d2cf64086184dab3d39ac9d84741c19a848fbfb4ff0dab3e2499d72f17dce99d11967235e0d09b2b03a1c5c3116588884ca6656e6daf0f0015f8
+  metadata.gz: d16d436959c3e1c29962a5c474de8db3b4638e2d99aaf66fe4046b22e8159298cc433e014b14d9c9b3e01cafff1052743cf90896c396d86e1ccfc87d689553da
+  data.tar.gz: 70f4ce83fd7c7c8aa4c066fb94e96ef62a5087c3f78e079cd473e8d45ab22e106eea7b3d7bf5965063fecb9b77c58b8548598f4a873d9480c5b501bc7854dea9

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,34 +20,32 @@ class TCPClient
   attr_reader :address
 
   def initialize
-    @socket = @address = @write_timeout = @read_timeout = nil
-    @deadline = nil
+    @socket = @address = @deadline = @cfg = nil
   end
 
   def to_s
     @address ? @address.to_s : ''
   end
 
-  def connect(addr, configuration, exception: ConnectTimeoutError)
+  def connect(addr, configuration, exception: nil)
     close
-    NoOpenSSL.raise! if configuration.ssl? && !defined?(SSLSocket)
+    raise(NoOpenSSL) if configuration.ssl? && !defined?(SSLSocket)
     @address = Address.new(addr)
-    @socket = TCPSocket.new(@address, configuration, exception)
-    configuration.ssl? &&
+    @cfg = configuration.dup
+    exception ||= configuration.connect_timeout_error
+    @socket = TCPSocket.new(@address, @cfg, exception)
+    @cfg.ssl? &&
       @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
-    @deadline = nil
+    @socket = @deadline = nil
   end
 
   def closed?
@@ -75,26 +53,32 @@ class TCPClient
   end
 
   def with_deadline(timeout)
-    raise('no block given') unless block_given?
-    raise('deadline already used') if @deadline
+    previous_deadline = @deadline
+    raise(NoBlockGiven) unless block_given?
     tm = timeout&.to_f
-    raise(ArgumentError, "invalid deadline - #{timeout}") unless tm&.positive?
+    raise(InvalidDeadLine) unless tm&.positive?
     @deadline = Time.now + tm
     yield(self)
   ensure
-    @deadline = nil
+    @deadline = previous_deadline
   end
 
-  def read(nbytes, timeout: nil, exception: ReadTimeoutError)
-    NotConnected.raise!(self) if closed?
-    time = timeout || remaining_time(exception) || @read_timeout
-    @socket.read(nbytes, timeout: time, exception: exception)
+  def read(nbytes, timeout: nil, exception: nil)
+    raise(NotConnected) 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: nil, exception: WriteTimeoutError)
-    NotConnected.raise!(self) if closed?
-    time = timeout || remaining_time(exception) || @write_timeout
-    @socket.write(*msg, timeout: time, exception: exception)
+  def write(*msg, timeout: nil, exception: nil)
+    raise(NotConnected) 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
@@ -104,9 +88,18 @@ class TCPClient
 
   private
 
-  def remaining_time(exception)
-    return unless @deadline
-    remaining_time = @deadline - Time.now
-    0 < remaining_time ? remaining_time : raise(exception)
+  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
+    msg.sum do |chunk|
+      @socket.write_with_deadline(chunk.b, deadline, exception)
+    end
   end
 end

data/lib/tcp-client/address.rb

@@ -10,10 +10,10 @@ class TCPClient
       case addr
       when self.class
         init_from_selfclass(addr)
-      when Integer
-        init_from_addrinfo(Addrinfo.tcp(nil, addr))
       when Addrinfo
         init_from_addrinfo(addr)
+      when Integer
+        init_from_addrinfo(Addrinfo.tcp(nil, addr))
       else
         init_from_string(addr)
       end
@@ -59,7 +59,9 @@ class TCPClient
     def from_string(str)
       idx = str.rindex(':') or return nil, str.to_i
       name = str[0, idx]
-      name = name[1, name.size - 2] if name[0] == '[' && name[-1] == ']'
+      if name.start_with?('[') && name.end_with?(']')
+        name = name[1, name.size - 2]
+      end
       [name, str[idx + 1, str.size - idx].to_i]
     end
   end

data/lib/tcp-client/configuration.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
 class TCPClient
   class Configuration
     def self.create(options = {})
@@ -6,15 +10,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 +65,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)
+      raise(NotAnException, 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)
+      raise(NotAnException, exception) unless exception_class?(exception)
+      @connect_timeout_error = exception
+    end
+
+    def read_timeout_error=(exception)
+      raise(NotAnException, exception) unless exception_class?(exception)
+      @read_timeout_error = exception
+    end
+
+    def write_timeout_error=(exception)
+      raise(NotAnException, exception) unless exception_class?(exception)
+      @write_timeout_error = exception
     end
 
     def to_h
@@ -75,6 +111,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 +129,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}")
+      raise(UnknownAttribute, 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,72 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+class TCPClient
+  class NoOpenSSL < RuntimeError
+    def initialize
+      super('OpenSSL is not avail')
+    end
+  end
+
+  class NoBlockGiven < ArgumentError
+    def initialize
+      super('no block given')
+    end
+  end
+
+  class InvalidDeadLine < ArgumentError
+    def initialize(timeout)
+      super("invalid deadline - #{timeout}")
+    end
+  end
+
+  class UnknownAttribute < ArgumentError
+    def initialize(attribute)
+      super("unknown attribute - #{attribute}")
+    end
+  end
+
+  class NotAnException < TypeError
+    def initialize(object)
+      super("not a valid exception class - #{object.inspect}")
+    end
+  end
+
+  class NotConnected < IOError
+    def initialize
+      super('client not connected')
+    end
+  end
+
+  class TimeoutError < IOError
+    def initialize(message = nil)
+      super(message || "unable to #{action} in time")
+    end
+
+    def action
+      :process
+    end
+  end
+
+  class ConnectTimeoutError < TimeoutError
+    def action
+      :connect
+    end
+  end
+
+  class ReadTimeoutError < TimeoutError
+    def action
+      :read
+    end
+  end
+
+  class WriteTimeoutError < TimeoutError
+    def action
+      :write
+    end
+  end
+
+  Timeout = TimeoutError # backward compatibility
+  deprecate_constant(:Timeout)
+end

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

@@ -0,0 +1,83 @@
+module IOWithDeadlineMixin
+  def self.included(mod)
+    methods = mod.instance_methods
+    if methods.index(:wait_writable) && methods.index(:wait_readable)
+      mod.include(ViaWaitMethod)
+    else
+      mod.include(ViaSelect)
+    end
+  end
+
+  def read_with_deadline(bytes_to_read, deadline, exception)
+    raise(exception) if Time.now > deadline
+    result = ''.b
+    return result if bytes_to_read <= 0
+    loop do
+      read =
+        with_deadline(deadline, exception) do
+          read_nonblock(bytes_to_read - result.bytesize, exception: false)
+        end
+      unless read
+        close
+        return result
+      end
+      result += read
+      return result if result.bytesize >= bytes_to_read
+    end
+  end
+
+  def write_with_deadline(data, deadline, exception)
+    raise(exception) if Time.now > deadline
+    return 0 if (size = data.bytesize).zero?
+    result = 0
+    loop do
+      written =
+        with_deadline(deadline, exception) 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, exception)
+      loop do
+        case ret = yield
+        when :wait_writable
+          raise(exception) if (remaining_time = deadline - Time.now) <= 0
+          raise(exception) if wait_writable(remaining_time).nil?
+        when :wait_readable
+          raise(exception) if (remaining_time = deadline - Time.now) <= 0
+          raise(exception) if 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
+        case ret = yield
+        when :wait_writable
+          raise(exception) if (remaining_time = deadline - Time.now) <= 0
+          raise(exception) if ::IO.select(nil, [self], nil, remaining_time).nil?
+        when :wait_readable
+          raise(exception) if (remaining_time = deadline - Time.now) <= 0
+          raise(exception) if ::IO.select([self], nil, nil, remaining_time).nil?
+        else
+          return ret
+        end
+      end
+    rescue Errno::ETIMEDOUT
+      raise(exception)
+    end
+  end
+
+  private_constant(:ViaWaitMethod, :ViaSelect)
+end

data/lib/tcp-client/ssl_socket.rb

@@ -4,14 +4,15 @@ 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]
+      self.sync_close = true
       super(socket, create_context(ssl_params))
       connect_to(
         address,
@@ -24,19 +25,20 @@ class TCPClient
     private
 
     def create_context(ssl_params)
-      ctx = OpenSSL::SSL::SSLContext.new
-      ctx.set_params(ssl_params)
-      ctx
+      context = OpenSSL::SSL::SSLContext.new
+      context.set_params(ssl_params)
+      context
     end
 
     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.5'.freeze
+  VERSION = '0.3.2'.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/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)

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

@@ -11,6 +11,10 @@ class TCPClientTest < MiniTest::Test
     @config = TCPClient::Configuration.create(buffered: false)
   end
 
+  def port
+    PseudoServer.local_address.ip_port
+  end
+
   def test_defaults
     subject = TCPClient.new
     assert(subject.closed?)
@@ -43,15 +47,15 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_connected_state
-    TCPClient.open('localhost:1234', config) do |subject|
+    TCPClient.open("localhost:#{port}", config) do |subject|
       refute(subject.closed?)
-      assert_equal('localhost:1234', subject.to_s)
+      assert_equal("localhost:#{port}", subject.to_s)
       refute_nil(subject.address)
       address_when_opened = subject.address
-      assert_equal('localhost:1234', subject.address.to_s)
+      assert_equal("localhost:#{port}", subject.address.to_s)
       assert_equal('localhost', subject.address.hostname)
       assert_instance_of(Addrinfo, subject.address.addrinfo)
-      assert_same(1234, subject.address.addrinfo.ip_port)
+      assert_same(port, subject.address.addrinfo.ip_port)
 
       subject.close
       assert(subject.closed?)
@@ -60,14 +64,14 @@ class TCPClientTest < MiniTest::Test
   end
 
   def check_read_timeout(timeout)
-    TCPClient.open('localhost:1234', config) do |subject|
+    TCPClient.open("localhost:#{port}", config) do |subject|
       refute(subject.closed?)
       start_time = nil
       assert_raises(TCPClient::ReadTimeoutError) do
         start_time = Time.now
         subject.read(42, timeout: timeout)
       end
-      assert_in_delta(timeout, Time.now - start_time, 0.11)
+      assert_in_delta(timeout, Time.now - start_time, 0.15)
     end
   end
 
@@ -78,14 +82,14 @@ class TCPClientTest < MiniTest::Test
   end
 
   def check_write_timeout(timeout)
-    TCPClient.open('localhost:1234', config) do |subject|
+    TCPClient.open("localhost:#{port}", config) do |subject|
       refute(subject.closed?)
       start_time = nil
       assert_raises(TCPClient::WriteTimeoutError) do
         start_time = Time.now
         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
 
@@ -95,7 +99,7 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_write_deadline
-    TCPClient.open('localhost:1234', config) do |subject|
+    TCPClient.open("localhost:#{port}", config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::WriteTimeoutError) do
         subject.with_deadline(0.25) do |*args|
@@ -107,7 +111,7 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_read_deadline
-    TCPClient.open('localhost:1234', config) do |subject|
+    TCPClient.open("localhost:#{port}", config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::ReadTimeoutError) do
         subject.with_deadline(0.25) do |*args|
@@ -119,7 +123,7 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_read_write_deadline
-    TCPClient.open('localhost:1234', config) do |subject|
+    TCPClient.open("localhost:#{port}", config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::TimeoutError) do
         subject.with_deadline(0.25) do |*args|
@@ -137,9 +141,9 @@ class TCPClientTest < MiniTest::Test
     start_time = nil
     assert_raises(TCPClient::ConnectTimeoutError) do
       start_time = Time.now
-      TCPClient.new.connect('localhost:1234', ssl_config)
+      TCPClient.new.connect("localhost:#{port}", ssl_config)
     end
-    assert_in_delta(ssl_config.connect_timeout, Time.now - start_time, 0.11)
+    assert_in_delta(ssl_config.connect_timeout, Time.now - start_time, 0.25)
   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', 0)
+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.5
+  version: 0.3.2
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-12 00:00:00.000000000 Z
+date: 2021-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,7 +71,8 @@ files:
 - lib/tcp-client/address.rb
 - lib/tcp-client/configuration.rb
 - lib/tcp-client/default_configuration.rb
-- lib/tcp-client/mixin/io_timeout.rb
+- lib/tcp-client/errors.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 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.9
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: A TCP client implementation with working timeout support.

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

@@ -1,96 +0,0 @@
-IOTimeoutError = Class.new(IOError) unless defined?(IOTimeoutError)
-
-module IOTimeoutMixin
-  def self.included(mod)
-    im = mod.instance_methods
-    if im.index(:wait_writable) && im.index(:wait_readable)
-      mod.include(DeadlineMethods)
-    else
-      mod.include(DeadlineIO)
-    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
-    deadline = Time.now + timeout
-    read_all(nbytes) do |junk_size|
-      with_deadline(deadline, exception) do
-        read_nonblock(junk_size, exception: false)
-      end
-    end
-  end
-
-  def write(*msgs, timeout: nil, exception: IOTimeoutError)
-    timeout = timeout.to_f
-    return write_all(msgs.join.b) { |junk| super(junk) } if timeout <= 0
-    deadline = Time.now + timeout
-    write_all(msgs.join.b) do |junk|
-      with_deadline(deadline, exception) do
-        write_nonblock(junk, exception: false)
-      end
-    end
-  end
-
-  private
-
-  def read_all(nbytes)
-    return '' if nbytes.zero?
-    result = ''
-    loop do
-      unless read = yield(nbytes - result.bytesize)
-        close
-        return result
-      end
-      result += read
-      return result if result.bytesize >= nbytes
-    end
-  end
-
-  def write_all(data)
-    return 0 if (size = data.bytesize).zero?
-    result = 0
-    loop do
-      written = yield(data)
-      result += written
-      return result if result >= size
-      data = data.byteslice(written, data.bytesize - written)
-    end
-  end
-
-  module DeadlineMethods
-    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 DeadlineIO
-    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(:DeadlineMethods, :DeadlineIO)
-end