grockit-resque 1.5.0

data/lib/resque/failure/multiple.rb

@@ -0,0 +1,44 @@
+module Resque
+  module Failure
+    # A Failure backend that uses multiple backends
+    # delegates all queries to the first backend
+    class Multiple < Base
+      
+      class << self
+        attr_accessor :classes
+      end
+      
+      def self.configure
+        yield self
+        Resque::Failure.backend = self
+      end
+      
+      def initialize(*args)
+        @backends = self.class.classes.map {|klass| klass.new(*args)}
+      end
+      def save
+        @backends.each(&:save)
+      end
+      
+      # The number of failures.
+      def self.count
+        classes.first.count
+      end
+
+      # Returns a paginated array of failure objects.
+      def self.all(start = 0, count = 1)
+        classes.first.all(start,count)
+      end
+
+      # A URL where someone can go to view failures.
+      def self.url
+        classes.first.url
+      end
+      
+      # Clear all failure objects
+      def self.clear
+        classes.first.clear
+      end
+    end
+  end
+end

data/lib/resque/failure/redis.rb

@@ -0,0 +1,33 @@
+module Resque
+  module Failure
+    # A Failure backend that stores exceptions in Redis. Very simple but
+    # works out of the box, along with support in the Resque web app.
+    class Redis < Base
+      def save
+        data = {
+          :failed_at => Time.now.strftime("%Y/%m/%d %H:%M:%S"),
+          :payload   => payload,
+          :error     => exception.to_s,
+          :backtrace => exception.backtrace,
+          :worker    => worker.to_s,
+          :queue     => queue
+        }
+        data = Resque.encode(data)
+        Resque.redis.rpush(:failed, data)
+      end
+
+      def self.count
+        Resque.redis.llen(:failed).to_i
+      end
+
+      def self.all(start = 0, count = 1)
+        Resque.list_range(:failed, start, count)
+      end
+      
+      def self.clear
+        Resque.redis.delete('resque:failed')
+      end
+      
+    end
+  end
+end

data/lib/resque/helpers.rb

@@ -0,0 +1,57 @@
+module Resque
+  # Methods used by various classes in Resque.
+  module Helpers
+    # Direct access to the Redis instance.
+    def redis
+      Resque.redis
+    end
+
+    # Given a Ruby object, returns a string suitable for storage in a
+    # queue.
+    def encode(object)
+      if defined? Yajl
+        Yajl::Encoder.encode(object)
+      else
+        object.to_json
+      end
+    end
+
+    # Given a string, returns a Ruby object.
+    def decode(object)
+      return unless object
+
+      if defined? Yajl
+        Yajl::Parser.parse(object, :check_utf8 => false)
+      else
+        JSON.parse(object)
+      end
+    end
+
+    # Given a word with dashes, returns a camel cased version of it.
+    #
+    # classify('job-name') # => 'JobName'
+    def classify(dashed_word)
+      dashed_word.split('-').each { |part| part[0] = part[0].chr.upcase }.join
+    end
+
+    # Given a camel cased word, returns the constant it represents
+    #
+    # constantize('JobName') # => JobName
+    def constantize(camel_cased_word)
+      camel_cased_word = camel_cased_word.to_s
+
+      if camel_cased_word.include?('-')
+        camel_cased_word = classify(camel_cased_word)
+      end
+
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_get(name) || constant.const_missing(name)
+      end
+      constant
+    end
+  end
+end

data/lib/resque/job.rb

