tcp-client 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4738c2c07c1163d9a991fa08978d148ebdee182193a90103ecba277cd783f4b3
-  data.tar.gz: a69ecf05054b5260ab9a324226d5d0a592e337a09a68865c4702e37f4a948a4a
+  metadata.gz: 404b30eadc3a1f6f255257328ad49b1cd0827bd502f86e08d283bb94a1ab6447
+  data.tar.gz: e4825578860b8b74ae180988beecf1faef75230e456e20da9a5ce86baa4c729e
 SHA512:
-  metadata.gz: 8c348cb8696ab9fec32321499b4fa62f169ce5b62e4d703df009a7762cd40e9c6e9cbe22c52affce4a493f4d473907f6b051a74e2a46e9de9ff5fc13d24bdd24
-  data.tar.gz: 40d45b9e44f4f7d6fd8e9514ae0e507c39e7177df8cca986b13f461753d00de579bae04578db49a0b5a67b86e6d9527e35cc8db87eb5ff4646b972c9ac4a6b90
+  metadata.gz: 662962d4c32d91547f15623c92a8ae7951cb96189619bea97ea55d02725a2d05c7ea665f92d27e9dbbbb3e541d1e5bb04b40437a54e986d1240fa19b77bd91ae
+  data.tar.gz: dbc18f0ee4b6d025f5fe1a2a9be257ad280687dc3b165d4e2bfbc3d68976548172df2da865a58ad0801ac6c0b50244d33438f08570c33f852143bb6c16309ab1

data/lib/tcp-client.rb

@@ -20,22 +20,22 @@ class TCPClient
   attr_reader :address
 
   def initialize
-    @socket = @address = @write_timeout = @read_timeout = @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)
     @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
 
@@ -53,8 +53,8 @@ class TCPClient
   end
 
   def with_deadline(timeout)
-    NoBlockGiven.raise! unless block_given?
     previous_deadline = @deadline
+    NoBlockGiven.raise! unless block_given?
     tm = timeout&.to_f
     InvalidDeadLine.raise! unless tm&.positive?
     @deadline = Time.now + tm
@@ -63,34 +63,45 @@ class TCPClient
     @deadline = previous_deadline
   end
 
-  def read(nbytes, timeout: nil, exception: ReadTimeoutError)
+  def read(nbytes, timeout: nil, exception: nil)
     NotConnected.raise! if closed?
-    if timeout.nil? && @deadline
-      return @socket.read_with_deadline(nbytes, @deadline, exception)
-    end
-    timeout = (timeout || @read_timeout).to_f
-    if timeout.positive?
-      @socket.read_with_deadline(nbytes, Time.now + timeout, exception)
-    else
-      @socket.read(nbytes)
-    end
+    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)
+  def write(*msg, timeout: nil, exception: nil)
     NotConnected.raise! if closed?
-    if timeout.nil? && @deadline
-      return @socket.write_with_deadline(msg.join.b, @deadline, exception)
-    end
-    timeout = (timeout || @read_timeout).to_f
-    if timeout.positive?
-      @socket.write_with_deadline(msg.join.b, Time.now + timeout, exception)
-    else
-      @socket.write(*msg)
-    end
+    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
     @socket.flush unless closed?
     self
   end
+
+  private
+
+  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
+    result = 0
+    msg.each do |chunk|
+      result += @socket.write_with_deadline(chunk.b, deadline, exception)
+    end
+    result
+  end
 end

data/lib/tcp-client/configuration.rb

@@ -1,3 +1,5 @@
+require_relative 'errors'
+
 class TCPClient
   class Configuration
     def self.create(options = {})
@@ -6,15 +8,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 +63,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)
+      NotAnException.raise!(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)
+      NotAnException.raise!(exception) unless exception_class?(exception)
+      @connect_timeout_error = exception
+    end
+
+    def read_timeout_error=(exception)
+      NotAnException.raise!(exception) unless exception_class?(exception)
+      @read_timeout_error = exception
+    end
+
+    def write_timeout_error=(exception)
+      NotAnException.raise!(exception) unless exception_class?(exception)
+      @write_timeout_error = exception
     end
 
     def to_h
@@ -75,6 +109,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 +127,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}")
+      UnknownAttribute.raise!(attribute)
     end
 
     def seconds(value)

data/lib/tcp-client/errors.rb

@@ -21,6 +21,18 @@ class TCPClient
     end
   end
 
+  class UnknownAttribute < ArgumentError
+    def self.raise!(attribute)
+      raise(self, "unknown attribute - #{attribute}", caller(1))
+    end
+  end
+
+  class NotAnException < TypeError
+    def self.raise!(object)
+      raise(self, "not a valid exception class - #{object.inspect}", caller(1))
+    end
+  end
+
   class NotConnected < SocketError
     def self.raise!
       raise(self, 'client not connected', caller(1))

data/lib/tcp-client/version.rb

@@ -1,3 +1,3 @@
 class TCPClient
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.2.2'.freeze
 end

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

@@ -67,7 +67,7 @@ class TCPClientTest < MiniTest::Test
         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
 
@@ -85,7 +85,7 @@ class TCPClientTest < MiniTest::Test
         start_time = Time.now
         subject.write(*HUGE_AMOUNT_OF_DATA, 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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-22 00:00:00.000000000 Z
+date: 2021-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler