tcp-client 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f36e18e6865766292ff44adf5cd46244e8944049f524553ba4168725454a2d0b
-  data.tar.gz: abd4ec63f48c1be4e73922aaed7702bdacebe398e6cda13887fcd2efaa62818c
+  metadata.gz: 30592a849daf948c39b138e5f2d634761d59328f7a6eab11d45a9b069b8a747d
+  data.tar.gz: 39d0b9afe676700627a9b671c974ab5465cdb72e5ed6ec5c009add638a2b02b3
 SHA512:
-  metadata.gz: 11b5302d3da2d0d46f35fb2370177916b1044b659b1f62bdbf0a30c39581844dd425487a6c94300b4a7afcf25eafef5828a6ef04cb0ff9bcae4fff01a9a312bb
-  data.tar.gz: 54b3505c1eb90565e0a80dab5c92a394883b74cf3bb975ed83df4c1affbad15e9acbfcee7ec3d0a5bb79c1486fa46fbfbd958fc9e43106b9a97dc22411c84335
+  metadata.gz: d6a44381c618b1a89128499f7256bd9559dd4ea1efc5f34b82b681cfcca29f1c51b7ab47b13b513977e3276e298ec5ad02f6619f5ed36320f724e9cd192f925e
+  data.tar.gz: dfbcb8fb0e4b77770023023afbaee354e71ba4e41fe89daff9e197ce7d7a8a785e7891dbb4801651ae4702b56324d3431695e27acc781fafae9e7336db6c2c52

data/lib/tcp-client/deadline.rb

@@ -29,4 +29,6 @@ class TCPClient
       end
     end
   end
+
+  private_constant(:Deadline)
 end

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

@@ -12,6 +12,13 @@ module IOWithDeadlineMixin
 
   def read_with_deadline(bytes_to_read, deadline, exception)
     raise(exception) unless deadline.remaining_time
+    if bytes_to_read.nil?
+      return(
+        with_deadline(deadline, exception) do
+          read_nonblock(65_536, exception: false)
+        end
+      )
+    end
     result = ''.b
     while result.bytesize < bytes_to_read
       read =

data/lib/tcp-client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class TCPClient
-  VERSION = '0.5.1'
+  VERSION = '0.6.0'
 end

data/lib/tcp-client.rb

@@ -13,12 +13,25 @@ class TCPClient
   def self.open(address, configuration = Configuration.default)
     client = new
     client.connect(Address.new(address), configuration)
-    return client unless block_given?
-    begin
-      yield(client)
-    ensure
-      client.close
+    block_given? ? yield(client) : client
+  ensure
+    client.close if block_given?
+  end
+
+  def self.with_deadline(
+    timeout,
+    address,
+    configuration = Configuration.default
+  )
+    client = nil
+    raise(NoBlockGiven) unless block_given?
+    address = Address.new(address)
+    client = new
+    client.with_deadline(timeout) do
+      yield(client.connect(address, configuration))
     end
+  ensure
+    client&.close
   end
 
   attr_reader :address, :configuration
@@ -31,12 +44,12 @@ class TCPClient
     @address&.to_s || ''
   end
 
-  def connect(address, configuration, exception: nil)
+  def connect(address, configuration, timeout: nil, exception: nil)
+    close if @socket
     raise(NoOpenSSL) if configuration.ssl? && !defined?(SSLSocket)
-    close
     @address = Address.new(address)
     @configuration = configuration.dup.freeze
-    @socket = create_socket(exception)
+    @socket = create_socket(timeout, exception)
     self
   end
 
@@ -63,48 +76,40 @@ class TCPClient
     @deadline = previous_deadline
   end
 
-  def read(nbytes, timeout: nil, exception: nil)
+  def read(nbytes = nil, timeout: nil, exception: nil)
     raise(NotConnected) if closed?
-    timeout.nil? && @deadline and
-      return read_with_deadline(nbytes, @deadline, exception)
-    deadline = Deadline.new(timeout || @configuration.read_timeout)
+    deadline = create_deadline(timeout, configuration.read_timeout)
     return @socket.read(nbytes) unless deadline.valid?
-    read_with_deadline(nbytes, deadline, exception)
+    exception ||= configuration.read_timeout_error
+    @socket.read_with_deadline(nbytes, deadline, exception)
   end
 
   def write(*msg, timeout: nil, exception: nil)
     raise(NotConnected) if closed?
