kjess 1.0.0

data/example/client_test.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+#require 'perftools'
+require 'kjess'
+require 'trollop'
+require 'hitimes'
+
+ACTIONS = %w[ produce consume clear status ].sort
+
+options = Trollop::options do
+  opt :action,  "Which action to perform (#{ACTIONS.join(', ')})", :default => 'produce'
+  opt :qname,  "The name of the queue to use"                    , :default => 'testing'
+  opt :count,  "How many messages to produce or consume"         , :default => 1000
+  opt :length, "The length of the messages (only for produce)"   , :default => 1024
+  opt :host,   "The host to contact"                             , :default => 'localhost'
+  opt :port,   "The port number to use"                          , :default => 22133
+end
+
+Trollop::die :action, "must be one of #{ACTIONS.join(', ')}" unless ACTIONS.include?( options[:action] )
+
+trap( 'INT' ) do
+  puts "Closing down"
+  exit
+end
+
+class ClientTest
+  attr_reader :options
+  attr_reader :client
+  attr_reader :timer
+  attr_reader :item
+
+  def initialize( options )
+    @options = options
+    @client  = KJess::Client.new( :host => options[:host], :port => options[:port] )
+    @timer   = Hitimes::TimedMetric.new( options[:action] )
+    @item    = "x" * options[:length]
+  end
+
+  def time_and_count( &block )
+    options[:count].times do |x|
+      timer.measure do
+        block.call
+      end
+    end
+    return timer.stats.to_hash
+  end
+
+  def produce
+    puts "Inserting #{options[:count]} items into the queue at #{options[:host]}:#{options[:port]}"
+    time_and_count do
+      client.set( options[:qname], item )
+    end
+  end
+
+  def consume
+    puts "Consuming #{options[:count]} items from the queue at #{options[:host]}:#{options[:port]}"
+    time_and_count do
+      client.get( options[:qname] )
+    end
+  end
+
+  def run_test
+#    PerfTools::CpuProfiler.start( "/tmp/#{options[:action]}_profile" ) do
+      send( options[:action] )
+#    end
+  end
+end
+
+test = ClientTest.new( options )
+s = test.run_test
+puts s.inspect
+
+

data/lib/kjess.rb

@@ -0,0 +1,11 @@
+module KJess
+  VERSION = "1.0.0"
+end
+
+require 'kjess/connection'
+require 'kjess/stats_cache'
+require 'kjess/client'
+require 'kjess/error'
+require 'kjess/protocol'
+require 'kjess/request'
+require 'kjess/response'

data/lib/kjess/client.rb

