beaneater 0.1.0

data/lib/beaneater/stats/stat_struct.rb

@@ -0,0 +1,39 @@
+module Beaneater
+  # Represents a stats hash with proper underscored keys
+  class StatStruct < FasterOpenStruct
+    # Convert a stats hash into a struct.
+    #
+    # @param [Hash(String => String)] hash Hash Stats hash to convert to struct
+    # @return [Beaneater::StatStruct, nil] Stats struct from hash
+    # @example
+    #   s = StatStruct.from_hash(:foo => "bar")
+    #   s.foo # => 'bar'
+    #
+    def self.from_hash(hash)
+      return unless hash.is_a?(Hash)
+      underscore_hash = hash.inject({}) { |r, (k, v)| r[k.to_s.gsub(/-/, '_')] = v; r }
+      self.new(underscore_hash)
+    end
+
+    # Access value for stat with specified key.
+    #
+    # @param [String] key Key to fetch from stats.
+    # @return [String,Integer] Value for specified stat key.
+    # @example
+    #  @stats['foo'] # => "bar"
+    #
+    def [](key)
+      self.send(key.to_s)
+    end
+
+    # Returns set of keys within this struct
+    #
+    # @return [Array<String>] Value for specified stat key.
+    # @example
+    #  @stats.keys # => ['foo', 'bar', 'baz']
+    #
+    def keys
+      @hash.keys.map { |k| k.to_s }
+    end
+  end # StatStruct
+end # Beaneater

data/lib/beaneater/tube.rb

@@ -0,0 +1,2 @@
+require 'beaneater/tube/record'
+require 'beaneater/tube/collection'

data/lib/beaneater/tube/collection.rb

@@ -0,0 +1,134 @@
+module Beaneater
+  # Represents collection of tube related commands.
+  class Tubes < PoolCommand
+
+    # Creates new tubes instance.
+    #
+    # @param [Beaneater::Pool] pool The beaneater pool for this tube.
+    # @example
+    #  Beaneater::Tubes.new(@pool)
+    #
+    def initialize(pool)
+      @last_used = 'default'
+      super
+    end
+
+    # Finds the specified beanstalk tube.
+    #
+    # @param [String] tube_name Name of the beanstalkd tube
+    # @return [Beaneater::Tube] specified tube
+    # @example
+    #   @pool.tubes.find('tube2')
+    #   @pool.tubes['tube2']
+    #     # => <Beaneater::Tube name="tube2">
+    #
+    def find(tube_name)
+      Tube.new(self.pool, tube_name)
+    end
+    alias_method :[], :find
+
+    # Reserves a ready job looking at all watched tubes.
+    #
+    # @param [Integer] timeout Number of seconds before timing out.
+    # @param [Proc] block Callback to perform on the reserved job.
+    # @yield [job] Reserved beaneater job.
+    # @return [Beaneater::Job] Reserved beaneater job.
+    # @example
+    #   @conn.tubes.reserve { |job| process(job) }
+    #     # => <Beaneater::Job id=5 body="foo">
+    #
+    def reserve(timeout=nil, &block)
+      res = transmit_to_rand(timeout ? "reserve-with-timeout #{timeout}" : 'reserve')
+      job = Job.new(res)
+      block.call(job) if block_given?
+      job
+    end
+
+    # Set specified tube as used.
+    #
+    # @param [String] tube Tube to be used.
+    # @example
+    #  @conn.tubes.use("some-tube")
+    #
+    def use(tube)
+      return tube if @last_used == tube
+      res = transmit_to_all("use #{tube}")
+      @last_used = tube
+    rescue BadFormatError
+      raise InvalidTubeName, "Tube cannot be named '#{tube}'"
+    end
+
+    # List of all known beanstalk tubes.
+    #
+    # @return [Array<Beaneater::Tube>] List of all beanstalk tubes.
+    # @example
+    #   @pool.tubes.all
+    #     # => [<Beaneater::Tube name="tube2">, <Beaneater::Tube name="tube3">]
+    #
+    def all
+      transmit_to_rand('list-tubes')[:body].map { |tube_name| Tube.new(self.pool, tube_name) }
+    end
+
+    # List of watched beanstalk tubes.
+    #
+    # @return [Array<Beaneater::Tube>] List of watched beanstalk tubes.
+    # @example
+    #   @pool.tubes.watched
+    #     # => [<Beaneater::Tube name="tube2">, <Beaneater::Tube name="tube3">]
+    #
+    def watched
+      transmit_to_rand('list-tubes-watched')[:body].map { |tube_name| Tube.new(self.pool, tube_name) }
+    end
+
+    # Currently used beanstalk tube.
+    #
+    # @return [Beaneater::Tube] Currently used beanstalk tube.
+    # @example
+    #   @pool.tubes.used
+    #     # => <Beaneater::Tube name="tube2">
+    #
+    def used
+      Tube.new(self.pool, transmit_to_rand('list-tube-used')[:id])
+    end
+
+    # Add specified beanstalkd tubes as watched.
+    #
+    # @param [*String] names Name of tubes to watch
+    # @raise [Beaneater::InvalidTubeName] Tube to watch was invalid.
+    # @example
+    #   @pool.tubes.watch('foo', 'bar')
+    #
+    def watch(*names)
+      names.each do |t|
+        transmit_to_all "watch #{t}"
+      end
+    rescue BadFormatError => ex
+      raise InvalidTubeName, "Tube in '#{ex.cmd}' is invalid!"
+    end
+
+    # Add specified beanstalkd tubes as watched and ignores all other tubes.
+    #
+    # @param [*String] names Name of tubes to watch
+    # @raise [Beaneater::InvalidTubeName] Tube to watch was invalid.
+    # @example
+    #   @pool.tubes.watch!('foo', 'bar')
+    #
+    def watch!(*names)
+      old_tubes = watched.map(&:name) - names.map(&:to_s)
+      watch(*names)
+      ignore(*old_tubes)
+    end
+
+    # Ignores specified beanstalkd tubes.
+    #
+    # @param [*String] names Name of tubes to ignore
+    # @example
+    #   @pool.tubes.ignore('foo', 'bar')
+    #
+    def ignore(*names)
+      names.each do |w|
+        transmit_to_all "ignore #{w}"
+      end
+    end
+  end # Tubes
+end # Beaneater