-    timeout.nil? && @deadline and
-      return write_with_deadline(msg, @deadline, exception)
-    deadline = Deadline.new(timeout || @configuration.read_timeout)
+    deadline = create_deadline(timeout, configuration.write_timeout)
     return @socket.write(*msg) unless deadline.valid?
-    write_with_deadline(msg, deadline, exception)
+    exception ||= configuration.write_timeout_error
+    msg.sum do |chunk|
+      @socket.write_with_deadline(chunk.b, deadline, exception)
+    end
   end
 
   def flush
-    @socket.flush unless closed?
+    @socket&.flush
     self
   end
 
   private
 
-  def create_socket(exception)
-    exception ||= @configuration.connect_timeout_error
-    deadline = Deadline.new(@configuration.connect_timeout)
-    @socket = TCPSocket.new(@address, @configuration, deadline, exception)
-    return @socket unless @configuration.ssl?
-    SSLSocket.new(@socket, @address, @configuration, deadline, exception)
-  end
-
-  def read_with_deadline(nbytes, deadline, exception)
-    exception ||= @configuration.read_timeout_error
-    @socket.read_with_deadline(nbytes, deadline, exception)
+  def create_deadline(timeout, default)
+    timeout.nil? && @deadline ? @deadline : Deadline.new(timeout || default)
   end
 
-  def write_with_deadline(msg, deadline, exception)
-    exception ||= @configuration.write_timeout_error
-    msg.sum do |chunk|
-      @socket.write_with_deadline(chunk.b, deadline, exception)
-    end
+  def create_socket(timeout, exception)
+    deadline = create_deadline(timeout, configuration.connect_timeout)
+    exception ||= configuration.connect_timeout_error
+    @socket = TCPSocket.new(address, configuration, deadline, exception)
+    return @socket unless configuration.ssl?
+    SSLSocket.new(@socket, address, configuration, deadline, exception)
   end
 end

data/sample/google.rb

@@ -2,21 +2,20 @@
 
 require_relative '../lib/tcp-client'
 
-TCPClient.configure(
-  connect_timeout: 0.5, # seconds to connect the server
-  write_timeout: 0.25, # seconds to write a single data junk
-  read_timeout: 0.5 # seconds to read some bytes
-)
-
-# the following sequence is not allowed to last longer than 1.25 seconds:
-#   0.5 seconds to connect
-# + 0.25 seconds to write data
-# + 0.5 seconds to read a response
+# global configuration.
+# - 0.5 seconds to connect the server
+# - 0.25 seconds to write a single data junk
+# - 0.25 seconds to read some bytes
+TCPClient.configure do |cfg|
+  cfg.connect_timeout = 0.5
+  cfg.write_timeout = 0.25
+  cfg.read_timeout = 0.25
+end
 
+# request to Google:
+# - send a simple HTTP get request
+# - read 12 byte: "HTTP/1.1 " + 3 byte HTTP status code
 TCPClient.open('www.google.com:80') do |client|
-  # simple HTTP get request
-  pp client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
-
-  # read "HTTP/1.1 " + 3 byte HTTP status code
-  pp client.read(12)
+  p client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
+  p client.read(12)
 end

data/sample/google_ssl.rb

@@ -2,18 +2,23 @@
 
 require_relative '../lib/tcp-client'
 
-TCPClient.configure do |cfg|
-  cfg.connect_timeout = 1 # limit connect time the server to 1 second
-  cfg.ssl_params = { ssl_version: :TLSv1_2 } # use TLS 1.2
-end
-
-TCPClient.open('www.google.com:443') do |client|
-  # next sequence should not last longer than 0.5 seconds
-  client.with_deadline(0.5) do
-    # simple HTTP get request
-    pp client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
+# create a configuration.
+# - use TLS 1.2
+# - don't use internal buffering
+cfg =
+  TCPClient::Configuration.create(
+    buffered: false,
+    ssl_params: {
+      ssl_version: :TLSv1_2
+    }
+  )
 
-    # read "HTTP/1.1 " + 3 byte HTTP status code
-    pp client.read(12)
-  end
+# request to Google:
+# - limit all interactions to 0.5 seconds
+# - use the Configuration cfg
+# - send a simple HTTP get request
+# - read 12 byte: "HTTP/1.1 " + 3 byte HTTP status code
+TCPClient.with_deadline(0.5, 'www.google.com:443', cfg) do |client|
+  p client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
+  p client.read(12)
 end

