resilient_socket 0.1.0 → 0.2.0

data/README.md

@@ -36,30 +36,26 @@ to adjust the retry logic
 
 ### Dependencies
 
-- Ruby MRI 1.8.7 (or above) Or, JRuby 1.6.3 (or above)
-- SemanticLogger
+- Ruby MRI 1.8.7 (or above), Ruby 1.9.3,  Or JRuby 1.6.3 (or above)
+- [SemanticLogger](http://github.com/ClarityServices/semantic-logger)
 
 ### Install
 
-    gem install semantic-logger
-
-To log to MongoDB
-
-    gem install mongo
+    gem install resilient_socket
 
 ### Future
 
-- Web Interface to view and search log information stored in MongoDB
+- Look into using https://github.com/tarcieri/nio4r for Async IO
 
 Development
 -----------
 
-Want to contribute to Semantic Logger?
+Want to contribute to Resilient Socket?
 
 First clone the repo and run the tests:
 
-    git clone git://github.com/ClarityServices/semantic-logger.git
-    cd semantic-logger
+    git clone git://github.com/ClarityServices/resilient_socket.git
+    cd resilient_socket
     jruby -S rake test
 
 Feel free to ping the mailing list with any issues and we'll try to resolve it.
@@ -69,20 +65,19 @@ Contributing
 
 Once you've made your great commits:
 
-1. [Fork](http://help.github.com/forking/) semantic-logger
+1. [Fork](http://help.github.com/forking/) resilient_socket
 2. Create a topic branch - `git checkout -b my_branch`
 3. Push to your branch - `git push origin my_branch`
-4. Create an [Issue](http://github.com/ClarityServices/semantic-logger/issues) with a link to your branch
+4. Create an [Issue](http://github.com/ClarityServices/resilient_socket/issues) with a link to your branch
 5. That's it!
 
 Meta
 ----
 
-* Code: `git clone git://github.com/ClarityServices/semantic-logger.git`
-* Home: <https://github.com/ClarityServices/semantic-logger>
-* Docs: TODO <http://ClarityServices.github.com/semantic-logger/>
-* Bugs: <http://github.com/reidmorrison/semantic-logger/issues>
-* Gems: <http://rubygems.org/gems/semantic-logger>
+* Code: `git clone git://github.com/ClarityServices/resilient_socket.git`
+* Home: <https://github.com/ClarityServices/resilient_socket>
+* Bugs: <http://github.com/reidmorrison/resilient_socket/issues>
+* Gems: <http://rubygems.org/gems/resilient_socket>
 
 This project uses [Semantic Versioning](http://semver.org/).
 

data/lib/resilient_socket.rb

@@ -1,6 +1,3 @@
-require 'socket'
-require 'semantic_logger'
-
 require 'resilient_socket/version'
 require 'resilient_socket/exceptions'
 module ResilientSocket

data/lib/resilient_socket/exceptions.rb

@@ -1,8 +1,34 @@
+require 'socket'
 module ResilientSocket
 
-  class Exception < ::RuntimeError; end
-  class ConnectionTimeout < Exception; end
-  class ReadTimeout < Exception; end
-  class ConnectionFailure < Exception; end
+  class ConnectionTimeout < ::SocketError; end
+  class ReadTimeout < ::SocketError; end
+
+  # Raised by ResilientSocket whenever a Socket connection failure has occurred
+  class ConnectionFailure < ::SocketError
+    # Returns the hostname and port against which the connection failure occurred
+    attr_reader :server
+
+    # Returns the original exception that caused the connection failure
+    # For example instances of Errno::ECONNRESET
+    attr_reader :cause
+
+    # Parameters
+    #   message [String]
+    #     Text message of the reason for the failure and/or where it occurred
+    #
+    #   server [String]
+    #     Hostname and port
+    #     For example: "localhost:2000"
+    #
+    #   cause [Exception]
+    #     Original Exception if any, otherwise nil
+    def initialize(message, server, cause=nil)
+      @server = server
+      @cause = cause
+      super(message)
+    end
+
+  end
 
 end

data/lib/resilient_socket/tcp_client.rb

@@ -1,3 +1,5 @@
+require 'socket'
+require 'semantic_logger'
 module ResilientSocket
 
   # Make Socket calls resilient by adding timeouts, retries and specific
@@ -22,17 +24,25 @@ module ResilientSocket
   # Raises ReadTimeout when the read timeout is exceeded
   # Raises ConnectionFailure when a network error occurs whilst reading or writing
   #
+  # Note: Only the following methods currently have auto-reconnect enabled:
+  #  * read
+  #  * write
+  #
   # Future:
   #
   # * Automatic failover to another server should the current server not respond
   #   to a connection request by supplying an array of host names
+  # * Add auto-reconnect feature to sysread, syswrite, etc...
+  # * To be a drop-in replacement to TCPSocket should also need to implement the
+  #   following TCPSocket instance methods:  :addr, :peeraddr
+  #
+  # Design Notes:
+  # * Does not inherit from Socket or TCP Socket because the socket instance
+  #   has to be completely destroyed and recreated after a connection failure
   #
   class TCPClient
     # Supports embedding user supplied data along with this connection
     # such as sequence number, etc.
-    # TCPClient will reset this value to nil on connection start and
-    # after a connection is re-established. For example on automatic reconnect
-    # due to a failed connection to the server
     attr_accessor :user_data
 
     # Returns [String] Name of the server connected to including the port number
@@ -44,6 +54,26 @@ module ResilientSocket
     # Returns [TrueClass|FalseClass] Whether send buffering is enabled for this connection
     attr_reader :buffered
 
+    @@reconnect_on_errors = [
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::EIO,
+      Errno::ENETDOWN,
+      Errno::ENETRESET,
+      Errno::EPIPE,
+      Errno::ETIMEDOUT,
+      EOFError,
+    ]
+
+    # Return the array of errors that will result in an automatic connection retry
+    #  To add any additional errors to the standard list:
+    #    ResilientSocket::TCPClient.reconnect_on_errors << Errno::EPROTO
+    def self.reconnect_on_errors
+      @@reconnect_on_errors
+    end
+
     # Create a connection, call the supplied block and close the connection on
     # completion of the block
     #
@@ -118,6 +148,13 @@ module ResilientSocket
     #     Number of seconds between connection retry attempts after the first failed attempt
     #     Default: 0.5
     #
+    #   :retry_count [Fixnum]
+    #     Number of times to retry when calling #retry_on_connection_failure
+    #     This is independent of :connect_retry_count which still applies with
+    #     connection failures. This retry controls upto how many times to retry the
+    #     supplied block should a connection failure occurr during the block
+    #     Default: 3
+    #
     #   :on_connect [Proc]
     #     Directly after a connection is established and before it is made available
     #     for use this Block is invoked.
@@ -149,6 +186,7 @@ module ResilientSocket
       buffered = params.delete(:buffered)
       @buffered = buffered.nil? ? true : buffered
       @connect_retry_count = params.delete(:connect_retry_count) || 10
+      @retry_count = params.delete(:retry_count) || 3
       @connect_retry_interval = (params.delete(:connect_retry_interval) || 0.5).to_f
       @on_connect = params.delete(:on_connect)
 
@@ -156,7 +194,7 @@ module ResilientSocket
         raise "Missing mandatory :server or :servers" unless server = params.delete(:server)
         @servers = [ server ]
       end
-      @logger = SemanticLogger::Logger.new("#{self.class.name} #{@servers.inspect}", params[:log_level] || SemanticLogger::Logger.default_level)
+      @logger = SemanticLogger::Logger.new("#{self.class.name} #{@servers.inspect}", params.delete(:log_level) || SemanticLogger::Logger.default_level)
       params.each_pair {|k,v| @logger.warn "Ignoring unknown option #{k} = #{v}"}
 
       # Connect to the Server
@@ -185,19 +223,22 @@ module ResilientSocket
     # Note: When multiple servers are supplied it will only try to connect to
     #       the subsequent servers once the retry count has been exceeded
     #
+    # Note: Calling #connect on an open connection will close the current connection
+    #       and create a new connection
     def connect
-      if @servers.size > 0
+      @socket.close if @socket && !@socket.closed?
+      if @servers.size > 1
         # Try each server in sequence
         @servers.each_with_index do |server, server_id|
           begin
-            @socket = connect_to_server(server)
+            connect_to_server(server)
           rescue ConnectionFailure => exc
             # Raise Exception once it has also failed to connect to the last server
             raise(exc) if @servers.size <= (server_id + 1)
           end
         end
       else
-        @socket = connect_to_server(@servers.first)
+        connect_to_server(@servers.first)
       end
 
       # Invoke user supplied Block every time a new connection has been established
@@ -212,64 +253,86 @@ module ResilientSocket
     # Raises ConnectionFailure whenever the send fails
     #        For a description of the errors, see Socket#write
     #
-    def send(data)
-      @logger.trace("==> Sending", data)
-      @logger.benchmark_debug("==> #send Sent #{data.length} bytes") do
+    def write(data)
+      @logger.trace("#write ==> sending", data)
+      @logger.benchmark_debug("#write ==> sent #{data.length} bytes") do
         begin
           @socket.write(data)
         rescue SystemCallError => exception
-          @logger.warn "#send Connection failure: #{exception.class}: #{exception.message}"
+          @logger.warn "#write Connection failure: #{exception.class}: #{exception.message}"
           close
-          raise ConnectionFailure.new("Send Connection failure: #{exception.class}: #{exception.message}")
+          raise ConnectionFailure.new("Send Connection failure: #{exception.class}: #{exception.message}", @server, exception)
         end
       end
     end
 
-    # 4. TCP receive timeout:
-    #    Send was successful but receive timed out after X seconds (for example 10 seconds)
-    #    No data or partial data received ( for example header but no body )
-    #    Close socket
-    #    Don't retry since it could result in duplicating the request
-    #    No retry, just raise a ReadTimeout
+    # Returns a response from the server
+    #
+    # Raises ConnectionTimeout when the time taken to create a connection
+    #        exceeds the :connect_timeout
+    #        Connection is closed
+    # Raises ConnectionFailure whenever Socket raises an error such as
+    #        Error::EACCESS etc, see Socket#connect for more information
+    #        Connection is closed
+    # Raises ReadTimeout if the timeout has been exceeded waiting for the
+    #        requested number of bytes from the server
+    #        Partial data will not be returned
+    #        Connection is _not_ closed and #read can be called again later
+    #        to read the respnse from the connection
     #
     # Parameters
-    #   maxlen [Fixnum]
-    #     The Maximum number of bytes to return
-    #     Very often less than maxlen bytes will be returned
+    #   length [Fixnum]
+    #     The number of bytes to return
+    #     #read will not return unitl 'length' bytes have been received from
+    #     the server
     #
     #   timeout [Float]
     #     Optional: Override the default read timeout for this read
     #     Number of seconds before raising ReadTimeout when no data has
     #     been returned
     #     Default: :read_timeout supplied to #initialize
-    def read(maxlen, buffer=nil, timeout=nil)
-      buffer ||= ''
-      @logger.benchmark_debug("<== #read Received upto #{maxlen} bytes") do
+    #
+    #  Note: After a ResilientSocket::ReadTimeout #read can be called again on
+    #        the same socket to read the response later.
+    #        If the application no longers want the connection after a
+    #        ResilientSocket::ReadTimeout, then the #close method _must_ be called
+    #        before calling _connect_ or _retry_on_connection_failure_ to create
+    #        a new connection
+    #
+    def read(length, buffer=nil, timeout=nil)
+      result = nil
+      @logger.benchmark_debug("#read <== read #{length} bytes") do
         # Block on data to read for @read_timeout seconds
         begin
           ready = IO.select([@socket], nil, [@socket], timeout || @read_timeout)
           unless ready
             @logger.warn "#read Timeout waiting for server to reply"
-            close
             raise ReadTimeout.new("Timedout after #{timeout || @read_timeout} seconds trying to read from #{@server}")
           end
         rescue IOError => exception
           @logger.warn "#read Connection failure while waiting for data: #{exception.class}: #{exception.message}"
           close
-          raise ConnectionFailure, "#{exception.class}: #{exception.message}"
+          raise ConnectionFailure.new("#{exception.class}: #{exception.message}", @server, exception)
         end
 
         # Read data from socket
         begin
-          @socket.sysread(maxlen, buffer)
-          @logger.trace("<== #read Received", buffer)
+          result = buffer.nil? ? @socket.read(length) : @socket.read(length, buffer)
+          @logger.trace("#read <== received", result.inspect)
+
+          # EOF before all the data was returned
+          if result.nil? || (result.length < length)
+            close
+            @logger.warn "#read server closed the connection before #{length} bytes were returned"
+            raise ConnectionFailure.new("Connection lost while reading data", @server, EOFError.new("end of file reached"))
+          end
         rescue SystemCallError, IOError => exception
-          @logger.warn "#read Connection failure while reading data: #{exception.class}: #{exception.message}"
           close
-          raise ConnectionFailure, "#{exception.class}: #{exception.message}"
+          @logger.warn "#read Connection failure while reading data: #{exception.class}: #{exception.message}"
+          raise ConnectionFailure.new("#{exception.class}: #{exception.message}", @server, exception)
         end
       end
-      buffer
+      result
     end
 
     # Send and/or receive data with automatic retry on connection failure
@@ -306,46 +369,35 @@ module ResilientSocket
     #    # Server returns "SAVED" if the call was successfull
     #    result = client.read(20).strip
     #
-    # 3. Example of a resilient request that _modifies_ data on the server:
-    #
-    #    When changing state on the server, for example when updating a value
-    #    Wrap _only_ the send with #retry_on_connection_failure
-    #    The read must be outside the #retry_on_connection_failure since we must
-    #    not retry the send if the connection fails during the #read
-    #
-    #    value = 45
-    #    # Only the send is within the retry block since we cannot re-send once
-    #    # the send was successful since the server may have made the change
-    #    client.retry_on_connection_failure do
-    #      client.send("SETVALUE:#{count}\n")
-    #    end
-    #    # Server returns "SAVED" if the call was successfull
-    #    saved = (client.read(20).strip == 'SAVED')
-    #
-    #
     # Error handling is implemented as follows:
     #    If a network failure occurrs during the block invocation the block
     #    will be called again with a new connection to the server.
     #    It will only be retried up to 3 times
     #    The re-connect will independently retry and timeout using all the
     #    rules of #connect
-    #
-    #
     def retry_on_connection_failure
       retries = 0
       begin
         connect if closed?
         yield(self)
       rescue ConnectionFailure => exception
+        # Connection no longer usable. The next call to #retry_on_connection_failure
+        # will create a new connection since this one is now closed
         close
-        if retries < 3
+
+        exc_str = exception.cause ? "#{exception.cause.class}: #{exception.cause.message}" : exception.message
+        # Re-raise exceptions that should not be retried
+        if !self.class.reconnect_on_errors.include?(exception.cause.class)
+          @logger.warn "#retry_on_connection_failure not configured to retry: #{exc_str}"
+          raise exception
+        elsif retries < @retry_count
           retries += 1
-          @logger.warn "#retry_on_connection_failure Connection failure: #{exception.message}. Retry: #{retries}"
+          @logger.warn "#retry_on_connection_failure retry #{retries} due to #{exception.class}: #{exception.message}"
           connect
           retry
         end
         @logger.error "#retry_on_connection_failure Connection failure: #{exception.class}: #{exception.message}. Giving up after #{retries} retries"
-        raise ConnectionFailure.new("After #{retries} retry_on_connection_failure attempts: #{exception.class}: #{exception.message}")
+        raise ConnectionFailure.new("After #{retries} retries to host '#{server}': #{exc_str}", @server, exception.cause)
       rescue Exception => exc
         # With any other exception we have to close the connection since the connection
         # is now in an unknown state
@@ -354,7 +406,7 @@ module ResilientSocket
       end
     end
 
-    # Close the socket
+    # Close the socket only if it is not already closed
     #
     # Logs a warning if an error occurs trying to close the socket
     def close
@@ -368,6 +420,31 @@ module ResilientSocket
       @socket.closed?
     end
 
+    # Returns whether the connection to the server is alive
+    #
+    # It is useful to call this method before making a call to the server
+    # that would change data on the server
+    #
+    # Note: This method is only useful if the server closed the connection or
+    #       if a previous connection failure occurred.
+    #       If the server is hard killed this will still return true until one
+    #       or more writes are attempted
+    #
+    # Note: In testing the overhead of this call is rather low, with the ability to
+    # make about 120,000 calls per second against an active connection.
+    # I.e. About 8.3 micro seconds per call
+    def alive?
+      return false if @socket.closed?
+
+      if IO.select([@socket], nil, nil, 0)
+        !@socket.eof? rescue false
+      else
+        true
+      end
+    rescue IOError
+      false
+    end
+
     # See: Socket#setsockopt
     def setsockopt(level, optname, optval)
       @socket.setsockopt(level, optname, optval)
@@ -382,44 +459,44 @@ module ResilientSocket
     # Raises ConnectionTimeout when the connection timeout has been exceeded
     # Raises ConnectionFailure
     def connect_to_server(server)
-      socket = nil
+      # Have to use Socket internally instead of TCPSocket since TCPSocket
+      # does not offer async connect API amongst others:
+      # :accept, :accept_nonblock, :bind, :connect, :connect_nonblock, :getpeereid,
+      # :ipv6only!, :listen, :recvfrom_nonblock, :sysaccept
       retries = 0
       @logger.benchmark_info "Connecting to server #{server}" do
-        begin
-          host_name, port = server.split(":")
-          port = port.to_i
-          address = Socket.getaddrinfo('localhost', nil, Socket::AF_INET)
+        host_name, port = server.split(":")
+        port = port.to_i
 
-          socket = Socket.new(Socket.const_get(address[0][0]), Socket::SOCK_STREAM, 0)
-          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) unless buffered
+        address = Socket.getaddrinfo(host_name, nil, Socket::AF_INET)
+        socket_address = Socket.pack_sockaddr_in(port, address[0][3])
 
-          # http://stackoverflow.com/questions/231647/how-do-i-set-the-socket-timeout-in-ruby
+        begin
           begin
-            socket_address = Socket.pack_sockaddr_in(port, address[0][3])
-            socket.connect_nonblock(socket_address)
+            @socket = Socket.new(Socket.const_get(address[0][0]), Socket::SOCK_STREAM, 0)
+            @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) unless buffered
+            @socket.connect_nonblock(socket_address)
           rescue Errno::EINPROGRESS
-            resp = IO.select(nil, [socket], nil, @connect_timeout)
-            raise(ConnectionTimeout.new("Timedout after #{@connect_timeout} seconds trying to connect to #{host_name}:#{port}")) unless resp
+            resp = IO.select(nil, [@socket], nil, @connect_timeout)
+            raise(ConnectionTimeout.new("Timedout after #{@connect_timeout} seconds trying to connect to #{server}")) unless resp
             begin
-              socket_address = Socket.pack_sockaddr_in(port, address[0][3])
-              socket.connect_nonblock(socket_address)
+              @socket.connect_nonblock(socket_address)
             rescue Errno::EISCONN
             end
           end
           break
         rescue SystemCallError => exception
-          if retries < @connect_retry_count
+          if retries < @connect_retry_count && self.class.reconnect_on_errors.include?(exception.class)
             retries += 1
             @logger.warn "Connection failure: #{exception.class}: #{exception.message}. Retry: #{retries}"
             sleep @connect_retry_interval
             retry
           end
           @logger.error "Connection failure: #{exception.class}: #{exception.message}. Giving up after #{retries} retries"
-          raise ConnectionFailure.new("After #{retries} attempts: #{exception.class}: #{exception.message}")
+          raise ConnectionFailure.new("After #{retries} connection attempts to host '#{server}': #{exception.class}: #{exception.message}", @server, exception)
         end
       end
       @server = server
-      socket
     end
 
   end

data/lib/resilient_socket/version.rb

@@ -1,3 +1,3 @@
 module ResilientSocket #:nodoc
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/nbproject/private/private.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project-private xmlns="http://www.netbeans.org/ns/project-private/1">
+    <editor-bookmarks xmlns="http://www.netbeans.org/ns/editor-bookmarks/1"/>
+</project-private>

data/nbproject/private/rake-d.txt

@@ -1,4 +1,4 @@
-clean=Remove any temporary products.
-clobber=Remove any generated file.
-gem=Build gem
-test=Run Test Suite
+clean=
+clobber=
+gem=
+test=

data/nbproject/project.properties

@@ -1,6 +1,5 @@
 file.reference.resilient_socket-lib=lib
 file.reference.resilient_socket-test=test
-javac.classpath=
 main.file=
 platform.active=Ruby
 source.encoding=UTF-8

data/test/tcp_client_test.rb

@@ -23,7 +23,7 @@ class TCPClientTest < Test::Unit::TestCase
             :connect_retry_interval => 0.1,
             :connect_retry_count    => 5)
         end
-        assert_match /After 5 attempts: Errno::ECONNREFUSED/, exception.message
+        assert_match /After 5 connection attempts to host 'localhost:3300': Errno::ECONNREFUSED/, exception.message
       end
 
     end
@@ -58,35 +58,54 @@ class TCPClientTest < Test::Unit::TestCase
             :server          => @server_name,
             :read_timeout    => @read_timeout
           )
+          assert @client.alive?
         end
 
         def teardown
-          @client.close if @client
+          if @client
+            @client.close
+            assert !@client.alive?
+          end
         end
 
         should "successfully send and receive data" do
           request = { 'action' => 'test1' }
-          @client.send(BSON.serialize(request))
+          @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.send(BSON.serialize(request))
+          @client.write(BSON.serialize(request))
 
           exception = assert_raise ResilientSocket::ReadTimeout do
             # Read 4 bytes from server
             @client.read(4)
           end
+          assert @client.alive?
           assert_match /Timedout after #{@read_timeout} seconds trying to read from #{@server_name}/, exception.message
         end
 
+        should "timeout on first receive and then successfully read the response" do
+          request = { 'action' => 'sleep', 'duration' => @read_timeout + 0.5}
+          @client.write(BSON.serialize(request))
+
+          exception = assert_raise ResilientSocket::ReadTimeout do
+            # Read 4 bytes from server
+            @client.read(4)
+          end
+          assert @client.alive?
+          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']
+        end
+
         should "retry on connection failure" do
           attempt = 0
           reply = @client.retry_on_connection_failure do
             request = { 'action' => 'fail', 'attempt' => (attempt+=1) }
-            @client.send(BSON.serialize(request))
+            @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)
@@ -105,7 +124,7 @@ class TCPClientTest < Test::Unit::TestCase
           assert_equal @server_name, client.server
 
           request = { 'action' => 'test1' }
-          client.send(BSON.serialize(request))
+          client.write(BSON.serialize(request))
           reply = read_bson_document(client)
           assert_equal 'test1', reply['result']
 
@@ -125,7 +144,7 @@ class TCPClientTest < Test::Unit::TestCase
           assert_equal 1, client.user_data[:sequence]
 
           request = { 'action' => 'test1' }
-          client.send(BSON.serialize(request))
+          client.write(BSON.serialize(request))
           reply = read_bson_document(client)
           assert_equal 'test1', reply['result']
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resilient_socket
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-04 00:00:00.000000000 Z
+date: 2012-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -41,16 +41,16 @@ files:
 - LICENSE.txt
 - nbproject/private/config.properties
 - nbproject/private/private.properties
+- nbproject/private/private.xml
 - nbproject/private/rake-d.txt
 - nbproject/project.properties
 - nbproject/project.xml
 - Rakefile
 - README.md
-- resilient_socket-0.0.1.gem
-- resilient_socket-0.0.2.gem
 - test/simple_tcp_server.rb
 - test/tcp_client_test.rb
 - test.log
+- test.log.working
 homepage: https://github.com/ClarityServices/resilient_socket
 licenses: []
 post_install_message: