beaneater 0.1.0

data/lib/beaneater/job/record.rb

@@ -0,0 +1,174 @@
+module Beaneater
+  # Represents job related commands.
+  class Job
+
+    # @!attribute id
+    #   @return [Integer] returns Job id
+    # @!attribute body
+    #   @return [String] returns Job body
+    # @!attribute connection
+    #   @return [Beaneater::Connection] returns Connection which has retrieved job
+    # @!attribute reserved
+    #   @return [Boolean] returns If job is being reserved
+    attr_reader :id, :body, :connection, :reserved
+
+
+    # Initialize new connection
+    #
+    # @param [Hash] res result from beanstalkd response
+    def initialize(res)
+      @id         = res[:id]
+      @body       = res[:body]
+      @connection = res[:connection]
+      @reserved   = res[:status] == 'RESERVED'
+    end
+
+    # Send command to bury job
+    #
+    # @param [Hash] options Settings to bury job
+    # @option options [Integer] pri Assign new priority to job
+    #
+    # @example
+    #   @beaneater_connection.bury({:pri => 100})
+    #
+    # @api public
+    def bury(options={})
+      options = { :pri => stats.pri }.merge(options)
+      with_reserved("bury #{id} #{options[:pri]}") do
+        @reserved = false
+      end
+    end
+
+    # Send command to release job
+    #
+    # @param [Hash] options Settings to release job
+    # @option options [Integer] pri Assign new priority to job
+    # @option options [Integer] pri Assign new delay to job
+    #
+    # @example
+    #   @beaneater_connection.jobs.find(123).release(:pri => 10, :delay => 5)
+    #
+    # @api public
+    def release(options={})
+      options = { :pri => stats.pri, :delay => stats.delay }.merge(options)
+      with_reserved("release #{id} #{options[:pri]} #{options[:delay]}") do
+        @reserved = false
+      end
+    end
+
+    # Send command to touch job
+    #
+    # @example
+    #   @beaneater_connection.jobs.find(123).touch
+    #
+    # @api public
+    def touch
+      with_reserved("touch #{id}")
+    end
+
+    # Send command to delete job
+    #
+    # @example
+    #   @beaneater_connection.jobs.find(123).delete
+    #
+    # @api public
+    def delete
+      transmit("delete #{id}") { @reserved = false }
+    end
+
+    # Send command to kick job
+    #
+    # @example
+    #   @beaneater_connection.jobs.find(123).kick
+    #
+    # @api public
+    def kick
+      transmit("kick-job #{id}")
+    end
+
+    # Send command to get stats about job
+    #
+    # @example
+    #   @beaneater_connection.jobs.find(123).stats
+    #
+    # @api public
+    def stats
+      res = transmit("stats-job #{id}")
+      StatStruct.from_hash(res[:body])
+    end
+
+    # Check if job is being reserved
+    #
+    # @example
+    #   @beaneater_connection.jobs.find(123).reserved?
+    #
+    # @api public
+    def reserved?
+      @reserved || self.stats.state == "reserved"
+    end
+
+    # Check if job exists
+    #
+    # @example
+    #   @beaneater_connection.jobs.find(123).exists?
+    #
+    # @api public
+    def exists?
+      !!self.stats
+    rescue Beaneater::NotFoundError
+      false
+    end
+
+    # Returns the name of the tube this job is in
+    #
+    # @example
+    #   @beaneater_connection.jobs.find(123).tube
+    #
+    # @api public
+    def tube
+      self.stats && self.stats.tube
+    end
+
+    # Returns string representation of job
+    #
+    # @example
+    #   @beaneater_connection.jobs.find(123).to_s
+    #   @beaneater_connection.jobs.find(123).inspect
+    #
+    # @api public
+    def to_s
+      "#<Beaneater::Job id=#{id} body=#{body.inspect}>"
+    end
+    alias :inspect :to_s
+
+    protected
+
+    # Transmit command to beanstalkd instances and fetch response.
+    #
+    # @param [String] cmd Beanstalkd command to send.
+    # @return [Hash] Beanstalkd response for the command.
+    # @example
+    #  transmit('stats')
+    #  transmit('stats') { 'success' }
+    #
+    def transmit(cmd, &block)
+      res = connection.transmit(cmd)
+      yield if block_given?
+      res
+    end
+
+    # Transmits a command which requires the job to be reserved.
+    #
+    # @param [String] cmd Beanstalkd command to send.
+    # @return [Hash] Beanstalkd response for the command.
+    # @raise [Beaneater::JobNotReserved] Command cannot execute since job is not reserved.
+    # @example
+    #   with_reserved("bury 26") { @reserved = false }
+    #
+    def with_reserved(cmd, &block)
+      raise JobNotReserved unless reserved?
+      transmit(cmd, &block)
+    end
+
+  end # Job
+end # Beaneater

