resque_ui 3.1.7 → 3.2.0

data/History.txt

@@ -1,3 +1,9 @@
+== 3.2.0 2011-11-14
+
+*  Added the ability to pause workers from the UI.
+*  If the worker is processing a job, it will pause the job on the next call to tick.
+*  JobWithStatus class now exposed the worker so the job can manually inspect the worker's status if necessary.
+
 == 3.1.7 2011-11-03
 
 *  It seems that when jruby workers are started in server mode, they don't accept the -INT signal.

data/README.markdown

@@ -49,15 +49,16 @@ Display Process Status
 ----------------------
 
 Added the ability to display process status in the worker "Processing" column on the workers and working pages.
-To do this, yield the status message back in your perform method.
+To do this, yield the status message back in your perform method.  You should check that a block was sent. If you
+set Resque.inline = true in development, then the block is not passed.
 
     Class YourClass
 
       self.perform(arg)
       ...your code here
-      yield "Your status message"
+      yield "Your status message" if block_given?
       ...more code
-      yield "Another status message"
+      yield "Another status message" if block_given?
       ...more code
       end
     end
@@ -128,7 +129,7 @@ the chained job from the preceding job, you just need to pass {'uuid' => uuid} a
     end
 
 So now, the data_contribution worker and the single_record_loader workers will update the same status on the status page.
-You can call tick or set_status to add messages along the way too.
+You can call #tick or #set_status to add messages along the way too.
 
 You will want to override the completed method so that it isn't called until the very end of the entire process.
 
@@ -141,6 +142,94 @@ symbol to read the integer back.  The redis entries created by these methods all
 
 When you kill a job on the UI, it will kill all the workers in the chain.
 
+Pause a Worker
+--------------
+
+The workers page now has a button for every worker to pause that worker.
+
+### Regular Workers
+
+For workers that do not inherit from JobWithStatus, this will pause the worker, but not the job.  So if the worker is in
+the middle of a job when it is paused, it will finish it's process, but then will not pick anything else up off the queue.
+
+You can manually pause the processing though.
+
+yield, which is used to set the workers status, as described above, now returns the worker.
+
+    Class YourClass
+
+      self.perform(arg)
+      ...your code here
+      worker = yield "Your status message" if block_given?
+
+      if worker && worker.paused?
+          loop do
+            break unless worker.paused?
+            sleep 60
+          end
+        end
+      end
+
+      ...continue
+    end
+
+Remember to check that a block was sent. If you set Resque.inline = true in development, then the block is not passed.
+
+
+### JobWithStatus Workers
+
+For workers that do inherit from JobWithStatus or ChainedJobWithStatus, this will pause the worker, and will automatically pause the job it is processing
+on the next call to #tick.  The worker is also available to JobWithStatus so you can manually check it's status as well.
+
+    Class YourClass << Resque::JobWithStatus
+
+    def perform
+      ...your code here
+      tick "Retrieving file."  #You're process with pause here automatically and the status on the Status tab will be set to paused if the worker is paused.
+
+      #Alternatively, you have access to the worker, so you can pause the process yourself too.
+      if worker && worker.paused?
+          # There could be workers in a chained job still doing work.
+          loop do
+            pause! unless status.paused?
+            break unless worker.paused?
+            sleep 60
+          end
+          tick("Job resumed at #{Time.now}")
+        end
+
+      ...continue
+    end
+
+    This will only pause the work being processed by the worker that was paused.  If the job is paused by the call to #tick,
+    the job will sleep for 60 seconds before checking the status again.
+
+    You may have a series of ChainedJobWithStatus and you want all processing in the chain stopped.
+
+    Class YourClass << Resque::ChainedJobWithStatus
+
+    def perform
+      ...your code here
+      tick "Retrieving file."  #You're process with pause here automatically and the status on the Status tab will be set to paused if the worker is paused.
+
+      #Alternatively, you have access to the worker, so you can pause the process yourself too.
+      if (worker && worker.paused?) || status.paused?
+          # There could be workers in a chained job still doing work.
+          loop do
+            pause! unless status.paused?
+            break unless worker.paused?
+            sleep 60
+          end
+          tick("Job resumed at #{Time.now}")
+        end
+
+      ...continue
+    end
+
+    By looking at the status.paused? method too, this process will stop, even if it's worker has not been paused.
+    But be aware, if this worker does other jobs, it will not process anything else and it's queue could get backed up.
+    This is where pausing one worker, could affect other, unrelated workers and jobs from getting backed up as well.
+
 Throttle a Queue
 ----------------
 

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :major: 3
-:minor: 1
-:patch: 7
+:minor: 2
+:patch: 0
 :build: 