@@ -0,0 +1,158 @@
+module Resque
+  # A Resque::Job represents a unit of work. Each job lives on a
+  # single queue and has an associated payload object. The payload
+  # is a hash with two attributes: `class` and `args`. The `class` is
+  # the name of the Ruby class which should be used to run the
+  # job. The `args` are an array of arguments which should be passed
+  # to the Ruby class's `perform` class-level method.
+  #
+  # You can manually run a job using this code:
+  #
+  #   job = Resque::Job.reserve(:high)
+  #   klass = Resque::Job.constantize(job.payload['class'])
+  #   klass.perform(*job.payload['args'])
+  class Job
+    include Helpers
+    extend Helpers
+
+    # The worker object which is currently processing this job.
+    attr_accessor :worker
+
+    # The name of the queue from which this job was pulled (or is to be
+    # placed)
+    attr_reader :queue
+
+    # This job's associated payload object.
+    attr_reader :payload
+
+    def initialize(queue, payload)
+      @queue = queue
+      @payload = payload
+    end
+
+    # Creates a job by placing it on a queue. Expects a string queue
+    # name, a string class name, and an optional array of arguments to
+    # pass to the class' `perform` method.
+    #
+    # Raises an exception if no queue or class is given.
+    def self.create(queue, klass, *args)
+      if !queue
+        raise NoQueueError.new("Jobs must be placed onto a queue.")
+      end
+
+      if klass.to_s.empty?
+        raise NoClassError.new("Jobs must be given a class.")
+      end
+
+      Resque.push(queue, :class => klass.to_s, :args => args)
+    end
+    
+    def self.create_unique(queue, klass, *args)
+      if !queue
+        raise NoQueueError.new("Jobs must be placed onto a queue.")
+      end
+
+      if klass.to_s.empty?
+        raise NoClassError.new("Jobs must be given a class.")
+      end
+
+      Resque.push(queue, :class => klass.to_s, :args => args, :unique => true)
+    end
+
+    # Removes a job from a queue. Expects a string queue name, a
+    # string class name, and, optionally, args.
+    #
+    # Returns the number of jobs destroyed.
+    #
+    # If no args are provided, it will remove all jobs of the class
+    # provided.
+    #
+    # That is, for these two jobs:
+    #
+    # { 'class' => 'UpdateGraph', 'args' => ['defunkt'] }
+    # { 'class' => 'UpdateGraph', 'args' => ['mojombo'] }
+    #
+    # The following call will remove both:
+    #
+    #   Resque::Job.destroy(queue, 'UpdateGraph')
+    #
+    # Whereas specifying args will only remove the 2nd job:
+    #
+    #   Resque::Job.destroy(queue, 'UpdateGraph', 'mojombo')
+    #
+    # This method can be potentially very slow and memory intensive,
+    # depending on the size of your queue, as it loads all jobs into
+    # a Ruby array before processing.
+    def self.destroy(queue, klass, *args)
+      klass = klass.to_s
+      queue = "queue:#{queue}"
+      destroyed = 0
+
+      redis.lrange(queue, 0, -1).each do |string|
+        json   = decode(string)
+
+        match  = json['class'] == klass
+        match &= json['args'] == args unless args.empty?
+
+        if match
+          destroyed += redis.lrem(queue, 0, string).to_i
+        end
+      end
+
+      destroyed
+    end
+
+    # Given a string queue name, returns an instance of Resque::Job
+    # if any jobs are available. If not, returns nil.
+    def self.reserve(queue)
+      return unless payload = Resque.pop(queue)
+      new(queue, payload)
+    end
+
+    # Attempts to perform the work represented by this job instance.
+    # Calls #perform on the class given in the payload with the
+    # arguments given in the payload.
+    def perform
+      args ? payload_class.perform(*args) : payload_class.perform
+    end
+
+    # Returns the actual class constant represented in this job's payload.
+    def payload_class
+      @payload_class ||= constantize(@payload['class'])
+    end
+
+    # Returns an array of args represented in this job's payload.
+    def args
+      @payload['args']
+    end
+
+    # Given an exception object, hands off the needed parameters to
+    # the Failure module.
+    def fail(exception)
+      Failure.create \
+        :payload   => payload,
+        :exception => exception,
+        :worker    => worker,
+        :queue     => queue
+    end
+
+    # Creates an identical job, essentially placing this job back on
+    # the queue.
+    def recreate
+      self.class.create(queue, payload_class, *args)
+    end
+
+    # String representation
+    def inspect
+      obj = @payload
+      "(Job{%s} | %s | %s)" % [ @queue, obj['class'], obj['args'].inspect ]
+    end
+
+    # Equality
+    def ==(other)
+      queue == other.queue &&
+        payload_class == other.payload_class &&
+        args == other.args
+    end
+  end
+end

data/lib/resque/server.rb