data/lib/beaneater/pool.rb

@@ -0,0 +1,141 @@
+# Simple ruby client for beanstalkd.
+module Beaneater
+  # Represents collection of connections.
+  class Pool
+    # Default number of retries to send a command to a connection
+    MAX_RETRIES = 3
+
+    # @!attribute connections
+    #   @return [Array<Beaneater::Connection>] returns Collection of connections
+    attr_reader :connections
+
+    # Initialize new connection
+    #
+    # @param [Array] hosts Array of beanstalkd server host
+    #
+    # @example
+    #   Beaneater::Pool.new(['localhost:11300', '127.0.0.1:11300'])
+    #
+    #   ENV['BEANSTALKD_URL'] = 'localhost:11300,127.0.0.1:11300'
+    #   @bp = Beaneater::Pool.new
+    #   @bp.connections.first.host # => 'localhost'
+    #   @bp.connections.last.host # => '127.0.0.1'
+    def initialize(hosts=nil)
+      hosts = hosts || host_from_env
+      @connections = Array(hosts).map { |h| Connection.new(h) }
+    end
+
+    # Returns Beaneater::Stats object
+    #
+    # @api public
+    def stats
+      @stats ||= Stats.new(self)
+    end
+
+    # Returns Beaneater::Jobs object
+    #
+    # @api public
+    def jobs
+      @jobs ||= Jobs.new(self)
+    end
+
+    # Returns Beaneater::Tubes object
+    #
+    # @api public
+    def tubes
+      @tubes ||= Tubes.new(self)
+    end
+
+    # Send command to every beanstalkd servers set in pool
+    #
+    # @param [String] command Beanstalkd command
+    # @param [Hash] options telnet connections options
+    # @param [Proc] block Block passed in telnet connection object
+    #
+    # @example
+    #   @pool.transmit_to_all("stats")
+    def transmit_to_all(command, options={}, &block)
+      connections.map do |conn|
+        safe_transmit { conn.transmit(command, options, &block) }
+      end
+    end
+
+    # Send command to a random beanstalkd servers set in pool
+    #
+    # @param [String] command Beanstalkd command
+    # @param [Hash] options telnet connections options
+    # @param [Proc] block Block passed in telnet connection object
+    #
+    # @example
+    #   @pool.transmit_to_rand("stats", :match => /\n/)
+    def transmit_to_rand(command, options={}, &block)
+      safe_transmit do
+        conn = connections.respond_to?(:sample) ? connections.sample : connections.choice
+        conn.transmit(command, options, &block)
+      end
+    end
+
+    # Send command to each beanstalkd servers until getting response expected
+    #
+    # @param [String] command Beanstalkd command
+    # @param [Hash] options telnet connections options
+    # @param [Proc] block Block passed in telnet connection object
+    #
+    # @example
+    #   @pool.transmit_until_res('peek-ready', :status => "FOUND", &block)
+    def transmit_until_res(command, options={}, &block)
+      status_expected  = options.delete(:status)
+      connections.each do |conn|
+        res = safe_transmit { conn.transmit(command, options, &block) }
+        return res if res[:status] == status_expected
+      end && nil
+    end
+
+    # Closes all connections within pool
+    def close
+      while @connections.any?
+        conn = @connections.pop
+        conn.close
+      end
+    end
+
+    protected
+
+    # Transmit command to beanstalk connections safely handling failed connections
+    #
+    # @param [Proc] block The command to execute.
+    # @return [Object] Result of the block passed
+    # @raise [Beaneater::DrainingError,Beaneater::NotConnected] Could not connect to Beanstalk client
+    # @example
+    #  safe_transmit { conn.transmit('foo') }
+    #   # => "result of foo command from beanstalk"
+    #
+    def safe_transmit(&block)
+      retries = 1
+      begin
+        yield
+      rescue DrainingError, EOFError, Errno::ECONNRESET, Errno::EPIPE => ex
+        # TODO remove faulty connections from pool?
+        # https://github.com/kr/beanstalk-client-ruby/blob/master/lib/beanstalk-client/connection.rb#L405-410
+        if retries < MAX_RETRIES
+          retries += 1
+          retry
+        else # finished retrying, fail out
+          ex.is_a?(DrainingError) ? raise(ex) : raise(NotConnected, "Could not connect!")
+        end
+      end
+    end # transmit_call
+
+    # The hosts provided by BEANSTALKD_URL environment variable, if available.
+    #
+    # @return [Array] Set of beanstalkd host addresses
+    # @example
+    #  ENV['BEANSTALKD_URL'] = "localhost:1212,localhost:2424"
+    #   # => ['localhost:1212', 'localhost:2424']
+    #
+    def host_from_env
+      ENV['BEANSTALKD_URL'].respond_to?(:length) && ENV['BEANSTALKD_URL'].length > 0 && ENV['BEANSTALKD_URL'].split(',').map(&:strip)
+    end
+
+  end # Pool
+end # Beaneater