data/test/helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/parallel'
+require_relative '../lib/tcp-client'
+
+# this pseudo-server never reads or writes anything
+PseudoServer = TCPServer.new('localhost', 0)
+Minitest.after_run { PseudoServer.close }
+
+class Test < MiniTest::Test
+  parallelize_me!
+end
+
+class Timing
+  def initialize
+    @start_time = nil
+  end
+
+  def started?
+    @start_time != nil
+  end
+
+  def start
+    @start_time = now
+  end
+
+  def elapsed
+    now - @start_time
+  end
+
+  if defined?(Process::CLOCK_MONOTONIC)
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  else
+    def now
+      ::Time.now
+    end
+  end
+end

data/test/tcp-client/address_test.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-
-class AddressTest < MiniTest::Test
-  parallelize_me!
+require_relative '../helper'
 
+class AddressTest < Test
   def test_create_from_integer
     subject = TCPClient::Address.new(42)
     assert_equal('localhost:42', subject.to_s)

data/test/tcp-client/configuration_test.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-
-class ConfigurationTest < MiniTest::Test
-  parallelize_me!
+require_relative '../helper'
 
+class ConfigurationTest < Test
   def test_defaults
     subject = TCPClient::Configuration.new
     assert(subject.buffered)

data/test/tcp-client/deadline_test.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
+require_relative '../helper'
 
-class Deadlineest < MiniTest::Test
-  parallelize_me!
+class DeadlineTest < Test
+  Deadline = TCPClient.const_get(:Deadline)
 
   def test_validity
-    assert(TCPClient::Deadline.new(1).valid?)
-    assert(TCPClient::Deadline.new(0.0001).valid?)
+    assert(Deadline.new(1).valid?)
+    assert(Deadline.new(0.0001).valid?)
 
-    refute(TCPClient::Deadline.new(0).valid?)
-    refute(TCPClient::Deadline.new(nil).valid?)
+    refute(Deadline.new(0).valid?)
+    refute(Deadline.new(nil).valid?)
   end
 
   def test_remaining_time
-    assert(TCPClient::Deadline.new(1).remaining_time > 0)
+    assert(Deadline.new(1).remaining_time > 0)
 
-    assert_nil(TCPClient::Deadline.new(0).remaining_time)
-    assert_nil(TCPClient::Deadline.new(nil).remaining_time)
+    assert_nil(Deadline.new(0).remaining_time)
+    assert_nil(Deadline.new(nil).remaining_time)
 
-    deadline = TCPClient::Deadline.new(0.2)
+    deadline = Deadline.new(0.2)
     sleep(0.2)
     assert_nil(deadline.remaining_time)
   end

data/test/tcp-client/default_configuration_test.rb

@@ -1,4 +1,4 @@
-require_relative '../test_helper'
+require_relative '../helper'
 
 class DefauktConfigurationTest < MiniTest::Test
   def test_default

data/test/tcp-client/version_test.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-
-class VersionTest < MiniTest::Test
-  parallelize_me!
+require_relative '../helper'
 
+class VersionTest < Test
   def test_format
     assert_match(/\d+\.\d+\.\d+/, TCPClient::VERSION)
   end

data/test/tcp_client_test.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'test_helper'
+require_relative 'helper'
 
-class TCPClientTest < MiniTest::Test
-  parallelize_me!
-
-  HUGE_AMOUNT_OF_DATA = Array.new(2024, '?' * 1024).freeze
+class TCPClientTest < Test
+  HUGE_AMOUNT_OF_DATA = Array.new(1024, '?' * 2048).freeze
 
   attr_reader :config
 
@@ -17,6 +15,10 @@ class TCPClientTest < MiniTest::Test
     PseudoServer.local_address.ip_port
   end
 
+  def address
+    "localhost:#{port}"
+  end
+
   def test_defaults
     subject = TCPClient.new
     assert(subject.closed?)
@@ -30,7 +32,7 @@ class TCPClientTest < MiniTest::Test
   def create_nonconnected_client
     client = TCPClient.new
     client.connect('', config)
-    client
+    :you_should_not_get_this
   rescue Errno::EADDRNOTAVAIL
     client
   end
@@ -49,12 +51,12 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_connected_state
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
-      assert_equal("localhost:#{port}", subject.to_s)
+      assert_equal(address, subject.to_s)
       refute_nil(subject.address)
       address_when_opened = subject.address
