tcp-client 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c78407e818a50dbd68dcee0fe5b5cebcb24c05e8067a85e58d041708d7f17d6d
-  data.tar.gz: 02d404e555b0aeab3536654171563a90c33d6f38a9d00a4931e44915d099667f
+  metadata.gz: 1100d0c6684061225cff8107b369fe38d56454f3e5bb4c7efd4a7e2c07adc491
+  data.tar.gz: 584cda11bc5398b9dd1574ea1e459a4ec963cf73195a5a200bdd520aa9725ece
 SHA512:
-  metadata.gz: 564d3dd03cf6a63997e58cc2cee355f285682af61efda74caed413bfa09b672331de4cd29f1a8434403d128f45175ffbc9ca21818c6031e3a4fb5d15e19476f3
-  data.tar.gz: b563240e1fed9791c4f0714e1fe9d5711441488b482e17e2a37de2e6e0828bf004d15a24db69b7b4ffc1ef2bdc79c936f3de87a4213f9ae4832c1985aa820988
+  metadata.gz: eafb90f60c331022b7115d291ede9334a6963842ba453329dff11d2ae9c208c5cc8acf2afaa9f4b377d20a3bddb6c60ab7baeccc0bee77a3b17665a2df18587f
+  data.tar.gz: 7d174d7172e9d1da102da679741f655e8bda71f888e3b68868d1ec993cd9f82ba8ed6f185be58483296c77868eefce4c2897b79e2fcb1fe71b52c6774b05fb6a

data/.gitignore

@@ -1,4 +1,4 @@
-_local/
+.local/
 tmp/
 pkg/
 gems.locked

data/README.md

@@ -11,14 +11,14 @@ This gem implements a TCP client with (optional) SSL support. The motivation of
 configuration = TCPClient::Configuration.create do |cfg|
   cfg.connect_timeout = 1 # second to connect the server
   cfg.write_timeout = 0.25 # seconds to write a single data junk
-  cfg.read_timeout = 0.25 # seconds to read some bytes
-  cfg.ssl_params = {} # use SSL, but without any specific parameters
+  cfg.read_timeout = 0.5 # seconds to read some bytes
+  cfg.ssl_params = {ssl_version: :TLSv1_2} # use TLS 1.2
 end
 
-# the following request sequence is not allowed to last longer than 1.5 seconds:
+# the following request sequence is not allowed to last longer than 2 seconds:
 # 1 second to connect (incl. SSL handshake etc.)
 # + 0.25 seconds to write data
-# + 0.25 seconds to read
+# + 0.5 seconds to read
 # a response
 TCPClient.open('www.google.com:443', configuration) do |client|
   pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n") # simple HTTP get request

data/lib/tcp-client.rb

@@ -19,6 +19,8 @@ class TCPClient
     end
   end
 
+  Timeout = Class.new(IOError)
+
   def self.open(addr, configuration = Configuration.new)
     addr = Address.new(addr)
     client = new
@@ -44,8 +46,8 @@ class TCPClient
     close
     NoOpenSSL.raise! if configuration.ssl? && !defined?(SSLSocket)
     @address = Address.new(addr)
-    @socket = TCPSocket.new(@address, configuration)
-    @socket = SSLSocket.new(@socket, @address, configuration) if configuration.ssl?
+    @socket = TCPSocket.new(@address, configuration, Timeout)
+    @socket = SSLSocket.new(@socket, @address, configuration, Timeout) if configuration.ssl?
     @write_timeout = configuration.write_timeout
     @read_timeout = configuration.read_timeout
     self
@@ -64,11 +66,10 @@ class TCPClient
   end
 
   def read(nbytes, timeout: @read_timeout)
-    closed? ? NotConnected.raise!(self) : @socket.read(nbytes, timeout: timeout)
+    closed? ? NotConnected.raise!(self) : @socket.read(nbytes, timeout: timeout, exception: Timeout)
   end
 
