tcp-client 0.14.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9cfd60cce36d13e734e17197f76d5d887eae87f9b4ec08ef00a43d6ea5d8d5a
-  data.tar.gz: ff17c9f4cb54ae7a6d00d888c34e45077b17c8225e26d1695854587ecb01f3dc
+  metadata.gz: f087df088e9bdfc71ffd19b01d3f9f7a229f4db510a339a08ea7d02c07a32eda
+  data.tar.gz: 4b4d332dcdeb98a2bc81f3e7963973da21336e5b2d89199bfc9b0d2c92c9b122
 SHA512:
-  metadata.gz: d2c03a28cc57eba3b3468ed911ac24bb7a24279bbe80d6ddea6fca8a65848b5079c409d968599348476e041e04ff891196a90014ce5cee19e5204fdfad78ed15
-  data.tar.gz: 68551bdbc6e978368cf615c2d68d078ceb20b8857fdd6451efba921efdf37bc25732e366d246126bb42006bffa50fa60540f30b3390f635080c99116b296f575
+  metadata.gz: f0c31448b596bc77288424a2863528714db40576f7201f2927172d0c39cac4086fe976a315347d6da78a96ca022a33e31956533caa02c025b18b7b3e3129d97d
+  data.tar.gz: 69dd0aa063a8019c07976b6942f0d08df0f31036eb903040e63cfdc40844c0275396a879a2e7f27332ad9843b2a2ba4326fbccabee3d12e1a3b31a587cb5ba9a

data/.yardopts

@@ -2,4 +2,9 @@
 --title 'tcp-client Documentation'
 --charset utf-8
 --markup markdown
-'lib/**/*.rb' - 'README.md' 'LICENSE'
+--tag comment
+--hide-tag comment
+lib/**/*.rb
+-
+README.md
+LICENSE

data/README.md

