tcp-client 0.2.3 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2791642003fb16623a27988401ff3bb532194032a5bbd4f62b853aae94790055
-  data.tar.gz: 030a2b3ebecf1334dea84e2c8f18aecd3b900c7c467c10c624c1354429a66195
+  metadata.gz: 4a9fe010bf08d26652d93212beee9ffe55275b3b051809a3093d2ff066719372
+  data.tar.gz: bf23f4441be6f32d581dfb069afb09bfbb8a9ca78b90f3e0f2332f16abed89e8
 SHA512:
-  metadata.gz: e4ef14d49cd323a418190e62bc190af01fcc9be1b7008b7fd27c8fa7b8779ae29947045a660080e9403ba1d932e1318a6f98c819006d816f91eb093caf6d7873
-  data.tar.gz: 29617e860ad0b419638b54a8258541ccf3c668530a38aa2e629badcb373b94df71c33e538d54faf12d732ffd51670e1ad57cc8fabcaac11bb2d4de3d28cd29b1
+  metadata.gz: c929de839e7335c4e8e950d0b96fb6028c74ba1ae6a1acec3bb4a572e54a6564d799a8ee8fdef51b77273a83a2af4c5cc29d66a4ed92c3647e1185e103d82fda
+  data.tar.gz: 00dacdc8d09584e1f4421c7ca62786ab617eaed1005db955ca36da4c1294738591820159d282d27e24fe3194d84e9cd5cb02b47966f231af5d5a26336bcfa366

data/.gitignore

@@ -1,4 +1,4 @@
-.local/
+local/
 tmp/
 pkg/
 gems.locked

data/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2017-2021, Mike Blumtritt. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -3,7 +3,8 @@
 A TCP client implementation with working timeout support.
 
 ## Description
