kjess 1.0.0 → 1.1.0

data/CONTRIBUTING.md

@@ -35,7 +35,8 @@ easiest way to contribute.
 
 # Contributors
 
-* Jeremy Hinegardner
+* Jeremy Hinegardner <https://github.com/copiousfreetime>
+* Eric Lindvall <https://github.com/eric>
 
 [GitHub Account]: https://github.com/signup/free "GitHub Signup"
 [GitHub Issues]:  https://github.com/copiousfreetime/kjess/issues "KJess Issues"

data/HISTORY.rdoc

@@ -1,4 +1,15 @@
 = KJess Changlog
+
+== Version 1.1.0 - 2013-01-08
+
+* Allow the setting of the kestrel server processes ports for testing (eric)
+* Update development dependencies, new version and missing gems
+* Re-wrap all network errors with KJess Errors (eric)
+* Ensure clients are not shared across fork() (eric)
+* Enforce boolean return value from KJess::Client#set (eric)
+* Added socket timeout feature (eric)
+* Added support for tcp keepalive
+
 == Version 1.0.0 - 2012-10-31
 
 * Initial Release - Yeah!

data/Manifest.txt

@@ -36,10 +36,12 @@ lib/kjess/response/not_stored.rb
 lib/kjess/response/reloaded_config.rb
 lib/kjess/response/server_error.rb
 lib/kjess/response/stats.rb
+lib/kjess/response/status.rb
 lib/kjess/response/stored.rb
 lib/kjess/response/unknown.rb
 lib/kjess/response/value.rb
 lib/kjess/response/version.rb
+lib/kjess/socket.rb
 lib/kjess/stats_cache.rb
 spec/client_spec.rb
 spec/kestrel_server.rb

data/Rakefile

@@ -19,13 +19,7 @@ namespace :develop do
     require 'rubygems/dependency_installer'
     installer = Gem::DependencyInstaller.new
 
-    # list these here instead of gem dependencies since there is not a way to
-    # specify ruby version specific dependencies
-    if RUBY_VERSION < "1.9.2"
-      Util.platform_gemspec.add_development_dependency( 'rcov', '~> 0.9.11' )
-    else
-      Util.platform_gemspec.add_development_dependency( 'simplecov', '~> 0.6.4' )
-    end
+    Util.set_coverage_gem
 
     puts "Installing gem depedencies needed for development"
     Util.platform_gemspec.dependencies.each do |dep|
@@ -194,14 +188,13 @@ This.gemspec['ruby'] = Gem::Specification.new do |spec|
                         "--markup", "tomdoc" ]
 
   # The Runtime Dependencies
-  # FIXME
-  # spec.add_dependency( 'map', '~> 6.2.0')
 
   # The Development Dependencies
-  spec.add_development_dependency( 'rake'     , '~> 0.9.2.2')
-  spec.add_development_dependency( 'minitest' , '~> 3.3.0' )
-  spec.add_development_dependency( 'rdoc'     , '~> 3.12'   )
-  spec.add_development_dependency( 'zip'      , "~> 2.0.2"  )
+  spec.add_development_dependency( 'rake'     , '~> 10.0.3')
+  spec.add_development_dependency( 'minitest' , '~> 4.4.0' )
+  spec.add_development_dependency( 'rdoc'     , '~> 3.12'  )
+  spec.add_development_dependency( 'zip'      , '~> 2.0.2' )
+  spec.add_development_dependency( 'json'     , '~> 1.7.6' )
 end
 
 
@@ -211,6 +204,7 @@ This.gemspec_file = "#{This.name}.gemspec"
 # Really this is only here to support those who use bundler
 desc "Build the #{This.name}.gemspec file"
 task :gemspec do
+  Util.set_coverage_gem
   File.open( This.gemspec_file, "wb+" ) do |f|
     f.write Util.platform_gemspec.to_ruby
   end
@@ -261,7 +255,13 @@ end
 # Load the extra rake tasks
 #------------------------------------------------------------------------------
 $: << "." unless $:.include?(".")
-load 'tasks/kestrel.rake'
+begin
+  load 'tasks/kestrel.rake'
+rescue LoadError => le
+  Util.task_warning( 'kestrel' )
+end
+
+
 
 #------------------------------------------------------------------------------
 # Rakefile Support - This is all the guts and utility methods that are