-  def write(*args, timeout: @write_timeout)
-    closed? ? NotConnected.raise!(self)  : @socket.write(*args, timeout: timeout)
+  def write(*msg, timeout: @write_timeout)
+    closed? ? NotConnected.raise!(self)  : @socket.write(*msg, timeout: timeout, exception: Timeout)
   end
 end
-

data/lib/tcp-client/address.rb

@@ -13,7 +13,7 @@ class TCPClient
       when Integer
         init_from_addrinfo(Addrinfo.tcp(nil, addr))
       when Addrinfo
-        init_from_addrinfo(add)
+        init_from_addrinfo(addr)
       else
         init_from_string(addr)
       end
@@ -24,8 +24,9 @@ class TCPClient
 
     def init_from_string(str)
       @hostname, port = from_string(str.to_s)
+      return init_from_addrinfo(Addrinfo.tcp(nil, port)) unless @hostname
       @addrinfo = Addrinfo.tcp(@hostname, port)
-      @to_s = "#{@hostname}:#{port}"
+      @to_s = @hostname.index(':') ? "[#{@hostname}]:#{port}" : "#{@hostname}:#{port}"
     end
 
     def init_from_selfclass(address)

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

@@ -6,21 +6,21 @@ module IOTimeoutMixin
     mod.include(im.index(:wait_writable) && im.index(:wait_readable) ? WithDeadlineMethods : WidthDeadlineIO)
   end
 
-  def read(nbytes, timeout: nil)
+  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){ read_nonblock(junk_size, exception: false) }
+      with_deadline(deadline, exception){ read_nonblock(junk_size, exception: false) }
     end
   end
 
-  def write(*args, timeout: nil)
+  def write(*msgs, timeout: nil, exception: IOTimeoutError)
     timeout = timeout.to_f
-    return write_all(args.join){ |junk| super(junk) } if timeout <= 0
+    return write_all(msgs.join){ |junk| super(junk) } if timeout <= 0
     deadline = Time.now + timeout
-    write_all(args.join) do |junk|
-      with_deadline(deadline){ write_nonblock(junk, exception: false) }
+    write_all(msgs.join) do |junk|
+      with_deadline(deadline, exception){ write_nonblock(junk, exception: false) }
     end
   end
 
@@ -53,15 +53,15 @@ module IOTimeoutMixin
   module WithDeadlineMethods
     private
 
-    def with_deadline(deadline)
+    def with_deadline(deadline, exclass)
       loop do
         case ret = yield
         when :wait_writable
           remaining_time = deadline - Time.now
-          raise(IOTimeoutError) if remaining_time <= 0 || wait_writable(remaining_time).nil?
+          raise(exclass) if remaining_time <= 0 || wait_writable(remaining_time).nil?
         when :wait_readable
           remaining_time = deadline - Time.now
-          raise(IOTimeoutError) if remaining_time <= 0 || wait_readable(remaining_time).nil?
+          raise(exclass) if remaining_time <= 0 || wait_readable(remaining_time).nil?
         else
           return ret
         end
@@ -72,15 +72,15 @@ module IOTimeoutMixin
   module WidthDeadlineIO
     private
 
-    def with_deadline(deadline)
+    def with_deadline(deadline, exclass)
       loop do
         case ret = yield
         when :wait_writable
           remaining_time = deadline - Time.now
-          raise(IOTimeoutError) if remaining_time <= 0 || ::IO.select(nil, [self], nil, remaining_time).nil?
+          raise(exclass) if remaining_time <= 0 || ::IO.select(nil, [self], nil, remaining_time).nil?
         when :wait_readable
           remaining_time = deadline - Time.now
-          raise(IOTimeoutError) if remaining_time <= 0 || ::IO.select([self], nil, nil, remaining_time).nil?
+          raise(exclass) if remaining_time <= 0 || ::IO.select([self], nil, nil, remaining_time).nil?
         else
           return ret
         end

data/lib/tcp-client/ssl_socket.rb

