kjess 1.1.0 → 1.2.0

data/lib/kjess.rb

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

data/lib/kjess/client.rb

@@ -65,7 +65,7 @@ module KJess
       v = KJess::Request::Version.new
       r = send_recv( v )
       return r.version if Response::Version === r
-      raise KJess::Error, "Unexpected Response from VERSION command"
+      raise KJess::ProtocolError, "Unexpected Response from VERSION command"
     end
 
     # Public: Add an item to the given queue
@@ -98,7 +98,7 @@ module KJess
       g    = KJess::Request::Get.new( opts )
 
       if opts[:wait_for]
-        wait_for_in_seconds = opts[:wait_for] / 1000
+        wait_for_in_seconds = Float(opts[:wait_for]) / 1000.0
       else
         wait_for_in_seconds = 0.1
       end
@@ -236,7 +236,7 @@ module KJess
     # Returns a String.
     def status( update_to = nil )
       resp = send_recv( KJess::Request::Status.new( :update_to => update_to ) )
-      raise KJess::Error, "Status command is not supported" if KJess::Response::ClientError === resp
+      raise KJess::ProtocolError, "Status command is not supported" if KJess::Response::ClientError === resp
       return resp.message
     end
 
@@ -256,7 +256,7 @@ 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
+      raise KJess::ProtocolError, "Problem receiving stats: #{stats.inspect}" unless KJess::Response::Stats === stats
 
       h           = stats.data
       dump_stats  = send_recv( KJess::Request::DumpStats.new )

data/lib/kjess/connection.rb

@@ -7,16 +7,39 @@ require 'kjess/socket'
 module KJess
   # Connection
   class Connection
-    class Error < KJess::Error; end
+    class Error < KJess::NetworkError; end
+
+    # Public: Set a socket factory
+    #
+    # factory - an object that responds to #call(options) where options is
+    #           a Hash.
+    #
+    # returns nothing
+    def self.socket_factory=(factory)
+      @socket_factory = factory
+    end
+
+    # Public: Return the socket factory
+    #
+    def self.socket_factory
+      @socket_factory ||= nil
+      @socket_factory.respond_to?(:call) ? @socket_factory : default_socket_factory
+    end
+
+    # Internal: Returns the default socket factory
+    #
+    def self.default_socket_factory
+      lambda { |options| KJess::Socket.connect(options) }
+    end
 
     # Public: The hostname/ip address to connect to.
     def host
-      socket.host
+      @options[:host]
     end
 
     # Public: The port number to connect to. Default 22133
     def port
-      socket.port
+      @options[:port]
     end
 
     # Public: The timeout for connecting in seconds. Defaults to 2
@@ -95,10 +118,12 @@ module KJess
     def socket
       close if @pid && @pid != Process.pid
       return @socket if @socket and not @socket.closed?
-      @socket      = Socket.connect( @options )
+      @socket      = self.class.socket_factory.call(@options)
       @pid         = Process.pid
       @read_buffer = ''
       return @socket
+    rescue => e
+      raise Error, "Could not connect to #{host}:#{port}: #{e.class}: #{e.message}", e.backtrace
     end
 
     # Internal: close the socket if it is not already closed
@@ -127,9 +152,12 @@ module KJess
     def write( msg )
       $stderr.puts "--> #{msg}" if $DEBUG
       socket.write( msg )
-    rescue KJess::Error
+    rescue KJess::NetworkError
       close
       raise
+    rescue => e
+      close
+      raise Error, "Could not write to #{host}:#{port}: #{e.class}: #{e.message}", e.backtrace
     end
 
     # Internal: read a single line from the socket
@@ -148,7 +176,7 @@ module KJess
         break unless line.strip.length == 0
       end
       return line
-    rescue KJess::Error
+    rescue KJess::NetworkError
       close
       raise
     rescue EOFError
@@ -173,9 +201,12 @@ module KJess
 
       $stderr.puts "<-- #{result}" if $DEBUG
       return result
-    rescue KJess::Error
+    rescue KJess::NetworkError
       close
       raise
+    rescue => e
+      close
+      raise Error, "Could not read from #{host}:#{port}: #{e.class}: #{e.message}", e.backtrace
     end
   end
 end

data/lib/kjess/error.rb

@@ -1,5 +1,8 @@
 module KJess
   class Error < ::StandardError; end
-  class ClientError < Error; end
-  class ServerError < Error; end
+  class NetworkError < Error; end
+
+  class ProtocolError < Error; end
+  class ClientError < ProtocolError; end
+  class ServerError < ProtocolError; end
 end