data/app/controllers/resque_controller.rb

@@ -58,6 +58,18 @@ class ResqueController < ApplicationController
     redirect_to(:action => "workers")
   end
 
+  def pause_worker
+    worker = find_worker(params[:worker])
+    worker.pause if worker
+    redirect_to(:action => "workers")
+  end
+
+  def continue_worker
+    worker = find_worker(params[:worker])
+    worker.continue if worker
+    redirect_to(:action => "workers")
+  end
+
   def restart_worker
     worker = find_worker(params[:worker])
     worker.restart if worker

data/app/views/resque/_workers.html.erb

@@ -1,110 +1,130 @@
-
 <% if params[:id] && worker = find_worker(params[:id]) %>
 
-  <h1>Worker <%= worker %></h1>
-  <table class='workers'>
-    <tr>
-      <th>&nbsp;</th>
-      <th>Host</th>
-      <th>Pid</th>
-      <th>Thread</th>
-      <th>Started</th>
-      <th>Queues</th>
-      <th>Processed</th>
-      <th>Failed</th>
-      <th>Processing</th>
-    </tr>
-    <tr>
-      <td class='icon'><img src="<%=u "../../images/resque/#{state = worker.state}" %>.png" alt="<%= state %>" title="<%= state %>"></td>
+    <h1>Worker <%= worker %></h1>
+    <table class='workers'>
+      <tr>
+        <th>&nbsp;</th>
+        <th>Host</th>
+        <th>Pid</th>
+        <th>Thread</th>
+        <th>Started</th>
+        <th>Paused</th>
+        <th>Queues</th>
+        <th>Processed</th>
+        <th>Failed</th>
+        <th>Processing</th>
+      </tr>
+      <tr>
+        <td class='icon'>
+          <img src="<%= u "../../images/resque/#{state = worker.state}" %>.png" alt="<%= state %>" title="<%= state %>">
+        </td>
 
-      <% host, pid, thread, queues = worker.to_s.split(':') %>
-      <td><%= host %></td>
-      <td><%= pid %></td>
-      <td><%= thread %></td>
-      <td><span class="time"><%= format_time(Time.zone.parse(worker.started)) %></span></td>
-      <td class='queues'><%= queues.split(',').map { |q| link_to(q, {:action => 'queues', :id => q}, :class => 'queue-tag')}.join('').html_safe %></td>
-      <td><%= worker.processed %></td>
-      <td><%= worker.failed %></td>
-      <td class='process'>
-        <% data = worker.processing || {} %>
-        <% if data['queue'] %>
-          <code><%= data['payload']['class'] %></code>
-          <small><%= link_to(format_time(Time.zone.parse(data['run_at'])), {:action => 'working', :id => worker.to_s.gsub(/\./,'_')}, :class => "queue time") %></small>
-          <br>
-          <small><%=worker.status%></small>
+        <% host, pid, thread, queues = worker.to_s.split(':') %>
+        <td><%= host %></td>
+        <td><%= pid %></td>
+        <td><%= thread %></td>
+        <td><span class="time"><%= format_time(Time.zone.parse(worker.started)) %></span></td>
+        <td>
+          <% if worker.paused? %>
+              <span class="time"><%= format_time(Time.zone.parse(worker.paused)) %></span>
         <% else %>