@@ -10,10 +10,10 @@ class TCPClient
   class SSLSocket < ::OpenSSL::SSL::SSLSocket
     include IOTimeoutMixin
 
-    def initialize(socket, address, configuration)
+    def initialize(socket, address, configuration, exception)
       ssl_params = Hash[configuration.ssl_params]
       super(socket, create_context(ssl_params))
-      connect_to(address, configuration.connect_timeout)
+      connect_to(address, configuration.connect_timeout, exception)
     end
 
     private
@@ -24,9 +24,9 @@ class TCPClient
       ctx
     end
 
-    def connect_to(address, timeout)
+    def connect_to(address, timeout, exception)
       self.hostname = address.hostname
-      timeout ? with_deadline(Time.now + timeout){ connect_nonblock(exception: false) } : connect
+      timeout ? with_deadline(Time.now + timeout, exception){ connect_nonblock(exception: false) } : connect
       post_connection_check(address.hostname)
     end
   end

data/lib/tcp-client/tcp_socket.rb

@@ -5,17 +5,18 @@ class TCPClient
   class TCPSocket < ::Socket
     include IOTimeoutMixin
 
-    def initialize(address, configuration)
+    def initialize(address, configuration, exception)
       super(address.addrinfo.ipv6? ? :INET6 : :INET, :STREAM)
       configure(configuration)
-      connect_to(address, configuration.connect_timeout)
+      connect_to(address, configuration.connect_timeout, exception)
     end
 
     private
 
-    def connect_to(address, timeout)
+    def connect_to(address, timeout, exception)
       addr = ::Socket.pack_sockaddr_in(address.addrinfo.ip_port, address.addrinfo.ip_address)
-      timeout ? with_deadline(Time.now + timeout){ connect_nonblock(addr, exception: false) } : connect(addr)
+      return connect(addr) unless timeout
+      with_deadline(Time.now + timeout, exception){ connect_nonblock(addr, exception: false) }
     end
 
     def configure(configuration)

data/lib/tcp-client/version.rb

@@ -1,3 +1,3 @@
 class TCPClient
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.0.4'.freeze
 end

data/sample/google.rb

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

data/sample/google_ssl.rb

@@ -3,14 +3,14 @@ require_relative '../lib/tcp-client'
 configuration = TCPClient::Configuration.create do |cfg|
   cfg.connect_timeout = 1 # second to connect the server
   cfg.write_timeout = 0.25 # seconds to write a single data junk
-  cfg.read_timeout = 0.25 # seconds to read some bytes
-  cfg.ssl_params = {} # use SSL, but without any specific parameters
+  cfg.read_timeout = 0.5 # seconds to read some bytes
+  cfg.ssl_params = {ssl_version: :TLSv1_2} # use TLS 1.2
 end
 
-# the following request sequence is not allowed to last longer than 1.5 seconds:
+# the following request sequence is not allowed to last longer than 2 seconds:
 # 1 second to connect (incl. SSL handshake etc.)
 # + 0.25 seconds to write data
-# + 0.25 seconds to read
+# + 0.5 seconds to read
 # a response
 TCPClient.open('www.google.com:443', configuration) do |client|
   pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n") # simple HTTP get request

data/tcp-client.gemspec

@@ -25,7 +25,7 @@ GemSpec = Gem::Specification.new do |spec|
 
   spec.platform = Gem::Platform::RUBY
   spec.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
-  spec.required_ruby_version = '>= 2.0.0'
+  spec.required_ruby_version = '>= 2.5.0'
 
   spec.require_paths = %w[lib]
 

data/test/tcp-client/address_test.rb