data/lib/beaneater/pool_command.rb

@@ -0,0 +1,71 @@
+require 'set'
+
+module Beaneater
+  # Represents collection of pool related commands.
+  class PoolCommand
+    # @!attribute pool
+    #   @return [Beaneater::Pool] returns Pool object
+    attr_reader :pool
+
+    # Initialize new connection
+    #
+    # @param [Beaneater::Pool] pool Pool object
+    def initialize(pool)
+      @pool = pool
+    end
+
+    # Delegate to Pool#transmit_to_all and if needed will merge responses from beanstalkd
+    #
+    # @param [String] body Beanstalkd command
+    # @param [Hash] options telnet connections options
+    # @option options [Boolean] merge Ask for merging responses or not
+    # @param [Proc] block Block passed in telnet connection object
+    #
+    # @example
+    #   @pool.transmit_to_all("stats")
+    def transmit_to_all(body, options={}, &block)
+      merge = options.delete(:merge)
+      res = pool.transmit_to_all(body, options, &block)
+      if merge
+        res = { :status => res.first[:status], :body => sum_hashes(res.map { |r| r[:body] }) }
+      end
+      res
+    end
+
+    # Delegate missing methods to pool
+    # @api public
+    def method_missing(name, *args, &block)
+      if pool.respond_to?(name)
+        pool.send(name, *args, &block)
+      else # not a known pool command
+        super
+      end
+    end
+
+    protected
+
+    # Selects hashes from collection and then merges the individual key values
+    #
+    # @param [Array<Hash>] hs Collection of hash responses returned from beanstalkd
+    # @return [Hash] Merged responses combining values from all the hash bodies
+    # @example
+    #  self.sum_hashes([{ :foo => 1, :bar => 5 }, { :foo => 2, :bar => 3 }])
+    #    => { :foo => 3, :bar => 8 }
+    #
+    def sum_hashes(hs)
+      hs.select { |h| h.is_a?(Hash) }.
+        inject({}) { |a,b| a.merge(b) { |k,o,n| combine_stats(k, o, n) } }
+    end
+
+    # Combine two values for given key
+    #
+    # @param [String] k key name within response hash
+    # @return [Set,Integer] combined value for stat
+    # @example
+    #  self.combine_stats('total_connections', 4, 5) # => 9
+    #
+    def combine_stats(k, a, b)
+      ['name', 'version', 'pid'].include?(k) ? Set[a] + Set[b] : a + b
+    end
+  end # PoolCommand
+end # Beaneater

data/lib/beaneater/stats.rb

