Kill resque workers using rake task, let god handle the restart

cap.rb

after "deploy:restart", "resque:stop_workers"

namespace :resque do
  task :stop_workers, :except => { :no_release => true } do
    run "cd #{current_path} && rake RAILS_ENV=#{rails_env} resque:stop_workers"
  end
end

monitor.god

rails_env   = ENV['RAILS_ENV']  || "production"
rails_root  = ENV['RAILS_ROOT'] || "/var/www/<appname>/current"
num_workers = 3

num_workers.times do |num|
  God.watch do |w|
    w.name     = "resque-<appname>-#{num}"
    w.group    = 'resque-<appname>'
    w.interval = 30.seconds
    w.env      = {"QUEUE"=>"*", "RAILS_ENV"=>rails_env}
    w.dir      = rails_root
    w.start    = "cd #{rails_root} && rake resque:work"
    w.start_grace = 10.seconds
    w.log      = File.join(rails_root, "log", "resque-worker.log")

    w.uid = 'capistrano'
    w.gid = 'www-data'

    # retart if memory gets too high
    w.transition(:up, :restart) do |on|
      on.condition(:memory_usage) do |c|
        c.above = 350.megabytes
        c.times = 2
      end
    end

    # determine the state on startup
    w.transition(:init, { true => :up, false => :start }) do |on|
      on.condition(:process_running) do |c|
        c.running = true
      end
    end

    # determine when process has finished starting
    w.transition([:start, :restart], :up) do |on|
      on.condition(:process_running) do |c|
        c.running = true
        c.interval = 5.seconds
      end

      # failsafe
      on.condition(:tries) do |c|
        c.times = 5
        c.transition = :start
        c.interval = 5.seconds
      end
    end

    # start if process is not running
    w.transition(:up, :start) do |on|
      on.condition(:process_running) do |c|
        c.running = false
      end
    end
  end
end

resque.rake

namespace :resque do
  desc "let resque workers always load the rails environment"
  task :setup => :environment do
  end

  desc "kill all workers (using -QUIT), god will take care of them"
  task :stop_workers => :environment do
    pids = Array.new

    Resque.workers.each do |worker|
      pids << worker.to_s.split(/:/).second
    end

    if pids.size > 0
      system("kill -QUIT #{pids.join(' ')}")
    end

    # god should handle the restart
  end
end

I like your :stop_workers task. It seems to work more properly compared to the one provided by resque itself. I've been pulling my hair for the last 2 days trying to figure out how to kill workers without receiving a SIGQUIT.