2012-02-13 00:16:49 -05:00
|
|
|
trap 'INT' do
|
|
|
|
# Handle Ctrl-C in JRuby like MRI
|
|
|
|
# http://jira.codehaus.org/browse/JRUBY-4637
|
|
|
|
Thread.main.raise Interrupt
|
|
|
|
end
|
|
|
|
|
2012-02-13 22:58:16 -05:00
|
|
|
trap 'TERM' do
|
|
|
|
# Heroku sends TERM and then waits 10 seconds for process to exit.
|
|
|
|
Thread.main.raise Interrupt
|
|
|
|
end
|
|
|
|
|
2012-01-16 19:14:47 -05:00
|
|
|
require 'optparse'
|
2012-01-25 16:32:51 -05:00
|
|
|
require 'sidekiq/version'
|
|
|
|
require 'sidekiq/util'
|
2012-02-08 17:43:57 -05:00
|
|
|
require 'sidekiq/redis_connection'
|
2012-02-03 13:02:57 -05:00
|
|
|
require 'sidekiq/manager'
|
2012-01-16 19:14:47 -05:00
|
|
|
|
|
|
|
module Sidekiq
|
|
|
|
class CLI
|
2012-01-22 19:01:46 -05:00
|
|
|
include Util
|
|
|
|
|
2012-02-14 12:00:26 -05:00
|
|
|
# Used for CLI testing
|
2012-02-12 22:53:34 -05:00
|
|
|
attr_accessor :options, :code
|
|
|
|
|
2012-01-16 19:14:47 -05:00
|
|
|
def initialize
|
2012-02-12 22:53:34 -05:00
|
|
|
@code = nil
|
|
|
|
end
|
|
|
|
|
|
|
|
def parse(args=ARGV)
|
2012-02-14 12:00:26 -05:00
|
|
|
Sidekiq::Util.logger
|
2012-02-16 13:47:26 -05:00
|
|
|
|
|
|
|
@options = {
|
|
|
|
:queues => [],
|
|
|
|
:concurrency => 25,
|
|
|
|
:require => '.',
|
|
|
|
:environment => nil,
|
|
|
|
}
|
|
|
|
cli = parse_options(args)
|
|
|
|
config = parse_config(cli)
|
|
|
|
@options.merge!(config.merge(cli))
|
|
|
|
|
|
|
|
set_logger_level_to_debug if @options[:verbose]
|
|
|
|
|
2012-02-15 13:56:36 -05:00
|
|
|
write_pid
|
2012-01-16 23:02:58 -05:00
|
|
|
validate!
|
2012-02-09 23:32:59 -05:00
|
|
|
boot_system
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def run
|
2012-02-17 16:39:36 -05:00
|
|
|
Sidekiq.redis = RedisConnection.create(:url => @options[:server], :namespace => @options[:namespace])
|
2012-02-11 16:14:03 -05:00
|
|
|
manager = Sidekiq::Manager.new(@options)
|
2012-01-16 19:14:47 -05:00
|
|
|
begin
|
2012-02-14 12:00:26 -05:00
|
|
|
logger.info 'Starting processing, hit Ctrl-C to stop'
|
2012-02-03 13:02:57 -05:00
|
|
|
manager.start!
|
2012-02-05 16:22:57 -05:00
|
|
|
# HACK need to determine how to pause main thread while
|
|
|
|
# waiting for signals.
|
2012-02-12 23:48:13 -05:00
|
|
|
sleep
|
2012-01-16 19:14:47 -05:00
|
|
|
rescue Interrupt
|
2012-02-05 16:22:57 -05:00
|
|
|
# TODO Need clean shutdown support from Celluloid
|
2012-02-18 00:33:17 -05:00
|
|
|
logger.info 'Shutting down'
|
2012-02-03 13:02:57 -05:00
|
|
|
manager.stop!
|
|
|
|
manager.wait(:shutdown)
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2012-01-16 19:18:36 -05:00
|
|
|
private
|
|
|
|
|
2012-02-12 22:53:34 -05:00
|
|
|
def die(code)
|
|
|
|
exit(code)
|
|
|
|
end
|
|
|
|
|
2012-02-09 23:32:59 -05:00
|
|
|
def detected_environment
|
2012-02-14 21:19:17 -05:00
|
|
|
@options[:environment] ||= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
|
2012-02-09 23:32:59 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def boot_system
|
|
|
|
ENV['RACK_ENV'] = ENV['RAILS_ENV'] = detected_environment
|
|
|
|
|
2012-02-15 21:13:32 -05:00
|
|
|
raise ArgumentError, "#{@options[:require]} does not exist" unless File.exist?(@options[:require])
|
2012-02-09 23:32:59 -05:00
|
|
|
|
|
|
|
if File.directory?(@options[:require])
|
|
|
|
require File.expand_path("#{@options[:require]}/config/environment.rb")
|
|
|
|
::Rails.application.eager_load!
|
|
|
|
else
|
|
|
|
require @options[:require]
|
|
|
|
end
|
2012-01-16 23:02:58 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def validate!
|
2012-02-07 20:22:05 -05:00
|
|
|
@options[:queues] << 'default' if @options[:queues].empty?
|
|
|
|
@options[:queues].shuffle!
|
|
|
|
|
2012-02-10 00:56:14 -05:00
|
|
|
if !File.exist?(@options[:require]) ||
|
|
|
|
(File.directory?(@options[:require]) && !File.exist?("#{@options[:require]}/config/application.rb"))
|
2012-02-14 12:00:26 -05:00
|
|
|
logger.info "=================================================================="
|
|
|
|
logger.info " Please point sidekiq to a Rails 3 application or a Ruby file "
|
|
|
|
logger.info " to load your worker classes with -r [DIR|FILE]."
|
|
|
|
logger.info "=================================================================="
|
|
|
|
logger.info @parser
|
2012-02-12 22:53:34 -05:00
|
|
|
die(1)
|
2012-01-23 17:05:03 -05:00
|
|
|
end
|
2012-01-16 23:02:58 -05:00
|
|
|
end
|
|
|
|
|
2012-02-12 22:53:34 -05:00
|
|
|
def parse_options(argv)
|
2012-02-16 13:47:26 -05:00
|
|
|
opts = {}
|
2012-01-16 19:14:47 -05:00
|
|
|
|
|
|
|
@parser = OptionParser.new do |o|
|
2012-01-16 23:02:58 -05:00
|
|
|
o.on "-q", "--queue QUEUE,WEIGHT", "Queue to process, with optional weight" do |arg|
|
|
|
|
(q, weight) = arg.split(",")
|
2012-02-15 21:13:32 -05:00
|
|
|
parse_queues(q, weight)
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2012-01-16 23:02:58 -05:00
|
|
|
o.on "-v", "--verbose", "Print more verbose output" do
|
2012-02-15 21:13:32 -05:00
|
|
|
set_logger_level_to_debug
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2012-02-08 17:43:57 -05:00
|
|
|
o.on "-n", "--namespace NAMESPACE", "namespace worker queues are under" do |arg|
|
2012-02-16 13:47:26 -05:00
|
|
|
opts[:namespace] = arg
|
2012-02-08 17:43:57 -05:00
|
|
|
end
|
|
|
|
|
2012-01-26 00:12:18 -05:00
|
|
|
o.on "-s", "--server LOCATION", "Where to find Redis" do |arg|
|
2012-02-16 13:47:26 -05:00
|
|
|
opts[:server] = arg
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2012-02-09 23:32:59 -05:00
|
|
|
o.on '-e', '--environment ENV', "Application environment" do |arg|
|
2012-02-16 13:47:26 -05:00
|
|
|
opts[:environment] = arg
|
2012-01-24 01:08:38 -05:00
|
|
|
end
|
|
|
|
|
2012-02-09 23:32:59 -05:00
|
|
|
o.on '-r', '--require [PATH|DIR]', "Location of Rails application with workers or file to require" do |arg|
|
2012-02-16 13:47:26 -05:00
|
|
|
opts[:require] = arg
|
2012-01-23 17:05:03 -05:00
|
|
|
end
|
|
|
|
|
2012-01-25 16:32:51 -05:00
|
|
|
o.on '-c', '--concurrency INT', "processor threads to use" do |arg|
|
2012-02-16 13:47:26 -05:00
|
|
|
opts[:concurrency] = arg.to_i
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
2012-02-15 13:56:36 -05:00
|
|
|
|
2012-02-15 21:13:32 -05:00
|
|
|
o.on '-P', '--pidfile PATH', "path to pidfile" do |arg|
|
2012-02-16 13:47:26 -05:00
|
|
|
opts[:pidfile] = arg
|
2012-02-15 13:56:36 -05:00
|
|
|
end
|
2012-02-15 21:13:32 -05:00
|
|
|
|
|
|
|
o.on '-C', '--config PATH', "path to YAML config file" do |arg|
|
2012-02-16 13:47:26 -05:00
|
|
|
opts[:config_file] = arg
|
2012-02-15 21:13:32 -05:00
|
|
|
end
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2012-01-24 17:53:36 -05:00
|
|
|
@parser.banner = "sidekiq [options]"
|
2012-01-16 19:14:47 -05:00
|
|
|
@parser.on_tail "-h", "--help", "Show help" do
|
2012-02-14 12:00:26 -05:00
|
|
|
logger.info @parser
|
2012-02-12 22:53:34 -05:00
|
|
|
die 1
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
@parser.parse!(argv)
|
2012-02-16 13:47:26 -05:00
|
|
|
opts
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2012-02-15 13:56:36 -05:00
|
|
|
def write_pid
|
|
|
|
if path = @options[:pidfile]
|
|
|
|
File.open(path, 'w') do |f|
|
|
|
|
f.puts Process.pid
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2012-02-16 13:47:26 -05:00
|
|
|
def parse_config(cli)
|
|
|
|
opts = {}
|
|
|
|
if cli[:config_file] && File.exist?(cli[:config_file])
|
2012-02-15 21:13:32 -05:00
|
|
|
require 'yaml'
|
2012-02-16 13:47:26 -05:00
|
|
|
opts = YAML.load_file cli[:config_file]
|
|
|
|
queues = opts.delete(:queues) || []
|
|
|
|
if @options[:queues].empty?
|
|
|
|
queues.each { |pair| parse_queues(*pair) }
|
2012-02-16 12:45:55 -05:00
|
|
|
end
|
2012-02-15 21:13:32 -05:00
|
|
|
end
|
2012-02-16 13:47:26 -05:00
|
|
|
opts
|
2012-02-15 21:13:32 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def parse_queues(q, weight)
|
|
|
|
(weight || 1).to_i.times do
|
|
|
|
@options[:queues] << q
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def set_logger_level_to_debug
|
|
|
|
Sidekiq::Util.logger.level = Logger::DEBUG
|
|
|
|
end
|
|
|
|
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
end
|