beanstalk-client 0.9.0 → 0.10.0

data/History.txt

@@ -1,3 +1,10 @@
+== 0.10.0 2008-04-11
+
+* Some optimizations to avoid sending unnecessary use and watch commands.
+* Use newer protocol features to open only one connection per server address.
+* More consistent and complete peek methods.
+* Various bug fixes.
+
 == 0.9.0 2008-02-27
 
 * Skipping 0.8.x; beanstalkd 0.8 was a botched release.

data/Manifest.txt

@@ -6,7 +6,6 @@ Rakefile
 config/hoe.rb
 config/requirements.rb
 lib/beanstalk-client.rb
-lib/beanstalk-client/bag.rb
 lib/beanstalk-client/connection.rb
 lib/beanstalk-client/errors.rb
 lib/beanstalk-client/job.rb

data/lib/beanstalk-client/connection.rb

@@ -19,18 +19,19 @@ require 'socket'
 require 'fcntl'
 require 'yaml'
 require 'set'
-require 'beanstalk-client/bag'
 require 'beanstalk-client/errors'
 require 'beanstalk-client/job'
 
 module Beanstalk
-  class RawConnection
+  class Connection
     attr_reader :addr
 
     def initialize(addr, jptr=self)
       @addr = addr
       @jptr = jptr
       connect
+      @last_used = 'default'
+      @watch_list = ['default']
     end
 
     def connect
@@ -47,98 +48,116 @@ module Beanstalk
     end
 
     def put(body, pri=65536, delay=0, ttr=120)
-      @socket.write("put #{pri} #{delay} #{ttr} #{body.size}\r\n#{body}\r\n")
-      check_resp('INSERTED', 'BURIED')[0].to_i
+      interact("put #{pri} #{delay} #{ttr} #{body.size}\r\n#{body}\r\n",
+               %w(INSERTED BURIED))[0].to_i
     end
 
     def yput(obj, pri=65536, delay=0, ttr=120)
       put(YAML.dump(obj), pri, delay, ttr)
     end
 
-    def peek()
-      @socket.write("peek\r\n")
-      begin
-        Job.new(@jptr, *read_job('FOUND'))
-      rescue UnexpectedResponse
-        nil
-      end
+    def peek_job(id)
+      interact("peek #{id}\r\n", :job)
     end
 
-    def peek_job(id)
-      @socket.write("peek #{id}\r\n")
-      Job.new(@jptr, *read_job('FOUND'))
+    def peek_ready()
+      interact("peek-ready\r\n", :job)
+    end
+
+    def peek_delayed()
+      interact("peek-delayed\r\n", :job)
+    end
+
+    def peek_buried()
+      interact("peek-buried\r\n", :job)
     end
 
     def reserve()
+      raise WaitingForJobError if @waiting
       @socket.write("reserve\r\n")
+
+      begin
+        @waiting = true
+        # Give the user a chance to select on multiple fds.
+        Beanstalk.select.call([@socket]) if Beanstalk.select
+      rescue WaitingForJobError
+        # just continue
+      ensure
+        @waiting = false
+      end
+
       Job.new(@jptr, *read_job('RESERVED'))
     end
 
     def delete(id)
-      @socket.write("delete #{id}\r\n")
-      check_resp('DELETED')
+      interact("delete #{id}\r\n", %w(DELETED))
       :ok
     end
 
     def release(id, pri, delay)
-      @socket.write("release #{id} #{pri} #{delay}\r\n")
-      check_resp('RELEASED')
+      interact("release #{id} #{pri} #{delay}\r\n", %w(RELEASED))
       :ok
     end
 
     def bury(id, pri)
-      @socket.write("bury #{id} #{pri}\r\n")
-      check_resp('BURIED')
+      interact("bury #{id} #{pri}\r\n", %w(BURIED))
       :ok
     end
 
     def use(tube)
-      @socket.write("use #{tube}\r\n")
-      check_resp('USING')[0]
+      return tube if tube == @last_used
+      @last_used = interact("use #{tube}\r\n", %w(USING))[0]
     end
 
     def watch(tube)
-      @socket.write("watch #{tube}\r\n")
-      check_resp('WATCHING')[0]
+      return @watch_list.size if @watch_list.include?(tube)
+      r = interact("watch #{tube}\r\n", %w(WATCHING))[0].to_i
+      @watch_list += [tube]
+      return r
     end
 
     def ignore(tube)