@@ -0,0 +1,55 @@
+require_relative '../test_helper'
+
+class AddressTest < Test
+  def test_create_from_integer
+    subject = TCPClient::Address.new(42)
+    assert_equal('localhost:42', subject.to_s)
+    assert_equal('localhost', subject.hostname)
+    assert(subject.addrinfo.ip?)
+    assert(subject.addrinfo.ipv6?)
+    assert_same(42, subject.addrinfo.ip_port)
+  end
+
+  def test_create_from_addrinfo
+    addrinfo = Addrinfo.tcp('google.com', 42)
+    subject = TCPClient::Address.new(addrinfo)
+    assert_equal(addrinfo.getnameinfo[0], subject.hostname)
+    assert_equal(addrinfo, subject.addrinfo)
+  end
+
+  def test_create_from_str
+    subject = TCPClient::Address.new('localhost:42')
+    assert_equal('localhost:42', subject.to_s)
+    assert_equal('localhost', subject.hostname)
+    assert(subject.addrinfo.ip?)
+    assert(subject.addrinfo.ipv6?)
+    assert_same(42, subject.addrinfo.ip_port)
+  end
+
+  def test_create_from_str_short
+    subject = TCPClient::Address.new(':42')
+    assert_equal(':42', subject.to_s)
+    assert_empty(subject.hostname)
+    assert_same(42, subject.addrinfo.ip_port)
+    assert(subject.addrinfo.ip?)
+    assert(subject.addrinfo.ipv4?)
+  end
+
+  def test_create_from_str_ip6
+    subject = TCPClient::Address.new('[::1]:42')
+    assert_equal('[::1]:42', subject.to_s)
+    assert_equal('::1', subject.hostname)
+    assert_same(42, subject.addrinfo.ip_port)
+    assert(subject.addrinfo.ip?)
+    assert(subject.addrinfo.ipv6?)
+  end
+
+  def test_create_from_empty_str
+    subject = TCPClient::Address.new('')
+    assert_equal('localhost:0', subject.to_s)
+    assert_equal('localhost', subject.hostname)
+    assert_same(0, subject.addrinfo.ip_port)
+    assert(subject.addrinfo.ip?)
+    assert(subject.addrinfo.ipv6?)
+  end
+end

data/test/tcp_client_test.rb

@@ -26,10 +26,10 @@ class TCPClientTest < Test
   def test_failed_state
     subject = create_nonconnected_client
     assert(subject.closed?)
-    assert_equal(':0', subject.to_s)
+    assert_equal('localhost:0', subject.to_s)
     refute_nil(subject.address)
-    assert_equal(':0', subject.address.to_s)
-    assert_nil(subject.address.hostname)
+    assert_equal('localhost:0', subject.address.to_s)
+    assert_equal('localhost', subject.address.hostname)
     assert_instance_of(Addrinfo, subject.address.addrinfo)
     assert_same(0, subject.address.addrinfo.ip_port)
     assert_raises(TCPClient::NotConnected) do
@@ -64,13 +64,13 @@ class TCPClientTest < Test
     TCPClient.open(addr) do |subject|
       refute(subject.closed?)
       start_time = nil
-      assert_raises(IOTimeoutError) do
+      assert_raises(TCPClient::Timeout) do
         start_time = Time.now
         # we need to send 1MB to avoid any TCP stack buffering
         subject.write('?' * (1024 * 1024), timeout: timeout)
       end
       assert_in_delta(timeout, Time.now - start_time, 0.02)
-      assert_raises(IOTimeoutError) do
+      assert_raises(TCPClient::Timeout) do
         start_time = Time.now
         subject.read(42, timeout: timeout)
       end
@@ -89,7 +89,7 @@ class TCPClientTest < Test
 
   def check_connect_timeout(addr, config, timeout)
     start_time = nil
-    assert_raises(IOTimeoutError) do
+    assert_raises(TCPClient::Timeout) do
       start_time = Time.now
       TCPClient.new.connect(addr, config)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-17 00:00:00.000000000 Z
+date: 2018-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -79,6 +79,7 @@ files:
 - sample/google.rb
 - sample/google_ssl.rb
 - tcp-client.gemspec
+- test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb
@@ -95,7 +96,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -108,6 +109,7 @@ signing_key:
 specification_version: 4
 summary: A TCP client implementation with working timeout support.
 test_files:
+- test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb