net_tcp_client 1.0.0

data/lib/net/tcp_client/version.rb

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

data/test/simple_tcp_server.rb

@@ -0,0 +1,114 @@
+require 'rubygems'
+require 'socket'
+require 'bson'
+require 'semantic_logger'
+
+# Read the bson document, returning nil if the IO is closed
+# before receiving any data or a complete BSON document
+def read_bson_document(io)
+  bytebuf = BSON::ByteBuffer.new
+  # Read 4 byte size of following BSON document
+  bytes = io.read(4)
+  return unless bytes
+  # Read BSON document
+  sz = bytes.unpack("V")[0]
+  bytebuf.append!(bytes)
+  bytes = io.read(sz-4)
+  return unless bytes
+  bytebuf.append!(bytes)
+  return BSON.deserialize(bytebuf)
+end
+
+# Simple single threaded server for testing purposes using a local socket
+# Sends and receives BSON Messages
+class SimpleTCPServer
+  attr_reader :thread
+  def initialize(port = 2000)
+    start(port)
+  end
+
+  def start(port)
+    @server = TCPServer.open(port)
+    @logger = SemanticLogger::Logger.new(self.class)
+
+    @thread = Thread.new do
+      loop do
+        @logger.debug "Waiting for a client to connect"
+
+        # Wait for a client to connect
+        on_request(@server.accept)
+      end
+    end
+  end
+
+  def stop
+    if @thread
+      @thread.kill
+      @thread.join
+      @thread = nil
+    end
+    begin
+      @server.close if @server
+    rescue IOError
+    end
+  end
+
+  # Called for each message received from the client
+  # Returns a Hash that is sent back to the caller
+  def on_message(message)
+    case message['action']
+    when 'test1'
+      { 'result' => 'test1' }
+    when 'sleep'
+      sleep message['duration'] || 1
+      { 'result' => 'sleep' }
+    when 'fail'
+      if message['attempt'].to_i >= 2
+        { 'result' => 'fail' }
+      else
+        nil
+      end
+    else
+      { '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"
+
+    while(request = read_bson_document(client)) do
+      @logger.debug "\n****************** Received request"
+      @logger.trace 'Request', request
+      break unless request
+
+      if reply = on_message(request)
+        @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
+        client.close
+        @logger.debug "Server closed"
+        #@thread.kill
+        @logger.debug "thread killed"
+        start(2000)
+        @logger.debug "Server Restarted"
+        break
+      end
+    end
+    # Disconnect from the client
+    client.close
+    @logger.debug "Disconnected from the client"
+  end
+
+end
+
+if $0 == __FILE__
+  SemanticLogger.default_level = :trace
+  SemanticLogger.add_appender(STDOUT)
+  server = SimpleTCPServer.new(2000)
+  server.thread.join
+end

data/test/tcp_client_test.rb

@@ -0,0 +1,190 @@
+# 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')
+
+# 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
+          Net::TCPClient.new(
+            :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
+        # Create a TCP Server, but do not respond to connections
+        server = TCPServer.open(2001)
+
+        exception = assert_raise Net::TCPClient::ConnectionTimeout do
+          1000.times do
+            Net::TCPClient.new(
+              :server              => 'localhost:2001',
+              :connect_timeout     => 0.5,
+              :connect_retry_count => 3
+            )
+          end
+        end
+        assert_match /Timedout after/, exception.message
+        server.close
+      end
+
+    end
+
+    context "with server" do
+      setup do
+        @server = SimpleTCPServer.new(2000)
+        @server_name = 'localhost:2000'
+      end
+
+      teardown do
+        @server.stop if @server
+      end
+
+      context "without client connection" do
+        should "timeout on first receive and then successfully read 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
+          )
+
+          request = { 'action' => 'sleep', 'duration' => @read_timeout + 0.5}
+          @client.write(BSON.serialize(request))
+
+          exception = assert_raise 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_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
+          @client = Net::TCPClient.new(
+            :server          => @server_name,
+            :connect_timeout => -1
+          )
+          request = { 'action' => 'test1' }
+          @client.write(BSON.serialize(request))
+          reply = read_bson_document(@client)
+          assert_equal 'test1', reply['result']
+          @client.close
+        end
+      end
+
+      context "with client connection" do
+        setup do
+          @read_timeout = 3.0
+          @client = Net::TCPClient.new(
+            :server          => @server_name,
+            :read_timeout    => @read_timeout
+          )
+          assert @client.alive?
+          assert_equal true, @client.close_on_error
+        end
+
+        def teardown
+          if @client
+            @client.close
+            assert !@client.alive?
+          end
+        end
+
+        should "successfully send and receive 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}
+          @client.write(BSON.serialize(request))
+
+          exception = assert_raise 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
+          # 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
+          attempt = 0
+          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
+            #       same request twice to the server
+            read_bson_document(@client)
+          end
+          assert_equal 'fail', reply['result']
+        end
+
+      end
+
+      context "without client connection" do
+        should "connect to second server when first is down" do
+          client = Net::TCPClient.new(
+            :servers         => ['localhost:1999', @server_name],
+            :read_timeout    => 3
+          )
+          assert_equal @server_name, client.server
+
+          request = { 'action' => 'test1' }
+          client.write(BSON.serialize(request))
+          reply = read_bson_document(client)
+          assert_equal 'test1', reply['result']
+
+          client.close
+        end
+
+        should "call on_connect after connection" do
+          client = Net::TCPClient.new(
+            :server          => @server_name,
+            :read_timeout    => 3,
+            :on_connect      => Proc.new do |socket|
+              # Reset user_data on each connection
+              socket.user_data = { :sequence => 1 }
+            end
+          )
+          assert_equal @server_name, client.server
+          assert_equal 1, client.user_data[:sequence]
+
+          request = { 'action' => 'test1' }
+          client.write(BSON.serialize(request))
+          reply = read_bson_document(client)
+          assert_equal 'test1', reply['result']
+
+          client.close
+        end
+      end
+
+    end
+
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: net_tcp_client
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Reid Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-25 00:00:00.000000000 Z
+dependencies: []
+description: Net::TCPClient implements resilience features that most developers wish
+  was already included in the standard Ruby libraries.
+email:
+- reidmo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/net/tcp_client.rb
+- lib/net/tcp_client/exceptions.rb
+- lib/net/tcp_client/logging.rb
+- lib/net/tcp_client/tcp_client.rb
+- lib/net/tcp_client/version.rb
+- test/simple_tcp_server.rb
+- test/tcp_client_test.rb
+homepage: https://github.com/reidmorrison/net_tcp_client
+licenses:
+- Apache License V2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Net::TCPClient is a TCP Socket Client with built-in timeouts, retries, and
+  logging
+test_files:
+- test/simple_tcp_server.rb
+- test/tcp_client_test.rb