-      @socket.write("ignore #{tube}\r\n")
-      check_resp('WATCHING')[0]
+      return @watch_list.size if !@watch_list.include?(tube)
+      r = interact("ignore #{tube}\r\n", %w(WATCHING))[0].to_i
+      @watch_list -= [tube]
+      return r
     end
 
     def stats()
-      @socket.write("stats\r\n")
-      read_yaml('OK')
+      interact("stats\r\n", :yaml)
     end
 
     def job_stats(id)
-      @socket.write("stats-job #{id}\r\n")
-      read_yaml('OK')
+      interact("stats-job #{id}\r\n", :yaml)
     end
 
     def stats_tube(tube)
-      @socket.write("stats-tube #{tube}\r\n")
-      read_yaml('OK')
+      interact("stats-tube #{tube}\r\n", :yaml)
     end
 
     def list_tubes()
-      @socket.write("list-tubes\r\n")
-      read_yaml('OK')
+      interact("list-tubes\r\n", :yaml)
     end
 
     def list_tube_used()
-      @socket.write("list-tube-used\r\n")
-      check_resp('USING')[0]
+      interact("list-tube-used\r\n", %w(USING))[0]
     end
 
-    def list_tubes_watched()
-      @socket.write("list-tubes-watched\r\n")
-      read_yaml('OK')
+    def list_tubes_watched(cached=false)
+      return @watch_list if cached
+      @watch_list = interact("list-tubes-watched\r\n", :yaml)
     end
 
     private
 
+    def interact(cmd, rfmt)
+      raise WaitingForJobError if @waiting
+      @socket.write(cmd)
+      return read_yaml('OK') if rfmt == :yaml
+      return found_job if rfmt == :job
+      check_resp(*rfmt)
+    end
+
     def get_resp()
       r = @socket.gets("\r\n")
       raise EOFError if r == nil
@@ -149,15 +168,18 @@ module Beanstalk
       r = get_resp()
       rword, *vals = r.split(/\s+/)
       if (words.size > 0) and !words.include?(rword)
-        raise UnexpectedResponse.new(r)
+        raise UnexpectedResponse.classify(rword, r)
       end
       vals
     end
 
-    def read_job(word)
-      # Give the user a chance to select on multiple fds.
-      Beanstalk.select.call([@socket]) if Beanstalk.select
+    def found_job()
+      Job.new(@jptr, *read_job('FOUND'))
+    rescue NotFoundError
+      nil
+    end
 
+    def read_job(word)
       id, bytes = check_resp(word).map{|s| s.to_i}
       body = read_bytes(bytes)
       raise 'bad trailer' if read_bytes(2) != "\r\n"
@@ -179,47 +201,6 @@ module Beanstalk
     end
   end
 
-  # Same interface as RawConnection.
-  # With this you can reserve more than one job at a time.
-  class Connection
-    attr_reader :addr
-
-    def initialize(addr, jptr=self)
-      @addr = addr
-      @misc = RawConnection.new(addr, jptr)
-      @free = Bag.new{RawConnection.new(addr, jptr)}
-      @used = {}
-    end
-
-    def reserve()
-      c = @free.take()
-      j = c.reserve()
-      @used[j.id] = c
-      j
-    ensure
-      @free.give(c) if c and not j
-    end
-
-    def delete(id)
-      @used[id].delete(id)
-      @free.give(@used.delete(id))
-    end
-
-    def release(id, pri, delay)
-      @used[id].release(id, pri, delay)
-      @free.give(@used.delete(id))
-    end
-
-    def bury(id, pri)
-      @used[id].bury(id, pri)
-      @free.give(@used.delete(id))
-    end
-
-    def method_missing(selector, *args, &block)
-      @misc.send(selector, *args, &block)
-    end
-  end
-
   class CleanupWrapper
     def initialize(addr, multi)
       @conn = Connection.new(addr, self)
@@ -266,14 +247,6 @@ module Beanstalk
       @last_conn.addr
     end
 
-    def send_to_rand_conn(sel, *args)
-      wrap(pick_connection, sel, *args)
-    end
-
-    def send_to_all_conns(sel, *args)
-      make_hash(@connections.map{|a, c| [a, wrap(c, sel, *args)]})
-    end
-
     def put(body, pri=65536, delay=0, ttr=120)
       send_to_rand_conn(:put, body, pri, delay, ttr)
     end
