net_tcp_client 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf88786139faafadc4b1f1fad33c681c4137b083
-  data.tar.gz: ef3ed6ce5f9ab0620bc7ef8746d3d0291ae03364
+  metadata.gz: f5b976dfea9f0cdbd07d3f25bfae55c230d26fd9
+  data.tar.gz: 10240a3b20378e17b9af022fef1e3bc7f27a29c2
 SHA512:
-  metadata.gz: 610d155da8d923ab15282c013900f16a9a624855a154ce97ea74388820352ebb112dc7fe19aa777aaef7d6b388a0da3c611f2b24a8dec8cb37b58b669e90f314
-  data.tar.gz: 30c4854a12224824e2e804f185ca8ca96c9dab9f809a4b669813a396b47ba4b1f3f266b367ec4527fa3cf13aa6383435d6f09dc91c0c66af0e5fa9ca8a2459d7
+  metadata.gz: 71c89932e7a8a378d4386eb5885e66224afc9b25d22f4edda43a0382398cb434570dbfb140cdb706067e35cb728307a1b3030bf1a24fc9a93b411b5abd872f3b
+  data.tar.gz: 5eca04bf84b8e02ef677b2069c962b3429bf8906aa4f67ce7c66ba3e60d7c7be32095c2719b99df4f0ad67bf2804fa708c211781aaa9e21e82ecd1485a1d60c7

data/README.md

