resque_ui 3.0.0

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

@@ -0,0 +1,72 @@
+<%= render(:partial => 'status_styles') %>
+
+<h1 class='wi'>Statuses</h1>
+<%unless @statuses.empty?%>
+  <form method="POST" action="clear_statuses" class='clear-failed'>
+  <input type='submit' name='' value='Clear Statuses' />
+</form>
+<%end%>
+<p class='intro'>These are recent jobs created with the JobWithStatus class</p>
+<p class='sub'>Showing <%=@start%> to <%= @start + 20 %> of <b><%= @size %></b> statuses</p>
+<table>
+  <tr>
+    <th>ID</th>
+    <th style="width:40%">Name</th>
+    <th>Status</th>
+    <th>Last Updated</th>
+    <th class="progress">% Complete</th>
+    <th>Message</th>
+    <th>Kill</th>
+  </tr>
+  <% unless @statuses.empty? %>
+    <% @statuses.each do |status| %>
+    <tr>
+      <td><%= link_to(status.uuid, {:action => 'status', :id => status.uuid}) %></td>
+      <td><%= status.name %></td>
+      <td class="status status-<%= status.status %>"><%= status.status %></td>
+      <td class="time"><%= format_time(Time.zone.parse(status.time.to_s)) %></td>
+      <td class="progress">
+        <div class="progress-bar" style="width:<%= status.pct_complete %>%">&nbsp;</div>
+        <div class="progress-pct"><%= status.pct_complete ? "#{status.pct_complete}%" : '' %></div>
+      </td>
+      <td><%= status.message.html_safe %></td>
+      <td><% if status.killable? %><%= link_to('Kill', {:action => :kill, :id => status.uuid}, :class => 'kill') %><% end %></td>
+    </tr>
+    <% end %>
+  <% else %>
+  <tr>
+    <td colspan="7" class='no-data'>No Statuses right now...</td>
+  </tr>
+  <% end %>
+</table>
+
+<% unless @statuses.empty? %>
+<%= render(:partial => 'next_more', :locals => {:start => @start, :size => @size}) %>
+<% end %>
+
+<%= status_poll(@start) %>
+
+<script type="text/javascript" charset="utf-8">
+  jQuery(function($) {
+
+    $('a.kill').click(function(e) {
+      e.preventDefault();
+      var $link = $(this),
+          url = $link.attr('href'),
+          confirmed = confirm("Are you sure you want to kill this job? There is only do or do not.  There is no undo.");
+      if (confirmed) {
+        $link.animate({opacity: 0.5});
+        $.ajax({
+          url: url,
+          type: 'post',
+          success: function() {
+            $link.remove();
+          }
+        });
+      } else {
+        return false
+      }
+    });
+
+  });
+</script>

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

@@ -0,0 +1 @@
+<%= render(:partial => 'workers') %>

data/lib/resque_ui/cap.rb

@@ -0,0 +1,6 @@
+module ResqueUi
+  class Cap
+    @@path = 'REPLACE WITH THE PATH TO YOUR CAP INSTALLATION: ie. /opt/ruby-enterprise-1.8.6-20090421/bin/cap'
+    cattr_accessor :path
+  end
+end

data/lib/resque_ui/cap_recipes.rb