@@ -0,0 +1,289 @@
+require 'kjess/stats_cache'
+module KJess
+  class Client
+    # Public: The hostname of the kestrel server to connect to
+    attr_reader :host
+
+    # Public: The port on hostname of the Kestrel server
+    attr_reader :port
+
+    # Public: The admin HTTP Port on the Kestrel server
+    attr_reader :admin_port
+
+    # Internal: The cache of stats
+    attr_reader :stats_cache
+
+    # Public: The default parameters for a client connection to a Kestrel
+    # server.
+    def self.defaults
+      {
+        :host                   => 'localhost',
+        :port                   => 22133,
+        :admin_port             => 2223,
+        :stats_cache_expiration => 0, # number of seconds to keep stats around
+      }
+    end
+
+    def initialize( opts = {} )
+      merged       = Client.defaults.merge( opts )
+      @host        = merged[:host]
+      @port        = merged[:port]
+      @admin_port  = merged[:admin_port]
+      @stats_cache = StatsCache.new( self, merged[:stats_cache_expiration] )
+      @connection = KJess::Connection.new( host, port )
+    end
+
+    # Public: Disconnect from the Kestrel server
+    #
+    # Returns nothing
+    def disconnect
+      @connection.close if connected?
+      @connection = nil
+    end
+
+    # Internal: Allocate or return the existing connection to the server
+    #
+    # Returns a KJess::Connection
+    def connection
+      @connection ||= KJess::Connection.new( host, port )
+    end
+
+    # Public: is the client connected to a server
+    #
+    # Returns true or false
+    def connected?
+      return false if @connection.nil?
+      return false if @connection.closed?
+      return true
+    end
+
+    # Public: Return the version of the Kestrel Server.
+    #
+    # Return a string
+    # Raise Exception if there is a
+    def version
+      v = KJess::Request::Version.new
+      r = send_recv( v )
+      return r.version if Response::Version === r
+      raise KJess::Error, "Unexpected Response from VERSION command"
+    end
+
+    # Public: Add an item to the given queue
+    #
+    # queue_name - the queue to put an item on
+    # item       - the item to put on the queue. #to_s will be called on it.
+    # expiration - The number of seconds from now to expire the item
+    #
+    # 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 )
+    end
+
+    # Public: Retrieve an item from the given queue
+    #
+    # queue_name - the name of the queue to retrieve an item from
+    # options    - the options for retrieving the items
+    #              :wait_for - wait for this many ms for an item on the queued(default: 0)
+    #              :open     - count this as an reliable read (default: false)
+    #              :close    - close a previous read that was retrieved with :open
+    #              :abort    - close an existing read, returning that item to the head of the queue
+    #              :peek     - return the first item on the queue, and do not remove it
+    #
+    # returns a Response
+    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
+    end
+
+    # Public: Reserve the next item on the queue
+    #
+    # This is a helper method to get an item from a queue and open it for
+    # reliable read.
+    #
+    # queue_name - the name of the queue to retrieve an item from
+    # options    - Additional options
+    #              :wait_for - wait for this many ms for an item on the queue(default: 0)
+    def reserve( queue_name, opts = {} )
+      opts = opts.merge( :open => true )
+      get( queue_name, opts )
+    end
+
+    # Public: Reserve the next item on the queue and close out the previous
+    # read.
+    #
+    # This is a helper method to do a reliable read on a queue item while
+    # closing out the existing read at the same time.
+    #
+    # queue_name - the name of the quee to retieve and item from
+    # options    - Additional options
+    #              :wait_for - wait for this many ms for an item on the queue(default: 0)
+    def close_and_reserve( queue_name, opts = {} )
+      opts = opts.merge( :close => true )
+      reserve( queue_name, opts )
+    end
+
+    # Public: Peek at the top item in the queue
+    #
+    # queue_name - the name of the queue to retrieve an item from
+    #
+    # Returns a Response
+    def peek( queue_name )
+      get( queue_name, :peek => true )
+    end
+
+    # Public: Close an existing reliable read
+    #
+    # queue_name - the name of the queue to abort
+    #
+    # Returns a Response
+    def close( queue_name )
+      get( queue_name, :close => true )
+    end
+
+
+    # Public: Abort an existing reliable read
+    #
+    # queue_name - the name of the queue to abort
+    #
+    # Returns a Response
+    def abort( queue_name )
+      get( queue_name, :abort => true )
+    end
+
+    # Public : Remove a queue from the kestrel server
+    #
+    # This will remove any queue you want. Including queues that do not exist.
+    #
+    # queue_name - the name of the queue to remove
+    #
+    # Returns true if it was deleted false otherwise
+    def delete( queue_name )
+      req  = KJess::Request::Delete.new( :queue_name => queue_name )
+      resp = send_recv( req )
+      return KJess::Response::Deleted === resp
+    end
+
+    # Public: Remove all items from a queue on the kestrel server
+    #
+    # This will flush any and all queue. Even queues that do not exist.
+    #
+    # queue_name - the name of the queue to flush
+    #
+    # 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
+    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
+    end
+
+    # Public: Have Kestrel reload its config.
+    #
+    # Currently the kestrel server will say that the config was reloaded no
+    # matter what so there is no way to determine if the config failed to load.
+    #
+    # Returns true
+    def reload
+      resp = send_recv( KJess::Request::Reload.new )
+      return KJess::Response::ReloadedConfig === resp
+    end
+
+    # Public: Disconnect from the kestrel server.
+    #
+    # Returns true
+    def quit
+      resp = send_recv( KJess::Request::Quit.new )
+      return KJess::Response::Eof === resp
+    end
+
+    # Public: Return the server status.
+    #
+    # Currently this is only supported in the HEAD versin of kestrel. Version
+    # where this is not available will raise ServerError.
+    #
+    # Returns a String.
+    def status( update_to = nil )
+      resp = send_recv( KJess::Request::Status.new( update_to ) )
+      raise KJess::Error, "Status command is not supported" if KJess::Response::ClientError === resp
+      return resp.message
+    end
+
+    # Public: Return stats about the Kestrel server, they will be cached
+    # according to the stats_cache_expiration initialization parameter
+    #
+    # Returns a Hash
+    def stats
+      stats_cache.stats
+    end
+
+    # Internal: Return the hash of stats
+    #
+    # Using a combination of the STATS and DUMP_STATS commands this generates a
+    # good overview of all the most used stats for a Kestrel server.
+    #
+    # Returns a Hash
+    def stats!
+      stats       = send_recv( KJess::Request::Stats.new )
+      h           = stats.data
+      dump_stats  = send_recv( KJess::Request::DumpStats.new )
+      h['queues'] = Hash.new
+      if KJess::Response::DumpedStats === dump_stats then
+        h['queues'].merge!( dump_stats.data )
+      end
+      return h
+    end
+
+    # Public: Returns true if the server is alive
+    #
+    # This uses the 'stats' method to see if the server is alive
+    #
+    # Returns true or false
+    def ping
+      stats
+      true
+    rescue Errno::ECONNREFUSED => e
+      puts e
+      false
+    end
+
+    # Public: Return just the stats about a particular queue
+    #
+    # Returns a Hash
+    def queue_stats( queue_name )
+      stats['queues'][queue_name]
+    end
+
+    # Public: Tells the Kestrel server to shutdown
+    #
+    # Returns nothing
+    def shutdown
+      send_recv( KJess::Request::Shutdown.new )
+    end
+
+    # Internal: Send and recive a request/response
+    #
+    # request - the Request objec to send to the server
+    #
+    # Returns a Response object
+    def send_recv( request )
+      connection.write( request.to_protocol )
+      line = connection.readline
+      resp = KJess::Response.parse( line )
+      resp.read_more( connection )
+      raise resp if resp.error?
+      return resp
+    end
+  end
+end

