tcp-client 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ed9a12e8872f2399ace7bef72451c8f6b2d7821e4de069e095eb1ca7a5fcb96
-  data.tar.gz: 4b6b744fb885e99ea320cdfbfe21a9ff1aceaa12beedec2f2b068ceb3e932cd2
+  metadata.gz: a0318e4b31864c2b3f2b0af3e4d78f8d64b2d51b48eb2dd888d012583afd5f16
+  data.tar.gz: 5bf4683093179f1bf2a9c98ac0f208b401042b2303b8552bc98034dd138b5cb0
 SHA512:
-  metadata.gz: c4e7417600e74d3709a20b20f5d13804da51d0ff85670ca8a180bd173ae7f07ea513976c2b73c3436a852b5c51a1f6c99a61f917c4be769cd73cb91f9b65684a
-  data.tar.gz: 197b43ef8e44faec4a6bcd397f71505b3f8f4714a3775248eeaf2984acca4444bd5f8e290cc99be9408870f4a862f1c724cfadd55c114be12a4651027f7d7fd4
+  metadata.gz: d582c9da10d45d722a52621f205e471f0f280a5ad0bfe0b7dc3fbb2f019d3bbf9089fe9918fedf8661655c7b20c17d5586c869739f1323528c238c7f8b576f2e
+  data.tar.gz: 6d2507dc23e40951647c323ce6bf53be89952fc4d7177d1c4e17300625240937100968127c222b285af7ac117844717f2cd22696a5e0c70e068d9e66e98c507e

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/LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2017-2021, Mike Blumtritt. All rights reserved.
+Copyright (c) 2017-2025, 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:
@@ -26,3 +26,4 @@ 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

@@ -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/address.rb

@@ -100,10 +100,11 @@ class TCPClient
     # @return [Address] itself
     #
     def freeze
-      return super if frozen?
-      solve
-      @addrinfo.freeze
-      @host.freeze
+      unless frozen?
+        solve
+        @addrinfo.freeze
+        @host.freeze
+      end
       super
     end
 

data/lib/tcp-client/configuration.rb

@@ -43,7 +43,6 @@ class TCPClient
     #
     def initialize(options = nil)
       @buffered = @keep_alive = @reverse_lookup = true
-      self.timeout = @ssl_params = nil
       @connect_timeout_error = ConnectTimeoutError
       @read_timeout_error = ReadTimeoutError
       @write_timeout_error = WriteTimeoutError
@@ -107,7 +106,7 @@ class TCPClient
     def ssl_params=(value)
       @ssl_params =
         if value.respond_to?(:to_hash)
-          Hash[value.to_hash]
+          value.to_hash.dup
         elsif value.respond_to?(:to_h)
           value.nil? ? nil : value.to_h.dup
         else
@@ -336,7 +335,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/errors.rb

@@ -129,19 +129,4 @@ class TCPClient
     #
     def action = :write
   end
-
-  NoOpenSSL = NoOpenSSLError # @!visibility private
-  NoBlockGiven = NoBlockGivenError # @!visibility private
-  InvalidDeadLine = InvalidDeadLineError # @!visibility private
-  UnknownAttribute = UnknownAttributeError # @!visibility private
-  NotAnException = NotAnExceptionError # @!visibility private
-  NotConnected = NotConnectedError # @!visibility private
-  deprecate_constant(
-    :NoOpenSSL,
-    :NoBlockGiven,
-    :InvalidDeadLine,
-    :UnknownAttribute,
-    :NotAnException,
-    :NotConnected
-  )
 end

data/lib/tcp-client/ssl_socket.rb

@@ -13,13 +13,13 @@ class TCPClient
   class SSLSocket < ::OpenSSL::SSL::SSLSocket
     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)
@@ -53,6 +53,8 @@ class TCPClient
     CONTEXT_CACHE_MODE =
       ::OpenSSL::SSL::SSLContext::SESSION_CACHE_CLIENT |
         ::OpenSSL::SSL::SSLContext::SESSION_CACHE_NO_INTERNAL_STORE
+
+    private_constant(:CONTEXT_CACHE_MODE)
   end
 
   private_constant(:SSLSocket)

data/lib/tcp-client/tcp_socket.rb

@@ -8,24 +8,21 @@ class TCPClient
   class TCPSocket < ::Socket
     include WithDeadline
 
-    def initialize(address, configuration, deadline, exception)
-      super(address.addrinfo.ipv6? ? :INET6 : :INET, :STREAM)
+    def initialize(address, configuration, deadline)
+      addrinfo = address.addrinfo
+      super(addrinfo.ipv6? ? :INET6 : :INET, :STREAM)
       configure(configuration)
-      connect_to(as_addr_in(address), deadline, exception)
+      connect_to(
+        ::Socket.pack_sockaddr_in(addrinfo.ip_port, addrinfo.ip_address),
+        deadline
+      )
     end
 
     private
 
-    def as_addr_in(address)
-      addrinfo = address.addrinfo
-      ::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 = '1.0.0'
+  VERSION = '1.0.2'
 end

data/lib/tcp-client/with_deadline.rb

@@ -2,22 +2,22 @@
 
 class TCPClient
   module WithDeadline