@@ -1,13 +1,13 @@
-net_tcp_client
-==============
+# net_tcp_client
+![](https://img.shields.io/gem/v/net_tcp_client.svg) ![](https://img.shields.io/travis/rocketjob/net_tcp_client.svg) ![](https://img.shields.io/gem/dt/net_tcp_client.svg) ![](https://img.shields.io/badge/status-production%20ready-blue.svg)
 
 Net::TCPClient is a TCP Socket Client with built-in timeouts, retries, and logging
 
-* http://github.com/reidmorrison/net_tcp_client
+* http://github.com/rocketjob/net_tcp_client
 
 ## Introduction
 
-Net::TCPClient implements resilience features that most developers wish was
+Net::TCPClient implements resilience features that many developers wish was
 already included in the standard Ruby libraries.
 
 With so many "client" libraries to servers such us memcache, MongoDB, Redis, etc.
@@ -52,50 +52,74 @@ Net::TCPClient.connect(
 end
 ```
 
-## Dependencies
+## Project Status
 
-- Ruby 1.9.3, JRuby 1.7, or greater
+### Production Ready
 
-There is a soft dependency on SemanticLogger. It will use SemanticLogger only if
-it is already available, otherwise any other standard Ruby logger can be used.
-- [SemanticLogger](http://github.com/reidmorrison/semantic_logger)
-
-## Production Use
-
-Net::TCPClient was built for and is being used in a high performance, highly concurrent
-production environment. The resilient capabilities of Net::TCPClient are put to the
-test on a daily basis, especially with connections over the internet between
-remote data centers.
+Net::TCPClient is actively being used in a high performance, highly concurrent
+production environments. The resilient capabilities of Net::TCPClient are put to the
+test on a daily basis, including connections over the internet between remote data centers.
 
 ## Installation
 
     gem install net_tcp_client
 
-## Meta
+Although not required, it is recommended to use [Semantic Logger](http://rocketjob.github.io/semantic_logger) for logging purposes:
 
-* Code: `git clone git://github.com/reidmorrison/net_tcp_client.git`
-* Home: <https://github.com/reidmorrison/net_tcp_client>
-* Bugs: <http://github.com/reidmorrison/net_tcp_client/issues>
-* Gems: <http://rubygems.org/gems/net_tcp_client>
+    gem install semantic_logger
 
-This project uses [Semantic Versioning](http://semver.org/).
+Or, add the following lines to you `Gemfile`:
 
-## Author
+```ruby
+    gem 'semantic_logger'
+    gem 'net_tcp_client'
+```
+
+To configure a stand-alone application for Semantic Logger:
+
+```ruby
+require 'semantic_logger'
+
+# Set the global default log level
+SemanticLogger.default_level = :trace
+
+# Log to a file, and use the colorized formatter
+SemanticLogger.add_appender('development.log', &SemanticLogger::Appender::Base.colorized_formatter)
+```
 
-[Reid Morrison](https://github.com/reidmorrison) :: @reidmorrison
+If running Rails, see: [Semantic Logger Rails](http://rocketjob.github.io/semantic_logger/rails.html)
 
-## License
+Without Semantic Logger present a Ruby logger can be passed into Net::TCPClient.
 
-Copyright 2012, 2013, 2014 Reid Morrison
+### Upgrading from ResilientSocket
 
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
+ResilientSocket::TCPClient has been renamed to Net::TCPClient.
+The API is exactly the same, just with a new namespace. Please upgrade to the new
+`net_tcp_client` gem and replace all occurrences of `ResilientSocket::TCPClient`
+with `Net::TCPClient` in your code.
 
-    http://www.apache.org/licenses/LICENSE-2.0
+## Supports
 
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+Tested and supported on the following Ruby platforms:
+- Ruby 1.9.3, 2.0, 2.1, 2.2 and above
+- JRuby 1.7, 9.0 and above
+- Rubinius 2.5 and above
+
+There is a soft dependency on [Semantic Logger](http://github.com/rocketjob/semantic_logger). It will use SemanticLogger only if
+it is already available, otherwise any other standard Ruby logger can be used.
+
+### Note
+
+Be sure to place the `semantic_logger` gem dependency before `net_tcp_client` in your Gemfile.
+
+## Versioning
+
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## Author
+
+[Reid Morrison](https://github.com/reidmorrison)
+
+## Versioning
+
+This project uses [Semantic Versioning](http://semver.org/).

data/Rakefile

@@ -5,17 +5,17 @@ $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require 'net/tcp_client/version'
 
 task :gem do
-  system "gem build net_tcp_client.gemspec"
+  system 'gem build net_tcp_client.gemspec'
 end
 
 task :publish => :gem do
   system "git tag -a v#{Net::TCPClient::VERSION} -m 'Tagging #{Net::TCPClient::VERSION}'"
-  system "git push --tags"
+  system 'git push --tags'
   system "gem push net_tcp_client-#{Net::TCPClient::VERSION}.gem"
   system "rm net_tcp_client-#{Net::TCPClient::VERSION}.gem"
 end
 
-desc "Run Test Suite"
+desc 'Run Test Suite'
 task :test do
   Rake::TestTask.new(:functional) do |t|
     t.test_files = FileList['test/*_test.rb']

data/lib/net/tcp_client.rb

@@ -1,3 +1,4 @@
+require 'socket'
 require 'net/tcp_client/version'
 require 'net/tcp_client/exceptions'
 require 'net/tcp_client/tcp_client'

data/lib/net/tcp_client/exceptions.rb

@@ -1,9 +1,10 @@
-require 'socket'
 module Net
   class TCPClient
 
-    class ConnectionTimeout < ::SocketError; end
-    class ReadTimeout < ::SocketError; end
+    class ConnectionTimeout < ::SocketError;
+    end
+    class ReadTimeout < ::SocketError;
+    end
 
     # Raised by ResilientSocket whenever a Socket connection failure has occurred
     class ConnectionFailure < ::SocketError
@@ -26,7 +27,7 @@ module Net
       #     Original Exception if any, otherwise nil
       def initialize(message, server, cause=nil)
         @server = server
-        @cause = cause
+        @cause  = cause
         super(message)
       end
     end

data/lib/net/tcp_client/logging.rb

@@ -18,7 +18,7 @@ module Net
         else
           # Return a nil logger
           require 'logger'
-          logger = Logger.new($null)
+          logger       = Logger.new($null)
           logger.level = Logger::FATAL
           logger.extend(InstanceMethods)
           logger
@@ -64,7 +64,7 @@ module Net
         def format_log_message(level, message=nil, payload=nil, exception=nil, duration=nil, &block)
           if exception.nil? && payload && payload.is_a?(Exception)
             exception = payload
-            payload = nil
+            payload   = nil
           end
 
           if block && (result = block.call)
@@ -85,8 +85,8 @@ module Net
           tags_str = tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if tags && (tags.size > 0)
 
           message = message.to_s.dup
-          message << " -- " << payload.inspect if payload
-          message << " -- Exception: " << "#{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}" if exception
+          message << ' -- ' << payload.inspect if payload
+          message << ' -- Exception: ' << "#{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}" if exception
 
           duration_str = duration ? "(#{'%.1f' % duration}ms) " : ''
 
@@ -95,26 +95,27 @@ module Net
 
         # Measure the supplied block and log the message
         def benchmark(level, message, params, &block)
-          start     = Time.now
+          start = Time.now
           begin
-            rc = block.call(params) if block
+            rc        = block.call(params) if block
             exception = params[:exception]
             rc
           rescue Exception => exc
             exception = exc
           ensure
-            end_time = Time.now
+            end_time           = Time.now
             # Extract options after block completes so that block can modify any of the options
             log_exception      = params[:log_exception] || :partial
             on_exception_level = params[:on_exception_level]
             min_duration       = params[:min_duration] || 0.0
             payload            = params[:payload]
             metric             = params[:metric]
-            duration           = if block_given?
-              1000.0 * (end_time - start)
-            else
-              params[:duration] || raise("Mandatory block missing when :duration option is not supplied")
-            end
+            duration           =
+              if block_given?
+                1000.0 * (end_time - start)
+              else
+                params[:duration] || raise('Mandatory block missing when :duration option is not supplied')
+              end
 
             # Add scoped payload
             if self.payload
@@ -128,8 +129,8 @@ module Net
                 level = on_exception_level if on_exception_level
               when :partial
                 # On exception change the log level
-                level = on_exception_level if on_exception_level
-                message = "#{message} -- Exception: #{exception.class}: #{exception.message}"
+                level            = on_exception_level if on_exception_level
+                message          = "#{message} -- Exception: #{exception.class}: #{exception.message}"
                 logged_exception = nil
               else
                 logged_exception = nil
@@ -162,7 +163,8 @@ module Net
         def push_tags *tags
           # Need to flatten and reject empties to support calls from Rails 4
           new_tags = tags.flatten.collect(&:to_s).reject(&:empty?)
-          t = Thread.current[:semantic_logger_tags]
+          t        = Thread.current[:semantic_logger_tags]
+
           Thread.current[:semantic_logger_tags] = t.nil? ? new_tags : t.concat(new_tags)
           new_tags
         end
@@ -173,7 +175,7 @@ module Net
         end
 
         def with_payload(payload)
-          current_payload = self.payload
+          current_payload                          = self.payload
           Thread.current[:semantic_logger_payload] = current_payload ? current_payload.merge(payload) : payload
           yield
         ensure

data/lib/net/tcp_client/tcp_client.rb

@@ -1,6 +1,4 @@
-require 'socket'
 module Net
-
   # Make Socket calls resilient by adding timeouts, retries and specific
   # exception categories
   #
@@ -50,7 +48,7 @@ module Net
     attr_accessor :read_timeout, :connect_timeout, :connect_retry_count,
       :retry_count, :connect_retry_interval, :server_selector, :close_on_error
 
-    # Returns [TrueClass|FalseClass] Whether send buffering is enabled for this connection
+    # Returns [true|false] Whether send buffering is enabled for this connection
     attr_reader :buffered
 
     # Returns the logger being used by the TCPClient instance
@@ -237,15 +235,18 @@ module Net
       @close_on_error         = true if @close_on_error.nil?
       @logger                 = params.delete(:logger)
 
-      unless @servers = params.delete(:servers)
-        raise "Missing mandatory :server or :servers" unless server = params.delete(:server)
-        @servers = [ server ]
+      if server = params.delete(:server)
+        @servers = [server]
+      end
+      if servers = params.delete(:servers)
+        @servers = servers
       end
+      raise(ArgumentError, 'Missing mandatory :server or :servers') unless @servers
 
-      # If a logger is supplied, add the SemanticLogger extensions
+      # If a logger is supplied then extend it with the SemanticLogger API
       @logger = Logging.new_logger(logger, "#{self.class.name} #{@servers.inspect}", params.delete(:log_level))
 
-      params.each_pair {|k,v| logger.warn "Ignoring unknown option #{k} = #{v}"}
+      raise(ArgumentError, "Invalid options: #{params.inspect}") if params.size > 0
 
       # Connect to the Server
       connect
@@ -277,50 +278,17 @@ module Net
     #       and create a new connection
     def connect
       @socket.close if @socket && !@socket.closed?
-      if @servers.size > 1
-        case
-        when @server_selector.is_a?(Proc)
-          connect_to_server(@server_selector.call(@servers))
-
-        when @server_selector == :ordered
-          # Try each server in sequence
-          exception = nil
-          @servers.find do |server|
-            begin
-              connect_to_server(server)
-              exception = nil
-              true
-            rescue Net::TCPClient::ConnectionFailure => exc
-              exception = exc
-              false
-            end
-          end
-          # Raise Exception once it has also failed to connect to all servers
-          raise(exception) if exception
-
-        when @server_selector == :random
-          # Pick each server randomly, trying each server until one can be connected to
-          # If no server can be connected to a Net::TCPClient::ConnectionFailure is raised
-          servers_to_try = @servers.uniq
-          exception = nil
-          servers_to_try.size.times do |i|
-            server = servers_to_try[rand(servers_to_try.size)]
-            servers_to_try.delete(server)
-            begin
-              connect_to_server(server)
-              exception = nil
-            rescue Net::TCPClient::ConnectionFailure => exc
-              exception = exc
-            end
-          end
-          # Raise Exception once it has also failed to connect to all servers
-          raise(exception) if exception
-
-        else
-          raise ArgumentError.new("Invalid or unknown value for parameter :server_selector => #{@server_selector}")
-        end
-      else
+      case
+      when @servers.size == 1
         connect_to_server(@servers.first)
+      when @server_selector.is_a?(Proc)
+        connect_to_server(@server_selector.call(@servers))
+      when @server_selector == :ordered
+        connect_to_servers_in_order(@servers)
+      when @server_selector == :random
+        connect_to_servers_in_order(@servers.sample(@servers.size))
+      else
+        raise ArgumentError.new("Invalid or unknown value for parameter :server_selector => #{@server_selector}")
       end
 
       # Invoke user supplied Block every time a new connection has been established
@@ -336,9 +304,10 @@ module Net
     #        For a description of the errors, see Socket#write
     #
     def write(data)
-      logger.trace("#write ==> sending", data)
+      data = data.to_s
+      logger.trace('#write ==> sending', data)
       stats = {}
-      logger.benchmark_debug("#write ==> complete", stats) do
+      logger.benchmark_debug('#write ==> complete', stats) do
         begin
           stats[:bytes_sent] = @socket.write(data)
         rescue SystemCallError => exception
@@ -388,40 +357,21 @@ module Net
     #        before calling _connect_ or _retry_on_connection_failure_ to create
     #        a new connection
     #
-    def read(length, buffer=nil, timeout=nil)
+    def read(length, buffer = nil, timeout = read_timeout)
       result = nil
       logger.benchmark_debug("#read <== read #{length} bytes") do
-        if timeout != -1
-          # Block on data to read for @read_timeout seconds
-          ready = begin
-            ready = IO.select([@socket], nil, [@socket], timeout || @read_timeout)
-          rescue IOError => exception
-            logger.warn "#read Connection failure while waiting for data: #{exception.class}: #{exception.message}"
-            close if close_on_error
-            raise Net::TCPClient::ConnectionFailure.new("#{exception.class}: #{exception.message}", @server, exception)
-          rescue Exception
-            # Close the connection on any other exception since the connection
-            # will now be in an inconsistent state
-            close if close_on_error
-            raise
-          end
-          unless ready
-            close if close_on_error
-            logger.warn "#read Timeout waiting for server to reply"
-            raise Net::TCPClient::ReadTimeout.new("Timedout after #{timeout || @read_timeout} seconds trying to read from #{@server}")
-          end
-        end
+        wait_for_data(timeout)
 
         # Read data from socket
         begin
           result = buffer.nil? ? @socket.read(length) : @socket.read(length, buffer)
-          logger.trace("#read <== received", result.inspect)
+          logger.trace('#read <== received', result)
 
           # EOF before all the data was returned
           if result.nil? || (result.length < length)
             close if close_on_error
             logger.warn "#read server closed the connection before #{length} bytes were returned"
-            raise Net::TCPClient::ConnectionFailure.new("Connection lost while reading data", @server, EOFError.new("end of file reached"))
+            raise Net::TCPClient::ConnectionFailure.new('Connection lost while reading data', @server, EOFError.new('end of file reached'))
           end
         rescue SystemCallError, IOError => exception
           close if close_on_error
@@ -560,9 +510,9 @@ module Net
       retries = 0
       logger.benchmark_info "Connected to #{server}" do
         host_name, port = server.split(":")
-        port = port.to_i
+        port            = port.to_i
 
-        address = Socket.getaddrinfo(host_name, nil, Socket::AF_INET)
+        address        = Socket.getaddrinfo(host_name, nil, Socket::AF_INET)
         socket_address = Socket.pack_sockaddr_in(port, address[0][3])
 
         begin
@@ -600,5 +550,50 @@ module Net
       @server = server
     end
 
+    # Try connecting to each server in the order supplied
+    # The next server is tried if it cannot connect to the current one
+    # After the last server a ConnectionFailure will be raised
+    def connect_to_servers_in_order(servers)
+      exception = nil
+      servers.find do |server|
+        begin
+          connect_to_server(server)
+          exception = nil
+          true
+        rescue Net::TCPClient::ConnectionFailure => exc
+          exception = exc
+          false
+        end
+      end
+      # Raise Exception once it has also failed to connect to all servers
+      raise(exception) if exception
+    end
+
+    # Return once data is ready to be ready
+    # Raises Net::TCPClient::ReadTimeout if the timeout is exceeded
+    def wait_for_data(timeout)
+      return if timeout == -1
+
+      ready = false
+      begin
+        ready = IO.select([@socket], nil, [@socket], timeout)
+      rescue IOError => exception
+        logger.warn "#read Connection failure while waiting for data: #{exception.class}: #{exception.message}"
+        close if close_on_error
+        raise Net::TCPClient::ConnectionFailure.new("#{exception.class}: #{exception.message}", @server, exception)
+      rescue Exception
+        # Close the connection on any other exception since the connection
+        # will now be in an inconsistent state
+        close if close_on_error
+        raise
+      end
+
+      unless ready
+        close if close_on_error
+        logger.warn "#read Timeout after #{timeout} seconds"
+        raise Net::TCPClient::ReadTimeout.new("Timedout after #{timeout} seconds trying to read from #{@server}")
+      end
+    end
+
   end
 end

data/lib/net/tcp_client/version.rb

@@ -1,5 +1,5 @@
 module Net
   class TCPClient #:nodoc
-    VERSION = "1.0.0"
+    VERSION = '1.0.1'
   end
-end
+end

data/lib/net_tcp_client.rb

@@ -0,0 +1 @@
+require 'net/tcp_client'

data/test/simple_tcp_server.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'socket'
 require 'bson'
 require 'semantic_logger'
@@ -8,7 +7,7 @@ require 'semantic_logger'
 def read_bson_document(io)
   bytebuf = BSON::ByteBuffer.new
   # Read 4 byte size of following BSON document
-  bytes = io.read(4)
+  bytes   = io.read(4)
   return unless bytes
   # Read BSON document
   sz = bytes.unpack("V")[0]
@@ -22,33 +21,34 @@ end
 # Simple single threaded server for testing purposes using a local socket
 # Sends and receives BSON Messages
 class SimpleTCPServer
-  attr_reader :thread
+  include SemanticLogger::Loggable
+
+  attr_accessor :thread, :server
+
   def initialize(port = 2000)
     start(port)
   end
 
   def start(port)
-    @server = TCPServer.open(port)
-    @logger = SemanticLogger::Logger.new(self.class)
-
-    @thread = Thread.new do
+    self.server = TCPServer.open(port)
+    self.thread = Thread.new do
       loop do
-        @logger.debug "Waiting for a client to connect"
+        logger.debug 'Waiting for a client to connect'
 
         # Wait for a client to connect
-        on_request(@server.accept)
+        on_request(server.accept)
       end
     end
   end
 
   def stop
-    if @thread
-      @thread.kill
-      @thread.join
-      @thread = nil
+    if thread
+      thread.kill
+      thread.join
+      self.thread = nil
     end
     begin
-      @server.close if @server
+      server.close if server
     rescue IOError
     end
   end
@@ -58,50 +58,49 @@ class SimpleTCPServer
   def on_message(message)
     case message['action']
     when 'test1'
-      { 'result' => 'test1' }
+      {'result' => 'test1'}
     when 'sleep'
       sleep message['duration'] || 1
-      { 'result' => 'sleep' }
+      {'result' => 'sleep'}
     when 'fail'
       if message['attempt'].to_i >= 2
-        { 'result' => 'fail' }
+        {'result' => 'fail'}
       else
         nil
       end
     else
-      { 'result' => "Unknown action: #{message['action']}" }
+      {'result' => "Unknown action: #{message['action']}"}
     end
   end
 
   # Called for each client connection
   # In a real server each request would be handled in a separate thread
   def on_request(client)
-    @logger.debug "Client connected, waiting for data from client"
+    logger.debug 'Client connected, waiting for data from client'
 
-    while(request = read_bson_document(client)) do
-      @logger.debug "\n****************** Received request"
-      @logger.trace 'Request', request
+    while (request = read_bson_document(client)) do
+      logger.debug 'Received request', request
       break unless request
 
       if reply = on_message(request)
-        @logger.debug "Sending Reply"
-        @logger.trace 'Reply', reply
+        logger.debug 'Sending Reply'
+        logger.trace 'Reply', reply
         client.print(BSON.serialize(reply))
       else
-        @logger.debug "Closing client since no reply is being sent back"
-        @server.close
+        logger.debug 'Closing client since no reply is being sent back'
+        server.close
         client.close
-        @logger.debug "Server closed"
-        #@thread.kill
-        @logger.debug "thread killed"
+        logger.debug 'Server closed'
+        #thread.kill
+        logger.debug 'thread killed'
         start(2000)
-        @logger.debug "Server Restarted"
+        logger.debug 'Server Restarted'
         break
       end
     end
     # Disconnect from the client
     client.close
-    @logger.debug "Disconnected from the client"
+    logger.debug 'Disconnected from the client'
   end
 
 end
@@ -111,4 +110,4 @@ if $0 == __FILE__
   SemanticLogger.add_appender(STDOUT)
   server = SimpleTCPServer.new(2000)
   server.thread.join
-end
+end

data/test/tcp_client_test.rb

@@ -1,42 +1,31 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-$LOAD_PATH.unshift File.dirname(__FILE__)
-
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
 require 'socket'
-require 'net/tcp_client'
-require 'simple_tcp_server'
-
-SemanticLogger.default_level = :trace
-SemanticLogger.add_appender('test.log')
+require_relative 'test_helper'
+require_relative 'simple_tcp_server'
 
 # Unit Test for Net::TCPClient
-class TCPClientTest < Test::Unit::TestCase
-  context Net::TCPClient do
-
-    context "without server" do
-      should "raise exception when cannot reach server after 5 retries" do
-        exception = assert_raise Net::TCPClient::ConnectionFailure do
+class TCPClientTest < Minitest::Test
+  describe Net::TCPClient do
+    describe 'without server' do
+      it 'raises an exception when cannot reach server after 5 retries' do
+        exception = assert_raises Net::TCPClient::ConnectionFailure do
           Net::TCPClient.new(
-            :server                 => 'localhost:3300',
-            :connect_retry_interval => 0.1,
-            :connect_retry_count    => 5)
+            server:                 'localhost:3300',
+            connect_retry_interval: 0.1,
+            connect_retry_count:    5)
         end
         assert_match /After 5 connection attempts to host 'localhost:3300': Errno::ECONNREFUSED/, exception.message
       end
 
-      should "timeout on connect" do
+      it 'times out on connect' do
         # Create a TCP Server, but do not respond to connections
         server = TCPServer.open(2001)
 
-        exception = assert_raise Net::TCPClient::ConnectionTimeout do
+        exception = assert_raises Net::TCPClient::ConnectionTimeout do
           1000.times do
             Net::TCPClient.new(
-              :server              => 'localhost:2001',
-              :connect_timeout     => 0.5,
-              :connect_retry_count => 3
+              server:              'localhost:2001',
+              connect_timeout:     0.5,
+              connect_retry_count: 3
             )
           end
         end
@@ -46,47 +35,47 @@ class TCPClientTest < Test::Unit::TestCase
 
     end
 
-    context "with server" do
-      setup do
-        @server = SimpleTCPServer.new(2000)
+    describe "with server" do
+      before do
+        @server      = SimpleTCPServer.new(2000)
         @server_name = 'localhost:2000'
       end
 
-      teardown do
+      after do
         @server.stop if @server
       end
 
-      context "without client connection" do
-        should "timeout on first receive and then successfully read the response" do
+      describe 'without client connection' do
+        it 'times out on first receive and then successfully reads the response' do
           @read_timeout = 3.0
           # Need a custom client that does not auto close on error:
-          @client = Net::TCPClient.new(
-            :server          => @server_name,
-            :read_timeout    => @read_timeout,
-            :close_on_error  => false
+          @client       = Net::TCPClient.new(
+            server:         @server_name,
+            read_timeout:   @read_timeout,
+            close_on_error: false
           )
 
-          request = { 'action' => 'sleep', 'duration' => @read_timeout + 0.5}
+          request = {'action' => 'sleep', 'duration' => @read_timeout + 0.5}
           @client.write(BSON.serialize(request))
 
-          exception = assert_raise Net::TCPClient::ReadTimeout do
+          exception = assert_raises Net::TCPClient::ReadTimeout do
             # Read 4 bytes from server
             @client.read(4)
           end
           assert_equal false, @client.close_on_error
-          assert @client.alive?, "The client connection is not alive after the read timed out with :close_on_error => false"
+          assert @client.alive?, 'The client connection is not alive after the read timed out with close_on_error: false'
           assert_match /Timedout after #{@read_timeout} seconds trying to read from #{@server_name}/, exception.message
           reply = read_bson_document(@client)
           assert_equal 'sleep', reply['result']
           @client.close
         end
 
-        should "support infinite timeout" do
+        it 'support infinite timeout' do
           @client = Net::TCPClient.new(
-            :server          => @server_name,
-            :connect_timeout => -1
+            server:          @server_name,
+            connect_timeout: -1
           )
-          request = { 'action' => 'test1' }
+          request = {'action' => 'test1'}
           @client.write(BSON.serialize(request))
           reply = read_bson_document(@client)
           assert_equal 'test1', reply['result']
@@ -94,51 +83,51 @@ class TCPClientTest < Test::Unit::TestCase
         end
       end
 
-      context "with client connection" do
-        setup do
+      describe 'with client connection' do
+        before do
           @read_timeout = 3.0
-          @client = Net::TCPClient.new(
-            :server          => @server_name,
-            :read_timeout    => @read_timeout
+          @client       = Net::TCPClient.new(
+            server:       @server_name,
+            read_timeout: @read_timeout
           )
           assert @client.alive?
           assert_equal true, @client.close_on_error
         end
 
-        def teardown
+        def after
           if @client
             @client.close
             assert !@client.alive?
           end
         end
 
-        should "successfully send and receive data" do
-          request = { 'action' => 'test1' }
+        it 'sends and receives data' do
+          request = {'action' => 'test1'}
           @client.write(BSON.serialize(request))
           reply = read_bson_document(@client)
           assert_equal 'test1', reply['result']
         end
 
-        should "timeout on receive" do
-          request = { 'action' => 'sleep', 'duration' => @read_timeout + 0.5}
+        it 'timeouts on receive' do
+          request = {'action' => 'sleep', 'duration' => @read_timeout + 0.5}
           @client.write(BSON.serialize(request))
 
-          exception = assert_raise Net::TCPClient::ReadTimeout do
+          exception = assert_raises Net::TCPClient::ReadTimeout do
             # Read 4 bytes from server
             @client.read(4)
           end
-          # Due to :close_on_error => true, a timeout will close the connection
+          # Due to close_on_error: true, a timeout will close the connection
           # to prevent use of a socket connection in an inconsistent state
           assert_equal false, @client.alive?
           assert_match /Timedout after #{@read_timeout} seconds trying to read from #{@server_name}/, exception.message
         end
 
-        should "retry on connection failure" do
+        it 'retries on connection failure' do
           attempt = 0
-          reply = @client.retry_on_connection_failure do
-            request = { 'action' => 'fail', 'attempt' => (attempt+=1) }
+          reply   = @client.retry_on_connection_failure do
+            request = {'action' => 'fail', 'attempt' => (attempt+=1)}
             @client.write(BSON.serialize(request))
-            # Note: Do not put the read in this block if it should never send the
+            # Note: Do not put the read in this block if it never sends the
             #       same request twice to the server
             read_bson_document(@client)
           end
@@ -147,15 +136,15 @@ class TCPClientTest < Test::Unit::TestCase
 
       end
 
-      context "without client connection" do
-        should "connect to second server when first is down" do
+      describe 'without client connection' do
+        it 'connects to second server when the first is down' do
           client = Net::TCPClient.new(
-            :servers         => ['localhost:1999', @server_name],
-            :read_timeout    => 3
+            servers:      ['localhost:1999', @server_name],
+            read_timeout: 3
           )
           assert_equal @server_name, client.server
 
-          request = { 'action' => 'test1' }
+          request = {'action' => 'test1'}
           client.write(BSON.serialize(request))
           reply = read_bson_document(client)
           assert_equal 'test1', reply['result']
@@ -163,19 +152,19 @@ class TCPClientTest < Test::Unit::TestCase
           client.close
         end
 
-        should "call on_connect after connection" do
+        it 'calls on_connect after connection' do
           client = Net::TCPClient.new(
-            :server          => @server_name,
-            :read_timeout    => 3,
-            :on_connect      => Proc.new do |socket|
+            server:       @server_name,
+            read_timeout: 3,
+            on_connect:   Proc.new do |socket|
               # Reset user_data on each connection
-              socket.user_data = { :sequence => 1 }
+              socket.user_data = {sequence: 1}
             end
           )
           assert_equal @server_name, client.server
           assert_equal 1, client.user_data[:sequence]
 
-          request = { 'action' => 'test1' }
+          request = {'action' => 'test1'}
           client.write(BSON.serialize(request))
           reply = read_bson_document(client)
           assert_equal 'test1', reply['result']
@@ -187,4 +176,4 @@ class TCPClientTest < Test::Unit::TestCase
     end
 
   end
-end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'semantic_logger'
+require 'net/tcp_client'
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+SemanticLogger.default_level = :trace
+SemanticLogger.add_appender('test.log', &SemanticLogger::Appender::Base.colorized_formatter)

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: net_tcp_client
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-25 00:00:00.000000000 Z
+date: 2015-11-03 00:00:00.000000000 Z
 dependencies: []
-description: Net::TCPClient implements resilience features that most developers wish
+description: Net::TCPClient implements resilience features that many developers wish
   was already included in the standard Ruby libraries.
 email:
 - reidmo@gmail.com
@@ -26,9 +26,11 @@ files:
 - lib/net/tcp_client/logging.rb
 - lib/net/tcp_client/tcp_client.rb
 - lib/net/tcp_client/version.rb
+- lib/net_tcp_client.rb
 - test/simple_tcp_server.rb
 - test/tcp_client_test.rb
-homepage: https://github.com/reidmorrison/net_tcp_client
+- test/test_helper.rb
+homepage: https://github.com/rocketjob/net_tcp_client
 licenses:
 - Apache License V2.0
 metadata: {}
@@ -48,7 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Net::TCPClient is a TCP Socket Client with built-in timeouts, retries, and
@@ -56,3 +58,4 @@ summary: Net::TCPClient is a TCP Socket Client with built-in timeouts, retries,
 test_files:
 - test/simple_tcp_server.rb
 - test/tcp_client_test.rb
+- test/test_helper.rb