data/lib/beaneater/tube/record.rb

@@ -0,0 +1,158 @@
+module Beaneater
+  # Beanstalk tube which contains jobs which can be inserted, reserved, et al.
+  class Tube < PoolCommand
+    # The default delay for inserted jobs.
+    DEFAULT_DELAY = 0
+    # Default priority for inserted jobs, 0 is the highest.
+    DEFAULT_PRIORITY = 65536
+    # Default time to respond for inserted jobs.
+    DEFAULT_TTR = 120
+
+    # @!attribute name
+    #   @return [String] name of the tube
+    attr_reader :name
+
+    # Fetches the specified tube.
+    #
+    # @param [Beaneater::Pool] pool The beaneater pool for this tube.
+    # @param [String] name The name for this tube.
+    # @example
+    #  Beaneater::Tube.new(@pool, 'tube-name')
+    #
+    def initialize(pool, name)
+      @name = name.to_s
+      @mutex = Mutex.new
+      super(pool)
+    end
+
+    # Inserts job with specified body onto tube.
+    #
+    # @param [String] body The data to store with this job.
+    # @param [Hash] options The settings associated with this job.
+    # @option options [Integer] pri priority for this job
+    # @option options [Integer] ttr time to respond for this job
+    # @option options [Integer] delay delay for this job
+    # @return [Hash] beanstalkd command response
+    # @example
+    #   @tube.put "data", :pri => 1000, :ttr => 10, :delay => 5
+    #
+    # @api public
+    def put(body, options={})
+      safe_use do
+        options = { :pri => DEFAULT_PRIORITY, :delay => DEFAULT_DELAY, :ttr => DEFAULT_TTR }.merge(options)
+        cmd_options = "#{options[:pri]} #{options[:delay]} #{options[:ttr]} #{body.bytesize}"
+        transmit_to_rand("put #{cmd_options}\n#{body}")
+      end
+    end
+
+    # Peek at next job within this tube in given `state`.
+    #
+    # @param [String] state The job state to peek at (`ready`, `buried`, `delayed`)
+    # @return [Beaneater::Job] The next job within this tube.
+    # @example
+    #  @tube.peek(:ready) # => <Beaneater::Job id=5 body=foo>
+    #
+    # @api public
+    def peek(state)
+      safe_use do
+        res = transmit_until_res "peek-#{state}", :status => "FOUND"
+        Job.new(res)
+      end
+    rescue Beaneater::NotFoundError => ex
+      # Return nil if not found
+    end
+
+    # Reserves the next job from tube.
+    #
+    # @param [Integer] timeout Number of seconds before timing out
+    # @param [Proc] block Callback to perform on reserved job
+    # @yield [job] Job that was reserved.
+    # @return [Beaneater::Job] Job that was reserved.
+    # @example
+    #  @tube.reserve # => <Beaneater::Job id=5 body=foo>
+    #
+    def reserve(timeout=nil, &block)
+      pool.tubes.watch!(self.name)
+      pool.tubes.reserve(timeout, &block)
+    end
+
+    # Kick specified number of jobs from buried to ready state.
+    #
+    # @param [Integer] bounds The number of jobs to kick.
+    # @return [Hash] Beanstalkd command response
+    # @example
+    #   @tube.kick(5)
+    #
+    def kick(bounds=1)
+      safe_use { transmit_to_rand("kick #{bounds}") }
+    end
+
+    # Returns related stats for this tube.
+    #
+    # @return [Beaneater::StatStruct] Struct of tube related values
+    # @example
+    #  @tube.stats.delayed # => 24
+    #
+    def stats
+      res = transmit_to_all("stats-tube #{name}", :merge => true)
+      StatStruct.from_hash(res[:body])
+    end
+
+    # Pause the execution of this tube for specified `delay`.
+    #
+    # @param [Integer] delay Number of seconds to delay tube execution
+    # @return [Hash] Beanstalkd command response
+    # @example
+    #   @tube.pause(10)
+    #
+    def pause(delay)
+      transmit_to_all("pause-tube #{name} #{delay}")
+    end
+
+    # Clears all unreserved jobs in all states from the tube
+    #
+    # @example
+    #   @tube.clear
+    #
+    def clear
+      pool.tubes.watch!(self.name)
+      %w(delayed buried ready).each do |state|
+        while job = self.peek(state.to_sym)
+          job.delete
+        end
+      end
+      pool.tubes.ignore(name)
+    rescue Beaneater::UnexpectedResponse
+      # swallow any issues
+    end
+
+    # String representation of tube.
+    #
+    # @return [String] Representation of tube including name.
+    # @example
+    #  @tube.to_s # => "#<Beaneater::Tube name=foo>"
+    #
+    def to_s
+      "#<Beaneater::Tube name=#{name.inspect}>"
+    end
+    alias :inspect :to_s
+
+    protected
+
+    # Transmits a beanstalk command that requires this tube to be set as used.
+    #
+    # @param [Proc] block Beanstalk command to transmit.
+    # @return [Object] Result of block passed
+    # @example
+    #  safe_use { transmit_to_rand("kick 1") }
+    #    # => "Response to kick command"
+    #
+    def safe_use(&block)
+      @mutex.lock
+      tubes.use(self.name)
+      yield
+    ensure
+      @mutex.unlock
+    end
+  end # Tube
+end # Beaneater