@@ -0,0 +1,55 @@
+require 'beaneater/stats/fast_struct'
+require 'beaneater/stats/stat_struct'
+
+module Beaneater
+  # Represents stats related to the beanstalkd pool.
+  class Stats < PoolCommand
+    # Returns keys for stats data
+    #
+    # @return [Array<String>] Set of keys for stats.
+    # @example
+    #  @bp.stats.keys # => ["version", "total_connections"]
+    #
+    def keys
+      data.keys
+    end
+
+    # Returns value for specified key.
+    #
+    # @param [String,Symbol] key Name of key to retrieve
+    # @return [String,Integer] Value of specified key
+    # @example
+    #  @bp.stats['total_connections'] # => 4
+    #
+    def [](key)
+      data[key]
+    end
+
+    # Defines a cached method for looking up data for specified key
+    # Protects against infinite loops by checking stacktrace
+    # @api public
+    def method_missing(name, *args, &block)
+      if caller.first !~ /`(method_missing|data')/ && data.keys.include?(name.to_s)
+        self.class.class_eval <<-CODE, __FILE__, __LINE__
+          def #{name}; data[#{name.inspect}]; end
+        CODE
+        data[name.to_s]
+      else # no key matches or caught infinite loop
+        super
+      end
+    end
+
+    protected
+
+    # Returns struct based on stats data merged from all connections.
+    #
+    # @return [Beaneater::StatStruct] the combined stats for all beanstalk connections in the pool
+    # @example
+    #  self.data # => { 'version' : 1.7, 'total_connections' : 23 }
+    #  self.data.total_connections # => 23
+    #
+    def data
+      StatStruct.from_hash(transmit_to_all('stats', :merge => true)[:body])
+    end
+  end # Stats
+end # Beaneater

data/lib/beaneater/stats/fast_struct.rb

@@ -0,0 +1,96 @@
+module Beaneater
+  #
+  # Borrowed from:
+  # https://github.com/dolzenko/faster_open_struct/blob/master/lib/faster_open_struct.rb
+  #
+  # Up to 40 (!) times more memory efficient version of OpenStruct
+  #
+  # Differences from Ruby MRI OpenStruct:
+  #
+  # 1. Doesn't `dup` passed initialization hash (NOTE: only reference to hash is stored)
+  #
+  # 2. Doesn't convert hash keys to symbols (by default string keys are used,
+  #    with fallback to symbol keys)
+  #
+  # 3. Creates methods on the fly on `OpenStruct` class, instead of singleton class.
+  #    Uses `module_eval` with string to avoid holding scope references for every method.
+  #
+  # 4. Refactored, crud clean, spec covered :)
+  #
+  # @private
+  class FasterOpenStruct
+    # Undefine particularly nasty interfering methods on Ruby 1.8
+    undef :type if method_defined?(:type)
+    undef :id if method_defined?(:id)
+
+    def initialize(hash = nil)
+      @hash = hash || {}
+      @initialized_empty = hash == nil
+    end
+
+    def method_missing(method_name_sym, *args)
+      if method_name_sym.to_s[-1] == ?=
+        if args.size != 1
+          raise ArgumentError, "wrong number of arguments (#{args.size} for 1)", caller(1)
+        end
+
+        if self.frozen?
+          raise TypeError, "can't modify frozen #{self.class}", caller(1)
+        end
+
+        __new_ostruct_member__(method_name_sym.to_s.chomp("="))
+        send(method_name_sym, args[0])
+      elsif args.size == 0
+        __new_ostruct_member__(method_name_sym)
+        send(method_name_sym)
+      else
+        raise NoMethodError, "undefined method `#{method_name_sym}' for #{self}", caller(1)
+      end
+    end
+
+    def __new_ostruct_member__(method_name_sym)
+      self.class.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+      def #{ method_name_sym }
+        @hash.fetch("#{ method_name_sym }", @hash[:#{ method_name_sym }]) # read by default from string key, then try symbol
+                                                                          # if string key doesn't exist
+      end
+      END_EVAL
+
+      unless method_name_sym.to_s[-1] == ?? # can't define writer for predicate method
+        self.class.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+        def #{ method_name_sym }=(val)
+          if @hash.key?("#{ method_name_sym }") || @initialized_empty       # write by default to string key (when it is present
+                                                                            # in initialization hash or initialization hash
+                                                                            # wasn't provided)
+            @hash["#{ method_name_sym }"] = val                             # if it doesn't exist - write to symbol key
+          else
+            @hash[:#{ method_name_sym }] = val
+          end
+        end
+        END_EVAL
+      end
+    end
+
+    def empty?
+      @hash.empty?
+    end
+
+    #
+    # Compare this object and +other+ for equality.
+    #
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    end
+
+    #
+    # Returns a string containing a detailed summary of the keys and values.
+    #
+    def inspect
+      str = "#<#{ self.class }"
+      str << " #{ @hash.map { |k, v| "#{ k }=#{ v.inspect }" }.join(", ") }" unless @hash.empty?
+      str << ">"
+    end
+    alias :to_s :inspect
+  end # FasterOpenStruct
+end # Beaneater