tcp-client 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2791642003fb16623a27988401ff3bb532194032a5bbd4f62b853aae94790055
-  data.tar.gz: 030a2b3ebecf1334dea84e2c8f18aecd3b900c7c467c10c624c1354429a66195
+  metadata.gz: a9ec3cdc6d442ed7e748f9993d32be41d3dbe20b06bbced35ba0f5ba96caf47f
+  data.tar.gz: ef601054036a671f2073e6b8bbe02e0c23c182a5646db715e27a96a8b32a2485
 SHA512:
-  metadata.gz: e4ef14d49cd323a418190e62bc190af01fcc9be1b7008b7fd27c8fa7b8779ae29947045a660080e9403ba1d932e1318a6f98c819006d816f91eb093caf6d7873
-  data.tar.gz: 29617e860ad0b419638b54a8258541ccf3c668530a38aa2e629badcb373b94df71c33e538d54faf12d732ffd51670e1ad57cc8fabcaac11bb2d4de3d28cd29b1
+  metadata.gz: bd9f757eb175ecf86be1973126991e8a6b4cf50013c4d54854d9accff007e235003f5506b509729e8158ca1c43c05405ecc15802e207a719f44f45d22a4973d7
+  data.tar.gz: d30bd7e5361f310b49bf20357e814a495d0a3b7962f0a6a59e108cb978f0ca1785cc8ba5a4c349d90e0c191cd50dfb7a26b2084f7f36cb590f48237c592ea77c

data/lib/tcp-client.rb

@@ -29,7 +29,7 @@ class TCPClient
 
   def connect(addr, configuration, exception: nil)
     close
-    NoOpenSSL.raise! if configuration.ssl? && !defined?(SSLSocket)
+    raise(NoOpenSSL) if configuration.ssl? && !defined?(SSLSocket)
     @address = Address.new(addr)
     @cfg = configuration.dup
     exception ||= configuration.connect_timeout_error
@@ -54,9 +54,9 @@ class TCPClient
 
   def with_deadline(timeout)
     previous_deadline = @deadline
-    NoBlockGiven.raise! unless block_given?
+    raise(NoBlockGiven) unless block_given?
     tm = timeout&.to_f
-    InvalidDeadLine.raise! unless tm&.positive?
+    raise(InvalidDeadLine) unless tm&.positive?
     @deadline = Time.now + tm
     yield(self)
   ensure
@@ -64,7 +64,7 @@ class TCPClient
   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
@@ -73,7 +73,7 @@ class TCPClient
   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
@@ -98,10 +98,8 @@ class TCPClient
 
   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
@@ -59,7 +59,9 @@ 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] == ']'
+      if name.start_with?('[') && name.end_with?(']')
+        name = name[1, name.size - 2]
+      end
       [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
@@ -80,23 +82,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
 
@@ -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/errors.rb

@@ -4,45 +4,68 @@ require 'socket'
 
 class TCPClient
   class NoOpenSSL < RuntimeError
-    def self.raise!
-      raise(self, 'OpenSSL is not avail', caller(1))
+    def initialize
+      super('OpenSSL is not avail')
     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("not a valid exception class - #{object.inspect}")
     end
   end
 
-  class NotConnected < SocketError
-    def self.raise!
-      raise(self, 'client not connected', caller(1))
+  class NotConnected < IOError
+    def initialize
+      super('client not connected')
     end
   end
 
-  TimeoutError = Class.new(IOError)
-  ConnectTimeoutError = Class.new(TimeoutError)
-  ReadTimeoutError = Class.new(TimeoutError)
-  WriteTimeoutError = Class.new(TimeoutError)
+  class TimeoutError < IOError
+    def initialize(message = nil)
+      super(message || "unable to #{action} in time")
+    end
+
+    def action
+      :process
+    end
+  end
+
+  class ConnectTimeoutError < TimeoutError
+    def action
+      :connect
+    end
+  end
+
+  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,38 @@
 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) if Time.now > deadline
     result = ''.b
-    return result if nbytes.zero?
+    return result if bytes_to_read <= 0
     loop do
       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
+      return result if result.bytesize >= bytes_to_read
     end
   end
 
-  def write_with_deadline(data, deadline, exclass)
-    raise(exclass) if Time.now > deadline
+  def write_with_deadline(data, deadline, exception)
+    raise(exception) if Time.now > deadline
     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 +42,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?
+          raise(exception) if (remaining_time = deadline - Time.now) <= 0
+          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?
+          raise(exception) if (remaining_time = deadline - Time.now) <= 0
+          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?
+          raise(exception) if (remaining_time = deadline - Time.now) <= 0
+          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?
+          raise(exception) if (remaining_time = deadline - Time.now) <= 0
+          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

@@ -24,9 +24,9 @@ class TCPClient
     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)

data/lib/tcp-client/version.rb

@@ -1,3 +1,3 @@
 class TCPClient
-  VERSION = '0.2.3'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/test/tcp_client_test.rb

@@ -118,7 +118,7 @@ class TCPClientTest < MiniTest::Test
     end
   end
 
-  def xtest_read_write_deadline
+  def test_read_write_deadline
     TCPClient.open('localhost:1234', config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::TimeoutError) do
@@ -139,7 +139,7 @@ class TCPClientTest < MiniTest::Test
       start_time = Time.now
       TCPClient.new.connect('localhost:1234', 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-19 00:00:00.000000000 Z
+date: 2021-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,7 +72,6 @@ files:
 - lib/tcp-client/configuration.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

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