tcp-client 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c78407e818a50dbd68dcee0fe5b5cebcb24c05e8067a85e58d041708d7f17d6d
+  data.tar.gz: 02d404e555b0aeab3536654171563a90c33d6f38a9d00a4931e44915d099667f
+SHA512:
+  metadata.gz: 564d3dd03cf6a63997e58cc2cee355f285682af61efda74caed413bfa09b672331de4cd29f1a8434403d128f45175ffbc9ca21818c6031e3a4fb5d15e19476f3
+  data.tar.gz: b563240e1fed9791c4f0714e1fe9d5711441488b482e17e2a37de2e6e0828bf004d15a24db69b7b4ffc1ef2bdc79c936f3de87a4213f9ae4832c1985aa820988

data/.gitignore

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

data/README.md

@@ -0,0 +1,55 @@
+# TCPClient
+
+A TCP client implementation with working timeout support.
+
+## Description
+This gem implements a TCP client with (optional) SSL support. The motivation of this project is the need to have a _really working_ easy to use client which can handle time limits correctly. Unlike other implementations this client respects given/configurable time limits for each method (`connect`, `read`, `write`).
+
+## Sample
+
+```ruby
+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
+end
+
+# the following request sequence is not allowed to last longer than 1.5 seconds:
+# 1 second to connect (incl. SSL handshake etc.)
+# + 0.25 seconds to write data
+# + 0.25 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
+  pp client.read(12) # "HTTP/1.1 " + 3 byte HTTP status code
+end
+```
+
+### Installation
+
+Use [Bundler](http://gembundler.com/) to use TCPClient in your own project:
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'tcp-client'
+```
+
+and install it by running Bundler:
+
+```bash
+$ bundle
+```
+
+To install the gem globally use:
+
+```bash
+$ gem install tcp-client
+```
+
+After that you need only a single line of code in your project code to have all tools on board:
+
+```ruby
+require 'tcp-client'
+```

data/gems.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+source('https://rubygems.org'){ gemspec }

data/lib/tcp-client.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'tcp-client/address'
+require_relative 'tcp-client/tcp_socket'
+require_relative 'tcp-client/ssl_socket'
+require_relative 'tcp-client/configuration'
+require_relative 'tcp-client/version'
+
+class TCPClient
+  class NoOpenSSL < RuntimeError
+    def self.raise!
+      raise(self, 'OpenSSL is not avail', caller(1))
+    end
+  end
+
+  class NotConnected < SocketError
+    def self.raise!(which)
+      raise(self, format('client not connected - %s', which), caller(1))
+    end
+  end
+
+  def self.open(addr, configuration = Configuration.new)
+    addr = Address.new(addr)
+    client = new
+    client.connect(addr, configuration)
+    return yield(client) if block_given?
+    client, ret = nil, client
+    ret
+  ensure
+    client.close if client
+  end
+
+  attr_reader :address
+
+  def initialize
+    @socket = @address = @write_timeout = @read_timeout = nil
+  end
+
+  def to_s
+    @address ? @address.to_s : ''
+  end
+
+  def connect(addr, configuration)
+    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?
+    @write_timeout = configuration.write_timeout
+    @read_timeout = configuration.read_timeout
+    self
+  end
+
+  def close
+    socket, @socket = @socket, nil
+    socket.close if socket
+    self
+  rescue IOError
+    self
+  end
+
+  def closed?
+    @socket.nil? || @socket.closed?
+  end
+
+  def read(nbytes, timeout: @read_timeout)
+    closed? ? NotConnected.raise!(self) : @socket.read(nbytes, timeout: timeout)
+  end
+
+  def write(*args, timeout: @write_timeout)
+    closed? ? NotConnected.raise!(self)  : @socket.write(*args, timeout: timeout)
+  end
+end
+

data/lib/tcp-client/address.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+class TCPClient
+  class Address
+    attr_reader :to_s, :hostname, :addrinfo
+
+    def initialize(addr)
+      case addr
+      when self.class
+        init_from_selfclass(addr)
+      when Integer
+        init_from_addrinfo(Addrinfo.tcp(nil, addr))
+      when Addrinfo
+        init_from_addrinfo(add)
+      else
+        init_from_string(addr)
+      end
+      @addrinfo.freeze
+    end
+
+    private
+
+    def init_from_string(str)
+      @hostname, port = from_string(str.to_s)
+      @addrinfo = Addrinfo.tcp(@hostname, port)
+      @to_s = "#{@hostname}:#{port}"
+    end
+
+    def init_from_selfclass(address)
+      @to_s = address.to_s
+      @hostname = address.hostname
+      @addrinfo = address.addrinfo
+    end
+
+    def init_from_addrinfo(addrinfo)
+      @hostname, port = addrinfo.getnameinfo(Socket::NI_NUMERICSERV)
+      @to_s = "#{@hostname}:#{port}"
+      @addrinfo = addrinfo
+    end
+
+    def from_string(str)
+      return [nil, str.to_i] unless idx = str.rindex(':')
+      name = str[0, idx]
+      name = name[1, name.size - 2] if name[0] == '[' && name[-1] == ']'
+      [name, str[idx + 1, str.size - idx].to_i]
+    end
+  end
+end

data/lib/tcp-client/configuration.rb

@@ -0,0 +1,68 @@
+class TCPClient
+  class Configuration
+    def self.create
+      ret = new
+      yield(ret) if block_given?
+      ret
+    end
+
+    attr_reader :buffered, :keep_alive, :reverse_lookup
+    attr_accessor :ssl_params
+
+    def initialize
+      @buffered = @keep_alive = @reverse_lookup = true
+      self.timeout = @ssl_params = nil
+    end
+
+    def ssl?
+      @ssl_params ? true : false
+    end
+
+    def buffered=(yn)
+      @buffered = yn ? true : false
+    end
+
+    def keep_alive=(yn)
+      @keep_alive = yn ? true : false
+    end
+
+    def reverse_lookup=(yn)
+      @reverse_lookup = yn ? true : false
+    end
+
+    def timeout=(seconds)
+      @timeout = seconds(seconds)
+      @connect_timeout = @write_timeout = @read_timeout = nil
+    end
+
+    def connect_timeout
+      @connect_timeout || @timeout
+    end
+
+    def connect_timeout=(seconds)
+      @connect_timeout = seconds(seconds)
+    end
+
+    def write_timeout
+      @write_timeout || @timeout
+    end
+
+    def write_timeout=(seconds)
+      @write_timeout = seconds(seconds)
+    end
+
+    def read_timeout
+      @read_timeout || @timeout
+    end
+
+    def read_timeout=(seconds)
+      @read_timeout = seconds(seconds)
+    end
+
+    private
+
+    def seconds(value)
+      value && value > 0 ? value : nil
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+IOTimeoutError = Class.new(IOError) unless defined?(IOTimeoutError)
+
+module IOTimeoutMixin
+  def self.included(mod)
+    im = mod.instance_methods
+    mod.include(im.index(:wait_writable) && im.index(:wait_readable) ? WithDeadlineMethods : WidthDeadlineIO)
+  end
+
+  def read(nbytes, timeout: nil)
+    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) }
+    end
+  end
+
+  def write(*args, timeout: nil)
+    timeout = timeout.to_f
+    return write_all(args.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) }
+    end
+  end
+
+  private
+
+  def read_all(nbytes)
+    return '' if nbytes == 0
+    result = ''
+    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 0 == (size = data.bytesize)
+    result = 0
+    loop do
+      written = yield(data)
+      result += written
+      return result if result >= size
+      data = data.byteslice(written, data.bytesize - written)
+    end
+  end
+
+  module WithDeadlineMethods
+    private
+
+    def with_deadline(deadline)
+      loop do
+        case ret = yield
+        when :wait_writable
+          remaining_time = deadline - Time.now
+          raise(IOTimeoutError) 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?
+        else
+          return ret
+        end
+      end
+    end
+  end
+
+  module WidthDeadlineIO
+    private
+
+    def with_deadline(deadline)
+      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?
+        when :wait_readable
+          remaining_time = deadline - Time.now
+          raise(IOTimeoutError) if remaining_time <= 0 || ::IO.select([self], nil, nil, remaining_time).nil?
+        else
+          return ret
+        end
+      end
+    end
+  end
+
+  private_constant :WithDeadlineMethods, :WidthDeadlineIO
+end

data/lib/tcp-client/ssl_socket.rb

@@ -0,0 +1,35 @@
+begin
+  require 'openssl'
+rescue LoadError
+  return
+end
+
+require_relative 'mixin/io_timeout'
+
+class TCPClient
+  class SSLSocket < ::OpenSSL::SSL::SSLSocket
+    include IOTimeoutMixin
+
+    def initialize(socket, address, configuration)
+      ssl_params = Hash[configuration.ssl_params]
+      super(socket, create_context(ssl_params))
+      connect_to(address, configuration.connect_timeout)
+    end
+
+    private
+
+    def create_context(ssl_params)
+      ctx = OpenSSL::SSL::SSLContext.new
+      ctx.set_params(ssl_params)
+      ctx
+    end
+
+    def connect_to(address, timeout)
+      self.hostname = address.hostname
+      timeout ? with_deadline(Time.now + timeout){ connect_nonblock(exception: false) } : connect
+      post_connection_check(address.hostname)
+    end
+  end
+
+  private_constant :SSLSocket
+end

data/lib/tcp-client/tcp_socket.rb

@@ -0,0 +1,32 @@
+require 'socket'
+require_relative 'mixin/io_timeout'
+
+class TCPClient
+  class TCPSocket < ::Socket
+    include IOTimeoutMixin
+
+    def initialize(address, configuration)
+      super(address.addrinfo.ipv6? ? :INET6 : :INET, :STREAM)
+      configure(configuration)
+      connect_to(address, configuration.connect_timeout)
+    end
+
+    private
+
+    def connect_to(address, timeout)
+      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)
+    end
+
+    def configure(configuration)
+      unless configuration.buffered
+        self.sync = true
+        setsockopt(:TCP, :NODELAY, 1)
+      end
+      setsockopt(:SOCKET, :KEEPALIVE, configuration.keep_alive ? 1 : 0)
+      self.do_not_reverse_lookup = configuration.reverse_lookup
+    end
+  end
+
+  private_constant :TCPSocket
+end

data/lib/tcp-client/version.rb

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

data/lib/tcp_client.rb

@@ -0,0 +1 @@
+require_relative 'tcp-client'

data/rakefile.rb

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.ruby_opts = %w[-w]
+  t.verbose = true
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default do
+  exec('rake -T')
+end

data/sample/google.rb

@@ -0,0 +1,17 @@
+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
+end
+
+# the following request sequence is not allowed to last longer than 0.75 seconds:
+# 0.5 seconds to connect
+# + 0.25 seconds to write data
+# + 0.25 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
+  pp client.read(12) # "HTTP/1.1 " + 3 byte HTTP status code
+end

data/sample/google_ssl.rb

@@ -0,0 +1,18 @@
+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
+end
+
+# the following request sequence is not allowed to last longer than 1.5 seconds:
+# 1 second to connect (incl. SSL handshake etc.)
+# + 0.25 seconds to write data
+# + 0.25 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
+  pp client.read(12) # "HTTP/1.1 " + 3 byte HTTP status code
+end

data/tcp-client.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require File.expand_path('../lib/tcp-client/version', __FILE__)
+
+GemSpec = Gem::Specification.new do |spec|
+  spec.name = 'tcp-client'
+  spec.version = TCPClient::VERSION
+  spec.summary = 'A TCP client implementation with working timeout support.'
+  spec.description = <<~EOS
+    This gem implements a TCP client with (optional) SSL support. The
+    motivation of this project is the need to have a _really working_
+    easy to use client which can handle time limits correctly. Unlike
+    other implementations this client respects given/configurable time
+    limits for each method (`connect`, `read`, `write`).
+  EOS
+  spec.author = 'Mike Blumtritt'
+  spec.email = 'mike.blumtritt@invision.de'
+  spec.homepage = 'https://github.com/mblumtritt/tcp-client'
+  spec.metadata = {'issue_tracker' => 'https://github.com/mblumtritt/tcp-client/issues'}
+  spec.rubyforge_project = spec.name
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+
+  spec.platform = Gem::Platform::RUBY
+  spec.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.require_paths = %w[lib]
+
+  all_files = %x(git ls-files -z).split(0.chr)
+  spec.test_files = all_files.grep(%r{^(spec|test)/})
+  spec.files = all_files - spec.test_files
+
+  spec.has_rdoc = false
+  spec.extra_rdoc_files = %w[README.md]
+end

data/test/tcp-client/configuration_test.rb

@@ -0,0 +1,45 @@
+require_relative '../test_helper'
+
+class ConfigurationTest < Test
+  def test_defaults
+    subject = TCPClient::Configuration.new
+    assert(subject.buffered)
+    assert(subject.keep_alive)
+    assert(subject.reverse_lookup)
+    refute(subject.ssl?)
+    assert_nil(subject.connect_timeout)
+    assert_nil(subject.read_timeout)
+    assert_nil(subject.write_timeout)
+  end
+
+  def test_configure
+    subject = TCPClient::Configuration.create do |cfg|
+      cfg.buffered = cfg.keep_alive = cfg.reverse_lookup = false
+      cfg.timeout = 42
+      cfg.ssl_params = {}
+    end
+    refute(subject.buffered)
+    refute(subject.keep_alive)
+    refute(subject.reverse_lookup)
+    assert_same(42, subject.connect_timeout)
+    assert_same(42, subject.read_timeout)
+    assert_same(42, subject.write_timeout)
+    assert(subject.ssl?)
+  end
+
+  def test_timeout_overwrite
+    subject = TCPClient::Configuration.create do |cfg|
+      cfg.connect_timeout = 1
+      cfg.read_timeout = 2
+      cfg.write_timeout = 3
+    end
+    assert_same(1, subject.connect_timeout)
+    assert_same(2, subject.read_timeout)
+    assert_same(3, subject.write_timeout)
+
+    subject.timeout = 42
+    assert_same(42, subject.connect_timeout)
+    assert_same(42, subject.read_timeout)
+    assert_same(42, subject.write_timeout)
+  end
+end

data/test/tcp-client/version_test.rb

@@ -0,0 +1,7 @@
+require_relative '../test_helper'
+
+class VersionTest < Test
+  def test_format
+    assert_match(/\d+\.\d+\.\d+/, TCPClient::VERSION)
+  end
+end

data/test/tcp_client_test.rb

@@ -0,0 +1,111 @@
+require_relative 'test_helper'
+
+class TCPClientTest < Test
+  def test_defaults
+    subject = TCPClient.new
+    assert(subject.closed?)
+    assert_equal('', subject.to_s)
+    assert_nil(subject.address)
+    subject.close
+    assert_raises(TCPClient::NotConnected) do
+      subject.write('hello world!')
+    end
+    assert_raises(TCPClient::NotConnected) do
+      subject.read(42)
+    end
+  end
+
+  def create_nonconnected_client
+    client = TCPClient.new
+    client.connect('', TCPClient::Configuration.new)
+  rescue Errno::EADDRNOTAVAIL
+  ensure
+    return client
+  end
+
+  def test_failed_state
+    subject = create_nonconnected_client
+    assert(subject.closed?)
+    assert_equal(':0', subject.to_s)
+    refute_nil(subject.address)
+    assert_equal(':0', subject.address.to_s)
+    assert_nil(subject.address.hostname)
+    assert_instance_of(Addrinfo, subject.address.addrinfo)
+    assert_same(0, subject.address.addrinfo.ip_port)
+    assert_raises(TCPClient::NotConnected) do
+      subject.write('hello world!')
+    end
+    assert_raises(TCPClient::NotConnected) do
+      subject.read(42)
+    end
+  end
+
+  def test_connected_state
+    server = TCPServer.new(1234)
+    TCPClient.open('localhost:1234', TCPClient::Configuration.new) do |subject|
+      refute(subject.closed?)
+      assert_equal('localhost:1234', subject.to_s)
+      refute_nil(subject.address)
+      address_when_opened = subject.address
+      assert_equal('localhost:1234', subject.address.to_s)
+      assert_equal('localhost', subject.address.hostname)
+      assert_instance_of(Addrinfo, subject.address.addrinfo)
+      assert_same(1234, subject.address.addrinfo.ip_port)
+
+      subject.close
+      assert(subject.closed?)
+      assert_same(address_when_opened, subject.address)
+    end
+  ensure
+    server.close if server
+  end
+
+  def check_read_write_timeout(addr, timeout)
+    TCPClient.open(addr) do |subject|
+      refute(subject.closed?)
+      start_time = nil
+      assert_raises(IOTimeoutError) 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
+        start_time = Time.now
+        subject.read(42, timeout: timeout)
+      end
+      assert_in_delta(timeout, Time.now - start_time, 0.02)
+    end
+  end
+
+  def test_read_write_timeout
+    server = TCPServer.new(1235) # this server will never read/write client data
+    [0.5, 1, 1.5].each do |timeout|
+      check_read_write_timeout(':1235', timeout)
+    end
+  ensure
+    server.close if server
+  end
+
+  def check_connect_timeout(addr, config, timeout)
+    start_time = nil
+    assert_raises(IOTimeoutError) do
+      start_time = Time.now
+      TCPClient.new.connect(addr, config)
+    end
+    assert_in_delta(timeout, Time.now - start_time, 0.02)
+  end
+
+  def test_connect_ssl_timeout
+    server = TCPServer.new(1236)
+    config = TCPClient::Configuration.create do |cfg|
+      cfg.ssl_params = {}
+    end
+    [0.5, 1, 1.5].each do |timeout|
+      config.timeout = timeout
+      check_connect_timeout('localhost:1236', config, timeout)
+    end
+  ensure
+    server.close if server
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'minitest/autorun'
+require 'minitest/parallel'
+require_relative '../lib/tcp-client'
+
+$stdout.sync = $stderr.sync = true
+
+class Test < Minitest::Test
+  parallelize_me!
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: tcp-client
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Mike Blumtritt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  This gem implements a TCP client with (optional) SSL support. The
+  motivation of this project is the need to have a _really working_
+  easy to use client which can handle time limits correctly. Unlike
+  other implementations this client respects given/configurable time
+  limits for each method (`connect`, `read`, `write`).
+email: mike.blumtritt@invision.de
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- README.md
+- gems.rb
+- lib/tcp-client.rb
+- lib/tcp-client/address.rb
+- lib/tcp-client/configuration.rb
+- lib/tcp-client/mixin/io_timeout.rb
+- lib/tcp-client/ssl_socket.rb
+- lib/tcp-client/tcp_socket.rb
+- lib/tcp-client/version.rb
+- lib/tcp_client.rb
+- rakefile.rb
+- sample/google.rb
+- sample/google_ssl.rb
+- tcp-client.gemspec
+- test/tcp-client/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: []
+metadata:
+  issue_tracker: https://github.com/mblumtritt/tcp-client/issues
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: tcp-client
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A TCP client implementation with working timeout support.
+test_files:
+- test/tcp-client/configuration_test.rb
+- test/tcp-client/version_test.rb
+- test/tcp_client_test.rb
+- test/test_helper.rb