@@ -0,0 +1,182 @@
+require 'sinatra/base'
+require 'erb'
+require 'resque'
+require 'resque/version'
+
+module Resque
+  class Server < Sinatra::Base
+    dir = File.dirname(File.expand_path(__FILE__))
+
+    set :views,  "#{dir}/server/views"
+    set :public, "#{dir}/server/public"
+    set :static, true
+
+    helpers do
+      include Rack::Utils
+      alias_method :h, :escape_html
+
+      def current_section
+        url request.path_info.sub('/','').split('/')[0].downcase
+      end
+
+      def current_page
+        url request.path_info.sub('/','').downcase
+      end
+
+      def url(*path_parts)
+        [ path_prefix, path_parts ].join("/").squeeze('/')
+      end
+      alias_method :u, :url
+
+      def path_prefix
+        request.env['SCRIPT_NAME']
+      end
+
+      def class_if_current(page = '')
+        'class="current"' if current_page.include? page.to_s
+      end
+
+      def tab(name)
+        dname = name.to_s.downcase
+        "<li #{class_if_current(dname)}><a href='#{url dname}'>#{name}</a></li>"
+      end
+
+      def tabs
+        Resque::Server.tabs
+      end
+
+      def redis_get_size(key)
+        case Resque.redis.type(key)
+        when 'none'
+          []
+        when 'list'
+          Resque.redis.llen(key)
+        when 'set'
+          Resque.redis.scard(key)
+        when 'string'
+          Resque.redis.get(key).length
+        end
+      end
+
+      def redis_get_value_as_array(key)
+        case Resque.redis.type(key)
+        when 'none'
+          []
+        when 'list'
+          Resque.redis.lrange(key, 0, 20)
+        when 'set'
+          Resque.redis.smembers(key)
+        when 'string'
+          [Resque.redis.get(key)]
+        end
+      end
+
+      def show_args(args)
+        Array(args).map { |a| a.inspect }.join("\n")
+      end
+
+      def partial?
+        @partial
+      end
+
+      def partial(template, local_vars = {})
+        @partial = true
+        erb(template.to_sym, {:layout => false}, local_vars)
+      ensure
+        @partial = false
+      end
+      
+      def poll
+        if @polling
+          text = "Last Updated: #{Time.now.strftime("%H:%M:%S")}"
+        else
+          text = "<a href='#{url(request.path_info)}.poll' rel='poll'>Live Poll</a>"
+        end
+        "<p class='poll'>#{text}</p>"
+      end
+      
+    end
+
+    def show(page, layout = true)
+      begin
+        erb page.to_sym, {:layout => layout}, :resque => Resque
+      rescue Errno::ECONNREFUSED
+        erb :error, {:layout => false}, :error => "Can't connect to Redis! (#{Resque.redis.server})"
+      end
+    end
+
+    # to make things easier on ourselves
+    get "/?" do
+      redirect url(:overview)
+    end
+
+    %w( overview queues working workers key ).each do |page|
+      get "/#{page}" do
+        show page
+      end
+
+      get "/#{page}/:id" do
+        show page
+      end
+    end
+    
+    %w( overview workers ).each do |page|
+      get "/#{page}.poll" do
+        content_type "text/plain"
+        @polling = true
+        show(page.to_sym, false).gsub(/\s{1,}/, ' ')
+      end
+    end
+
+    get "/failed" do
+      if Resque::Failure.url
+        redirect Resque::Failure.url
+      else
+        show :failed
+      end
+    end
+    
+    post "/failed/clear" do
+      Resque::Failure.clear
+      redirect u('failed')
+    end
+
+    get "/stats" do
+      redirect url("/stats/resque")
+    end
+
+    get "/stats/:id" do
+      show :stats
+    end
+
+    get "/stats/keys/:key" do
+      show :stats
+    end
+
+    get "/stats.txt" do
+      info = Resque.info
+
+      stats = []
+      stats << "resque.pending=#{info[:pending]}"
+      stats << "resque.processed+=#{info[:processed]}"
+      stats << "resque.failed+=#{info[:failed]}"
+      stats << "resque.workers=#{info[:workers]}"
+      stats << "resque.working=#{info[:working]}"
+
+      Resque.queues.each do |queue|
+        stats << "queues.#{queue}=#{Resque.size(queue)}"
+      end
+
+      content_type 'text/plain'
+      stats.join "\n"
+    end
+
+    def resque
+      Resque
+    end
+
+    def self.tabs
+      @tabs ||= ["Overview", "Working", "Failed", "Queues", "Workers", "Stats"]
+    end
+  end
+end