resque_manager 3.3.4 → 3.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e0db9fb420334fd7c54d8fb92e4e21da021450d
-  data.tar.gz: b8a879596768bc9408d55ee95dcc78e075a0115a
+  metadata.gz: 266bb0448d58c29fa6aa53def87bbdfeda2af3e9
+  data.tar.gz: 5c2247ff48d7a8b077952f0b18d1a9b26076ffdf
 SHA512:
-  metadata.gz: 0c2df895f1b918c4e714ee87c9415d63426e3e113cae6fdd2be271c6feae10f8d7454de7c9d8b7fb3d071a594c53d5847457e5e3348e3106614a4d8aa4fb84ab
-  data.tar.gz: 2ff7f787613afff9eac289c2a83d705a89dd08e1ef4bb9296cbfc5aec3569239c6455ca30a26a051a3fe4ac0f4ddcefa963225cfd041f5ae761f945d461f370d
+  metadata.gz: 01382eccaa0fe394eec1c2c22ed39d2f7370d3a577d334eca90875a495be463e0012312d3401d63b2642d95d2f9506f94690188084acfabb3211751c6fb0433d
+  data.tar.gz: 86f9e6cffadfdb4ec49d3e4f7541cdd11dbab9156165bbe40ec3a5cc743ea8d430f553bfb2004cb620f9b2b05efff9cdff6da79cbbcd02c811eb01094f1b23d6

data/app/controllers/resque_manager/resque_controller.rb

@@ -5,313 +5,315 @@ unless defined?($rails_rake_task) && $rails_rake_task
   require 'digest/sha1'
 
 
-  class ResqueManager::ResqueController < ApplicationController
-    unloadable(self) #needed to prevent errors with authenticated system in dev env.
+  module ResqueManager
+    class ResqueController < ApplicationController
+      unloadable(self) #needed to prevent errors with authenticated system in dev env.
 
-    layout 'resque_manager/application'
+      layout 'resque_manager/application'
 
-    before_filter :check_connection
+      before_filter :check_connection
 
-    before_filter :get_cleaner, :only => [:cleaner, :cleaner_exec, :cleaner_list, :cleaner_stale, :cleaner_dump]
+      before_filter :get_cleaner, :only => [:cleaner, :cleaner_exec, :cleaner_list, :cleaner_stale, :cleaner_dump]
 
-    def working
-      render('_working')
-    end
-
-    def queues
-      render('_queues', :locals => {:partial => nil})
-    end
+      def working
+        render('_working')
+      end
 
-    def poll
-      @polling = true
-      render(:text => (render_to_string(:action => "#{params[:page]}", :formats => [:html], :layout => false, :resque => Resque)).gsub(/\s{1,}/, ' '))
-    end
+      def queues
+        render('_queues', :locals => {:partial => nil})
+      end
 
-    def status_poll
-      @polling = true
+      def poll
+        @polling = true
+        render(:text => (render_to_string(:action => "#{params[:page]}", :formats => [:html], :layout => false, :resque => Resque)).gsub(/\s{1,}/, ' '))
+      end
 
-      @start = params[:start].to_i
-      @end = @start + (params[:per_page] || 20)
-      @statuses = Resque::Plugins::Status::Hash.statuses(@start, @end)
-      @size = Resque::Plugins::Status::Hash.status_ids.size
+      def status_poll
+        @polling = true
 
-      render(:text => (render_to_string(:action => 'statuses', :formats => [:html], :layout => false)))
-    end
+        @start = params[:start].to_i
+        @end = @start + (params[:per_page] || 20)
+        @statuses = Resque::Plugins::Status::Hash.statuses(@start, @end) rescue []
+        @size = Resque::Plugins::Status::Hash.status_ids.size
 
-    def remove_job
-      # We can only dequeue a job when that job is in the same application as the UI.
-      # Otherwise we get an error when we try to constantize a class that does not exist
-      # in the application the UI is in.
-      if ResqueManager.applications.blank?
-        Resque.dequeue(params['class'].constantize, *Resque.decode(params['args']))
+        render(:text => (render_to_string(:action => 'statuses', :formats => [:html], :layout => false)))
       end
