resque-web-edge 1.0.0

data/app/controllers/resque_web/application_controller.rb

@@ -0,0 +1,26 @@
+module ResqueWeb
+  class ApplicationController < ActionController::Base
+    include ActionView::Helpers::TextHelper
+    protect_from_forgery
+    before_filter :set_subtabs, :authorize
+
+    helper :all
+
+    def self.subtabs(*tab_names)
+      return defined?(@subtabs) ? @subtabs : [] if tab_names.empty?
+      @subtabs = tab_names
+    end
+
+    def set_subtabs(subtabs = self.class.subtabs)
+      @subtabs = subtabs
+    end
+
+    private
+
+    def authorize
+      if ENV["RESQUE_WEB_HTTP_BASIC_AUTH_USER"] && ENV["RESQUE_WEB_HTTP_BASIC_AUTH_PASSWORD"]
+        authenticate_or_request_with_http_basic {|u, p| u == ENV["RESQUE_WEB_HTTP_BASIC_AUTH_USER"] && p == ENV["RESQUE_WEB_HTTP_BASIC_AUTH_PASSWORD"] }
+      end
+    end
+  end
+end

data/app/controllers/resque_web/failures_controller.rb

@@ -0,0 +1,62 @@
+module ResqueWeb
+  class FailuresController < ResqueWeb::ApplicationController
+
+    # Display all jobs in the failure queue
+    #
+    # @param [Hash] params
+    # @option params [String] :class filters failures shown by class
+    # @option params [String] :queue filters failures shown by failure queue name
+    def index
+    end
+
+    # remove an individual job from the failure queue
+    def destroy
+      Resque::Failure.remove(params[:id])
+      redirect_to failures_path(redirect_params)
+    end
+
+    # destroy all jobs from the failure queue
+    def destroy_all
+      queue = params[:queue] || 'failed'
+      Resque::Failure.clear(queue)
+      redirect_to failures_path(redirect_params)
+    end
+
+    # retry an individual job from the failure queue
+    def retry
+      reque_single_job(params[:id])
+      redirect_to failures_path(redirect_params)
+    end
+
+    # retry all jobs from the failure queue
+    def retry_all
+      if params[:queue].present? && params[:queue]!="failed"
+        Resque::Failure.requeue_queue(params[:queue])
+      else
+        (Resque::Failure.count-1).downto(0).each { |id| reque_single_job(id) }
+      end
+      redirect_to failures_path(redirect_params)
+    end
+
+    private
+
+    #API agnostic for Resque 2 with duck typing on requeue_and_remove
+    def reque_single_job(id)
+      if Resque::Failure.respond_to?(:requeue_and_remove)
+        Resque::Failure.requeue_and_remove(id)
+      else
+        Resque::Failure.requeue(id)
+        Resque::Failure.remove(id)
+      end
+    end
+
+    def redirect_params
+      {}.tap do |p|
+        if params[:queue].present?
+          p[:queue] = params[:queue]
+        end
+      end
+    end
+
+  end
+end

data/app/controllers/resque_web/jobs_controller.rb

@@ -0,0 +1,12 @@
+module ResqueWeb
+  class JobsController < ApplicationController
+  
+    def destroy
+      args = JSON.parse(params[:args])
+      destroyed = Resque::Job.destroy(params[:queue], params[:job_class], *args)
+      flash[:info] = "#{pluralize(destroyed, 'job')} deleted."
+      redirect_to queue_path(params[:queue])
+    end
+
+  end
+end

data/app/controllers/resque_web/overview_controller.rb

@@ -0,0 +1,7 @@
+module ResqueWeb
+  class OverviewController < ResqueWeb::ApplicationController
+    def show
+      render :layout => !request.xhr?, :locals => { :polling => request.xhr? }
+    end
+  end
+end

data/app/controllers/resque_web/queues_controller.rb

@@ -0,0 +1,22 @@
+module ResqueWeb
+  class QueuesController < ResqueWeb::ApplicationController
+
+    def index
+    end
+
+    def show
+      set_subtabs view_context.queue_names
+    end
+
+    def destroy
+      Resque.remove_queue(params[:id])
+      redirect_to queues_path
+    end
+
+    def clear
+      Resque.redis.del("queue:#{params[:id]}")
+      redirect_to queue_path(params[:id])
+    end
+
+  end
+end

data/app/controllers/resque_web/stats_controller.rb