@@ -320,6 +320,19 @@ BEGIN {
     def self.platform_gemspec
       This.gemspec[This.platform]
     end
+
+    def self.set_coverage_gem
+      # list these here instead of gem dependencies since there is not a way to
+      # specify ruby version specific dependencies
+      g, v = 'simplecov', '~> 0.7.1'
+      if RUBY_VERSION < "1.9.2"
+        g, v = 'rcov', '~> 1.0.0'
+      end
+
+      if Util.platform_gemspec.dependencies.none? { |s| s.name == g } then
+        Util.platform_gemspec.add_development_dependency( g, v )
+      end
+    end
   end
 
   # Hold all the metadata about this project

data/lib/kjess.rb

@@ -1,5 +1,5 @@
 module KJess
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end
 
 require 'kjess/connection'

data/lib/kjess/client.rb

@@ -30,7 +30,7 @@ module KJess
       @port        = merged[:port]
       @admin_port  = merged[:admin_port]
       @stats_cache = StatsCache.new( self, merged[:stats_cache_expiration] )
-      @connection = KJess::Connection.new( host, port )
+      @connection  = KJess::Connection.new( host, port, merged )
     end
 
     # Public: Disconnect from the Kestrel server
@@ -77,7 +77,9 @@ module KJess
     # Returns true if successful, false otherwise
     def set( queue_name, item, expiration = 0 )
       s = KJess::Request::Set.new( :queue_name => queue_name, :data => item, :expiration => expiration )
-      send_recv( s )
+      resp = send_recv( s )
+
+      return KJess::Response::Stored === resp
     end
 
     # Public: Retrieve an item from the given queue
@@ -94,10 +96,18 @@ module KJess
     def get( queue_name, opts = {} )
       opts = opts.merge( :queue_name => queue_name )
       g    = KJess::Request::Get.new( opts )
-      resp = send_recv( g )
 
-      return resp.data if KJess::Response::Value === resp
-      return nil
+      if opts[:wait_for]
+        wait_for_in_seconds = opts[:wait_for] / 1000
+      else
+        wait_for_in_seconds = 0.1
+      end
+
+      connection.with_additional_read_timeout(wait_for_in_seconds) do
+        resp = send_recv( g )
+        return resp.data if KJess::Response::Value === resp
+        return nil
+      end
     end
 
     # Public: Reserve the next item on the queue
@@ -176,17 +186,27 @@ module KJess
     #
     # Returns true if the queue was flushed.
     def flush( queue_name )
-      req  = KJess::Request::Flush.new( :queue_name => queue_name )
-      resp = send_recv( req )
-      return KJess::Response::End === resp
+      # It can take a long time to flush all of the messages
+      # on a server, so we'll set the read timeout to something
+      # much higher than usual.
+      connection.with_additional_read_timeout(60) do
+        req  = KJess::Request::Flush.new( :queue_name => queue_name )
+        resp = send_recv( req )
+        return KJess::Response::End === resp
+      end
     end
 
     # Public: Remove all items from all queues on the kestrel server
     #
     # Returns true.
     def flush_all
-      resp = send_recv( KJess::Request::FlushAll.new )
-      return KJess::Response::End === resp
+      # It can take a long time to flush all of the messages
+      # on a server, so we'll set the read timeout to something
+      # much higher than usual.
+      connection.with_additional_read_timeout(60) do
+        resp = send_recv( KJess::Request::FlushAll.new )
+        return KJess::Response::End === resp
+      end
     end
 
     # Public: Have Kestrel reload its config.
@@ -215,7 +235,7 @@ module KJess
     #
     # Returns a String.
     def status( update_to = nil )
-      resp = send_recv( KJess::Request::Status.new( update_to ) )
+      resp = send_recv( KJess::Request::Status.new( :update_to => update_to ) )
       raise KJess::Error, "Status command is not supported" if KJess::Response::ClientError === resp
       return resp.message
     end
@@ -236,6 +256,8 @@ module KJess
     # Returns a Hash
     def stats!
       stats       = send_recv( KJess::Request::Stats.new )
+      raise KJess::Error, "Problem receiving stats: #{stats.inspect}" unless KJess::Response::Stats === stats
+
       h           = stats.data
       dump_stats  = send_recv( KJess::Request::DumpStats.new )
       h['queues'] = Hash.new
@@ -253,8 +275,7 @@ module KJess
     def ping
       stats
       true
-    rescue Errno::ECONNREFUSED => e
-      puts e
+    rescue Errno::ECONNREFUSED
       false
     end
 

data/lib/kjess/connection.rb

@@ -1,65 +1,104 @@
 require 'fcntl'
-require 'socket'
 require 'resolv'
 require 'resolv-replace'
 require 'kjess/error'
+require 'kjess/socket'
 
 module KJess
   # Connection
   class Connection
     class Error < KJess::Error; end
 
-    CRLF = "\r\n"
+    # Public: The hostname/ip address to connect to.
+    def host
+      socket.host
+    end
 
-    # Public:
-    # The hostname/ip address to connect to
-    attr_reader :host
+    # Public: The port number to connect to. Default 22133
+    def port
+      socket.port
+    end
 
-    # Public
-    # The port number to connect to. Default 22133
-    attr_reader :port
+    # Public: The timeout for connecting in seconds. Defaults to 2
+    def connect_timeout
+      socket.connect_timeout
+    end
 
-    def initialize( host, port = 22133 )
-      @host   = host
-      @port   = Float( port ).to_i
-      @socket = nil
+    # Public: The timeout for reading in seconds. Defaults to 2
+    def read_timeout
+      socket.read_timeout
     end
 
-    # Internal: Return the raw socket that is connected to the Kestrel server
-    #
-    # Returns the raw socket. If the socket is not connected it will connect and
-    # then return it.
-    #
-    # Returns a TCPSocket
-    def socket
-      return @socket if @socket and not @socket.closed?
-      return @socket = connect()
+    # Public: The timeout for writing in seconds. Defaults to 2
+    def write_timeout
+      socket.write_timeout
     end
 
-    # Internal: Create the socket we use to talk to the Kestrel server
-    #
-    # Returns a TCPSocket
-    def connect
-      sock = TCPSocket.new( host, port )
+    # Internal: return thekeepalive timeout
+    def keepalive_active?
+      socket.keepalive_active?
+    end
 
-      # close file descriptors if we exec or something like that
-      sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+    # Internal: return the keepalive count
+    # The keepalive count
+    def keepalive_count
+      socket.keepalive_count
+    end
 
-      # Disable Nagle's algorithm
-      sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+    # Internal: return the keepalive interval
+    def keepalive_interval
+      socket.keepalive_interval
+    end
 
-      # limit only to IPv4?
-      # addr = ::Socket.getaddrinfo(host, nil, Socket::AF_INET)
-      # sock = ::Socket.new(::Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
-      # saddr = ::Socket.pack_sockaddr_in(port, addr[0][3])
+    # Internal: return the keepalive idle
+    def keepalive_idle
+      socket.keepalive_idle
+    end
 
-      # tcp keepalive
-      # :SOL_SOCKET, :SO_KEEPALIVE, :SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all?{|c| Socket.const_defined? c}
-      # @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE,  true)
-      # @sock.setsockopt(Socket::SOL_TCP,    Socket::TCP_KEEPIDLE,  keepalive[:time])
-      # @sock.setsockopt(Socket::SOL_TCP,    Socket::TCP_KEEPINTVL, keepalive[:intvl])
-      # @sock.setsockopt(Socket::SOL_TCP,    Socket::TCP_KEEPCNT,   keepalive[:probes])
-      return sock
+    # TODO: make port an option at next major version number change
+    def initialize( host, port = 22133, options = {} )
+      if port.is_a?(Hash)
+        options = port
+        port = 22133
+      end
+
+      @options         = options.dup
+      @options[:host] = host
+      @options[:port] = Float( port ).to_i
+      @socket          = nil
+      @pid             = nil
+      @read_buffer     = ''
+    end
+
+    # Internal: Adds time to the read timeout
+    #
+    # additional_timeout - additional number of seconds to the read timeout
+    #
+    # Returns nothing
+    def with_additional_read_timeout(additional_timeout, &block)
+      old_read_timeout = socket.read_timeout
+      socket.read_timeout += additional_timeout
+      block.call
+    ensure
+      @read_timeout = old_read_timeout
+    end
+
+    # Internal: Return the socket that is connected to the Kestrel server
+    #
+    # Returns the socket. If the socket is not connected it will connect and
+    # then return it.
+    #
+    # Make sure that we close the socket if we are not the same process that
+    # opened that socket to begin with.
+    #
+    # Returns a KJess::Socket
+    def socket
+      close if @pid && @pid != Process.pid
+      return @socket if @socket and not @socket.closed?
+      @socket      = Socket.connect( @options )
+      @pid         = Process.pid
+      @read_buffer = ''
+      return @socket
     end
 
     # Internal: close the socket if it is not already closed
@@ -67,6 +106,7 @@ module KJess
     # Returns nothing
     def close
       @socket.close if @socket and not @socket.closed?
+      @read_buffer = ''
       @socket = nil
     end
 
@@ -85,8 +125,11 @@ module KJess
     #
     # Returns nothing
     def write( msg )
-      $stderr.write "--> #{msg}" if $DEBUG
+      $stderr.puts "--> #{msg}" if $DEBUG
       socket.write( msg )
+    rescue KJess::Error
+      close
+      raise
     end
 
     # Internal: read a single line from the socket
@@ -95,25 +138,44 @@ module KJess
     #
     # Returns a String
     def readline( eom = Protocol::CRLF )
-      while line = socket.readline( eom ) do
-        $stderr.write "<-- #{line}" if $DEBUG
+      while true
+        while (idx = @read_buffer.index(eom)) == nil
+          @read_buffer << socket.readpartial(10240)
+        end
+
+        line = @read_buffer.slice!(0, idx + eom.length)
+        $stderr.puts "<-- #{line}" if $DEBUG
         break unless line.strip.length == 0
       end
       return line
+    rescue KJess::Error
+      close
+      raise
     rescue EOFError
       close
       return "EOF"
+    rescue => e
+      close
+      raise Error, "Could not read from #{host}:#{port}: #{e.class}: #{e.message}", e.backtrace
     end
 
     # Internal: Read from the socket
     #
-    # args - this method takes the same arguments as IO#read
+    # nbytes - this method takes the number of bytes to read
     #
     # Returns what IO#read returns
-    def read( *args )
-      d = socket.read( *args )
-      $stderr.puts "<-- #{d}" if $DEBUG
-      return d
+    def read( nbytes )
+      while @read_buffer.length < nbytes
+        @read_buffer << socket.readpartial(nbytes - @read_buffer.length)
+      end
+
+      result = @read_buffer.slice!(0, nbytes)
+
+      $stderr.puts "<-- #{result}" if $DEBUG
+      return result
+    rescue KJess::Error
+      close
+      raise
     end
   end
 end

data/lib/kjess/protocol.rb

@@ -1,5 +1,5 @@
 module KJess
-  # Protocl is the base class that all Kestrel requests and responses are
+  # Protocol is the base class that all Kestrel requests and responses are
   # developed on. it defines the DSL for creating the Request and Response
   # objects that make up the Protocol.
   #
@@ -14,11 +14,12 @@ module KJess
       #
       # Returns the name
       def keyword( name = nil )
+        @keyword = nil unless defined? @keyword
         if name then
           register( name )
           @keyword = name
         end
-        @keyword
+        @keyword ||= nil
       end
 
       # Internal: define or return the arity of this protocol item

data/lib/kjess/request/status.rb

@@ -3,6 +3,13 @@ class KJess::Request
   class Status < KJess::Request
     keyword 'STATUS'
     arity   1
-    #valid_responses [ KJess::Response::Eof ]
+    valid_responses [ KJess::Response::Status::Up, KJess::Response::Status::Down,
+                      KJess::Response::Status::ReadOnly, KJess::Response::Status::Quiescent,
+                      KJess::Response::End ]
+
+    def parse_options_to_args( opts )
+      [ opts[:update_to] ]
+    end
+
   end
 end

data/lib/kjess/response.rb

@@ -70,6 +70,7 @@ require 'kjess/response/not_stored'
 require 'kjess/response/reloaded_config'
 require 'kjess/response/server_error'
 require 'kjess/response/stats'
+require 'kjess/response/status'
 require 'kjess/response/stored'
 require 'kjess/response/unknown'
 require 'kjess/response/value'

data/lib/kjess/response/status.rb

@@ -0,0 +1,19 @@
+class KJess::Response
+  class Status < KJess::Response
+    class Up < KJess::Response::Status
+      keyword "UP"
+    end
+
+    class Down < KJess::Response::Status
+      keyword "DOWN"
+    end
+
+    class Quiescent < KJess::Response::Status
+      keyword "QUIESCENT"
+    end
+
+    class ReadOnly< KJess::Response::Status
+      keyword "READONLY"
+    end
+  end
+end

data/lib/kjess/socket.rb

@@ -0,0 +1,291 @@
+require 'socket'
+
+module KJess
+  # Socket: A specialized socket that has been configure
+  class Socket
+    class Error < KJess::Error; end
+    class Timeout < Error; end
+
+    # Internal:
+    # The timeout for reading in seconds. Defaults to 2
+    attr_accessor :read_timeout
+
+    # Internal:
+    # The timeout for connecting in seconds. Defaults to 2
+    attr_reader :connect_timeout
+
+    # Internal:
+    # The timeout for writing in seconds. Defaults to 2
+    attr_reader :write_timeout
+
+    # Internal:
+    # The host this socket is connected to
+    attr_reader :host
+    
+    # Internal:
+    # The port this socket is connected to
+    attr_reader :port
+
+    # Internal
+    #
+    # Used for setting TCP_KEEPIDLE: overrides tcp_keepalive_time for a single
+    # socket.
+    #
+    # http://tldp.org/HOWTO/TCP-Keepalive-HOWTO/usingkeepalive.html
+    #
+    # tcp_keepalive_time:
+    #
+    #  The interval between the last data packet sent (simple ACKs are not
+    #  considered data) and the first keepalive probe; after the connection is
+    #  marked to need keepalive, this counter is not used any further.
+    attr_reader :keepalive_idle
+
+    # Internal
+    #
+    # Used for setting TCP_KEEPINTVL: overrides tcp_keepalive_intvl for a single
+    # socket.
+    #
+    # http://tldp.org/HOWTO/TCP-Keepalive-HOWTO/usingkeepalive.html
+    #
+    # tcp_keepalive_intvl:
+    #
+    #   The interval between subsequential keepalive probes, regardless of what
+    #   the connection has exchanged in the meantime.
+    attr_reader :keepalive_interval
+
+    # Internal
+    #
+    # Used for setting TCP_KEEPCNT: overrides tcp_keepalive_probes for a single
+    # socket.
+    #
+    # http://tldp.org/HOWTO/TCP-Keepalive-HOWTO/usingkeepalive.html
+    #
+    # tcp_keepalive_probes:
+    #
+    #   The number of unacknowledged probes to send before considering the
+    #   connection dead and notifying the application layer.
+    attr_reader :keepalive_count
+
+
+    # Internal: Create and connect to the given location.
+    #
+    # options, same as Constructor
+    #
+    # Returns an instance of KJess::Socket
+    def self.connect( options = {} )
+      s = Socket.new( options )
+      s.connect
+      return s
+    end
+
+    # Internal: Creates a new KJess::Socket
+    def initialize( options = {} )
+      @host               = options.fetch(:host)
+      @port               = options.fetch(:port)
+      @connect_timeout    = options.fetch(:connect_timeout   ,  2)
+      @read_timeout       = options.fetch(:read_timeout      ,  2)
+      @write_timeout      = options.fetch(:write_timeout     ,  2)
+      @keepalive_active   = options.fetch(:keepalive_active  , true)
+      @keepalive_idle     = options.fetch(:keepalive_idle    , 60)
+      @keepalive_interval = options.fetch(:keepalive_interval, 30)
+      @keepalive_count    = options.fetch(:keepalive_count   ,  5)
+      @socket             = nil
+    end
+
+    # Internal: Return whether or not the keepalive_active flag is set.
+    def keepalive_active?
+      @keepalive_active
+    end
+
+    # Internal: Low level socket allocation and option configuration
+    # 
+    # Using the options from the initializer, a new ::Socket is created that
+    # is:
+    #
+    #   TCP, IPv4 only, autoclosing on exit, nagle's algorithm is disabled and has
+    #   TCP Keepalive options set if keepalive is supported.
+    #
+    # Returns a new ::Socket instance
+    def blank_socket
+      sock = ::Socket.new(::Socket::AF_INET, ::Socket::SOCK_STREAM, 0)
+
+      # close file descriptors if we exec
+      sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+      # Disable Nagle's algorithm
+      sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+      if using_keepalive? then
+        sock.setsockopt( ::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE , true )
+        sock.setsockopt( ::Socket::SOL_TCP,    ::Socket::TCP_KEEPIDLE , keepalive_idle )
+        sock.setsockopt( ::Socket::SOL_TCP,    ::Socket::TCP_KEEPINTVL, keepalive_interval)
+        sock.setsockopt( ::Socket::SOL_TCP,    ::Socket::TCP_KEEPCNT  , keepalive_count)
+      end
+
+      return sock
+    end
+
+    # Internal: Return the connected raw Socket.
+    #
+    # If the socket is closed or non-existent it will create and connect again.
+    #
+    # Returns a ::Socket
+    def socket
+      return @socket unless closed?
+      @socket = connect()
+    end
+
+    # Internal: Closes the internal ::Socket
+    #
+    # Returns nothing
+    def close
+      @socket.close unless closed?
+      @socket = nil
+    end
+
+    # Internal: Return true the socket is closed.
+    def closed?
+      return true if @socket.nil?
+      return true if @socket.closed?
+      return false
+    end
+
+    # Internal:
+    #
+    # Connect to the remote host in a non-blocking fashion.
+    #
+    # Raise Error if there is a failure connecting.
+    #
+    # Return the ::Socket on success
+    def connect
+      # Calculate our timeout deadline
+      deadline = Time.now.to_f + connect_timeout
+
+      # Lookup destination address, we only want    IPv4             , TCP
+      addrs      = ::Socket.getaddrinfo(host, port, ::Socket::AF_INET, ::Socket::SOCK_STREAM )
+      errors     = []
+      conn_error = lambda { raise errors.first }
+      sock       = nil
+
+      addrs.find( conn_error ) do |addr| 
+        sock = connect_or_error( addr, deadline, errors )
+      end
+      return sock
+    end
+  
+    # Internal: Connect to the destination or raise an error.
+    #
+    # Connect to the address or capture the error of the connection
+    #
+    # addr     - An address returned from Socket.getaddrinfo()
+    # deadline - the after which we should raise a timeout error
+    # errors   - a collection of errors to append an error too should we have one.
+    #
+    # Make an attempt to connect to the given address. If it is successful,
+    # return the socket.
+    #
+    # Should the connection fail, append the exception to the errors array and
+    # return false.
+    #
+    def connect_or_error( addr, deadline, errors )
+      timeout = deadline - Time.now.to_f
+      raise Timeout, "Could not connect to #{host}:#{port}" if timeout <= 0
+      return connect_nonblock( addr, timeout )
+    rescue Error => e
+      errors << e
+      return false
+    end
+
+    # Internal: Connect to the give address within the timeout.
+    #
+    # Make an attempt to connect to a single address within the given timeout.
+    #
+    # Return the ::Socket when it is connected, or raise an Error if no
+    # connection was possible.
+    def connect_nonblock( addr, timeout )
+      sockaddr = ::Socket.pack_sockaddr_in(addr[1], addr[3])
+      sock     = blank_socket()
+      sock.connect_nonblock( sockaddr )
+      return sock
+    rescue Errno::EINPROGRESS
+      if IO.select(nil, [sock], nil, timeout).nil? then
+        raise Timeout, "Could not connect to #{host}:#{port} within #{timeout} seconds"
+      end
+      return connect_nonblock_finalize( sock, sockaddr )
+    rescue => ex
+      raise Error, "Could not connect to #{host}:#{port}: #{ex.class}: #{ex.message}", ex.backtrace
+    end
+
+
+    # Internal: Make sure that a non-blocking connect has truely connected.
+    # 
+    # Ensure that the given socket is actually connected to the given adddress.
+    #
+    # Returning the socket if it is and raising an Error if it isn't.
+    def connect_nonblock_finalize( sock, sockaddr )
+      sock.connect_nonblock( sockaddr )
+    rescue Errno::EISCONN
+      return sock
+    rescue => ex
+      raise Error, "Could not connect to #{host}:#{port}: #{ex.class}: #{ex.message}", ex.backtrace
+    end
+
+    # Internal: say if we are using TCP Keep Alive or not
+    #
+    # We will return true if the initialization options :keepalive_active is
+    # set to true, and if all the constants that are necessary to use TCP keep
+    # alive are defined.
+    #
+    # It may be the case that on some operating systems that the constants are
+    # not defined, so in that case we do not want to attempt to use tcp keep
+    # alive if we are unable to do so in any case.
+    #
+    # Returns true or false
+    def using_keepalive?
+      using = false
+      if keepalive_active? then
+        using = [ :SOL_SOCKET, :SO_KEEPALIVE, :SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all? do |c|
+          ::Socket.const_defined? c
+        end
+      end
+      return using
+    end
+
+    # Internal: Read up to a maxlen of data from the socket and store it in outbuf
+    #
+    # maxlen - the maximum number of bytes to read from the socket
+    # outbuf - the buffer in which to store the bytes.
+    #
+    # Returns the bytes read
+    def readpartial(maxlen, outbuf = nil)
+      return socket.read_nonblock(maxlen, outbuf)
+    rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::ECONNRESET
+      if IO.select([@socket], nil, nil, read_timeout)
+        retry
+      else
+        raise Timeout, "Could not read from #{host}:#{port} in #{read_timeout} seconds"
+      end
+    end
+
+    # Internal: Write the given data to the socket
+    #
+    # buf - the data to write to the socket.
+    #
+    # Raises an error if it is unable to write the data to the socket within the
+    # write_timeout.
+    #
+    # returns nothing
+    def write( buf )
+      until buf.length == 0
+        written = socket.write_nonblock(buf)
+        buf = buf[written, buf.length]
+      end
+    rescue Errno::EWOULDBLOCK, Errno::EINTR, Errno::EAGAIN, Errno::ECONNRESET
+      if IO.select(nil, [socket], nil, write_timeout)
+        retry
+      else
+        raise Timeout, "Could not write to #{host}:#{port} in #{write_timeout} seconds"
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -1,15 +1,28 @@
 require 'spec_helper'
 
-#$DEBUG = true 
 describe KJess::Client do
   before do
-    @client = KJess::Client.new
+    @client_version = "2.4.1"
+    @client = KJess::Spec.kjess_client()
   end
 
   after do
     KJess::Spec.reset_server( @client )
   end
 
+  describe "#initialize" do
+    it "can set keepalive parameters" do
+      client = KJess::Client.new(  :port => KJess::Spec.memcache_port,
+                                   :keepalive_active   => true,
+                                   :keepalive_interval => 1,
+                                   :keepalive_idle     => 900,
+                                   :keepalive_count    => 42)
+      client.connection.keepalive_interval.must_equal 1
+      client.connection.keepalive_idle.must_equal     900
+      client.connection.keepalive_count.must_equal    42
+    end
+  end
+
   describe "connection" do
     it "knows if it is connected" do
       @client.ping
@@ -26,13 +39,13 @@ describe KJess::Client do
 
   describe "#version" do
     it "knows the version of the server" do
-      @client.version.must_equal "2.3.4"
+      @client.version.must_equal @client_version
     end
   end
 
   describe "#stats" do
     it "can see the stats on an empty server" do
-      @client.stats['version'].must_equal '2.3.4'
+      @client.stats['version'].must_equal @client_version
     end
 
     it "sees the stats on a server with queues" do
@@ -65,6 +78,12 @@ describe KJess::Client do
       end
       @client.get( 'set_q_2' ).must_equal 'setspec2'
     end
+
+    it 'a really long binary item' do
+      binary = (0..255).to_a.pack('c*') * 100
+      @client.set 'set_bin_q', binary
+      @client.get('set_bin_q').must_equal binary
+    end
   end
 
   describe "#get" do
@@ -253,7 +272,14 @@ describe KJess::Client do
 
   describe "#status" do
     it "returns the server status" do
-      lambda { @client.status }.must_raise KJess::ClientError
+      @client.status.must_equal "UP"
+    end
+
+    it "can change the status" do
+      @client.status( "readonly" ).must_equal "END"
+      @client.status.must_equal "READONLY"
+      @client.status( "up" ).must_equal "END"
+      @client.status.must_equal "UP"
     end
   end
 
@@ -262,4 +288,67 @@ describe KJess::Client do
       @client.ping.must_equal true
     end
   end
+
+  describe "connecting to a server on a port that isn't listening" do
+    it "throws an exception" do
+      c = KJess::Connection.new '127.0.0.1', 65521
+      lambda { c.socket }.must_raise KJess::Socket::Error
+    end
+  end
+
+  describe "connecting to a server that isn't responding" do
+    it "throws an exception" do
+      c = KJess::Connection.new '127.1.1.1', 65521, :timeout => 0.5
+      lambda { c.socket }.must_raise KJess::Socket::Timeout
+    end
+  end
+
+  describe "reading for longer than the timeout" do
+    it "throws an exception" do
+      q = Queue.new
+      t = Thread.new do
+        begin
+          server = TCPServer.new 65520
+          q.enq :go
+          client = server.accept
+          Thread.stop
+        ensure
+          server.close rescue nil
+          client.close rescue nil
+        end
+      end
+
+      q.deq
+      c = KJess::Connection.new '127.0.0.1', 65520, :timeout => 0.5
+
+      lambda { c.readline }.must_raise KJess::Socket::Timeout
+
+      t.run
+      t.join
+    end
+  end
+
+  describe "writing for longer than the timeout" do
+    it "throws an exception" do
+      q = Queue.new
+      t = Thread.new do
+        begin
+          server = TCPServer.new 65520
+          q.enq :go
+          client = server.accept
+          Thread.stop
+        ensure
+          server.close rescue nil
+          client.close rescue nil
+        end
+      end
+      q.deq
+      c = KJess::Connection.new '127.0.0.1', 65520, :timeout => 0.5
+
+      lambda { c.write('a' * 10000000) }.must_raise KJess::Socket::Timeout
+
+      t.run
+      t.join
+    end
+  end
 end

data/spec/kestrel_server.rb

@@ -6,7 +6,7 @@ module KJess::Spec
 
     class << self
       def version
-        "2.3.4"
+        "2.4.1"
       end
 
       def dir
@@ -18,7 +18,7 @@ module KJess::Spec
       end
 
       def jar
-        File.join( dir, "kestrel_2.9.1-#{version}.jar" )
+        File.join( dir, "kestrel_2.9.2-#{version}.jar" )
       end
 
       def queue_path
@@ -47,7 +47,9 @@ import net.lag.kestrel.config._
 
 new KestrelConfig {
   listenAddress = "0.0.0.0"
-  memcacheListenPort = 22133
+  memcacheListenPort = #{KJess::Spec.memcache_port}
+  textListenPort = #{KJess::Spec.text_port}
+  thriftListenPort = #{KJess::Spec.thrift_port}
 
   queuePath = "#{KJess::Spec::KestrelServer.queue_path}"
 
@@ -62,7 +64,7 @@ new KestrelConfig {
   default.maxMemorySize = 128.megabytes
   default.maxJournalSize = 1.gigabyte
 
-  admin.httpPort = 2223
+  admin.httpPort = #{KJess::Spec.admin_port}
 
   admin.statsNodes = new StatsConfig {
     reporters = new TimeSeriesCollectorConfig
@@ -80,7 +82,7 @@ _EOC
       end
 
       def get_response( path )
-        uri = URI.parse( "http://localhost:2223/#{path}" )
+        uri = URI.parse( "http://localhost:#{KJess::Spec.admin_port}/#{path}" )
         resp = Net::HTTP.get_response( uri )
         JSON.parse( resp.body )
       end
@@ -100,6 +102,7 @@ _EOC
       def is_running?
         return "pong" == ping
       rescue Exception => e
+        #$stderr.puts e
         false
       end
 
@@ -129,9 +132,9 @@ _EOC
         h = get_response( 'shutdown' )
         return h['response'] == "ok"
       rescue => e
+        $stderr.puts e
         false
       end
     end
-
   end
 end

data/spec/response/client_error_spec.rb

@@ -1,8 +1,15 @@
 require 'spec_helper'
 
+module KJess::Spec
+  class BadRequest < KJess::Request
+    keyword 'BADREQUEST'
+    arity   1
+  end
+end
+
 describe KJess::ClientError do
   before do
-    @client = KJess::Client.new
+    @client = KJess::Spec.kjess_client()
   end
 
   after do
@@ -10,7 +17,7 @@ describe KJess::ClientError do
   end
 
   it "raises a client error if we send an invalid command" do
-    lambda { @client.send_recv( KJess::Request::Status.new ) }.must_raise KJess::ClientError
+    lambda { @client.send_recv( KJess::Spec::BadRequest.new ) }.must_raise KJess::ClientError
   end
 end
 

data/spec/spec_helper.rb

@@ -9,4 +9,4 @@ require 'minitest/autorun'
 require 'minitest/pride'
 require 'kjess'
 require 'utils'
-
+require 'thread'

data/spec/utils.rb

@@ -5,6 +5,26 @@ module KJess
       File.expand_path( "..", ROOT )
     end
 
+    def self.memcache_port
+      ENV['KJESS_MEMCACHE_PORT'] || 33122
+    end
+
+    def self.thrift_port
+      ENV['KJESS_THRIFT_PORT'] || 9992
+    end
+
+    def self.text_port
+      ENV['KJESS_TEXT_PORT'] || 9998
+    end
+
+    def self.admin_port
+      ENV['KJESS_ADMIN_PORT'] || 9999
+    end
+
+    def self.kjess_client
+      KJess::Client.new( :port => memcache_port )
+    end
+
     def self.reset_server( client )
       client.flush_all
       qlist = client.stats['queues']

data/tasks/kestrel.rake

@@ -7,10 +7,10 @@ namespace :kestrel do
     require 'uri'
     require 'net/http'
 
-    url = ::URI.parse("http://robey.github.com/kestrel/download/kestrel-#{KJess::Spec::KestrelServer.erver.version}.zip")
+    url = ::URI.parse("http://robey.github.com/kestrel/download/kestrel-#{KJess::Spec::KestrelServer.version}.zip")
 
     puts "downloading #{url.to_s} to #{KJess::Spec::KestrelServer.zip} ..."
-    File.open( KJess::Spec::KestrelServer.erver.zip, "wb+") do |f|
+    File.open( KJess::Spec::KestrelServer.zip, "wb+") do |f|
       res = Net::HTTP.get_response( url )
       f.write( res.body )
     end

metadata

@@ -1,97 +1,106 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: kjess
-version: !ruby/object:Gem::Version 
-  hash: 23
+version: !ruby/object:Gem::Version
+  version: 1.1.0
   prerelease: 
-  segments: 
-  - 1
-  - 0
-  - 0
-  version: 1.0.0
 platform: ruby
-authors: 
+authors:
 - Jeremy Hinegardner
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-10-31 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 0
-        - 9
-        - 2
-        - 2
-        version: 0.9.2.2
+      - !ruby/object:Gem::Version
+        version: 10.0.3
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: minitest
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 3
-        - 3
-        - 0
-        version: 3.3.0
+      - !ruby/object:Gem::Version
+        version: 4.4.0
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rdoc
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 31
-        segments: 
-        - 3
-        - 12
-        version: "3.12"
+      - !ruby/object:Gem::Version
+        version: 4.4.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
   name: zip
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :development
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 2
-        - 0
-        - 2
+      - !ruby/object:Gem::Version
         version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.6
   type: :development
-  version_requirements: *id004
-description: KJess is a pure ruby Kestrel client that supports Kestrel's Memcache style protocol.
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.6
+description: KJess is a pure ruby Kestrel client that supports Kestrel's Memcache
+  style protocol.
 email: jeremy@copiousfreetime.org
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - HISTORY.rdoc
 - Manifest.txt
 - README.rdoc
-files: 
+files:
 - CONTRIBUTING.md
 - HISTORY.rdoc
 - LICENSE
@@ -130,10 +139,12 @@ files:
 - lib/kjess/response/reloaded_config.rb
 - lib/kjess/response/server_error.rb
 - lib/kjess/response/stats.rb
+- lib/kjess/response/status.rb
 - lib/kjess/response/stored.rb
 - lib/kjess/response/unknown.rb
 - lib/kjess/response/value.rb
 - lib/kjess/response/version.rb
+- lib/kjess/socket.rb
 - lib/kjess/stats_cache.rb
 - spec/client_spec.rb
 - spec/kestrel_server.rb
@@ -147,41 +158,34 @@ files:
 - tasks/kestrel.rake
 homepage: http://github.com/copiousfreetime/kjess
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.rdoc
 - --markup
 - tomdoc
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: KJess is a pure ruby Kestrel client that supports Kestrel's Memcache style protocol.
-test_files: 
+summary: KJess is a pure ruby Kestrel client that supports Kestrel's Memcache style
+  protocol.
+test_files:
 - spec/client_spec.rb
 - spec/kestrel_server.rb
 - spec/request/set_spec.rb