-      redirect_to request.referrer
-    end
-
-    def stop_worker
-      worker = find_worker(params[:worker])
-      worker.quit if worker
-      redirect_to workers_resque_path
-    end
 
-    def pause_worker
-      worker = find_worker(params[:worker])
-      worker.pause if worker
-      redirect_to workers_resque_path
-    end
+      def remove_job
+        # We can only dequeue a job when that job is in the same application as the UI.
+        # Otherwise we get an error when we try to constantize a class that does not exist
+        # in the application the UI is in.
+        if ResqueManager.applications.blank?
+          Resque.dequeue(params['class'].constantize, *Resque.decode(params['args']))
+        end
+        redirect_to request.referrer
+      end
 
-    def continue_worker
-      worker = find_worker(params[:worker])
-      worker.continue if worker
-      redirect_to workers_resque_path
-    end
+      def stop_worker
+        worker = find_worker(params[:worker])
+        worker.quit if worker
+        redirect_to workers_resque_path
+      end
 
-    def restart_worker
-      worker = find_worker(params[:worker])
-      worker.restart if worker
-      redirect_to workers_resque_path
-    end
+      def pause_worker
+        worker = find_worker(params[:worker])
+        worker.pause if worker
+        redirect_to workers_resque_path
+      end
 
-    def start_worker
-      Resque::Worker.start(params)
-      redirect_to workers_resque_path
-    end
+      def continue_worker
+        worker = find_worker(params[:worker])
+        worker.continue if worker
+        redirect_to workers_resque_path
+      end
 
-    def stats
-      unless params[:id]
-        redirect_to(stats_resque_path(:id => 'resque'))
+      def restart_worker
+        worker = find_worker(params[:worker])
+        worker.restart if worker
+        redirect_to workers_resque_path
       end
 
-      if params[:id] == 'txt'
-        info = Resque.info
+      def start_worker
+        Resque::Worker.start(params)
+        redirect_to workers_resque_path
+      end
 
-        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)}"
+      def stats
+        unless params[:id]
+          redirect_to(stats_resque_path(:id => 'resque'))
         end
 
-        render(:text => stats.join("</br>").html_safe)
-      end
-    end
-
-    # resque-scheduler actions
+        if params[:id] == 'txt'
+          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
 
-    def schedule
-      @farm_status = ResqueScheduler.farm_status
-    end
+          render(:text => stats.join("</br>").html_safe)
+        end
+      end
 
-    def schedule_requeue
-      config = Resque.schedule[params['job_name']]
-      Resque::Scheduler.enqueue_from_config(config)
-      redirect_to overview_resque_path
-    end
+      # resque-scheduler actions
 
-    def add_scheduled_job
-      errors = []
-      if Resque.schedule.keys.include?(params[:name])
-        errors << 'Name already exists.'
-      end
-      if params[:ip].blank?
-        errors << 'You must enter an ip address for the server you want this job to run on.'
+      def schedule
+        @farm_status = ResqueScheduler.farm_status
       end
-      if params[:cron].blank?
-        errors << 'You must enter the cron schedule.'
-      end
-      if errors.blank?
-        config = {params['name'] => {'class' => params['class'],
-                                     'ip' => params['ip'],
-                                     'cron' => params['cron'],
-                                     'args' => Resque.decode(params['args'].blank? ? nil : params['args']),
-                                     'description' => params['description']}
-        }
-        Resque.redis.rpush(:scheduled, Resque.encode(config))
-        ResqueScheduler.restart(params['ip'])
-      else
-        flash[:error] = errors.join('<br>').html_safe
+
+      def schedule_requeue
+        config = Resque.schedule[params['job_name']]
+        Resque::Scheduler.enqueue_from_config(config)
+        redirect_to overview_resque_path
       end
-      redirect_to schedule_resque_path
-    end
 