-          <span class='waiting'>Waiting for a job...</span>
+              <span>Not Paused</span>
         <% end %>
-      </td>
-    </tr>
-  </table>
-
-<% elsif params[:id] %>
-
-  <h1>Worker doesn't exist</h1>
-
-<% else %>
-
-  <h1 class='wi'><%= pluralize resque.workers.size, 'Worker' %></h1>
-  <p class='intro'>The workers listed below are all registered as active on your system.</p>
-  <table class='workers'>
-    <tr>
-      <th>&nbsp;</th>
-      <th>Where (ip):pid:thread</th>
-      <th>Queues</th>
-      <th>Processing</th>
-      <th>&nbsp;</th>
-    </tr>
-    <%  upid = ''%>
-    <% for worker in (workers = resque.workers.sort_by { |w| w.to_s }) %>
-      <tr class="<%=state = worker.state%>">
-        <td class='icon'><img src="<%=u "../../images/resque/#{state}" %>.png" alt="<%= state %>" title="<%= state %>"></td>
-
-        <% host, pid, thread, queues = worker.to_s.split(':') %>
-        <td class='where'><%=link_to("#{host}:#{pid}:#{thread}",:action => 'workers', :id => worker.to_s.gsub(/\./,'_'))%></td>
-        <td class='queues'><%= queues.split(',').map { |q| link_to(q, {:action => 'queues', :id => q}, :class => 'queue-tag')}.join('').html_safe %></td>
-
+        </td>
+        <td class='queues'><%= queues.split(',').map { |q| link_to(q, {:action => 'queues', :id => q}, :class => 'queue-tag') }.join('').html_safe %></td>
+        <td><%= worker.processed %></td>
+        <td><%= worker.failed %></td>
         <td class='process'>
           <% data = worker.processing || {} %>
           <% if data['queue'] %>
-            <code><%= data['payload']['class'] %></code>
-            <small><%= link_to(format_time(Time.zone.parse(data['run_at'])), {:action => 'working', :id => worker.to_s.gsub(/\./,'_')}, :class => "queue time") %></small>
-            <br/>
-            <small><%=worker.status%></small>
+              <code><%= data['payload']['class'] %></code>
+              <small><%= link_to(format_time(Time.zone.parse(data['run_at'])), {:action => 'working', :id => worker.to_s.gsub(/\./, '_')}, :class => "queue time") %></small>
+              <br>
+              <small><%= worker.status %></small>
           <% else %>
-            <span class='waiting'>Waiting for a job...</span>
-          <% end %>
-        </td>
-        <td>
-          <% if upid != pid %>
-            <%= button_to "Stop", {:controller=>'resque', :action=> 'stop_worker', :worker => worker.to_s}, :class => 'clear-failed', :title => "This will stop all workers on #{host} in pid #{pid}: #{worker.workers_in_pid.collect{|w| w.to_s}.join(', ')}", :method => :post %>
-            <%= button_to "Restart", {:controller=>'resque', :action=> 'restart_worker', :worker => worker.to_s}, :class => 'clear-failed', :title => "This will restart all workers on #{host} in pid #{pid}: #{worker.workers_in_pid.collect{|w| w.to_s}.join(', ')}", :method => :post %>
-            <% upid = pid %>
+              <span class='waiting'>Waiting for a job...</span>
           <% end %>
         </td>
       </tr>
-    <% end %>
-    <% if workers.empty? %>
+    </table>
+
+<% elsif params[:id] %>
+
+    <h1>Worker doesn't exist</h1>
+
+<% else %>
+
+    <h1 class='wi'><%= pluralize resque.workers.size, 'Worker' %></h1>
+    <p class='intro'>The workers listed below are all registered as active on your system.</p>
+    <table class='workers'>
       <tr>
-        <td colspan='5' class='no-data'>There are no registered workers</td>
+        <th>&nbsp;</th>
+        <th>Where (ip):pid:thread</th>
+        <th>Queues</th>
+        <th>Processing</th>
+        <th>&nbsp;</th>
       </tr>