data/lib/kjess/connection.rb

@@ -0,0 +1,119 @@
+require 'fcntl'
+require 'socket'
+require 'resolv'
+require 'resolv-replace'
+require 'kjess/error'
+
+module KJess
+  # Connection
+  class Connection
+    class Error < KJess::Error; end
+
+    CRLF = "\r\n"
+
+    # Public:
+    # The hostname/ip address to connect to
+    attr_reader :host
+
+    # Public
+    # The port number to connect to. Default 22133
+    attr_reader :port
+
+    def initialize( host, port = 22133 )
+      @host   = host
+      @port   = Float( port ).to_i
+      @socket = nil
+    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()
+    end
+
+    # Internal: Create the socket we use to talk to the Kestrel server
+    #
+    # Returns a TCPSocket
+    def connect
+      sock = TCPSocket.new( host, port )
+
+      # close file descriptors if we exec or something like that
+      sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+      # Disable Nagle's algorithm
+      sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+      # 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])
+
+      # 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
+    end
+
+    # Internal: close the socket if it is not already closed
+    #
+    # Returns nothing
+    def close
+      @socket.close if @socket and not @socket.closed?
+      @socket = nil
+    end
+
+    # Internal: is the socket closed
+    #
+    # Returns true or false
+    def closed?
+      return true if @socket.nil?
+      return true if @socket.closed?
+      return false
+    end
+
+    # Internal: write the given item to the socket
+    #
+    # msg - the message to write
+    #
+    # Returns nothing
+    def write( msg )
+      $stderr.write "--> #{msg}" if $DEBUG
+      socket.write( msg )
+    end
+
+    # Internal: read a single line from the socket
+    #
+    # eom - the End Of Mesasge delimiter (default: "\r\n")
+    #
+    # Returns a String
+    def readline( eom = Protocol::CRLF )
+      while line = socket.readline( eom ) do
+        $stderr.write "<-- #{line}" if $DEBUG
+        break unless line.strip.length == 0
+      end
+      return line
+    rescue EOFError
+      close
+      return "EOF"
+    end
+
+    # Internal: Read from the socket
+    #
+    # args - this method takes the same arguments as IO#read
+    #
+    # Returns what IO#read returns
+    def read( *args )
+      d = socket.read( *args )
+      $stderr.puts "<-- #{d}" if $DEBUG
+      return d
+    end
+  end
+end