-This gem implements a TCP client with (optional) SSL support. The motivation of this project is the need to have a _really working_ 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`).
+
+This Gem implements a TCP client with (optional) SSL support. It is an easy to use, versatile configurable client that can correctly handle time limits. Unlike other implementations, this client respects predefined/configurable time limits for each method (`connect`, `read`, `write`). Deadlines for a sequence of read/write actions can also be monitored.
 
 ## Sample
 
@@ -11,15 +12,15 @@ This gem implements a TCP client with (optional) SSL support. The motivation of
 require 'tcp-client'
 
 TCPClient.configure do |cfg|
-  cfg.connect_timeout = 1 # second to connect the server
+  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|
-  # query should not last longer than 0.5 seconds
+  # 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: google.com\r\n\r\n")
+    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)

data/lib/tcp-client.rb

@@ -2,6 +2,7 @@
 
 require_relative 'tcp-client/errors'
 require_relative 'tcp-client/address'
+require_relative 'tcp-client/deadline'
 require_relative 'tcp-client/tcp_socket'
 require_relative 'tcp-client/ssl_socket'
 require_relative 'tcp-client/configuration'
@@ -28,8 +29,8 @@ class TCPClient
   end
 
   def connect(addr, configuration, exception: nil)
+    raise(NoOpenSSL) if configuration.ssl? && !defined?(SSLSocket)
     close
-    NoOpenSSL.raise! if configuration.ssl? && !defined?(SSLSocket)
     @address = Address.new(addr)
     @cfg = configuration.dup
     exception ||= configuration.connect_timeout_error
@@ -54,31 +55,30 @@ class TCPClient
 
   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
+    raise(NoBlockGiven) unless block_given?
+    @deadline = Deadline.new(timeout)
+    raise(InvalidDeadLine, timeout) unless @deadline.valid?
     yield(self)
   ensure
     @deadline = previous_deadline
   end
 
   def read(nbytes, timeout: nil, exception: nil)
-    NotConnected.raise! if closed?
+    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)
+    deadline = Deadline.new(timeout || @cfg.read_timeout)
+    return @socket.read(nbytes) unless deadline.valid?
+    read_with_deadline(nbytes, deadline, exception)
   end
 
   def write(*msg, timeout: nil, exception: nil)
-    NotConnected.raise! if closed?
+    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)
+    deadline = Deadline.new(timeout || @cfg.read_timeout)
+    return @socket.write(*msg) unless deadline.valid?
+    write_with_deadline(msg, deadline, exception)
   end
 
   def flush
@@ -89,19 +89,14 @@ class TCPClient
   private
 
   def read_with_deadline(nbytes, deadline, exception)
-    @socket.read_with_deadline(
-      nbytes,
-      deadline,
-      exception || @cfg.read_timeout_error
-    )
+    exception ||= @cfg.read_timeout_error
+    @socket.read_with_deadline(nbytes, deadline, exception)
   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)
+    msg.sum do |chunk|
+      @socket.write_with_deadline(chunk.b, deadline, exception)
     end
-    result
   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
@@ -58,8 +58,7 @@ 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] == ']'
+      name = str[0, idx].delete_prefix('[').delete_suffix(']')
       [name, str[idx + 1, str.size - idx].to_i]
     end
   end

data/lib/tcp-client/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'errors'
 
 class TCPClient
@@ -11,7 +13,6 @@ class TCPClient
     attr_reader :buffered,
                 :keep_alive,
                 :reverse_lookup,
-                :timeout,
                 :connect_timeout,
                 :read_timeout,
                 :write_timeout,
@@ -45,9 +46,12 @@ class TCPClient
     end
 
     def ssl=(value)
-      return @ssl_params = nil unless value
-      return @ssl_params = value.dup if Hash === value
-      @ssl_params ||= {}
+      @ssl_params =
+        if Hash === value
+          value.dup
+        else
+          value ? {} : nil
+        end
     end
 
     def buffered=(value)
@@ -63,8 +67,7 @@ class TCPClient
     end
 
     def timeout=(seconds)
-      @timeout =
-        @connect_timeout = @write_timeout = @read_timeout = seconds(seconds)
+      @connect_timeout = @write_timeout = @read_timeout = seconds(seconds)
     end
 
     def connect_timeout=(seconds)
@@ -80,23 +83,23 @@ class TCPClient
     end
 
     def timeout_error=(exception)
-      NotAnException.raise!(exception) unless exception_class?(exception)
+      raise(NotAnException, exception) unless exception_class?(exception)
       @connect_timeout_error =
         @read_timeout_error = @write_timeout_error = exception
     end
 
     def connect_timeout_error=(exception)
-      NotAnException.raise!(exception) unless exception_class?(exception)
+      raise(NotAnException, exception) unless exception_class?(exception)
       @connect_timeout_error = exception
     end
 
     def read_timeout_error=(exception)
-      NotAnException.raise!(exception) unless exception_class?(exception)
+      raise(NotAnException, exception) unless exception_class?(exception)
       @read_timeout_error = exception
     end
 
     def write_timeout_error=(exception)
-      NotAnException.raise!(exception) unless exception_class?(exception)
+      raise(NotAnException, exception) unless exception_class?(exception)
       @write_timeout_error = exception
     end
 
@@ -105,7 +108,6 @@ class TCPClient
         buffered: @buffered,
         keep_alive: @keep_alive,
         reverse_lookup: @reverse_lookup,
-        timeout: @timeout,
         connect_timeout: @connect_timeout,
         read_timeout: @read_timeout,
         write_timeout: @write_timeout,
@@ -134,7 +136,7 @@ class TCPClient
     def set(attribute, value)
       public_send("#{attribute}=", value)
     rescue NoMethodError
-      UnknownAttribute.raise!(attribute)
+      raise(UnknownAttribute, attribute)
     end
 
     def seconds(value)

data/lib/tcp-client/deadline.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class TCPClient
+  class Deadline
+    MONOTONIC = !!defined?(Process::CLOCK_MONOTONIC)
+
+    def initialize(timeout)
+      timeout = timeout&.to_f
+      @deadline = timeout&.positive? ? now + timeout : 0
+    end
+
+    def valid?
+      @deadline != 0
+    end
+
+    def remaining_time
+      (@deadline != 0) && (remaining = @deadline - now) > 0 ? remaining : nil
+    end
+
+    private
+
+    if MONOTONIC
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    else
+      def now
+        ::Time.now
+      end
+    end
+  end
+end

data/lib/tcp-client/default_configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'configuration'
 
 class TCPClient

data/lib/tcp-client/errors.rb

@@ -1,48 +1,69 @@
 # frozen_string_literal: true
 
-require 'socket'
-
 class TCPClient
   class NoOpenSSL < RuntimeError
-    def self.raise!
-      raise(self, 'OpenSSL is not avail', caller(1))
+    def initialize
+      super('OpenSSL is not available')
     end
   end
 
-  class NoBlockGiven < RuntimeError
-    def self.raise!
-      raise(self, 'no block given', caller(1))
+  class NoBlockGiven < ArgumentError
+    def initialize
+      super('no block given')
     end
   end
 
   class InvalidDeadLine < ArgumentError
-    def self.raise!(timeout)
-      raise(self, "invalid deadline - #{timeout}", caller(1))
+    def initialize(timeout)
+      super("invalid deadline - #{timeout}")
     end
   end
 
   class UnknownAttribute < ArgumentError
-    def self.raise!(attribute)
-      raise(self, "unknown attribute - #{attribute}", caller(1))
+    def initialize(attribute)
+      super("unknown attribute - #{attribute}")
     end
   end
 
   class NotAnException < TypeError
-    def self.raise!(object)
-      raise(self, "not a valid exception class - #{object.inspect}", caller(1))
+    def initialize(object)
+      super("exception class required - #{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 NotConnected < SocketError
-    def self.raise!
-      raise(self, 'client not connected', caller(1))
+  class ConnectTimeoutError < TimeoutError
+    def action
+      :connect
     end
   end
 
-  TimeoutError = Class.new(IOError)
-  ConnectTimeoutError = Class.new(TimeoutError)
-  ReadTimeoutError = Class.new(TimeoutError)
-  WriteTimeoutError = Class.new(TimeoutError)
+  class ReadTimeoutError < TimeoutError
+    def action
+      :read
+    end
+  end
+
+  class WriteTimeoutError < TimeoutError
+    def action
+      :write
+    end
+  end
 
   Timeout = TimeoutError # backward compatibility
   deprecate_constant(:Timeout)

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

@@ -1,38 +1,37 @@
+# frozen_string_literal: true
+
 module IOWithDeadlineMixin
   def self.included(mod)
-    im = mod.instance_methods
-    if im.index(:wait_writable) && im.index(:wait_readable)
+    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(nbytes, deadline, exclass)
-    raise(exclass) if Time.now > deadline
+  def read_with_deadline(bytes_to_read, deadline, exception)
+    raise(exception) unless deadline.remaining_time
     result = ''.b
-    return result if nbytes.zero?
-    loop do
+    while result.bytesize < bytes_to_read
       read =
-        with_deadline(deadline, exclass) do
-          read_nonblock(nbytes - result.bytesize, exception: false)
+        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 >= nbytes
+      next result += read if read
+      close
+      break
     end
+    result
   end
 
-  def write_with_deadline(data, deadline, exclass)
-    raise(exclass) if Time.now > deadline
+  def write_with_deadline(data, deadline, exception)
+    raise(exception) unless deadline.remaining_time
     return 0 if (size = data.bytesize).zero?
     result = 0
     loop do
       written =
-        with_deadline(deadline, exclass) do
+        with_deadline(deadline, exception) do
           write_nonblock(data, exception: false)
         end
       result += written
@@ -42,40 +41,40 @@ module IOWithDeadlineMixin
   end
 
   module ViaWaitMethod
-    private def with_deadline(deadline, exclass)
+    private def with_deadline(deadline, exception)
       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?
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) 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?
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) if wait_readable(remaining_time).nil?
         else
           return ret
         end
       end
     rescue Errno::ETIMEDOUT
-      raise(exclass)
+      raise(exception)
     end
   end
 
   module ViaSelect
-    private def with_deadline(deadline, exclass)
+    private def with_deadline(deadline, exception)
       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?
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) 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?
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) if ::IO.select([self], nil, nil, remaining_time).nil?
         else
           return ret
         end
       end
     rescue Errno::ETIMEDOUT
-      raise(exclass)
+      raise(exception)
     end
   end
 

data/lib/tcp-client/ssl_socket.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 begin
   require 'openssl'
 rescue LoadError
   return
 end
 
+require_relative 'deadline'
 require_relative 'mixin/io_with_deadline'
 
 class TCPClient
@@ -13,33 +16,27 @@ class TCPClient
     def initialize(socket, address, configuration, exception)
       ssl_params = Hash[configuration.ssl_params]
       super(socket, create_context(ssl_params))
-      connect_to(
-        address,
-        ssl_params[:verify_mode] != OpenSSL::SSL::VERIFY_NONE,
-        configuration.connect_timeout,
-        exception
-      )
+      self.sync_close = true
+      self.hostname = address.hostname
+      deadline = Deadline.new(configuration.connect_timeout)
+      deadline.valid? ? connect_with_deadline(deadline, exception) : connect
+      post_connection_check(address.hostname) if should_verify?(ssl_params)
     end
 
     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
-      timeout = timeout.to_f
-      if timeout.zero?
-        connect
-      else
-        with_deadline(Time.now + timeout, exception) do
-          connect_nonblock(exception: false)
-        end
-      end
-      post_connection_check(address.hostname) if check
+    def connect_with_deadline(deadline, exception)
+      with_deadline(deadline, exception) { connect_nonblock(exception: false) }
+    end
+
+    def should_verify?(ssl_params)
+      ssl_params[:verify_mode] != OpenSSL::SSL::VERIFY_NONE
     end
   end
 

data/lib/tcp-client/tcp_socket.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'socket'
+require_relative 'deadline'
 require_relative 'mixin/io_with_deadline'
 
 class TCPClient
@@ -8,20 +11,20 @@ class TCPClient
     def initialize(address, configuration, exception)
       super(address.addrinfo.ipv6? ? :INET6 : :INET, :STREAM)
       configure(configuration)
-      connect_to(address, configuration.connect_timeout, exception)
+      deadline = Deadline.new(configuration.connect_timeout)
+      connect_to(address, deadline, exception)
     end
 
     private
 
-    def connect_to(address, timeout, exception)
+    def connect_to(address, deadline, exception)
       addr =
         ::Socket.pack_sockaddr_in(
           address.addrinfo.ip_port,
           address.addrinfo.ip_address
         )
-      timeout = timeout.to_f
-      return connect(addr) if timeout.zero?
-      with_deadline(Time.now + timeout, exception) do
+      return connect(addr) unless deadline.valid?
+      with_deadline(deadline, exception) do
         connect_nonblock(addr, exception: false)
       end
     end

data/lib/tcp-client/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class TCPClient
-  VERSION = '0.2.3'.freeze
+  VERSION = '0.4.1'
 end

data/rakefile.rb

@@ -11,7 +11,6 @@ CLOBBER << 'prj'
 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
+  task.pattern = 'test/**/*_test.rb'
+  task.warning = task.verbose = true
 end

data/sample/google.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../lib/tcp-client'
 
 TCPClient.configure(
@@ -6,15 +8,14 @@ TCPClient.configure(
   read_timeout: 0.5 # seconds to read some bytes
 )
 
-# the following request sequence is not allowed
-# to last longer than 1.25 seconds:
+# 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
 
 TCPClient.open('www.google.com:80') do |client|
   # simple HTTP get request
-  pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
+  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)

data/sample/google_ssl.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 require_relative '../lib/tcp-client'
 
 TCPClient.configure do |cfg|
-  cfg.connect_timeout = 1 # second to connect the server
+  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|
-  # query should not last longer than 0.5 seconds
+  # 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: google.com\r\n\r\n")
+    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)

data/tcp-client.gemspec

@@ -11,11 +11,13 @@ GemSpec = Gem::Specification.new do |spec|
 
   spec.summary = 'A TCP client implementation with working timeout support.'
   spec.description = <<~DESCRIPTION
-    This gem implements a TCP client with (optional) SSL support. The
-    motivation of this project is the need to have a _really working_
-    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`).
+    This Gem implements a TCP client with (optional) SSL support.
+    It is an easy to use, versatile configurable client that can correctly
+    handle time limits.
+    Unlike other implementations, this client respects
+    predefined/configurable time limits for each method
+    (`connect`, `read`, `write`). Deadlines for a sequence of read/write
+    actions can also be monitored.
   DESCRIPTION
   spec.homepage = 'https://github.com/mblumtritt/tcp-client'
 