-    <% end %>
-  </table>
-  <%=poll%>
-  <br/>
-  <hr />
-  <h1 class='wi'>Start New Workers</h1>
-  <%= form_tag :action =>  'start_worker' do -%>
-    <ul class='new_worker'>
-      <li>
-        <dl>
-          <dt>Queue(s)</dt>
-          <dd><%=text_field_tag :queues, nil, :size => 125 %><br/>  Prefix each worker with a '#', comma separate the list of queues you want each worker to monitor.  No Spaces. #queue1,queue2#queue3#queue2 will produce 3 workers in 3 threads.</dd>
-          <dt>Host(s)/IP(s)</dt>
-          <dd><%=text_field_tag :hosts, nil, :size => 125 %><br/>  Comma separate the IP address of the servers where you want your worker to run.</dd>
-          <dt><%= submit_tag "Start", :id => "submit" %></dt>
-        </dl>
-      </li>
-    </ul>
-  <%end-%>
+      <% upid = '' %>
+      <% for worker in (workers = resque.workers.sort_by { |w| w.to_s }) %>
+          <tr class="<%= state = worker.state %>">
+            <td class='icon'>
+              <img src="<%= u "../../images/resque/#{state}" %>.png" alt="<%= state %>" title="<%= state %>"></td>
+
+            <% host, pid, thread, queues = worker.to_s.split(':') %>
+            <td class='where'><%= link_to("#{host}:#{pid}:#{thread}", :action => 'workers', :id => worker.to_s.gsub(/\./, '_')) %></td>
+            <td class='queues'><%= queues.split(',').map { |q| link_to(q, {:action => 'queues', :id => q}, :class => 'queue-tag') }.join('').html_safe %></td>
+
+            <td class='process'>
+              <% data = worker.processing || {} %>
+              <% if data['queue'] %>
+                  <code><%= data['payload']['class'] %></code>
+                  <small><%= link_to(format_time(Time.zone.parse(data['run_at'])), {:action => 'working', :id => worker.to_s.gsub(/\./, '_')}, :class => "queue time") %></small>
+                  <br/>
+                  <small><%= worker.status %></small>
+              <% else %>
+                  <span class='waiting'>Waiting for a job...</span>
+              <% end %>
+            </td>
+            <td>
+              <% if upid != pid %>
+                  <%= button_to "Stop", {:controller=>'resque', :action=> 'stop_worker', :worker => worker.to_s}, :class => 'clear-failed', :title => "This will stop all workers on #{host} in pid #{pid}: #{worker.workers_in_pid.collect { |w| w.to_s }.join(', ')}", :method => :post %>
+                  <% if worker.paused? %>
+                      <%= button_to "Unpause", {:controller=>'resque', :action=> 'continue_worker', :worker => worker.to_s}, :class => 'clear-failed', :title => "This will unpause all workers on #{host} in pid #{pid}: #{worker.workers_in_pid.collect { |w| w.to_s }.join(', ')}", :method => :post %>
+                  <% else %>
+                      <%= button_to "Pause", {:controller=>'resque', :action=> 'pause_worker', :worker => worker.to_s}, :class => 'clear-failed', :title => "This will pause all workers on #{host} in pid #{pid}: #{worker.workers_in_pid.collect { |w| w.to_s }.join(', ')}", :method => :post %>
+                  <% end %>
+                  <%= button_to "Restart", {:controller=>'resque', :action=> 'restart_worker', :worker => worker.to_s}, :class => 'clear-failed', :title => "This will restart all workers on #{host} in pid #{pid}: #{worker.workers_in_pid.collect { |w| w.to_s }.join(', ')}", :method => :post %>
+                  <% upid = pid %>
+              <% end %>
+            </td>
+          </tr>
+      <% end %>
+      <% if workers.empty? %>
+          <tr>
+            <td colspan='5' class='no-data'>There are no registered workers</td>
+          </tr>
+      <% end %>
+    </table>
+    <%= poll %>
+    <br/>
+    <hr/>
+    <h1 class='wi'>Start New Workers</h1>
+    <%= form_tag :action => 'start_worker' do -%>
+        <ul class='new_worker'>
+          <li>
+            <dl>
+              <dt>Queue(s)</dt>
+              <dd><%= text_field_tag :queues, nil, :size => 125 %>
+                <br/> Prefix each worker with a '#', comma separate the list of queues you want each worker to monitor.
+                No Spaces. #queue1,queue2#queue3#queue2 will produce 3 workers in 3 threads.
+              </dd>
+              <dt>Host(s)/IP(s)</dt>
+              <dd><%= text_field_tag :hosts, nil, :size => 125 %>
+                <br/> Comma separate the IP address of the servers where you want your worker to run.
+              </dd>
+              <dt><%= submit_tag "Start", :id => "submit" %></dt>
+            </dl>
+          </li>
+        </ul>
+    <% end -%>
 <% end %>