-    def read_with_deadline(nbytes, deadline, exception)
-      raise(exception) unless deadline.remaining_time
-      return fetch_avail(deadline, exception) if nbytes.nil?
+    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, exception)
+      while (diff = nbytes - @read_buffer.bytesize) > 0
+        read = fetch_next(deadline, diff)
         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
+    def read_to_with_deadline(sep, deadline)
+      deadline.remaining_time
       @read_buffer ||= ''.b
       while (index = @read_buffer.index(sep)).nil?
-        read = fetch_next(deadline, exception)
+        read = fetch_next(deadline)
         read ? @read_buffer << read : (break close)
       end
       return fetch_slice(index + sep.bytesize) if index
@@ -26,15 +26,13 @@ class TCPClient
       result
     end
 
-    def write_with_deadline(data, deadline, exception)
+    def write_with_deadline(data, deadline)
       return 0 if (size = data.bytesize).zero?
-      raise(exception) unless deadline.remaining_time
+      deadline.remaining_time
       result = 0
       while true
         written =
-          with_deadline(deadline, exception) do
-            write_nonblock(data, exception: false)
-          end
+          with_deadline(deadline) { write_nonblock(data, exception: false) }
         return result if (result += written) >= size
         data = data.byteslice(written, data.bytesize - written)
       end
@@ -42,8 +40,8 @@ class TCPClient
 
     private
 
-    def fetch_avail(deadline, exception)
-      if (result = @read_buffer || fetch_next(deadline, exception)).nil?
+    def fetch_avail(deadline)
+      if (result = @read_buffer || fetch_next(deadline)).nil?
         close
         return ''.b
       end
@@ -59,27 +57,23 @@ class TCPClient
       result
     end
 
-    def fetch_next(deadline, exception)
-      with_deadline(deadline, exception) do
-        read_nonblock(65_536, exception: false)
-      end
+    def fetch_next(deadline, size = 65_536)
+      with_deadline(deadline) { read_nonblock(size, exception: false) }
     end
 
-    def with_deadline(deadline, exception)
+    def with_deadline(deadline)
       while true
         case ret = yield
         when :wait_writable
-          remaining_time = deadline.remaining_time or raise(exception)
-          wait_write[remaining_time] or raise(exception)
+          wait_write[deadline.remaining_time] or deadline.timed_out!
         when :wait_readable
-          remaining_time = deadline.remaining_time or raise(exception)
-          wait_read[remaining_time] or raise(exception)
+          wait_read[deadline.remaining_time] or deadline.timed_out!
         else
           return ret
         end
       end
     rescue Errno::ETIMEDOUT
-      raise(exception)
+      deadline.timed_out!
     end
 
     def wait_write

data/lib/tcp-client.rb

@@ -125,7 +125,7 @@ class TCPClient
   def close
     @socket&.close
     self
-  rescue *NETWORK_ERRORS
+  rescue *@@net_errors
     self
   ensure
     @socket = @deadline = nil
@@ -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,54 +300,62 @@ 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
+  rescue *@@net_errors => e
+    raise unless @configuration.normalize_network_errors
     except && e.is_a?(except) ? raise : raise(NetworkError, e)
   end
 
-  NETWORK_ERRORS =
-    [
-      Errno::EADDRNOTAVAIL,
-      Errno::ECONNABORTED,
-      Errno::ECONNREFUSED,
-      Errno::ECONNRESET,
-      Errno::EHOSTUNREACH,
-      Errno::EINVAL,
-      Errno::ENETUNREACH,
-      Errno::EPIPE,
-      IOError,
-      SocketError
-    ].tap do |errors|
-        errors << ::OpenSSL::SSL::SSLError if defined?(::OpenSSL::SSL::SSLError)
-      end
-      .freeze
-  private_constant(:NETWORK_ERRORS)
+  @@net_errors = [
+    Errno::EADDRNOTAVAIL,
+    Errno::ECONNABORTED,
+    Errno::ECONNREFUSED,
+    Errno::EHOSTUNREACH,
+    Errno::ENETUNREACH,
+    Errno::ECONNRESET,
+    Errno::EINVAL,
+    Errno::EPIPE,
+    Errno::EPERM,
+    SocketError,
+    IOError
+  ]
+  @@net_errors << ::OpenSSL::SSL::SSLError if defined?(::OpenSSL::SSL::SSLError)
+  @@net_errors.freeze
 end

metadata

@@ -1,21 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Mike Blumtritt
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-03 00:00:00.000000000 Z
+date: 2025-03-20 00:00:00.000000000 Z
 dependencies: []
 description: |
   This gem implements a customizable TCP client class that gives you control
   over time limits. You can set time limits for individual read or write calls
   or set a deadline for entire call sequences.
   It has a very small footprint, no dependencies and is easily useable.
-email:
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -44,7 +42,6 @@ metadata:
   bug_tracker_uri: https://github.com/mblumtritt/tcp-client/issues
   documentation_uri: https://rubydoc.info/gems/tcp-client
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -59,8 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 3.6.6
 specification_version: 4
 summary: Use your TCP connections with working timeout.
 test_files: []