data/test/tcp-client/address_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
 class AddressTest < MiniTest::Test

data/test/tcp-client/configuration_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
 class ConfigurationTest < MiniTest::Test

data/test/tcp-client/deadline_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+
+class Deadlineest < MiniTest::Test
+  parallelize_me!
+
+  def test_validity
+    assert(TCPClient::Deadline.new(1).valid?)
+    assert(TCPClient::Deadline.new(0.0001).valid?)
+
+    refute(TCPClient::Deadline.new(0).valid?)
+    refute(TCPClient::Deadline.new(nil).valid?)
+  end
+
+  def test_remaining_time
+    assert(TCPClient::Deadline.new(1).remaining_time > 0)
+
+    assert_nil(TCPClient::Deadline.new(0).remaining_time)
+    assert_nil(TCPClient::Deadline.new(nil).remaining_time)
+
+    deadline = TCPClient::Deadline.new(0.2)
+    sleep(0.2)
+    assert_nil(deadline.remaining_time)
+  end
+end

data/test/tcp-client/version_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
 class VersionTest < MiniTest::Test

data/test/tcp_client_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'test_helper'
 
 class TCPClientTest < MiniTest::Test
@@ -11,6 +13,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 +49,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,7 +66,7 @@ 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
@@ -78,7 +84,7 @@ 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
@@ -95,7 +101,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 +113,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|
@@ -118,8 +124,8 @@ class TCPClientTest < MiniTest::Test
     end
   end
 
