stalk_climber 0.0.6 → 0.1.0

data/lib/stalk_climber/lazy_enumerable.rb

@@ -2,6 +2,7 @@ module StalkClimber
   module LazyEnumerable
     include Enumerable
 
+    # Convert Enumerable public methods to their lazy counterparts
     def self.make_lazy(*methods)
       methods.each do |method|
         define_method method do |*args, &block|

data/lib/stalk_climber/tube.rb

@@ -0,0 +1,182 @@
+module StalkClimber
+  class Tube < Beaneater::Tube
+
+    # List of available attributes available via the stats object.
+    STATS_ATTRIBUTES = %w[
+      cmd-delete cmd-pause-tube current-jobs-buried current-jobs-delayed
+      current-jobs-ready current-jobs-reserved current-jobs-urgent current-using
+      current-waiting current-watching name pause pause-time-left total-jobs
+    ]
+
+    # Lookup table of which method to call to retrieve each stat
+    STATS_METHODS = Hash[
+      STATS_ATTRIBUTES.zip(STATS_ATTRIBUTES.map {|stat| stat.gsub(/-/, '_')})
+    ]
+
+    # Pause and name are available as stats but are not included in this list
+    # because Beaneater::Tube already defines methods with those names. Instead,
+    # the pause stat can be obtained via Tube#pause_time and name can be obtained
+    # via the superclass method.
+    STATS_METHODS.values.reject {|k,v| %w[name pause].include?(k)}.each do |method_name|
+      define_method method_name do |force_refresh = true|
+        return stats(force_refresh).send(method_name)
+      end
+    end
+
+
+    # :call-seq:
+    #   exists?() => Boolean
+    #
+    # Determines if a tube exists by retrieving stats for the tube. If Beaneater
+    # can't find the tube then it oes not exist and false is returned. If stats
+    # are retrieved successfully then true is returned. The stats command is used
+    # because it will return a response of near constant size, whereas, depending
+    # on the environment, list-tubes could return a much larger response.
+    # Additionally, updated stats information is usually more valuable than a list
+    # of tubes that is immediately discarded.
+    def exists?
+      return !stats.nil?
+    rescue Beaneater::NotFoundError
+      return false
+    end
+
+
+    # :call-seq:
+    #   pause_time(force_refresh = false) => Integer
+    #
+    # Returns pause stat which indicates the duration the tube is currently
+    # paused for. The name pause_time is used because Beaneater::Tube already
+    # defines a pause method.
+    def pause_time(force_refresh = false)
+      return stats(force_refresh).pause
+    end
+
+
+    # :call-seq:
+    #   stats(force_refresh = true) => Beaneater::StatStruct
+    #
+    # Returns related stats for this tube.
+    #
+    #   @tube.stats.current_jobs_delayed
+    #     #=> 3
+    def stats(force_refresh = true)
+      if force_refresh || @stats.nil?
+        stats = transmit_to_all("stats-tube #{name}", :merge => true)[:body]
+        @stats = Beaneater::StatStruct.from_hash(stats)
+      end
+      return @stats
+    end
+
+
+    # :call-seq:
+    #   to_h() => Hash
+    #
+    # Returns a hash of all tube attributes derived from updated stats
+    #
+    #   tube = StalkClimber::Tube.new(connection_pool, 'stalk_climber')
+    #   tube.to_h
+    #     #=> {"cmd-delete"=>100, "cmd-pause-tube"=>101, "current-jobs-buried"=>102, "current-jobs-delayed"=>103, "current-jobs-ready"=>104, "current-jobs-reserved"=>105, "current-jobs-urgent"=>106, "current-using"=>107, "current-waiting"=>108, "current-watching"=>109, "name"=>"stalk_climber", "pause"=>111, "pause-time-left"=>110, "total-jobs"=>112}
+    def to_h
+      stats
+      return Hash[
+        STATS_METHODS.map do |stat, method_name|
+          [stat, stats(false).send(method_name)]
+        end
+      ]
+    end
+
+
+    # :call-seq:
+    #   to_s() => String
+    #
+    # Returns string representation of the tube
+    #
+    #   tube = StalkClimber::Tube.new(connection_pool, 'stalk_climber')
+    #   tube.to_s
+    #     #=> #<StalkClimber::Tube name="stalk_climber">
+    def to_s
+      "#<StalkClimber::Tube name=#{name}>"
+    end
+    alias :inspect :to_s
+
+
+    # :method: cmd_delete
+    # :call-seq:
+    #   cmd_delete() => Integer
+    #
+    # Returns the number of times the delete command has been called for
+    # jobs in the tube.
+
+    # :method: cmd_pause_tube
+    # :call-seq:
+    #   cmd_pause_tube() => Integer
+    #
+    # Returns the number of times the pause-tube command has been called on
+    # the tube.
+
+    # :method: current_jobs_buried
+    # :call-seq:
+    #   current_jobs_buried() => Integer
+    #
+    # Returns the number of jobs in the tube that are currently buried.
+
+    # :method: current_jobs_delayed
+    # :call-seq:
+    #   current_jobs_buried() => Integer
+    #
+    # Returns the number of jobs in the tube that are currently buried.
+
+    # :method: current_jobs_ready
+    # :call-seq:
+    #   current_jobs_ready() => Integer
+    #
+    # Returns the number of jobs in the tube that are currently ready.
+
+    # :method: current_jobs_reserved
+    # :call-seq:
+    #   current_jobs_reserved() => Integer
+    #
+    # Returns the number of jobs in the tube that are currently reserved.
+
+    # :method: current_jobs_urgent
+    # :call-seq:
+    #   current_jobs_urgent() => Integer
+    #
+    # Returns the number of jobs currently in the tube with a priority
+    # less than 1024, and thus deemed urgent.
+
+    # :method: current_using
+    # :call-seq:
+    #   current_using() => Integer
+    #
+    # Returns the number of connections that are currently using the tube.
+
+    # :method: current_waiting
+    # :call-seq:
+    #   current_waiting() => Integer
+    #
+    # Returns the number of connections that have issued reserve requests
+    # for the tube and are currently awaiting a reply.
+
+    # :method: current_watching
+    # :call-seq:
+    #   current_watching() => Integer
+    #
+    # Returns the number of connections that are watching the tube.
+
+    # :method: pause_time_left
+    # :call-seq:
+    #   pause_time_left() => Integer
+    #
+    # Returns the number of seconds remaining before the tube is no longer
+    # paused.
+
+    # :method: total_jobs
+    # :call-seq:
+    #   total_jobs() => Integer
+    #
+    # Returns the total number of jobs that have been registered with the tube
+    # since the tube was most recently created.
+
+  end
+end