@@ -54,7 +54,7 @@ gem install tcp-client
 You can use [Bundler](http://gembundler.com/) to add TCPClient to your own project:
 
 ```shell
-bundle add 'tcp-client'
+bundle add tcp-client
 ```
 
 After that you only need one line of code to have everything together

data/lib/tcp-client/configuration.rb

@@ -336,7 +336,7 @@ class TCPClient
 
     private
 
-    def as_seconds(value) = value&.to_f&.positive? ? value : nil
+    def as_seconds(value) = value.to_f.positive? ? value : nil
 
     def as_exception(value)
       return value if value.is_a?(Class) && value < Exception

data/lib/tcp-client/deadline.rb

@@ -2,15 +2,26 @@
 
 class TCPClient
   class Deadline
-    def initialize(timeout)
-      timeout = timeout&.to_f
-      @deadline = timeout&.positive? ? now + timeout : nil
+    attr_accessor :exception
+
+    def initialize(timeout, exception)
+      @timeout = timeout.to_f
+      @exception = exception
+      @deadline = @timeout.positive? ? now + @timeout : nil
     end
 
     def valid? = !@deadline.nil?
 
     def remaining_time
-      @deadline && (remaining = @deadline - now) > 0 ? remaining : nil
+      (remaining = @deadline - now) > 0 ? remaining : timed_out!(caller(1))
+    end
+
+    def timed_out!(call_stack = nil)
+      raise(
+        @exception,
+        "execution expired - #{@timeout} seconds",
+        call_stack || caller(1)
+      )
     end
 
     private

data/lib/tcp-client/ssl_socket.rb

@@ -7,19 +7,19 @@ rescue LoadError
 end
 
 require_relative 'deadline'
-require_relative 'mixin/io_with_deadline'
+require_relative 'with_deadline'
 
 class TCPClient
   class SSLSocket < ::OpenSSL::SSL::SSLSocket
-    include IOWithDeadlineMixin
+    include WithDeadline
 
-    def initialize(socket, address, configuration, deadline, exception)
+    def initialize(socket, address, configuration, deadline)
       ssl_params = Hash[configuration.ssl_params]
       super(socket, create_context(ssl_params))
       self.sync_close = true
       self.hostname = address.hostname
       check_new_session if @new_session
-      deadline.valid? ? connect_with_deadline(deadline, exception) : connect
+      deadline.valid? ? connect_with_deadline(deadline) : connect
       post_connection_check(address.hostname) if should_verify?(ssl_params)
     end
 
@@ -41,8 +41,8 @@ class TCPClient
       end
     end
 
-    def connect_with_deadline(deadline, exception)
-      with_deadline(deadline, exception) { connect_nonblock(exception: false) }
+    def connect_with_deadline(deadline)
+      with_deadline(deadline) { connect_nonblock(exception: false) }
     end
 
     def should_verify?(ssl_params)

data/lib/tcp-client/tcp_socket.rb

@@ -2,16 +2,16 @@
 
 require 'socket'
 require_relative 'deadline'
-require_relative 'mixin/io_with_deadline'
+require_relative 'with_deadline'
 
 class TCPClient
   class TCPSocket < ::Socket
-    include IOWithDeadlineMixin
+    include WithDeadline
 
-    def initialize(address, configuration, deadline, exception)
+    def initialize(address, configuration, deadline)
       super(address.addrinfo.ipv6? ? :INET6 : :INET, :STREAM)
       configure(configuration)
-      connect_to(as_addr_in(address), deadline, exception)
+      connect_to(as_addr_in(address), deadline)
     end
 
     private
@@ -21,11 +21,9 @@ class TCPClient
       ::Socket.pack_sockaddr_in(addrinfo.ip_port, addrinfo.ip_address)
     end
 
-    def connect_to(addr, deadline, exception)
+    def connect_to(addr, deadline)
       return connect(addr) unless deadline.valid?
-      with_deadline(deadline, exception) do
-        connect_nonblock(addr, exception: false)
-      end
+      with_deadline(deadline) { connect_nonblock(addr, exception: false) }
     end
 
     def configure(configuration)

data/lib/tcp-client/version.rb

@@ -2,5 +2,5 @@
 
 class TCPClient
   # The current version number.
-  VERSION = '0.14.0'
+  VERSION = '1.0.1'
 end

data/lib/tcp-client/with_deadline.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+class TCPClient
+  module WithDeadline
+    def read_with_deadline(nbytes, deadline)
+      deadline.remaining_time
+      return fetch_avail(deadline) if nbytes.nil?
+      @read_buffer ||= ''.b
+      while @read_buffer.bytesize < nbytes
+        read = fetch_next(deadline)
+        read ? @read_buffer << read : (break close)
+      end
+      fetch_slice(nbytes)
+    end
+
+    def read_to_with_deadline(sep, deadline)
+      deadline.remaining_time
+      @read_buffer ||= ''.b
+      while (index = @read_buffer.index(sep)).nil?
+        read = fetch_next(deadline)
+        read ? @read_buffer << read : (break close)
+      end
+      return fetch_slice(index + sep.bytesize) if index
+      result = @read_buffer
+      @read_buffer = nil
+      result
+    end
+
+    def write_with_deadline(data, deadline)
+      return 0 if (size = data.bytesize).zero?
+      deadline.remaining_time
+      result = 0
+      while true
+        written =
+          with_deadline(deadline) { write_nonblock(data, exception: false) }
+        return result if (result += written) >= size
+        data = data.byteslice(written, data.bytesize - written)
+      end
+    end
+
+    private
+
+    def fetch_avail(deadline)
+      if (result = @read_buffer || fetch_next(deadline)).nil?
+        close
+        return ''.b
+      end
+      @read_buffer = nil
+      result
+    end
+
+    def fetch_slice(size)
+      return ''.b if size <= 0
+      result = @read_buffer.byteslice(0, size)
+      rest = @read_buffer.bytesize - result.bytesize
+      @read_buffer = rest.zero? ? nil : @read_buffer.byteslice(size, rest)
+      result
+    end
+
+    def fetch_next(deadline)
+      with_deadline(deadline) { read_nonblock(65_536, exception: false) }
+    end
+
+    def with_deadline(deadline)
+      while true
+        case ret = yield
+        when :wait_writable
+          wait_write[deadline.remaining_time] or deadline.timed_out!
+        when :wait_readable
+          wait_read[deadline.remaining_time] or deadline.timed_out!
+        else
+          return ret
+        end
+      end
+    rescue Errno::ETIMEDOUT
+      deadline.timed_out!
+    end
+
+    def wait_write
+      @wait_write ||=
+        if defined?(wait_writable)
+          ->(t) { wait_writable(t) }
+        elsif defined?(to_io)
+          ->(t) { to_io.wait_writable(t) }
+        else
+          ->(t) { ::IO.select(nil, [self], nil, t) }
+        end
+    end
+
+    def wait_read
+      @wait_read ||=
+        if defined?(wait_readable)
+          ->(t) { wait_readable(t) }
+        elsif defined?(to_io)
+          ->(t) { to_io.wait_readable(t) }
+        else
+          ->(t) { ::IO.select([self], nil, nil, t) }
+        end
+    end
+  end
+
+  private_constant(:WithDeadline)
+end

data/lib/tcp-client.rb

@@ -192,11 +192,15 @@ class TCPClient
   #
   def read(nbytes = nil, timeout: nil, exception: nil)
     raise(NotConnectedError) if closed?
-    deadline = create_deadline(timeout, configuration.read_timeout)
+    deadline =
+      create_deadline(
+        timeout,
+        @configuration.read_timeout,
+        exception || @configuration.read_timeout_error
+      )
     return stem_errors { @socket.read(nbytes) } unless deadline.valid?
-    exception ||= configuration.read_timeout_error
-    stem_errors(exception) do
-      @socket.read_with_deadline(nbytes, deadline, exception)
+    stem_errors(deadline.exception) do
+      @socket.read_with_deadline(nbytes, deadline)
     end
   end
 
@@ -221,13 +225,17 @@ class TCPClient
   #
   def readline(separator = $/, chomp: false, timeout: nil, exception: nil)
     raise(NotConnectedError) if closed?
-    deadline = create_deadline(timeout, configuration.read_timeout)
+    deadline =
+      create_deadline(
+        timeout,
+        @configuration.read_timeout,
+        exception || @configuration.read_timeout_error
+      )
     deadline.valid? or
       return stem_errors { @socket.readline(separator, chomp: chomp) }
-    exception ||= configuration.read_timeout_error
     line =
-      stem_errors(exception) do
-        @socket.read_to_with_deadline(separator, deadline, exception)
+      stem_errors(deadline.exception) do
+        @socket.read_to_with_deadline(separator, deadline)
       end
     chomp ? line.chomp : line
   end
@@ -265,7 +273,7 @@ class TCPClient
   def with_deadline(timeout)
     previous_deadline = @deadline
     raise(NoBlockGivenError) unless block_given?
-    @deadline = Deadline.new(timeout)
+    @deadline = Deadline.new(timeout, TimeoutError)
     raise(InvalidDeadLineError, timeout) unless @deadline.valid?
     yield(self)
   ensure
@@ -292,36 +300,46 @@ class TCPClient
   #
   def write(*messages, timeout: nil, exception: nil)
     raise(NotConnectedError) if closed?
-    deadline = create_deadline(timeout, configuration.write_timeout)
+    deadline =
+      create_deadline(
+        timeout,
+        @configuration.write_timeout,
+        exception || @configuration.write_timeout_error
+      )
     return stem_errors { @socket.write(*messages) } unless deadline.valid?
-    exception ||= configuration.write_timeout_error
-    stem_errors(exception) do
-      messages.sum do |chunk|
-        @socket.write_with_deadline(chunk.b, deadline, exception)
-      end
+    stem_errors(deadline.exception) do
+      messages.sum { |chunk| @socket.write_with_deadline(chunk.b, deadline) }
     end
   end
 
   private
 
-  def create_deadline(timeout, default)
-    timeout.nil? && @deadline ? @deadline : Deadline.new(timeout || default)
+  def create_deadline(timeout, timeout_default, exception)
+    if timeout.nil? && @deadline
+      @deadline.exception = exception
+      return @deadline
+    end
+    Deadline.new(timeout || timeout_default, exception)
   end
 
   def create_socket(timeout, exception)
-    deadline = create_deadline(timeout, configuration.connect_timeout)
-    exception ||= configuration.connect_timeout_error
-    stem_errors(exception) do
-      @socket = TCPSocket.new(address, configuration, deadline, exception)
-      return @socket unless configuration.ssl?
-      SSLSocket.new(@socket, address, configuration, deadline, exception)
+    deadline =
+      create_deadline(
+        timeout,
+        @configuration.connect_timeout,
+        exception || @configuration.connect_timeout_error
+      )
+    stem_errors(deadline.exception) do
+      @socket = TCPSocket.new(address, @configuration, deadline)
+      return @socket unless @configuration.ssl?
+      SSLSocket.new(@socket, address, @configuration, deadline)
     end
   end
 
   def stem_errors(except = nil)
     yield
   rescue *NETWORK_ERRORS => e
-    raise unless configuration.normalize_network_errors
+    raise unless @configuration.normalize_network_errors
     except && e.is_a?(except) ? raise : raise(NetworkError, e)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-09 00:00:00.000000000 Z
+date: 2024-05-12 00:00:00.000000000 Z
 dependencies: []
 description: |
   This gem implements a customizable TCP client class that gives you control
@@ -31,10 +31,10 @@ files:
 - lib/tcp-client/deadline.rb
 - lib/tcp-client/default_configuration.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
+- lib/tcp-client/with_deadline.rb
 - lib/tcp_client.rb
 homepage: https://github.com/mblumtritt/tcp-client
 licenses:
@@ -59,7 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
 summary: Use your TCP connections with working timeout.

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-class TCPClient
-  module IOWithDeadlineMixin
-    class << self
-      private
-
-      def included(mod)
-        return if defined?(mod.wait_writable) && defined?(mod.wait_readable)
-        mod.include(defined?(mod.to_io) ? WaitWithIO : WaitWithSelect)
-      end
-    end
-
-    def read_with_deadline(nbytes, deadline, exception)
-      raise(exception) unless deadline.remaining_time
-      return fetch_avail(deadline, exception) if nbytes.nil?
-      @read_buffer ||= ''.b
-      while @read_buffer.bytesize < nbytes
-        read = fetch_next(deadline, exception)
-        read ? @read_buffer << read : (break close)
-      end
-      fetch_slice(nbytes)
-    end
-
-    def read_to_with_deadline(sep, deadline, exception)
-      raise(exception) unless deadline.remaining_time
-      @read_buffer ||= ''.b
-      while (index = @read_buffer.index(sep)).nil?
-        read = fetch_next(deadline, exception)
-        read ? @read_buffer << read : (break close)
-      end
-      return fetch_slice(index + sep.bytesize) if index
-      result = @read_buffer
-      @read_buffer = nil
-      result
-    end
-
-    def write_with_deadline(data, deadline, exception)
-      return 0 if (size = data.bytesize).zero?
-      raise(exception) unless deadline.remaining_time
-      result = 0
-      while true
-        written =
-          with_deadline(deadline, exception) do
-            write_nonblock(data, exception: false)
-          end
-        return result if (result += written) >= size
-        data = data.byteslice(written, data.bytesize - written)
-      end
-    end
-
-    private
-
-    def fetch_avail(deadline, exception)
-      if (result = @read_buffer || fetch_next(deadline, exception)).nil?
-        close
-        return ''.b
-      end
-      @read_buffer = nil
-      result
-    end
-
-    def fetch_slice(size)
-      return ''.b if size <= 0
-      result = @read_buffer.byteslice(0, size)
-      rest = @read_buffer.bytesize - result.bytesize
-      @read_buffer = rest.zero? ? nil : @read_buffer.byteslice(size, rest)
-      result
-    end
-
-    def fetch_next(deadline, exception)
-      with_deadline(deadline, exception) do
-        read_nonblock(65_536, exception: false)
-      end
-    end
-
-    def with_deadline(deadline, exception)
-      while true
-        case ret = yield
-        when :wait_writable
-          remaining_time = deadline.remaining_time or raise(exception)
-          wait_writable(remaining_time) or raise(exception)
-        when :wait_readable
-          remaining_time = deadline.remaining_time or raise(exception)
-          wait_readable(remaining_time) or raise(exception)
-        else
-          return ret
-        end
-      end
-    rescue Errno::ETIMEDOUT
-      raise(exception)
-    end
-
-    module WaitWithIO
-      def wait_writable(time) = to_io.wait_writable(time)
-      def wait_readable(time) = to_io.wait_readable(time)
-    end
-
-    module WaitWithSelect
-      def wait_writable(time) = ::IO.select(nil, [self], nil, time)
-      def wait_readable(time) = ::IO.select([self], nil, nil, time)
-    end
-
-    private_constant(:WaitWithIO, :WaitWithSelect)
-  end
-
-  private_constant(:IOWithDeadlineMixin)
-end