-  def xtest_read_write_deadline
-    TCPClient.open('localhost:1234', config) do |subject|
+  def test_read_write_deadline
+    TCPClient.open("localhost:#{port}", config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::TimeoutError) do
         subject.with_deadline(0.25) do |*args|
@@ -137,9 +143,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

@@ -5,5 +5,5 @@ require 'minitest/parallel'
 require_relative '../lib/tcp-client'
 
 # this pseudo-server never reads or writes anything
-PseudoServer = TCPServer.new('localhost', 1234)
+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.2.3
+  version: 0.4.1
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-19 00:00:00.000000000 Z
+date: 2021-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,11 +53,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: |
-  This gem implements a TCP client with (optional) SSL support. The
-  motivation of this project is the need to have a _really working_
-  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`).
+  This Gem implements a TCP client with (optional) SSL support.
+  It is an easy to use, versatile configurable client that can correctly
+  handle time limits.
+  Unlike other implementations, this client respects
+  predefined/configurable time limits for each method
+  (`connect`, `read`, `write`). Deadlines for a sequence of read/write
+  actions can also be monitored.
 email:
 executables: []
 extensions: []
@@ -65,14 +67,15 @@ extra_rdoc_files:
 - README.md
 files:
 - ".gitignore"
+- LICENSE
 - README.md
 - gems.rb
 - lib/tcp-client.rb
 - lib/tcp-client/address.rb
 - lib/tcp-client/configuration.rb
+- lib/tcp-client/deadline.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
@@ -84,6 +87,7 @@ files:
 - tcp-client.gemspec
 - test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
+- test/tcp-client/deadline_test.rb
 - test/tcp-client/default_configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb
@@ -108,13 +112,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: A TCP client implementation with working timeout support.
 test_files:
 - test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
+- test/tcp-client/deadline_test.rb
 - test/tcp-client/default_configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb

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

@@ -1,118 +0,0 @@
-# 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
-  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_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
-    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 ''.b if nbytes.zero?
-    result = ''.b
-    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