data/lib/beaneater/version.rb

@@ -0,0 +1,4 @@
+module Beaneater
+  # Current version of gem.
+  VERSION = "0.1.0"
+end

data/test/beaneater_test.rb

@@ -0,0 +1,115 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "beanstalk-client" do
+  before do
+    @beanstalk = Beaneater::Pool.new(['127.0.0.1:11300'])
+    @tubes = ['one', 'two', 'three']
+
+    # Put something on each tube so they exist
+    tube_one = @beanstalk.tubes.find('one')
+    tube_one.put('one')
+
+    tube_two = @beanstalk.tubes.find('two')
+    tube_two.put('two')
+  end
+
+  describe "test thread safe one" do
+    before do
+      # Create threads that will execute
+      # A: use one
+      # B: use one
+      # B: put two
+      # A: put one
+      a = Thread.new do
+        tube_one = @beanstalk.tubes.find('one')
+        sleep 4
+        tube_one.put('one')
+      end
+
+      b = Thread.new do
+        sleep 1
+        tube_two = @beanstalk.tubes.find('two')
+        tube_two.put('two')
+      end
+
+      a.join
+      b.join
+    end
+
+    it "should return correct current-jobs-ready for tube one" do
+      one = @beanstalk.tubes.find('one').stats
+      assert_equal 2, one.current_jobs_ready
+    end
+
+    it "should return correct current-jobs-ready for tube two" do
+      two = @beanstalk.tubes.find('two').stats
+      assert_equal 2, two.current_jobs_ready
+    end
+  end
+
+  describe "test thread safe two" do
+    before do
+      a = Thread.new do
+        tube_one = @beanstalk.tubes.find('one')
+        sleep 4
+        tube_one.put('one')
+      end
+
+      b = Thread.new do
+        tube_two = @beanstalk.tubes.find('two')
+        sleep 1
+        tube_two.put('two')
+      end
+
+      a.join
+      b.join
+    end
+
+    it "should return correct current-jobs-ready for tube one" do
+      one = @beanstalk.tubes.find('one').stats
+      assert_equal 2, one.current_jobs_ready
+    end
+
+    it "should return correct current-jobs-ready for tube two" do
+      two = @beanstalk.tubes.find('two').stats
+      assert_equal 2, two.current_jobs_ready
+    end
+  end
+
+  describe "test delete job in reserved state" do
+    before do
+      @tube_three = @beanstalk.tubes.find('three')
+      @tube_three.put('one')
+      @job = @tube_three.reserve
+    end
+
+    it "should be deleted properly" do
+      assert_equal 'one', @job.body
+      assert_equal 'one', @beanstalk.jobs.find(@job.id).body
+      @job.delete
+      assert_nil @beanstalk.jobs.find(@job.id)
+    end
+  end
+
+  describe "test delete job in buried state" do
+    before do
+      @tube_three = @beanstalk.tubes.find('three')
+      @tube_three.put('two')
+      @job = @tube_three.reserve
+    end
+
+    it "should delete job as expected in buried state" do
+      assert_equal 'two', @job.body
+      @job.bury
+      assert_equal 'two', @tube_three.peek(:buried).body
+
+      @job.delete
+      assert_nil @beanstalk.jobs.find(@job.id)
+    end
+  end
+
+  after do
+    cleanup_tubes!(@tubes, @beanstalk)
+  end
+
+end