tr_resque 1.20.1

data/lib/resque/job.rb

@@ -0,0 +1,227 @@
+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
+
+    # Raise Resque::Job::DontPerform from a before_perform hook to
+    # abort the job.
+    DontPerform = Class.new(StandardError)
+
+    # 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
+      @failure_hooks_ran = false
+    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)
+      Resque.validate(klass, queue)
+
+      if Resque.inline?
+        constantize(klass).perform(*decode(encode(args)))
+      else
+        Resque.push(queue, :class => klass.to_s, :args => args)
+      end
+    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
+
+      if args.empty?
+        redis.lrange(queue, 0, -1).each do |string|
+          if decode(string)['class'] == klass
+            destroyed += redis.lrem(queue, 0, string).to_i
+          end
+        end
+      else
+        destroyed += redis.lrem(queue, 0, encode(:class => klass, :args => args))
+      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
+      job = payload_class
+      job_args = args || []
+      job_was_performed = false
+
+      begin
+        # Execute before_perform hook. Abort the job gracefully if
+        # Resque::DontPerform is raised.
+        begin
+          before_hooks.each do |hook|
+            job.send(hook, *job_args)
+          end
+        rescue DontPerform
+          return false
+        end
+
+        # Execute the job. Do it in an around_perform hook if available.
+        if around_hooks.empty?
+          job.perform(*job_args)
+          job_was_performed = true
+        else
+          # We want to nest all around_perform plugins, with the last one
+          # finally calling perform
+          stack = around_hooks.reverse.inject(nil) do |last_hook, hook|
+            if last_hook
+              lambda do
+                job.send(hook, *job_args) { last_hook.call }
+              end
+            else
+              lambda do
+                job.send(hook, *job_args) do
+                  result = job.perform(*job_args)
+                  job_was_performed = true
+                  result
+                end
+              end
+            end
+          end
+          stack.call
+        end
+
+        # Execute after_perform hook
+        after_hooks.each do |hook|
+          job.send(hook, *job_args)
+        end
+
+        # Return true if the job was performed
+        return job_was_performed
+
+      # If an exception occurs during the job execution, look for an
+      # on_failure hook then re-raise.
+      rescue Object => e
+        run_failure_hooks(e)
+        raise e
+      end
+    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)
+      run_failure_hooks(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
+
+    def before_hooks
+      @before_hooks ||= Plugin.before_hooks(payload_class)
+    end
+
+    def around_hooks
+      @around_hooks ||= Plugin.around_hooks(payload_class)
+    end
+
+    def after_hooks
+      @after_hooks ||= Plugin.after_hooks(payload_class)
+    end
+
+    def failure_hooks
+      @failure_hooks ||= Plugin.failure_hooks(payload_class)
+    end
+
+    def run_failure_hooks(exception)
+      begin
+        job_args = args || []
+        failure_hooks.each { |hook| payload_class.send(hook, exception, *job_args) } unless @failure_hooks_ran
+      ensure
+        @failure_hooks_ran = true
+      end
+    end
+  end
+end

data/lib/resque/plugin.rb

@@ -0,0 +1,66 @@
+module Resque
+  module Plugin
+    extend self
+
+    LintError = Class.new(RuntimeError)
+
+    # Ensure that your plugin conforms to good hook naming conventions.
+    #
+    #   Resque::Plugin.lint(MyResquePlugin)
+    def lint(plugin)
+      hooks = before_hooks(plugin) + around_hooks(plugin) + after_hooks(plugin)
+
+      hooks.each do |hook|
+        if hook =~ /perform$/
+          raise LintError, "#{plugin}.#{hook} is not namespaced"
+        end
+      end
+
+      failure_hooks(plugin).each do |hook|
+        if hook =~ /failure$/
+          raise LintError, "#{plugin}.#{hook} is not namespaced"
+        end
+      end
+    end
+
+    # Given an object, returns a list `before_perform` hook names.
+    def before_hooks(job)
+      job.methods.grep(/^before_perform/).sort
+    end
+
+    # Given an object, returns a list `around_perform` hook names.
+    def around_hooks(job)
+      job.methods.grep(/^around_perform/).sort
+    end
+
+    # Given an object, returns a list `after_perform` hook names.
+    def after_hooks(job)
+      job.methods.grep(/^after_perform/).sort
+    end
+
+    # Given an object, returns a list `on_failure` hook names.
+    def failure_hooks(job)
+      job.methods.grep(/^on_failure/).sort
+    end
+
+    # Given an object, returns a list `after_enqueue` hook names.
+    def after_enqueue_hooks(job)
+      job.methods.grep(/^after_enqueue/).sort
+    end
+
+    # Given an object, returns a list `before_enqueue` hook names.
+    def before_enqueue_hooks(job)
+      job.methods.grep(/^before_enqueue/).sort
+    end
+
+    # Given an object, returns a list `after_dequeue` hook names.
+    def after_dequeue_hooks(job)
+      job.methods.grep(/^after_dequeue/).sort
+    end
+
+    # Given an object, returns a list `before_dequeue` hook names.
+    def before_dequeue_hooks(job)
+      job.methods.grep(/^before_dequeue/).sort
+    end
+  end
+end

data/lib/resque/server.rb

@@ -0,0 +1,248 @@
+require 'sinatra/base'
+require 'erb'
+require 'resque'
+require 'resque/version'
+require 'time'
+
+if defined? Encoding
+  Encoding.default_external = Encoding::UTF_8
+end
+
+module Resque
+  class Server < Sinatra::Base
+    dir = File.dirname(File.expand_path(__FILE__))
+
+    set :views,  "#{dir}/server/views"
+
+    if respond_to? :public_folder
+      set :public_folder, "#{dir}/server/public"
+    else
+      set :public, "#{dir}/server/public"
+    end
+
+    set :static, true
+
+    helpers do
+      include Rack::Utils
+      alias_method :h, :escape_html
+
+      def current_section
+        url_path request.path_info.sub('/','').split('/')[0].downcase
+      end
+
+      def current_page
+        url_path request.path_info.sub('/','')
+      end
+
+      def url_path(*path_parts)
+        [ path_prefix, path_parts ].join("/").squeeze('/')
+      end
+      alias_method :u, :url_path
+
+      def path_prefix
+        request.env['SCRIPT_NAME']
+      end
+
+      def class_if_current(path = '')
+        'class="current"' if current_page[0, path.size] == path
+      end
+
+      def tab(name)
+        dname = name.to_s.downcase
+        path = url_path(dname)
+        "<li #{class_if_current(path)}><a href='#{path}'>#{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
+        when 'zset'
+          Resque.redis.zcard(key)
+        end
+      end
+
+      def redis_get_value_as_array(key, start=0)
+        case Resque.redis.type(key)
+        when 'none'
+          []
+        when 'list'
+          Resque.redis.lrange(key, start, start + 20)
+        when 'set'
+          Resque.redis.smembers(key)[start..(start + 20)]
+        when 'string'
+          [Resque.redis.get(key)]
+        when 'zset'
+          Resque.redis.zrange(key, start, start + 20)
+        end
+      end
+
+      def show_args(args)
+        Array(args).map { |a| a.inspect }.join("\n")
+      end
+
+      def worker_hosts
+        @worker_hosts ||= worker_hosts!
+      end
+
+      def worker_hosts!
+        hosts = Hash.new { [] }
+
+        Resque.workers.each do |worker|
+          host, _ = worker.to_s.split(':')
+          hosts[host] += [worker.to_s]
+        end
+
+        hosts
+      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='#{u(request.path_info)}.poll' rel='poll'>Live Poll</a>"
+        end
+        "<p class='poll'>#{text}</p>"
+      end
+
+    end
+
+    def show(page, layout = true)
+      response["Cache-Control"] = "max-age=0, private, must-revalidate"
+      begin
+        erb page.to_sym, {:layout => layout}, :resque => Resque
+      rescue Errno::ECONNREFUSED
+        erb :error, {:layout => false}, :error => "Can't connect to Redis! (#{Resque.redis_id})"
+      end
+    end
+
+    def show_for_polling(page)
+      content_type "text/html"
+      @polling = true
+      show(page.to_sym, false).gsub(/\s{1,}/, ' ')
+    end
+
+    # to make things easier on ourselves
+    get "/?" do
+      redirect url_path(:overview)
+    end
+
+    %w( overview workers ).each do |page|
+      get "/#{page}.poll/?" do
+        show_for_polling(page)
+      end
+
+      get "/#{page}/:id.poll/?" do
+        show_for_polling(page)
+      end
+    end
+
+    %w( overview queues working workers key ).each do |page|
+      get "/#{page}/?" do
+        show page
+      end
+
+      get "/#{page}/:id/?" do
+        show page
+      end
+    end
+
+    post "/queues/:id/remove" do
+      Resque.remove_queue(params[:id])
+      redirect u('queues')
+    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
+
+    post "/failed/requeue/all" do
+      Resque::Failure.count.times do |num|
+        Resque::Failure.requeue(num)
+      end
+      redirect u('failed')
+    end
+
+    get "/failed/requeue/:index/?" do
+      Resque::Failure.requeue(params[:index])
+      if request.xhr?
+        return Resque::Failure.all(params[:index])['retried_at']
+      else
+        redirect u('failed')
+      end
+    end
+
+    get "/failed/remove/:index/?" do
+      Resque::Failure.remove(params[:index])
+      redirect u('failed')
+    end
+
+    get "/stats/?" do
+      redirect url_path("/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/html'
+      stats.join "\n"
+    end
+
+    def resque
+      Resque
+    end
+
+    def self.tabs
+      @tabs ||= ["Overview", "Working", "Failed", "Queues", "Workers", "Stats"]
+    end
+  end
+end