-      assert_equal("localhost:#{port}", subject.address.to_s)
+      assert_equal(address, subject.address.to_s)
       assert_equal('localhost', subject.address.hostname)
       assert_instance_of(Addrinfo, subject.address.addrinfo)
       assert_same(port, subject.address.addrinfo.ip_port)
@@ -66,14 +68,14 @@ class TCPClientTest < MiniTest::Test
   end
 
   def check_read_timeout(timeout)
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
-      start_time = nil
+      timing = Timing.new
       assert_raises(TCPClient::ReadTimeoutError) do
-        start_time = Time.now
+        timing.start
         subject.read(42, timeout: timeout)
       end
-      assert_in_delta(timeout, Time.now - start_time, 0.15)
+      assert_in_delta(timeout, timing.elapsed, 0.15)
     end
   end
 
@@ -84,14 +86,14 @@ class TCPClientTest < MiniTest::Test
   end
 
   def check_write_timeout(timeout)
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
-      start_time = nil
+      timing = Timing.new
       assert_raises(TCPClient::WriteTimeoutError) do
-        start_time = Time.now
+        timing.start
         subject.write(*HUGE_AMOUNT_OF_DATA, timeout: timeout)
       end
-      assert_in_delta(timeout, Time.now - start_time, 0.15)
+      assert_in_delta(timeout, timing.elapsed, 0.15)
     end
   end
 
@@ -101,7 +103,7 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_write_deadline
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::WriteTimeoutError) do
         subject.with_deadline(0.25) do |*args|
@@ -113,25 +115,25 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_read_deadline
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::ReadTimeoutError) do
         subject.with_deadline(0.25) do |*args|
           assert_equal([subject], args)
-          loop { subject.read(0) }
+          loop { subject.read(42) }
         end
       end
     end
   end
 
   def test_read_write_deadline
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::TimeoutError) do
         subject.with_deadline(0.25) do |*args|
           assert_equal([subject], args)
           loop do
-            subject.write('HUGE_AMOUNT_OF_DATA')
+            subject.write('some data')
             subject.read(0)
           end
         end
@@ -140,12 +142,12 @@ class TCPClientTest < MiniTest::Test
   end
 
   def check_connect_timeout(ssl_config)
-    start_time = nil
+    timing = Timing.new
     assert_raises(TCPClient::ConnectTimeoutError) do
-      start_time = Time.now
-      TCPClient.new.connect("localhost:#{port}", ssl_config)
+      timing.start
+      TCPClient.new.connect(address, ssl_config)
     end
-    assert_in_delta(ssl_config.connect_timeout, Time.now - start_time, 0.25)
+    assert_in_delta(ssl_config.connect_timeout, timing.elapsed, 0.25)
   end
 
   def test_connect_ssl_timeout
@@ -160,4 +162,19 @@ class TCPClientTest < MiniTest::Test
     ssl_config.connect_timeout = 1.5
     check_connect_timeout(ssl_config)
   end
+
+  def test_deadline
+    assert(TCPClient.with_deadline(0.15, address, config, &:itself).closed?)
+  end
+
+  def test_deadline_timeout
+    timing = Timing.new
+    assert_raises(TCPClient::ReadTimeoutError) do
+      timing.start
+      TCPClient.with_deadline(0.15, address, config) do |client|
+        client.read(42)
+      end
+    end
+    assert_in_delta(0.15, timing.elapsed, 0.15)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-10 00:00:00.000000000 Z
+date: 2021-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,13 +86,13 @@ files:
 - sample/google.rb
 - sample/google_ssl.rb
 - tcp-client.gemspec
+- test/helper.rb
 - test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
 - test/tcp-client/deadline_test.rb
 - test/tcp-client/default_configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb
-- test/test_helper.rb
 homepage: https://github.com/mblumtritt/tcp-client
 licenses:
 - BSD-3-Clause
@@ -114,15 +114,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.28
 signing_key:
 specification_version: 4
 summary: A TCP client implementation with working timeout support.
 test_files:
+- test/helper.rb
 - test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
 - test/tcp-client/deadline_test.rb
 - test/tcp-client/default_configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb
-- test/test_helper.rb

data/test/test_helper.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require 'minitest/parallel'
-require_relative '../lib/tcp-client'
-
-# this pseudo-server never reads or writes anything
-PseudoServer = TCPServer.new('localhost', 0)
-Minitest.after_run { PseudoServer.close }