data/lib/kjess/response/error.rb

@@ -7,7 +7,7 @@ class KJess::Response
     end
 
     def exception
-      raise KJess::Error
+      raise KJess::ClientError
     end
   end
 end

data/lib/kjess/response/stats.rb

@@ -24,7 +24,7 @@ class KJess::Response
         when "END"
           break
         else
-          raise KJess::Error, "Unknown line '#{line.strip}' from STAT command"
+          raise KJess::ClientError, "Unknown line '#{line.strip}' from STAT command"
         end
       end while line = connection.readline
 

data/lib/kjess/socket.rb

@@ -3,7 +3,7 @@ require 'socket'
 module KJess
   # Socket: A specialized socket that has been configure
   class Socket
-    class Error < KJess::Error; end
+    class Error < KJess::NetworkError; end
     class Timeout < Error; end
 
     # Internal:
@@ -21,7 +21,7 @@ module KJess
     # Internal:
     # The host this socket is connected to
     attr_reader :host
-    
+
     # Internal:
     # The port this socket is connected to
     attr_reader :port
@@ -98,7 +98,7 @@ module KJess
     end
 
     # Internal: Low level socket allocation and option configuration
-    # 
+    #
     # Using the options from the initializer, a new ::Socket is created that
     # is:
     #
@@ -167,12 +167,12 @@ module KJess
       conn_error = lambda { raise errors.first }
       sock       = nil
 
-      addrs.find( conn_error ) do |addr| 
+      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
@@ -208,7 +208,7 @@ module KJess
       sock.connect_nonblock( sockaddr )
       return sock
     rescue Errno::EINPROGRESS
-      if IO.select(nil, [sock], nil, timeout).nil? then
+      if !wait_writable(timeout, sock)
         raise Timeout, "Could not connect to #{host}:#{port} within #{timeout} seconds"
       end
       return connect_nonblock_finalize( sock, sockaddr )
@@ -218,12 +218,13 @@ module KJess
 
 
     # 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 )
+      return sock
     rescue Errno::EISCONN
       return sock
     rescue => ex
@@ -260,7 +261,7 @@ module KJess
     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)
+      if wait_readable(read_timeout)
         retry
       else
         raise Timeout, "Could not read from #{host}:#{port} in #{read_timeout} seconds"
@@ -276,16 +277,24 @@ module KJess
     #
     # returns nothing
     def write( buf )
-      until buf.length == 0
+      until buf.nil? or (buf.length == 0) do
         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)
+      if wait_writable(write_timeout)
         retry
       else
         raise Timeout, "Could not write to #{host}:#{port} in #{write_timeout} seconds"
       end
     end
+
+    def wait_writable(timeout = nil, socket = @socket)
+      IO.select(nil, [socket], nil, timeout || write_timeout)
+    end
+
+    def wait_readable(timeout = nil, socket = @socket)
+      IO.select([socket], nil, nil, timeout || read_timeout)
+    end
   end
 end

data/spec/client_spec.rb

@@ -128,7 +128,7 @@ describe KJess::Client do
       @client.set( "get_q", "get item 1" )
       @client.set( "get_q", "get item 2" )
       @client.reserve( "get_q" )
-      lambda { @client.get( "get_q" ) }.must_raise KJess::Error
+      lambda { @client.get( "get_q" ) }.must_raise KJess::ClientError
     end
 
   end
@@ -292,14 +292,14 @@ describe KJess::Client do
   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
+      lambda { c.socket }.must_raise KJess::Connection::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
+      lambda { c.socket }.must_raise KJess::Connection::Error
     end
   end
 

data/spec/connection_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe KJess::Connection do
+
+  it "Returns a callable for the factory" do
+    KJess::Connection.socket_factory.respond_to?(:call).must_equal true
+  end
+
+  it "Default Factory returns a KJess::Socket" do
+    factory = KJess::Connection.socket_factory
+    s = factory.call( :port => KJess::Spec.memcache_port, :host => 'localhost' )
+    s.instance_of?(KJess::Socket).must_equal true
+  end
+
+end

data/tasks/default.rake