data/lib/stalk_climber/tubes.rb

@@ -0,0 +1,37 @@
+module StalkClimber
+  class Tubes < Beaneater::Tubes
+
+    extend Forwardable
+    include RUBY_VERSION >= '2.0.0' ? LazyEnumerable : Enumerable
+
+    def_delegator :all, :each
+
+
+    # :call-seq:
+    #   all() => Array[StalkClimber::Tube]
+    #
+    # List of all known beanstalk tubes in the connection pool.
+    # Adapted with minor modification from Beaneater::Tubes#all
+    def all
+      return transmit_to_all('list-tubes', :merge => true)[:body].map do |tube_name|
+        StalkClimber::Tube.new(self.pool, tube_name)
+      end
+    end
+
+    # :call-seq:
+    #   each() => Enumerator
+    #   each {|tube| block }
+    #
+    # Interface for tube enumerator/enumeration. Tubes are mostly in creation order,
+    # though order can vary depending on the order in which responses to list-tubes are
+    # received from each of the Beanstalkd servers. Returns an instance of
+    # StalkClimber::Tube for each tube. Unlike Jobs, tubes are not cached because
+    # they are more easily accessible
+    #
+    #   tubes = StalkClimber::Tubes.new(connection_pool)
+    #   tubes.each do |tube|
+    #     tube.clear
+    #   end
+
+  end
+end

data/lib/stalk_climber/version.rb