-    def remove_from_schedule
-      Resque.list_range(:scheduled, 0, -0).each do |s|
-        if s[params['job_name']]
-          Resque.redis.lrem(:scheduled, 0, s.to_json)
-          # Restart the scheduler on the server that has changed it's schedule
+      def add_scheduled_job
+        errors = []
+        if Resque.schedule.keys.include?(params[:name])
+          errors << 'Name already exists.'
+        end
+        if params[:ip].blank?
+          errors << 'You must enter an ip address for the server you want this job to run on.'
+        end
+        if params[:cron].blank?
+          errors << 'You must enter the cron schedule.'
+        end
+        if errors.blank?
+          config = {params['name'] => {'class' => params['class'],
+                                       'ip' => params['ip'],
+                                       'cron' => params['cron'],
+                                       'args' => Resque.decode(params['args'].blank? ? nil : params['args']),
+                                       'description' => params['description']}
+          }
+          Resque.redis.rpush(:scheduled, Resque.encode(config))
           ResqueScheduler.restart(params['ip'])
+        else
+          flash[:error] = errors.join('<br>').html_safe
         end
+        redirect_to schedule_resque_path
       end
-      redirect_to schedule_resque_path
-    end
 
-    def start_scheduler
-      ResqueScheduler.start(params[:ip])
-      redirect_to schedule_resque_path
-    end
+      def remove_from_schedule
+        Resque.list_range(:scheduled, 0, -0).each do |s|
+          if s[params['job_name']]
+            Resque.redis.lrem(:scheduled, 0, s.to_json)
+            # Restart the scheduler on the server that has changed it's schedule
+            ResqueScheduler.restart(params['ip'])
+          end
+        end
+        redirect_to schedule_resque_path
+      end
 
-    def stop_scheduler
-      ResqueScheduler.quit(params[:ip])
-      redirect_to schedule_resque_path
-    end
+      def start_scheduler
+        ResqueScheduler.start(params[:ip])
+        redirect_to schedule_resque_path
+      end
+
+      def stop_scheduler
+        ResqueScheduler.quit(params[:ip])
+        redirect_to schedule_resque_path
+      end
 
-    # resque-status actions
+      # resque-status actions
 
-    def statuses
-      @start = params[:start].to_i
-      @end = @start + (params[:per_page] || 20)
-      @statuses = Resque::Plugins::Status::Hash.statuses(@start, @end)
-      @size = Resque::Plugins::Status::Hash.status_ids.size
-      respond_to do |format|
-        format.js { render json: @statuses }
-        format.html { render :statuses }
+      def statuses
+        @start = params[:start].to_i
+        @end = @start + (params[:per_page] || 20)
+        @statuses = Resque::Plugins::Status::Hash.statuses(@start, @end)
+        @size = Resque::Plugins::Status::Hash.status_ids.size
+        respond_to do |format|
+          format.js { render json: @statuses }
+          format.html { render :statuses }
+        end
       end
-    end
 
-    def clear_statuses
-      Resque::Plugins::Status::Hash.clear
-      redirect_to statuses_resque_path
-    end
+      def clear_statuses
+        Resque::Plugins::Status::Hash.clear
+        redirect_to statuses_resque_path
+      end
 
-    def status
-      @status = Resque::Plugins::Status::Hash.get(params[:id])
-      respond_to do |format|
-        format.js { render json: @status }
-        format.html { render :status }
+      def status
+        @status = Resque::Plugins::Status::Hash.get(params[:id])
+        respond_to do |format|
+          format.js { render json: @status }
+          format.html { render :status }
+        end
       end
-    end
 
-    def kill
-      Resque::Plugins::Status::Hash.kill(params[:id])
-      s = Resque::Plugins::Status::Hash.get(params[:id])
-      s.status = 'killed'
-      Resque::Plugins::Status::Hash.set(params[:id], s)
-      redirect_to statuses_resque_path
-    end
+      def kill
+        Resque::Plugins::Status::Hash.kill(params[:id])
+        s = Resque::Plugins::Status::Hash.get(params[:id])
+        s.status = 'killed'
+        Resque::Plugins::Status::Hash.set(params[:id], s)
+        redirect_to statuses_resque_path
+      end
 
-    def cleaner
-      load_cleaner_filter
+      def cleaner
+        load_cleaner_filter
 