data/lib/resque_ui/cap_recipes.rb

@@ -68,7 +68,7 @@ Capistrano::Configuration.instance(:must_exist).load do
     desc "Gracefully kill a worker.  If the worker is working, it will finish before shutting down. arg: host=ip pid=pid"
     task :quit_worker, :roles => :resque do
       if ENV['host'].nil? || ENV['host'].empty? || ENV['pid'].nil? || ENV['pid'].empty?
-        puts 'You must enter the host and pid to kill..cap resque:quit host=ip pid=pid'
+        puts 'You must enter the host and pid to kill..cap resque:quit_worker host=ip pid=pid'
       else
         hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
         if RUBY_PLATFORM =~ /java/
@@ -82,6 +82,26 @@ Capistrano::Configuration.instance(:must_exist).load do
       end
     end
 
+    desc "Pause all workers in a single process. arg: host=ip pid=pid"
+    task :pause_worker, :roles => :resque do
+      if ENV['host'].nil? || ENV['host'].empty? || ENV['pid'].nil? || ENV['pid'].empty?
+        puts 'You must enter the host and pid to kill..cap resque:pause_worker host=ip pid=pid'
+      else
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        run("kill -USR2 #{ENV['pid']}", :hosts => hosts)
+      end
+    end
+
+    desc "Continue all workers in a single process that have been paused. arg: host=ip pid=pid"
+    task :continue_worker, :roles => :resque do
+      if ENV['host'].nil? || ENV['host'].empty? || ENV['pid'].nil? || ENV['pid'].empty?
+        puts 'You must enter the host and pid to kill..cap resque:continue_worker host=ip pid=pid'
+      else
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        run("kill -CONT #{ENV['pid']}", :hosts => hosts)
+      end
+    end
+
     desc "Gracefully kill all workers on all servers.  If the worker is working, it will finish before shutting down."
     task :quit_workers, :roles => :resque do
       default_run_options[:pty] = true

data/lib/resque_ui/overrides/resque/job.rb

@@ -3,9 +3,73 @@ module Resque
     # 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.
-    # The worker is passed in so the status can be set for the UI to display.
+    # A block is sent so a message can be yielded back to be set in the worker.
     def perform
-      args ? payload_class.perform(*args) { |status| self.worker.status = status } : payload_class.perform { |status| self.worker.status = status }
+      job = payload_class
+      job_args = args || []
+      job_was_performed = false
+
+      before_hooks = Plugin.before_hooks(job)
+      around_hooks = Plugin.around_hooks(job)
+      after_hooks = Plugin.after_hooks(job)
+      failure_hooks = Plugin.failure_hooks(job)
+
+      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) do |status|
+            self.worker.status = status if status.present?
+            self.worker
+          end
+          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) do |status|
+                    self.worker.status = status if status.present?
+                    self.worker
+                  end
+                  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
+        failure_hooks.each { |hook| job.send(hook, e, *job_args) }
+        raise e
+      end
     end
 
   end