@@ -1,3 +1,4 @@
 module StalkClimber
-  VERSION = '0.0.6'
+  # StalkClimber version number
+  VERSION = '0.1.0'
 end

data/test/test_helper.rb

@@ -6,13 +6,15 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'test/unit'
 require 'mocha/setup'
-
+require 'minitest/autorun'
+require 'minitest/should'
 require 'stalk_climber'
+require 'securerandom'
 
 BEANSTALK_ADDRESS = ENV['BEANSTALK_ADDRESS'] || 'beanstalk://localhost'
 BEANSTALK_ADDRESSES = ENV['BEANSTALK_ADDRESSES'] || BEANSTALK_ADDRESS
 
-class Test::Unit::TestCase
+class StalkClimber::TestCase < MiniTest::Should::TestCase
 
   def seed_jobs(count = 5)
     count.times.map do

data/test/unit/beaneater_job_test.rb

@@ -0,0 +1,260 @@
+require 'test_helper'
+
+class BeaneaterJobTest < StalkClimber::TestCase
+
+  setup do
+    @pool  = Beaneater::Pool.new(['localhost'])
+    @tube  = @pool.tubes.find 'tube'
+  end
+
+  context "for #bury" do
+    setup do
+      @time = Time.now.to_i
+      @tube.put "foo bury #{@time}", :pri => 5
+    end
+
+    should "be buried with same pri" do
+      job = @tube.reserve
+      assert_equal "foo bury #{@time}", job.body
+      assert_equal 'reserved', job.stats.state
+      job.bury
+      assert_equal 'buried', job.stats.state
+      assert_equal 5, job.stats.pri
+      assert_equal "foo bury #{@time}", @tube.peek(:buried).body
+    end
+
+    should "be released with new pri" do
+      job = @tube.reserve
+      assert_equal "foo bury #{@time}", job.body
+      assert_equal 'reserved', job.stats.state
+      job.bury(:pri => 10)
+      assert_equal 'buried', job.stats.state
+      assert_equal 10, job.stats.pri
+      assert_equal "foo bury #{@time}", @tube.peek(:buried).body
+    end
+
+    should "not bury if not reserved" do
+      job = @tube.peek(:ready)
+      assert_raises(Beaneater::JobNotReserved) { job.bury }
+    end
+
+    should "not bury if reserved and deleted" do
+      job = @tube.reserve
+      job.delete
+      assert_equal false, job.reserved
+      assert_raises(Beaneater::NotFoundError) { job.bury }
+    end
+  end # bury
+
+  context "for #release" do
+    setup do
+      @time = Time.now.to_i
+      @tube.put "foo release #{@time}", :pri => 5
+    end
+
+    should "be released with same pri" do
+      job = @tube.reserve
+      assert_equal "foo release #{@time}", job.body
+      assert_equal 'reserved', job.stats.state
+      job.release
+      assert_equal 'ready', job.stats.state
+      assert_equal 5, job.stats.pri
+      assert_equal 0, job.stats.delay
+    end
+
+    should "be released with new pri" do
+      job = @tube.reserve
+      assert_equal "foo release #{@time}", job.body
+      assert_equal 'reserved', job.stats.state
+      job.release :pri => 10, :delay => 2
+      assert_equal 'delayed', job.stats.state
+      assert_equal 10, job.stats.pri
+      assert_equal 2, job.stats.delay
+    end
+
+    should "not released if not reserved" do
+      job = @tube.peek(:ready)
+      assert_raises(Beaneater::JobNotReserved) { job.release }
+    end
+
+    should "not release if not reserved and buried" do
+      job = @tube.reserve
+      job.bury
+      assert_raises(Beaneater::JobNotReserved) { job.release }
+    end
+  end # release
+
+  describe "for #delete" do
+    setup do
+      @tube.put 'foo'
+    end
+
+    should "deletable" do
+      job = @tube.peek(:ready)
+      assert_equal 'foo', job.body
+      job.delete
+      assert_nil @tube.peek(:ready)
+    end
+  end # delete
+
+  describe "for #touch" do
+    setup do
+      @tube.put 'foo touch', :ttr => 1
+    end
+
+    should "be toucheable" do
+      job = @tube.reserve
+      assert_equal 'foo touch', job.body
+      job.touch
+      assert_equal 1, job.stats.reserves
+      job.delete
+    end
+
+    should "not touch if not reserved" do
+      job = @tube.peek(:ready)
+      assert_raises(Beaneater::JobNotReserved) { job.touch }
+    end
+
+    should "not touch if not reserved and released" do
+      job = @tube.reserve
+      job.release
+      assert_raises(Beaneater::JobNotReserved) { job.touch }
+    end
+
+    should "not touch if reserved and deleted" do
+      job = @tube.reserve
+      job.delete
+      assert_raises(Beaneater::NotFoundError) { job.touch }
+    end
+  end # touch
+
+  describe "for #kick" do
+    setup do
+      @tube.put 'foo touch', :ttr => 1
+    end
+
+    should "be toucheable" do
+      job = @tube.reserve
+      assert_equal 'foo touch', job.body
+      job.bury
+      assert_equal 1, @tube.stats.current_jobs_buried
+      if @pool.stats.version.to_f > 1.7
+        job.kick
+        assert_equal 0, @tube.stats.current_jobs_buried
+        assert_equal 1, @tube.stats.current_jobs_ready
+      end
+    end
+  end # kick
+
+  describe "for #stats" do
+    setup do
+      @tube.put 'foo'
+      @job = @tube.peek(:ready)
+    end
+
+    should "have stats" do
+      assert_equal 'tube', @job.stats['tube']
+      assert_equal 'ready', @job.stats.state
+    end
+
+    should "return nil for deleted job with no stats" do
+      @job.delete
+      assert_raises(Beaneater::NotFoundError) { @job.stats }
+    end
+  end # stats
+
+  describe "for #reserved?" do
+    setup do
+      @tube.put 'foo'
+      @job = @tube.peek(:ready)
+    end
+
+    should "have stats" do
+      assert_equal false, @job.reserved?
+      job = @tube.reserve
+      assert_equal job.id, @job.id
+      assert_equal true, @job.reserved?
+      @job.delete
+      assert_raises(Beaneater::NotFoundError) { @job.reserved? }
+    end
+  end # reserved?
+
+  describe "for #exists?" do
+    setup do
+      @tube.put 'foo'
+      @job = @tube.peek(:ready)
+    end
+
+    should "exists?" do
+      assert @job.exists?
+    end
+
+    should "not exist" do
+      @job.delete
+      assert !@job.exists?
+    end
+  end # exists?
+
+  describe "for #tube" do
+    setup do
+      @tube.put 'bar'
+      @job = @tube.peek(:ready)
+    end
+
+    should "have stats" do
+      job = @tube.reserve
+      assert_equal @tube.name, job.tube
+      job.release
+    end
+  end # tube
+
+  describe "for #pri" do
+    setup do
+      @tube.put 'bar', :pri => 1
+      @job = @tube.peek(:ready)
+    end
+
+    should "return pri" do
+      job = @tube.reserve
+      assert_equal 1, job.pri
+      job.release
+    end
+  end # tube
+
+
+  describe "for #ttr" do
+    setup do
+      @tube.put 'bar', :ttr => 5
+      @job = @tube.peek(:ready)
+    end
+
+    should "return ttr" do
+      job = @tube.reserve
+      assert_equal 5, job.ttr
+      job.release
+    end
+  end # tube
+
+  describe "for #delay" do
+    setup do
+      @tube.put 'bar', :delay => 5
+      @job = @tube.peek(:delayed)
+    end
+
+    should "return delay" do
+      assert_equal 5, @job.delay
+    end
+  end # tube
+
+  after do
+    cleanup_tubes!(['tube'])
+  end
+
+  def cleanup_tubes!(tubes, bp=nil)
+    bp ||= @pool
+    tubes.each do |name|
+      bp.tubes.find(name).clear
+    end
+  end
+
+end # Beaneater::Job