@@ -0,0 +1,36 @@
+module ResqueWeb
+  class StatsController < ResqueWeb::ApplicationController
+    subtabs :resque, :redis, :keys
+
+    def index
+      redirect_to action: "resque"
+    end
+
+    def resque
+      respond_to do |format|
+        format.html
+        format.json { render json: Hash[Resque.info.sort] }
+      end
+    end
+
+    def redis
+      respond_to do |format|
+        format.html
+        format.json { render json: Hash[Resque.redis.info.sort] }
+      end
+    end
+
+    def keys
+      respond_to do |format|
+        format.html do
+          if params[:id]
+            render 'key'
+          else
+            render 'keys'
+          end
+        end
+        format.json { render json: Resque.keys.sort }
+      end
+    end
+  end
+end

data/app/controllers/resque_web/workers_controller.rb

@@ -0,0 +1,23 @@
+module ResqueWeb
+  class WorkersController < ResqueWeb::ApplicationController
+    before_filter :display_subtabs
+
+    def index
+    end
+
+    def show
+      if params[:id] && params[:id] != 'all'
+        @workers = view_context.worker_hosts[params[:id]].map { |id| Resque::Worker.find(id) }
+      else
+        @workers = Resque.workers
+      end
+    end
+
+    private
+
+    def display_subtabs
+      set_subtabs view_context.worker_hosts.map(&:first)
+    end
+
+  end
+end

data/app/controllers/resque_web/working_controller.rb

@@ -0,0 +1,8 @@
+module ResqueWeb
+  class WorkingController < ResqueWeb::ApplicationController
+
+    def index
+    end
+
+  end
+end

data/app/helpers/resque_web/application_helper.rb