@@ -0,0 +1,106 @@
+# ====================================
+# Resque TASKS
+# ====================================
+
+
+#You must set the path to your rake task in your deploy.rb file.
+#ex.
+# set :rake, "/opt/ruby-enterprise-1.8.6-20090421/bin/rake"
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :resque do
+    desc "start a resque worker. optional arg: host=ip queue=name"
+    task :work, :roles => :app do
+      default_run_options[:pty] = true
+      hosts                     = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+      queue                     = ENV['queue'] || '*'
+      rake                      = fetch(:rake, "rake")
+      run("cd #{current_path}; nohup #{rake} RAILS_ENV=#{stage} QUEUE=#{queue} resque:work >> log/resque_worker.log 2>&1", :hosts => hosts)
+    end
+
+    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 => :app 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'
+      else
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        run("kill -INT #{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 => :app, :only => {:resque_restart => true} do
+      default_run_options[:pty] = true
+      rake                      = fetch(:rake, "rake")
+      run("cd #{current_path}; #{rake} RAILS_ENV=#{stage} resque:quit_workers")
+    end
+
+    desc "Kill a rogue worker.  If the worker is working, it will not finish and the job will go to the Failed queue as a DirtExit. arg: host=ip pid=pid"
+    task :kill_worker_with_impunity, :roles => :app 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'
+      else
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        run("kill -9 #{ENV['pid']}", :hosts => hosts)
+      end
+    end
+
+    desc "Kill all rogue workers on all servers.  If the worker is working, it will not finish and the job will go to the Failed queue as a DirtExit. arg: host=ip pid=pid"
+    task :kill_workers_with_impunity, :roles => :app do
+      default_run_options[:pty] = true
+      rake                      = fetch(:rake, "rake")
+      run("cd #{current_path}; #{rake} RAILS_ENV=#{stage} resque:kill_workers_with_impunity")
+    end
+
+    desc "start multiple resque workers. arg:count=x optional arg: host=ip queue=name"
+    task :workers, :roles => :app do
+      default_run_options[:pty] = true
+      hosts                     = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+      queue                     = ENV['queue'] || '*'
+      count                     = ENV['count'] || '1'
+      rake                      = fetch(:rake, "rake")
+      run("cd #{current_path}; nohup #{rake} RAILS_ENV=#{stage} COUNT=#{count} QUEUE=#{queue} resque:work >> log/resque_worker.log 2>&1", :hosts => hosts)
+    end
+
+    desc "Restart all workers on all servers"
+    task :restart_workers, :roles => :app, :only => {:resque_restart => true} do
+      default_run_options[:pty] = true
+      rake                      = fetch(:rake, "rake")
+      run("cd #{current_path}; nohup #{rake} RAILS_ENV=#{stage} resque:restart_workers")
+    end
+
+    # ====================================
+    # ResqueScheduler TASKS
+    # ====================================
+
+    desc "start a resque worker. optional arg: host=ip queue=name"
+    task :scheduler, :roles => :app do
+      default_run_options[:pty] = true
+      hosts                     = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+      rake                      = fetch(:rake, "rake")
+      run("cd #{current_path}; nohup #{rake} RAILS_ENV=#{stage} resque:scheduler", :hosts => hosts)
+    end
+
+    desc "Gracefully kill the scheduler on a server. arg: host=ip"
+    task :quit_scheduler, :roles => :app do
+      if ENV['host'].nil? || ENV['host'].empty?
+        puts 'You must enter the host to kill..cap resque:quit_scheduler host=ip pid=pid'
+      else
+        hosts = ENV['host'] || find_servers_for_task(current_task).collect { |s| s.host }
+        rake  = fetch(:rake, "rake")
+        run("cd #{current_path}; nohup #{rake} RAILS_ENV=#{stage} resque:quit_scheduler", :hosts => hosts)
+      end
+    end
+
+    desc "Determine if the scheduler is running or not on a server"
+    task :scheduler_status, :roles => :app do
+      hosts  = ENV['hosts'].to_s.split(',') || find_servers_for_task(current_task).collect { |s| s.host }
+
+      status = nil
+
+      run("ps -eaf | grep resque | grep -v cap", :hosts => hosts) do |channel, stream, data|
+        status = (data =~ /resque:scheduler/) ? 'up' : 'down'
+        puts " ** [#{stream} :: #{channel[:host]}] resque:scheduler is #{status}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'resque/failure/redis'
+
+module Resque
+  module Failure
+
+    # Requeues all failed jobs of a given class
+    def self.requeue_class(failed_class)
+      length = Resque.redis.llen(:failed)
+      i = 0
+      length.times do
+        f = Resque.list_range(:failed, i, 1)
+        if f && (failed_class.blank? || (f["payload"]["class"] == failed_class))
+          Resque.redis.lrem(:failed, 0, f.to_json)
+          args = f["payload"]["args"]
+          Resque.enqueue(eval(f["payload"]["class"]), *args)
+        else
+          i += 1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Resque
+  class Job
+    # 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.
+    def perform
+      args ? payload_class.perform(*args) { |status| self.worker.status = status } : payload_class.perform { |status| self.worker.status = status }
+    end
+
+  end
+end

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

@@ -0,0 +1,8 @@
+module Resque
+  def self.throttle(queue, limit = 10000, sleep_for = 60)
+    loop do
+      break if Resque.size(queue.to_s) < limit
+      sleep sleep_for
+    end
+  end
+end

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

@@ -0,0 +1,230 @@
+require 'socket'
+
+module Resque
+  class Worker
+
+    def local_ip
+      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true # turn off reverse DNS resolution temporarily
+
+      UDPSocket.open do |s|
+        s.connect '64.233.187.99', 1
+        s.addr.last
+      end
+    ensure
+      Socket.do_not_reverse_lookup = orig
+    end
+
+    # The string representation is the same as the id for this worker
+    # instance. Can be used with `Worker.find`.
+    def to_s
+      @to_s || "#{hostname}(#{local_ip}):#{Process.pid}:#{Thread.current.object_id}:#{Thread.current[:queues]}"
+    end
+
+    alias_method :id, :to_s
+
+    def pid
+      to_s.split(':').second
+    end
+
+    def thread
+      to_s.split(':').third
+    end
+
+    def queue
+      to_s.split(':').last
+    end
+
+    def workers_in_pid
+      Array(redis.smembers(:workers)).select { |id| id =~ /\(#{ip}\):#{pid}/ }.map { |id| Resque::Worker.find(id) }.compact
+    end
+
+    def ip
+      to_s.split(':').first[/\b(?:\d{1,3}\.){3}\d{1,3}\b/]
+    end
+
+    def queues_in_pid
+      workers_in_pid.collect { |w| w.queue }
+    end
+
+    #OVERRIDE for multithreaded workers
+    def queues
+      Thread.current[:queues] == "*" ? Resque.queues.sort : Thread.current[:queues].split(',')
+    end
+
+    # Runs all the methods needed when a worker begins its lifecycle.
+    #OVERRIDE for multithreaded workers
+    def startup
+      enable_gc_optimizations
+      if Thread.current == Thread.main
+        register_signal_handlers
+        prune_dead_workers
+      end
+      run_hook :before_first_fork
+      register_worker
+
+      # Fix buffering so we can `rake resque:work > resque.log` and
+      # get output from the child in there.
+      $stdout.sync = true
+    end
+
+    # Schedule this worker for shutdown. Will finish processing the
+    # current job.
+    #OVERRIDE for multithreaded workers
+    def shutdown
+      log 'Exiting...'
+      Thread.list.each { |t| t[:shutdown] = true }
+      @shutdown = true
+    end
+
+    # Looks for any workers which should be running on this server
+    # and, if they're not, removes them from Redis.
+    #
+    # This is a form of garbage collection. If a server is killed by a
+    # hard shutdown, power failure, or something else beyond our
+    # control, the Resque workers will not die gracefully and therefor
+    # will leave stale state information in Redis.
+    #
+    # By checking the current Redis state against the actual
+    # environment, we can determine if Redis is old and clean it up a bit.
+    def prune_dead_workers
+      Worker.all.each do |worker|
+        host, pid, thread, queues = worker.id.split(':')
+        next unless host.include?(hostname)
+        next if worker_pids.include?(pid)
+        log! "Pruning dead worker: #{worker}"
+        worker.unregister_worker
+      end
+    end
+
+    def all_workers_in_pid_working
+      workers_in_pid.select { |w| (hash = w.processing) && !hash.empty? }
+    end
+
+    # Jruby won't allow you to trap the QUIT signal, so we're changing the INT signal to replace it for Jruby.
+    def register_signal_handlers
+      trap('TERM') { shutdown! }
+      trap('INT') { shutdown }
+
+      begin
+        s = trap('QUIT') { shutdown }
+        warn "Signal QUIT not supported." unless s
+        s = trap('USR1') { kill_child }
+        warn "Signal USR1 not supported." unless s
+        s = trap('USR2') { pause_processing }
+        warn "Signal USR2 not supported." unless s
+        s = trap('CONT') { unpause_processing }
+        warn "Signal CONT not supported." unless s
+      rescue ArgumentError
+        warn "Signals QUIT, USR1, USR2, and/or CONT not supported."
+      end
+    end
+
+    # This is the main workhorse method. Called on a Worker instance,
+    # it begins the worker life cycle.
+    #
+    # The following events occur during a worker's life cycle:
+    #
+    # 1. Startup:   Signals are registered, dead workers are pruned,
+    #               and this worker is registered.
+    # 2. Work loop: Jobs are pulled from a queue and processed.
+    # 3. Teardown:  This worker is unregistered.
+    #
+    # Can be passed an integer representing the polling frequency.
+    # The default is 5 seconds, but for a semi-active site you may
+    # want to use a smaller value.
+    #
+    # Also accepts a block which will be passed the job as soon as it
+    # has completed processing. Useful for testing.
+    #OVERRIDE for multithreaded workers
+    def work(interval = 5, &block)
+      $0 = "resque: Starting"
+      startup
+
+      loop do
+        break if @shutdown || Thread.current[:shutdown]
+
+        if not @paused and job = reserve
+          log "got: #{job.inspect}"
+          run_hook :before_fork
+          working_on job
+
+          if @child = fork
+            rand # Reseeding
+            procline "Forked #{@child} at #{Time.now.to_i}"
+            Process.wait
+          else
+            procline "Processing #{job.queue} since #{Time.now.to_i}"
+            perform(job, &block)
+            exit! unless @cant_fork
+          end
+
+          done_working
+          @child = nil
+        else
+          break if interval.to_i == 0
+          log! "Sleeping for #{interval.to_i}"
+          procline @paused ? "Paused" : "Waiting for #{@queues.join(',')}"
+          sleep interval.to_i
+        end
+      end
+      unregister_worker rescue nil
+      loop do
+        #hang onto the process until all threads are done
+        break if all_workers_in_pid_working.blank?
+        sleep interval.to_i
+      end
+    ensure
+      unregister_worker
+    end
+
+    # logic for mappged_mget changed where it returns keys with nil values in latest redis gem.
+    def self.working
+      names = all
+      return [] unless names.any?
+      names.map! { |name| "worker:#{name}" }
+      redis.mapped_mget(*names).map do |key, value|
+        find key.sub("worker:", '') unless value.nil?
+      end.compact
+    end
+
+    # Returns an array of string pids of all the other workers on this
+    # machine. Useful when pruning dead workers on startup.
+    def worker_pids
+      `ps -A -o pid,command | grep [r]esque`.split("\n").map do |line|
+        line.split(' ')[0]
+      end
+    end
+
+    def status=(status)
+      data = encode(job.merge('status' => status))
+      redis.set("worker:#{self}", data)
+    end
+
+    def status
+      job['status']
+    end
+
+    def self.start(ips, queues)
+      if Rails.env =~ /development|test/
+        Thread.new(queues) { |queue| system("rake QUEUE=#{queue} resque:work") }
+      else
+        Thread.new(queues, ips) { |queue, ip_list| system("cd #{Rails.root}; #{ResqueUi::Cap.path} #{Rails.env} resque:work host=#{ip_list} queue=#{queue}") }
+      end
+    end
+
+    def quit
+      if Rails.env =~ /development|test/
+        system("kill -INT  #{self.pid}")
+      else
+        system("cd #{Rails.root}; #{ResqueUi::Cap.path} #{Rails.env} resque:quit_worker pid=#{self.pid} host=#{self.ip}")
+      end
+    end
+
+    def restart
+      queues = self.queues_in_pid.join('#')
+      quit
+      self.class.start(self.ip, queues)
+    end
+
+  end
+end

data/lib/resque_ui/overrides/resque_scheduler/resque_scheduler.rb

@@ -0,0 +1,58 @@
+module ResqueScheduler
+  def schedule=(schedule_hash)
+    raise 'not implemented'
+  end
+
+  # Returns the schedule hash
+  def schedule
+    #the scheduler gem expects a hash, but it's now stored in
+    #redis as an array.
+    hash = {}
+    Resque.list_range(:scheduled, 0, -0).each do |job|
+      hash.merge! job
+    end
+    hash
+  end
+
+  def self.start(ips)
+    if Rails.env =~ /development|test/
+      Thread.new{system("rake resque:scheduler")}
+    else
+      Thread.new(ips){|ip_list|system("cd #{Rails.root}; #{ResqueUi::Cap.path} #{Rails.env} resque:scheduler host=#{ip_list}")}
+    end
+  end
+
+  def self.quit(ips)
+    if Rails.env =~ /development|test/
+      system("rake resque:quit_scheduler")
+    else
+      system("cd #{Rails.root}; #{ResqueUi::Cap.path} #{Rails.env} resque:quit_scheduler host=#{ips}")
+    end
+  end
+
+  def self.restart(ips)
+    quit(ips)
+    start(ips)
+  end
+
+  def self.farm_status
+    status = {}
+    if Rails.env =~ /development|test/
+      status['localhost'] = pids.present? ? 'Running' : 'Stopped'
+    else
+      Resque.schedule.values.collect{|job| job['ip']}.each do |ip|
+        cap = `cd #{Rails.root}; #{ResqueUi::Cap.path} #{Rails.env} resque:scheduler_status hosts=#{ip}`
+        status[ip] = cap =~ /resque:scheduler is up/ ? 'Running' : 'Stopped'
+      end
+    end
+    status
+  end
+
+  # Returns an array of string pids of all the other workers on this
+  # machine. Useful when pruning dead workers on startup.
+  def self.pids
+    `ps -A -o pid,command | grep [r]esque:scheduler`.split("\n").map do |line|
+      line.split(' ')[0]
+    end
+  end
+end

data/lib/resque_ui/overrides/resque_status/chained_job_with_status.rb

@@ -0,0 +1,24 @@
+module Resque
+  class ChainedJobWithStatus < JobWithStatus
+    def name
+      status.name rescue nil
+    end
+
+    def completed(*messages)
+      super(*messages)
+      # "You must override this method to provide your own logic of when to actually call complete."
+#      if counter(:processed) >= options['total']
+#        super
+#      end
+    end
+
+    def self.enqueue(klass, options = {})
+      #tie this job to the status of the calling job
+      opts = HashWithIndifferentAccess.new(options)
+      raise ArgumentError, "You must supply a :uuid attribute in your call to create." unless opts['uuid']
+      uuid = opts['uuid']
+      Resque.enqueue(klass, uuid, options)
+      uuid
+    end
+  end
+end

data/lib/resque_ui/overrides/resque_status/job_with_status.rb

@@ -0,0 +1,59 @@
+module Resque
+  class JobWithStatus
+    # Adds a job of type <tt>klass<tt> to the queue with <tt>options<tt>.
+    # Returns the UUID of the job
+    # override to pass actual parameters instead of a single hash, to make backward compatible with existing resque jobs.
+    def self.enqueue(klass, options = {})
+      uuid = Resque::Status.create :name => "#{self.name}: #{options.inspect}"
+      Resque.enqueue(klass, uuid, options)
+      uuid
+    end
+
+    # sets the status of the job for the current iteration. You should use
+    # the <tt>at</tt> method if you have actual numbers to track the iteration count.
+    # This will kill the job if it has been added to the kill list with
+    # <tt>Resque::Status.kill()</tt>
+    def tick(*messages)
+      kill! if should_kill? || status.killed?
+      set_status({'status' => 'working'}, *messages)
+    end
+
+    # Run by the Resque::Worker when processing this job. It wraps the <tt>perform</tt>
+    # method ensuring that the final status of the job is set regardless of error.
+    # If an error occurs within the job's work, it will set the status as failed and
+    # re-raise the error.
+    def safe_perform!
+      unless should_kill? || (status && status.killed?)
+        set_status({'status' => 'working'})
+        perform
+        kill! if should_kill?
+        completed unless status && status.completed?
+        on_success if respond_to?(:on_success)
+      end
+    rescue Killed
+      logger.info "Job #{self} Killed at #{Time.now}"
+      Resque::Status.killed(uuid)
+      on_killed if respond_to?(:on_killed)
+    rescue => e
+      logger.error e
+      failed("The task failed because of an error: #{e}")
+      if respond_to?(:on_failure)
+        on_failure(e)
+      else
+        raise e
+      end
+    end
+
+    def name
+      "#{self.class.name}: #{options.inspect}"
+    end
+
+    def incr_counter(counter)
+      Resque::Status.incr_counter(counter, uuid)
+    end
+
+    def counter(counter)
+      Resque::Status.counter(counter, uuid)
+    end
+  end
+end

data/lib/resque_ui/overrides/resque_status/status.rb

@@ -0,0 +1,53 @@
+module Resque
+  class Status
+    # Return the <tt>num</tt> most recent status/job UUIDs in reverse chronological order.
+    #override the gem to fix the ordering
+    def self.status_ids(range_start = nil, range_end = nil)
+      unless range_end && range_start
+        # Because we want a reverse chronological order, we need to get a range starting
+        # by the higest negative number.
+        redis.zrevrange(set_key, 0, -1) || []
+      else
+        # Because we want a reverse chronological order, we need to get a range starting
+        # by the higest negative number. The ordering is transparent from the API user's
+        # perspective so we need to convert the passed params
+        if range_start == 0
+          range_start = -1
+        else
+          range_start += 1
+        end
+        (redis.zrange(set_key, -(range_end.abs), -(range_start.abs)) || []).reverse
+      end
+    end
+
+    # clear statuses from redis passing an optional range. See `statuses` for info
+    # about ranges
+    def self.clear(range_start = nil, range_end = nil)
+      status_ids(range_start, range_end).each do |id|
+        redis.zrem(set_key, id)
+        Resque.redis.keys("*#{id}").each do |key|
+          Resque.redis.del(key)
+        end
+      end
+    end
+
+    #If multiple workers are running at once and you need an incrementer, you can't use the status' num attribute because of race conditions.
+    #You can use a counter and call incr on it instead
+    def self.counter_key(counter, uuid)
+      "#{counter}:#{uuid}"
+    end
+
+    def self.counter(counter, uuid)
+      redis[counter_key(counter, uuid)].to_i
+    end
+
+    def self.incr_counter(counter, uuid)
+      key = counter_key(counter, uuid)
+      n = redis.incr(key)
+      if expire_in
+        redis.expire(key, expire_in)
+      end
+      n
+    end
+  end
+end

data/lib/resque_ui.rb

@@ -0,0 +1,26 @@
+require 'resque/server'
+require 'resque_ui/cap'
+require 'resque_ui/overrides/resque/worker'
+require 'resque_ui/overrides/resque/resque'
+require 'resque_ui/overrides/resque/job'
+require 'resque_ui/overrides/resque/failure/failure'
+if Resque.respond_to? :schedule
+  require 'resque_scheduler/tasks'
+  require 'resque_ui/overrides/resque_scheduler/resque_scheduler'
+end
+require 'resque/job_with_status'
+require 'resque_ui/overrides/resque_status/status'
+require 'resque_ui/overrides/resque_status/job_with_status'
+require 'resque_ui/overrides/resque_status/chained_job_with_status'
+
+Resque::Server.tabs << 'Statuses'
+
+module ResqueUi
+  class Engine < Rails::Engine
+    rake_tasks do
+      load 'tasks/worker.rake'
+      load 'tasks/failure.rake'
+      load 'tasks/scheduler.rake' if Resque.respond_to? :schedule
+    end
+  end
+end