tcp-client 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ed9a12e8872f2399ace7bef72451c8f6b2d7821e4de069e095eb1ca7a5fcb96
-  data.tar.gz: 4b6b744fb885e99ea320cdfbfe21a9ff1aceaa12beedec2f2b068ceb3e932cd2
+  metadata.gz: f087df088e9bdfc71ffd19b01d3f9f7a229f4db510a339a08ea7d02c07a32eda
+  data.tar.gz: 4b4d332dcdeb98a2bc81f3e7963973da21336e5b2d89199bfc9b0d2c92c9b122
 SHA512:
-  metadata.gz: c4e7417600e74d3709a20b20f5d13804da51d0ff85670ca8a180bd173ae7f07ea513976c2b73c3436a852b5c51a1f6c99a61f917c4be769cd73cb91f9b65684a
-  data.tar.gz: 197b43ef8e44faec4a6bcd397f71505b3f8f4714a3775248eeaf2984acca4444bd5f8e290cc99be9408870f4a862f1c724cfadd55c114be12a4651027f7d7fd4
+  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

@@ -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)

data/lib/tcp-client/tcp_socket.rb

@@ -8,10 +8,10 @@ class TCPClient
   class TCPSocket < ::Socket
     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 = '1.0.0'
+  VERSION = '1.0.1'
 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)
+        read = fetch_next(deadline)
         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)
+      with_deadline(deadline) { read_nonblock(65_536, 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

@@ -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: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-03 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
@@ -59,7 +59,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.10
 signing_key:
 specification_version: 4
 summary: Use your TCP connections with working timeout.