@@ -0,0 +1,69 @@
+module ResqueWeb
+  module ApplicationHelper
+
+    PER_PAGE = 20
+
+    def tabs
+      t = {'overview' => ResqueWeb::Engine.app.url_helpers.overview_path,
+       'working'  => ResqueWeb::Engine.app.url_helpers.working_index_path,
+       'failures' => ResqueWeb::Engine.app.url_helpers.failures_path,
+       'queues' => ResqueWeb::Engine.app.url_helpers.queues_path,
+       'workers' => ResqueWeb::Engine.app.url_helpers.workers_path,
+       'stats' => ResqueWeb::Engine.app.url_helpers.stats_path
+      }
+      ResqueWeb::Plugins.plugins.each do |p|
+        p.tabs.each { |tab| t.merge!(tab) }
+      end
+      t
+    end
+
+    def tab(name,path)
+      content_tag :li, link_to(name.capitalize, path), :class => current_tab?(name) ? "active" : nil
+    end
+
+    def current_tab
+      params[:controller].gsub(/resque_web\//, "#{root_path}")
+    end
+
+    def current_tab?(name)
+      request.path.starts_with? tabs[name.to_s]
+    end
+
+    attr_reader :subtabs
+
+    def subtab(name)
+      content_tag :li, link_to(name, "#{current_tab}/#{name}"), :class => current_subtab?(name) ? "current" : nil
+    end
+
+    def current_subtab?(name)
+      params[:id] == name.to_s
+    end
+
+    def pagination(options = {})
+      start    = options[:start] || 1
+      per_page = options[:per_page] || PER_PAGE
+      total    = options[:total] || 0
+      return if total < per_page
+
+      markup = ""
+      if start - per_page >= 0
+        markup << link_to(raw("&laquo; less"), params.merge(:start => start - per_page), :class => 'btn less')
+      end
+
+      if start + per_page <= total
+        markup << link_to(raw("more &raquo;"), params.merge(:start => start + per_page), :class => 'btn more')
+      end
+
+      content_tag :p, raw(markup), :class => 'pagination'
+    end
+
+    def poll(polling=false)
+      if polling
+        text = "Last Updated: #{Time.now.strftime("%H:%M:%S")}".html_safe
+      else
+        text = "<a href='#{h(request.path)}' rel='poll'>Live Poll</a>".html_safe
+      end
+      content_tag :p, text, :class => 'poll'
+    end
+  end
+end

data/app/helpers/resque_web/failures_helper.rb

@@ -0,0 +1,58 @@
+module ResqueWeb
+  module FailuresHelper
+    def each_failure(&block)
+      Resque::Failure.each(failure_start_at, failure_per_page, params[:queue], params[:class], &block)
+    end
+
+    def failure_date_format
+      "%Y/%m/%d %T %z"
+    end
+
+    def multiple_failure_queues?
+      @multiple_failure_queues ||= Resque::Failure.queues.size > 1
+    end
+
+    def failure_queue
+      multiple_failure_queues? ? params[:id] : 'failed'
+    end
+
+    def failure_queue_name
+      @failure_queue_name ||= params[:queue] ? params[:queue] : 'Failed'
+    end
+
+    def failure_size
+      @failure_size ||= Resque::Failure.count(params[:id], params[:class])
+    end
+
+    def failure_per_page
+      @failures_per_page ||= params[:class] ? failure_size : 20
+    end
+
+    def failure_start_at
+      params[:start].to_i
+    end
+
+    def failure_end_at
+      if failure_start_at + failure_per_page > failure_size
+        failure_size
+      else
+        failure_start_at + failure_per_page
+      end
+    end
+
+    def failure_class_counts(queue = params[:id])
+      classes = Hash.new(0)
+      Resque::Failure.each(0, Resque::Failure.count(queue), queue) do |_, item|
+        class_name = item['payload']['class'] if item['payload']
+        class_name ||= "nil"
+        classes[class_name] += 1
+      end
+      classes.sort_by { |name,_| name }
+    end
+
+    def job_arguments(job)
+      return 'nil' unless job['payload']
+      Array(job['payload']['args']).map { |arg| arg.inspect }.join("\n")
+    end
+  end
+end

data/app/helpers/resque_web/overview_helper.rb

@@ -0,0 +1,6 @@
+module ResqueWeb
+  module OverviewHelper
+    include QueuesHelper
+    include WorkingHelper
+  end
+end

data/app/helpers/resque_web/queues_helper.rb

@@ -0,0 +1,72 @@
+require 'resque/failure/redis_multi_queue'
+
+module ResqueWeb
+  module QueuesHelper
+    def queues_partial_name
+      if Resque::Failure.backend == Resque::Failure::RedisMultiQueue
+        'resque_web/queues/queues_advanced'
+      else
+        'resque_web/queues/queues_basic'
+      end
+    end
+
+    def queue_names
+      Resque.queues.sort_by(&:to_s)
+    end
+
+    def queue_start_at
+      params[:start].to_i
+    end
+
+    def queue_end_at
+      if queue_start_at + queue_per_page > queue_size
+        queue_size
+      else
+        queue_start_at + queue_per_page
+      end
+    end
+
+    def queue_per_page
+      20
+    end
+
+    def queue_size(queue_name = params[:id])
+      Resque.size queue_name
+    end
+
+    def queue_jobs
+      @queue_jobs ||= Resque.peek(params[:id], queue_start_at, queue_per_page)
+    end
+
+    def failed_queue_names
+      Resque::Failure.queues.sort_by(&:to_s)
+    end
+
+    def failed_queue_name(original_queue_name)
+      "#{original_queue_name}_failed"
+    end
+
+    def failed_queue_class(queue_name)
+      Resque::Failure.count(queue_name).zero? ? "failed" : "failure"
+    end
+
+    def failed_queue_size(queue_name)
+      Resque::Failure.count(queue_name)
+    end
+
+    def failed_queue_info(queue_name)
+      failed_queue = failed_queue_name(queue_name)
+      size = failed_queue_size(failed_queue)
+
+      if size > 0
+        css_class = "badge badge-important"
+        badge = link_to(size, failure_path(failed_queue))
+      else
+        css_class = "badge"
+        badge = size.to_s
+      end
+
+      raw "<span class=\"#{css_class}\">#{badge}</span>"
+    end
+  end
+end

data/app/helpers/resque_web/stats_helper.rb

@@ -0,0 +1,54 @@
+module ResqueWeb
+  module StatsHelper
+    def resque_info
+      Resque.info.sort_by { |i| i[0].to_s }
+    end
+
+    def redis_info
+      Resque.redis.info.to_a.sort_by { |i| i[0].to_s }
+    end
+
+    def redis_key_type(key)
+      Resque.redis.type(key)
+    end
+
+    def redis_key_size(key)
+      # FIXME: there's a potential race in this method if a key is modified
+      # "in flight". Not sure how to fix it, unfortunately :(
+      case redis_key_type(key)
+      when 'none'
+        0
+      when 'list'
+        Resque.redis.llen(key)
+      when 'set'
+        Resque.redis.scard(key)
+      when 'string'
+        string = Resque.redis.get(key)
+        string ? string.length : 0
+      when 'zset'
+        Resque.redis.zcard(key)
+      end
+    end
+
+    def redis_get_array(key, start=0)
+      case redis_key_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)
+      when 'hash'
+        Resque.redis.hgetall(key)
+      end
+    end
+
+    def current_subtab?(name)
+      params[:action] == name.to_s
+    end
+  end
+end