@@ -332,20 +305,46 @@ module Beanstalk
 
     def close
       while @connections.size > 0
-        addr, conn = @connections.pop
+        addr = @connections.keys.last
+        conn = @connections[addr]
+        @connections.delete(addr)
         conn.close
       end
     end
 
-    def peek()
+    def peek_ready()
+      send_to_each_conn_first_res(:peek_ready)
+    end
+
+    def peek_delayed()
+      send_to_each_conn_first_res(:peek_delayed)
+    end
+
+    def peek_buried()
+      send_to_each_conn_first_res(:peek_buried)
+    end
+
+    def peek_job(id)
+      make_hash(send_to_all_conns(:peek_job, id))
+    end
+
+    private
+
+    def send_to_each_conn_first_res(sel, *args)
       open_connections.each do |c|
-        job = c.peek
-        return job if job
+        x = wrap(c, sel, *args)
+        return x if x
       end
       nil
     end
 
-    private
+    def send_to_rand_conn(sel, *args)
+      wrap(pick_connection, sel, *args)
+    end
+
+    def send_to_all_conns(sel, *args)
+      compact_hash(make_hash(@connections.map{|a, c| [a, wrap(c, sel, *args)]}))
+    end
 
     def pick_connection()
       open_connections[rand(open_connections.size)] or raise NotConnected
@@ -365,6 +364,10 @@ module Beanstalk
       Hash[*pairs.inject([]){|a,b|a+b}]
     end
 
+    def compact_hash(hash)
+      hash.reject{|k,v| v == nil}
+    end
+
     def sum_hashes(hs)
       hs.inject({}){|a,b| a.merge(b) {|k,o,n| combine_stats(k, o, n)}}
     end

data/lib/beanstalk-client/errors.rb

@@ -20,14 +20,30 @@ module Beanstalk
   end
 
   class UnexpectedResponse < RuntimeError
-    def self.new(word)
-      if self == UnexpectedResponse and word == 'DRAINING'
-        return DrainingError.new(nil)
+    def self.subclasses
+      @classes ||= []
+    end
+
+    def self.inherited(subclass)
+      subclasses << subclass
+    end
+
+    def self.classify(word, message)
+      for clas in subclasses
+        return clas.new(message) if clas::WORD == word
       end
-      super(word)
+      return new(message)
     end
   end
 
   class DrainingError < UnexpectedResponse
+    WORD = 'DRAINING'
+  end
+
+  class NotFoundError < UnexpectedResponse
+    WORD = 'NOT_FOUND'
+  end
+
+  class WaitingForJobError < RuntimeError
   end
 end

data/lib/beanstalk-client/version.rb

@@ -1,5 +1,5 @@
 module Beanstalk #:nodoc:
   module VERSION #:nodoc:
-    STRING = '0.9.0'
+    STRING = '0.10.0'
   end
 end

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>Beanstalk Client</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/beanstalk"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/beanstalk" class="numbers">0.9.0</a>
+      <a href="http://rubyforge.org/projects/beanstalk" class="numbers">0.10.0</a>
     </div>
     <h1>&#x2192; &#8216;beanstalk-client&#8217;</h1>
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: beanstalk-client
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
-date: 2008-02-27 00:00:00 -08:00
+  version: 0.10.0
+date: 2008-04-11 00:00:00 -07:00
 summary: Ruby client library for the Beanstalk protocol
 require_paths: 
 - lib
@@ -37,7 +37,6 @@ files:
 - config/hoe.rb
 - config/requirements.rb
 - lib/beanstalk-client.rb
-- lib/beanstalk-client/bag.rb
 - lib/beanstalk-client/connection.rb
 - lib/beanstalk-client/errors.rb
 - lib/beanstalk-client/job.rb

data/lib/beanstalk-client/bag.rb

@@ -1,36 +0,0 @@
-# beanstalk-client/bag.rb - client library for beanstalk
-
-# Copyright (C) 2007 Philotic Inc.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-class Beanstalk::Bag
-  def initialize(initial_size=0, &default)
-    @default = default
-    @items = []
-    initial_size.times{give(default.call())}
-  end
-
-  def give(x)
-    (@items << x)[-1]
-  end
-
-  def take()
-    @items.pop or @default.call()
-  end
-
-  def size()
-    @items.size
-  end
-end