-      @jobs = @cleaner.select
-      @stats, @total = {}, {"total" => 0, "1h" => 0, "3h" => 0, "1d" => 0, "3d" => 0, "7d" => 0}
-      @jobs.each do |job|
-        klass = job["payload"]["class"]
-        failed_at = Time.parse job["failed_at"]
+        @jobs = @cleaner.select
+        @stats, @total = {}, {"total" => 0, "1h" => 0, "3h" => 0, "1d" => 0, "3d" => 0, "7d" => 0}
+        @jobs.each do |job|
+          klass = job["payload"]["class"]
+          failed_at = Time.parse job["failed_at"]
 
-        @stats[klass] ||= {"total" => 0, "1h" => 0, "3h" => 0, "1d" => 0, "3d" => 0, "7d" => 0}
-        items = [@stats[klass], @total]
+          @stats[klass] ||= {"total" => 0, "1h" => 0, "3h" => 0, "1d" => 0, "3d" => 0, "7d" => 0}
+          items = [@stats[klass], @total]
 
-        items.each { |a| a["total"] += 1 }
-        items.each { |a| a["1h"] += 1 } if failed_at >= hours_ago(1)
-        items.each { |a| a["3h"] += 1 } if failed_at >= hours_ago(3)
-        items.each { |a| a["1d"] += 1 } if failed_at >= hours_ago(24)
-        items.each { |a| a["3d"] += 1 } if failed_at >= hours_ago(24*3)
-        items.each { |a| a["7d"] += 1 } if failed_at >= hours_ago(24*7)
+          items.each { |a| a["total"] += 1 }
+          items.each { |a| a["1h"] += 1 } if failed_at >= hours_ago(1)
+          items.each { |a| a["3h"] += 1 } if failed_at >= hours_ago(3)
+          items.each { |a| a["1d"] += 1 } if failed_at >= hours_ago(24)
+          items.each { |a| a["3d"] += 1 } if failed_at >= hours_ago(24*3)
+          items.each { |a| a["7d"] += 1 } if failed_at >= hours_ago(24*7)
+        end
       end
-    end
 
-    def cleaner_list
-      load_cleaner_filter
+      def cleaner_list
+        load_cleaner_filter
 
-      block = filter_block
+        block = filter_block
 
-      @failed = @cleaner.select(&block).reverse
+        @failed = @cleaner.select(&block).reverse
 
-      url = "cleaner_list?c=#{@klass}&ex=#{@exception}&f=#{@from}&t=#{@to}"
-      @dump_url = "cleaner_dump?c=#{@klass}&ex=#{@exception}&f=#{@from}&t=#{@to}"
-      @paginate = ResqueManager::Paginate.new(@failed, url, params[:p].to_i)
+        url = "cleaner_list?c=#{@klass}&ex=#{@exception}&f=#{@from}&t=#{@to}"
+        @dump_url = "cleaner_dump?c=#{@klass}&ex=#{@exception}&f=#{@from}&t=#{@to}"
+        @paginate = ResqueManager::Paginate.new(@failed, url, params[:p].to_i)
 
-      @klasses = @cleaner.stats_by_class.keys
-      @exceptions = @cleaner.stats_by_exception.keys
-      @count = @cleaner.select(&block).size
-    end
+        @klasses = @cleaner.stats_by_class.keys
+        @exceptions = @cleaner.stats_by_exception.keys
+        @count = @cleaner.select(&block).size
+      end
 
-    def cleaner_exec
-      load_cleaner_filter
+      def cleaner_exec
+        load_cleaner_filter
 
-      if params[:select_all_pages]!="1"
-        @sha1 = {}
-        params[:sha1].split(",").each { |s| @sha1[s] = true }
-      end
+        if params[:select_all_pages]!="1"
+          @sha1 = {}
+          params[:sha1].split(",").each { |s| @sha1[s] = true }
+        end
 
-      block = filter_block
+        block = filter_block
 
-      @count =
-          case params[:form_action]
-            when "clear" then
-              @cleaner.clear(&block)
-            when "retry_and_clear" then
-              @cleaner.requeue(true, &block)
-            when "retry" then
-              @cleaner.requeue(false, {}, &block)
-          end
+        @count =
+            case params[:form_action]
+              when "clear" then
+                @cleaner.clear(&block)
+              when "retry_and_clear" then
+                @cleaner.requeue(true, &block)
+              when "retry" then
+                @cleaner.requeue(false, {}, &block)
+            end
 
-      @link_url = "cleaner_list?c=#{@klass}&ex=#{@exception}&f=#{@from}&t=#{@to}"
-    end
+        @link_url = "cleaner_list?c=#{@klass}&ex=#{@exception}&f=#{@from}&t=#{@to}"
+      end
 
-    def cleaner_dump
-      load_cleaner_filter
+      def cleaner_dump
+        load_cleaner_filter
 
-      block = filter_block
-      failures = @cleaner.select(&block)
-      # pretty generate throws an error with the json gem on jruby
-      output = JSON.pretty_generate(failures) rescue failures.to_json
-      render :json => output
-    end
+        block = filter_block
+        failures = @cleaner.select(&block)
+        # pretty generate throws an error with the json gem on jruby
+        output = JSON.pretty_generate(failures) rescue failures.to_json
+        render :json => output
+      end
 
-    def cleaner_stale
-      @cleaner.clear_stale
-      redirect_to cleaner_resque_path
-    end
+      def cleaner_stale
+        @cleaner.clear_stale
+        redirect_to cleaner_resque_path
+      end
 
 
-    private
+      private
 
-    def check_connection
-      Resque.keys
-    rescue Errno::ECONNREFUSED
-      render(:template => 'resque_manager/resque/error', :layout => false, :locals => {:error => "Can't connect to Redis! (#{Resque.redis_id})"})
-      false
-    end
+      def check_connection
+        Resque.keys
+      rescue Errno::ECONNREFUSED
+        render(:template => 'resque_manager/resque/error', :layout => false, :locals => {:error => "Can't connect to Redis! (#{Resque.redis_id})"})
+        false
+      end
 
-    def find_worker(worker)
-      return nil if worker.blank?
-      worker = CGI::unescape(worker)
-      first_part, *rest = worker.split(':')
-      first_part.gsub!(/_/, '.')
-      Resque::Worker.find("#{first_part}:#{rest.join(':')}")
-    end
+      def find_worker(worker)
+        return nil if worker.blank?
+        worker = CGI::unescape(worker)
+        first_part, *rest = worker.split(':')
+        first_part.gsub!(/_/, '.')
+        Resque::Worker.find("#{first_part}:#{rest.join(':')}")
+      end
 
-    # resque-cleaner methods
+      # resque-cleaner methods
 
-    def get_cleaner
-      @cleaner ||= Resque::Plugins::ResqueCleaner.new
-      @cleaner.print_message = false
-      @cleaner
-    end
+      def get_cleaner
+        @cleaner ||= Resque::Plugins::ResqueCleaner.new
+        @cleaner.print_message = false
+        @cleaner
+      end
 
-    def load_cleaner_filter
-      @from = params[:f].blank? ? nil : params[:f]
-      @to = params[:t].blank? ? nil : params[:t]
-      @klass = params[:c].blank? ? nil : params[:c]
-      @exception = params[:ex].blank? ? nil : params[:ex]
-    end
+      def load_cleaner_filter
+        @from = params[:f].blank? ? nil : params[:f]
+        @to = params[:t].blank? ? nil : params[:t]
+        @klass = params[:c].blank? ? nil : params[:c]
+        @exception = params[:ex].blank? ? nil : params[:ex]
+      end
 
-    def filter_block
-      lambda { |j|
-        (!@from || j.after?(hours_ago(@from))) &&
-            (!@to || j.before?(hours_ago(@to))) &&
-            (!@klass || j.klass?(@klass)) &&
-            (!@exception || j.exception?(@exception)) &&
-            (!@sha1 || @sha1[Digest::SHA1.hexdigest(j.to_json)])
-      }
-    end
+      def filter_block
+        lambda { |j|
+          (!@from || j.after?(hours_ago(@from))) &&
+              (!@to || j.before?(hours_ago(@to))) &&
+              (!@klass || j.klass?(@klass)) &&
+              (!@exception || j.exception?(@exception)) &&
+              (!@sha1 || @sha1[Digest::SHA1.hexdigest(j.to_json)])
+        }
+      end
 
-    def hours_ago(h)
-      Time.now - h.to_i*60*60
+      def hours_ago(h)
+        Time.now - h.to_i*60*60
+      end
     end
   end
 end