@@ -0,0 +1,271 @@
+# vim: syntax=ruby
+require 'rake/clean'
+#------------------------------------------------------------------------------
+# If you want to Develop on this project just run 'rake develop' and you'll
+# have all you need to get going. If you want to use bundler for development,
+# then run 'rake develop:using_bundler'
+#------------------------------------------------------------------------------
+namespace :develop do
+
+  # Install all the development and runtime dependencies of this gem using the
+  # gemspec.
+  task :default do
+    require 'rubygems/dependency_installer'
+    installer = Gem::DependencyInstaller.new
+
+    This.set_coverage_gem
+
+    puts "Installing gem depedencies needed for development"
+    This.platform_gemspec.dependencies.each do |dep|
+      if dep.matching_specs.empty? then
+        puts "Installing : #{dep}"
+        installer.install dep
+      else
+        puts "Skipping   : #{dep} -> already installed #{dep.matching_specs.first.full_name}"
+      end
+    end
+    puts "\n\nNow run 'rake test'"
+  end
+
+  # Create a Gemfile that just references the gemspec
+  file 'Gemfile' => :gemspec do
+    File.open( "Gemfile", "w+" ) do |f|
+      f.puts 'source :rubygems'
+      f.puts 'gemspec'
+    end
+  end
+
+  desc "Create a bundler Gemfile"
+  task :using_bundler => 'Gemfile' do
+    puts "Now you can 'bundle'"
+  end
+
+  # Gemfiles are build artifacts
+  CLOBBER << FileList['Gemfile*']
+end
+desc "Boostrap development"
+task :develop => "develop:default"
+
+#------------------------------------------------------------------------------
+# Minitest - standard TestTask
+#------------------------------------------------------------------------------
+begin
+  require 'rake/testtask'
+  Rake::TestTask.new( :test ) do |t|
+    t.ruby_opts    = %w[ -w -rubygems ]
+    t.libs         = %w[ lib spec ]
+    t.pattern      = "spec/**/*_spec.rb"
+  end
+
+  task :test_requirements
+  task :test => :test_requirements
+  task :default => :test
+rescue LoadError
+  This.task_warning( 'test' )
+end
+
+#------------------------------------------------------------------------------
+# RDoc - standard rdoc rake task, although we must make sure to use a more
+#        recent version of rdoc since it is the one that has 'tomdoc' markup
+#------------------------------------------------------------------------------
+begin
+  gem 'rdoc' # otherwise we get the wrong task from stdlib
+  require 'rdoc/task'
+  RDoc::Task.new do |t|
+    t.markup   = 'tomdoc'
+    t.rdoc_dir = 'doc'
+    t.main     = 'README.md'
+    t.title    = "#{This.name} #{This.version}"
+    t.rdoc_files.include( FileList['*.{rdoc,md,txt}'], FileList['ext/**/*.c'],
+                          FileList['lib/**/*.rb'] )
+  end
+rescue StandardError, LoadError
+  This.task_warning( 'rdoc' )
+end
+
+#------------------------------------------------------------------------------
+# Coverage - optional code coverage, rcov for 1.8 and simplecov for 1.9, so
+#            for the moment only rcov is listed.
+#------------------------------------------------------------------------------
+if RUBY_VERSION < "1.9.0"
+  begin
+   require 'rcov/rcovtask'
+   Rcov::RcovTask.new( 'coverage' ) do |t|
+     t.libs      << 'spec'
+     t.pattern   = 'spec/**/*_spec.rb'
+     t.verbose   = true
+     t.rcov_opts << "-x ^/"           # remove all the global files
+     t.rcov_opts << "--sort coverage" # so we see the worst files at the top
+   end
+  rescue LoadError
+   This.task_warning( 'rcov' )
+  end
+else
+  begin
+    require 'simplecov'
+    desc 'Run tests with code coverage'
+    task :coverage do
+      ENV['COVERAGE'] = 'true'
+      Rake::Task[:test].execute
+    end
+    CLOBBER << FileList["coverage"]
+  rescue LoadError
+    This.task_warning( 'simplecov' )
+  end
+end
+
+#------------------------------------------------------------------------------
+# Manifest - We want an explicit list of thos files that are to be packaged in
+#            the gem. Most of this is from Hoe.
+#------------------------------------------------------------------------------
+namespace 'manifest' do
+  desc "Check the manifest"
+  task :check => :clean do
+    files = FileList["**/*", ".*"].exclude( This.exclude_from_manifest ).to_a.sort
+    files = files.select{ |f| File.file?( f ) }
+
+    tmp = "Manifest.tmp"
+    File.open( tmp, 'w' ) do |f|
+      f.puts files.join("\n")
+    end
+
+    begin
+      sh "diff -du Manifest.txt #{tmp}"
+    ensure
+      rm tmp
+    end
+    puts "Manifest looks good"
+  end
+
+  desc "Generate the manifest"
+  task :generate => :clean do
+    files = %x[ git ls-files ].split("\n").sort
+    files.reject! { |f| f =~ This.exclude_from_manifest }
+    File.open( "Manifest.txt", "w" ) do |f|
+      f.puts files.join("\n")
+    end
+  end
+end
+
+#------------------------------------------------------------------------------
+# Fixme - look for fixmes and report them
+#------------------------------------------------------------------------------
+namespace :fixme do
+  task :default => 'manifest:check' do
+    This.manifest.each do |file|
+      next if file == __FILE__
+      next unless file =~ %r/(txt|rb|md|rdoc|css|html|xml|css)\Z/
+      puts "FIXME: Rename #{file}" if file =~ /fixme/i
+      IO.readlines( file ).each_with_index do |line, idx|
+        prefix = "FIXME: #{file}:#{idx+1}".ljust(42)
+        puts "#{prefix} => #{line.strip}" if line =~ /fixme/i
+      end
+    end
+  end
+
+  def fixme_project_root
+    This.project_path( '../fixme' )
+  end
+
+  def fixme_project_path( subtree )
+    fixme_project_root.join( subtree )
+  end
+
+  def local_fixme_files
+    This.manifest.select { |p| p =~ %r|^tasks/| }
+  end
+
+  def outdated_fixme_files
+    local_fixme_files.reject do |local|
+      upstream     = fixme_project_path( local )
+      Digest::SHA256.file( local ) == Digest::SHA256.file( upstream )
+    end
+  end
+
+  def fixme_up_to_date?
+    outdated_fixme_files.empty?
+  end
+
+  desc "See if the fixme tools are outdated"
+  task :outdated => :release_check do
+    if fixme_up_to_date? then
+      puts "Fixme files are up to date."
+    else
+      outdated_fixme_files.each do |f|
+        puts "#{f} is outdated"
+      end
+    end
+  end
+
+  desc "Update outdated fixme files"
+  task :update => :release_check do
+    if fixme_up_to_date? then
+      puts "Fixme files are already up to date."
+    else
+      puts "Updating fixme files:"
+      outdated_fixme_files.each do |local|
+        upstream = fixme_project_path( local )
+        puts "  * #{local}"
+        FileUtils.cp( upstream, local )
+      end
+      puts "Use your git commands as appropriate."
+    end
+  end
+end
+desc "Look for fixmes and report them"
+task :fixme => "fixme:default"
+
+#------------------------------------------------------------------------------
+# Gem Specification
+#------------------------------------------------------------------------------
+# Really this is only here to support those who use bundler
+desc "Build the #{This.name}.gemspec file"
+task :gemspec do
+  File.open( This.gemspec_file, "wb+" ) do |f|
+    f.write This.platform_gemspec.to_ruby
+  end
+end
+
+# the gemspec is also a dev artifact and should not be kept around.
+CLOBBER << This.gemspec_file.to_s
+
+# .rbc files from ruby 2.0
+CLOBBER << FileList["**/*.rbc"]
+
+# The standard gem packaging task, everyone has it.
+require 'rubygems/package_task'
+Gem::PackageTask.new( This.platform_gemspec ) do
+  # nothing
+end
+
+#------------------------------------------------------------------------------
+# Release - the steps we go through to do a final release, this is pulled from
+#           a compbination of mojombo's rakegem, hoe and hoe-git
+#
+# 1) make sure we are on the master branch
+# 2) make sure there are no uncommitted items
+# 3) check the manifest and make sure all looks good
+# 4) build the gem
+# 5) do an empty commit to have the commit message of the version
+# 6) tag that commit as the version
+# 7) push master
+# 8) push the tag
+# 7) pus the gem
+#------------------------------------------------------------------------------
+task :release_check do
+  unless `git branch` =~ /^\* master$/
+    abort "You must be on the master branch to release!"
+  end
+  unless `git status` =~ /^nothing to commit/m
+    abort "Nope, sorry, you have unfinished business"
+  end
+end
+
+desc "Create tag v#{This.version}, build and push #{This.platform_gemspec.full_name} to rubygems.org"
+task :release => [ :release_check, 'manifest:check', :gem ] do
+  sh "git commit --allow-empty -a -m 'Release #{This.version}'"
+  sh "git tag -a -m 'v#{This.version}' v#{This.version}"
+  sh "git push origin master"
+  sh "git push origin v#{This.version}"
+  sh "gem push pkg/#{This.platform_gemspec.full_name}.gem"
+end