2014-11-12 11:19:45 -05:00
|
|
|
# encoding: utf-8
|
2016-11-22 23:39:00 -05:00
|
|
|
# frozen_string_literal: true
|
2012-06-19 11:41:41 -04:00
|
|
|
$stdout.sync = true
|
|
|
|
|
2012-02-19 16:02:32 -05:00
|
|
|
require 'yaml'
|
2012-03-08 23:58:51 -05:00
|
|
|
require 'singleton'
|
2012-01-16 19:14:47 -05:00
|
|
|
require 'optparse'
|
2012-10-19 16:50:59 -04:00
|
|
|
require 'erb'
|
2014-04-05 17:42:09 -04:00
|
|
|
require 'fileutils'
|
2012-03-31 15:45:24 -04:00
|
|
|
|
2012-02-19 16:02:32 -05:00
|
|
|
require 'sidekiq'
|
2012-01-25 16:32:51 -05:00
|
|
|
require 'sidekiq/util'
|
2012-01-16 19:14:47 -05:00
|
|
|
|
|
|
|
module Sidekiq
|
|
|
|
class CLI
|
2012-01-22 19:01:46 -05:00
|
|
|
include Util
|
2014-05-17 18:55:21 -04:00
|
|
|
include Singleton unless $TESTING
|
2012-01-22 19:01:46 -05:00
|
|
|
|
2015-10-12 12:43:51 -04:00
|
|
|
PROCTITLES = [
|
|
|
|
proc { 'sidekiq'.freeze },
|
|
|
|
proc { Sidekiq::VERSION },
|
|
|
|
proc { |me, data| data['tag'] },
|
|
|
|
proc { |me, data| "[#{Processor::WORKER_STATE.size} of #{data['concurrency']} busy]" },
|
|
|
|
proc { |me, data| "stopping" if me.stopping? },
|
|
|
|
]
|
|
|
|
|
2012-02-14 12:00:26 -05:00
|
|
|
# Used for CLI testing
|
2012-03-18 02:04:31 -04:00
|
|
|
attr_accessor :code
|
2013-01-29 11:15:34 -05:00
|
|
|
attr_accessor :launcher
|
2013-01-18 23:57:26 -05:00
|
|
|
attr_accessor :environment
|
2012-02-12 22:53:34 -05:00
|
|
|
|
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-03-08 23:58:51 -05:00
|
|
|
@code = nil
|
2012-02-16 13:47:26 -05:00
|
|
|
|
2013-01-18 23:57:26 -05:00
|
|
|
setup_options(args)
|
2012-12-11 06:32:22 -05:00
|
|
|
initialize_logger
|
2012-01-16 23:02:58 -05:00
|
|
|
validate!
|
2013-01-29 14:19:36 -05:00
|
|
|
daemonize
|
2012-03-08 23:58:51 -05:00
|
|
|
write_pid
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2017-01-03 18:24:48 -05:00
|
|
|
def jruby?
|
|
|
|
defined?(::JRUBY_VERSION)
|
|
|
|
end
|
|
|
|
|
2014-05-17 18:12:48 -04:00
|
|
|
# Code within this method is not tested because it alters
|
|
|
|
# global process state irreversibly. PRs which improve the
|
|
|
|
# test coverage of Sidekiq::CLI are welcomed.
|
2012-01-16 19:14:47 -05:00
|
|
|
def run
|
2014-05-17 18:12:48 -04:00
|
|
|
boot_system
|
2014-05-26 16:34:24 -04:00
|
|
|
print_banner
|
2014-03-22 17:41:53 -04:00
|
|
|
|
2013-03-09 12:19:17 -05:00
|
|
|
self_read, self_write = IO.pipe
|
2017-01-03 18:24:48 -05:00
|
|
|
sigs = %w(INT TERM TTIN TSTP)
|
|
|
|
# USR1 and USR2 don't work on the JVM
|
|
|
|
if !jruby?
|
|
|
|
sigs << 'USR1'
|
|
|
|
sigs << 'USR2'
|
|
|
|
end
|
2013-03-09 12:19:17 -05:00
|
|
|
|
2017-01-03 18:24:48 -05:00
|
|
|
sigs.each do |sig|
|
2014-02-18 04:27:04 -05:00
|
|
|
begin
|
|
|
|
trap sig do
|
|
|
|
self_write.puts(sig)
|
|
|
|
end
|
|
|
|
rescue ArgumentError
|
|
|
|
puts "Signal #{sig} not supported"
|
2013-03-09 12:19:17 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2012-09-03 14:34:07 -04:00
|
|
|
logger.info "Running in #{RUBY_DESCRIPTION}"
|
|
|
|
logger.info Sidekiq::LICENSE
|
2015-08-14 15:25:09 -04:00
|
|
|
logger.info "Upgrade to Sidekiq Pro for more features and support: http://sidekiq.org" unless defined?(::Sidekiq::Pro)
|
2012-09-03 14:34:07 -04:00
|
|
|
|
2016-02-25 17:29:41 -05:00
|
|
|
# touch the connection pool so it is created before we
|
|
|
|
# fire startup and start multithreading.
|
|
|
|
ver = Sidekiq.redis_info['redis_version']
|
|
|
|
raise "You are using Redis v#{ver}, Sidekiq requires Redis v2.8.0 or greater" if ver < '2.8'
|
2015-10-20 18:48:36 -04:00
|
|
|
|
2017-06-05 13:45:22 -04:00
|
|
|
# cache process identity
|
2017-06-05 14:29:22 -04:00
|
|
|
Sidekiq.options[:identity] = identity
|
2017-06-05 13:45:22 -04:00
|
|
|
|
2016-06-30 14:03:10 -04:00
|
|
|
# Touch middleware so it isn't lazy loaded by multiple threads, #3043
|
|
|
|
Sidekiq.server_middleware
|
|
|
|
|
2015-10-20 18:48:36 -04:00
|
|
|
# Before this point, the process is initializing with just the main thread.
|
|
|
|
# Starting here the process will now have multiple threads running.
|
2018-01-11 12:37:55 -05:00
|
|
|
fire_event(:startup, reverse: false, reraise: true)
|
2014-03-10 23:46:19 -04:00
|
|
|
|
2016-01-26 12:40:19 -05:00
|
|
|
logger.debug { "Client Middleware: #{Sidekiq.client_middleware.map(&:klass).join(', ')}" }
|
|
|
|
logger.debug { "Server Middleware: #{Sidekiq.server_middleware.map(&:klass).join(', ')}" }
|
2015-08-24 13:25:16 -04:00
|
|
|
|
2013-01-29 14:19:36 -05:00
|
|
|
if !options[:daemon]
|
|
|
|
logger.info 'Starting processing, hit Ctrl-C to stop'
|
|
|
|
end
|
|
|
|
|
2013-02-22 15:40:19 -05:00
|
|
|
require 'sidekiq/launcher'
|
2013-01-29 11:15:34 -05:00
|
|
|
@launcher = Sidekiq::Launcher.new(options)
|
|
|
|
|
2012-01-16 19:14:47 -05:00
|
|
|
begin
|
2013-01-29 11:15:34 -05:00
|
|
|
launcher.run
|
2013-02-23 15:24:38 -05:00
|
|
|
|
2013-03-09 12:19:17 -05:00
|
|
|
while readable_io = IO.select([self_read])
|
2013-03-08 08:39:33 -05:00
|
|
|
signal = readable_io.first[0].gets.strip
|
|
|
|
handle_signal(signal)
|
2013-02-23 15:24:38 -05:00
|
|
|
end
|
2012-01-16 19:14:47 -05:00
|
|
|
rescue Interrupt
|
2012-02-18 00:33:17 -05:00
|
|
|
logger.info 'Shutting down'
|
2013-01-29 11:15:34 -05:00
|
|
|
launcher.stop
|
2012-04-07 22:33:32 -04:00
|
|
|
# Explicitly exit so busy Processor threads can't block
|
|
|
|
# process shutdown.
|
2015-10-30 18:19:19 -04:00
|
|
|
logger.info "Bye!"
|
2012-04-06 23:53:03 -04:00
|
|
|
exit(0)
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-06-12 23:28:28 -04:00
|
|
|
def self.banner
|
2015-08-31 12:37:57 -04:00
|
|
|
%q{
|
|
|
|
m,
|
|
|
|
`$b
|
2015-08-31 21:43:50 -04:00
|
|
|
.ss, $$: .,d$
|
|
|
|
`$$P,d$P' .,md$P"'
|
|
|
|
,$$$$$bmmd$$$P^'
|
|
|
|
.d$$$$$$$$$$P'
|
|
|
|
$$^' `"^$$$' ____ _ _ _ _
|
|
|
|
$: ,$$: / ___|(_) __| | ___| | _(_) __ _
|
|
|
|
`b :$$ \___ \| |/ _` |/ _ \ |/ / |/ _` |
|
|
|
|
$$: ___) | | (_| | __/ <| | (_| |
|
|
|
|
$$ |____/|_|\__,_|\___|_|\_\_|\__, |
|
|
|
|
.d$$ |_|
|
2015-08-31 12:37:57 -04:00
|
|
|
}
|
2014-06-12 23:28:28 -04:00
|
|
|
end
|
|
|
|
|
2013-03-08 08:39:33 -05:00
|
|
|
def handle_signal(sig)
|
|
|
|
Sidekiq.logger.debug "Got #{sig} signal"
|
|
|
|
case sig
|
|
|
|
when 'INT'
|
|
|
|
# Handle Ctrl-C in JRuby like MRI
|
|
|
|
# http://jira.codehaus.org/browse/JRUBY-4637
|
|
|
|
raise Interrupt
|
|
|
|
when 'TERM'
|
|
|
|
# Heroku sends TERM and then waits 10 seconds for process to exit.
|
|
|
|
raise Interrupt
|
|
|
|
when 'USR1'
|
|
|
|
Sidekiq.logger.info "Received USR1, no longer accepting new work"
|
2015-10-06 15:43:01 -04:00
|
|
|
launcher.quiet
|
2017-01-03 18:24:48 -05:00
|
|
|
when 'TSTP'
|
|
|
|
# USR1 is not available on JVM, allow TSTP as an alternate signal
|
|
|
|
Sidekiq.logger.info "Received TSTP, no longer accepting new work"
|
|
|
|
launcher.quiet
|
2013-03-08 08:39:33 -05:00
|
|
|
when 'USR2'
|
|
|
|
if Sidekiq.options[:logfile]
|
|
|
|
Sidekiq.logger.info "Received USR2, reopening log file"
|
2014-02-07 16:27:35 -05:00
|
|
|
Sidekiq::Logging.reopen_logs
|
2013-03-08 08:39:33 -05:00
|
|
|
end
|
|
|
|
when 'TTIN'
|
|
|
|
Thread.list.each do |thread|
|
2017-12-08 16:26:50 -05:00
|
|
|
Sidekiq.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread['sidekiq_label']}"
|
2013-03-08 08:39:33 -05:00
|
|
|
if thread.backtrace
|
2014-09-19 13:55:51 -04:00
|
|
|
Sidekiq.logger.warn thread.backtrace.join("\n")
|
2013-03-08 08:39:33 -05:00
|
|
|
else
|
2014-09-19 13:55:51 -04:00
|
|
|
Sidekiq.logger.warn "<no backtrace available>"
|
2013-02-23 15:24:38 -05:00
|
|
|
end
|
2012-05-21 14:13:20 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-12-10 17:42:03 -05:00
|
|
|
private
|
|
|
|
|
|
|
|
def print_banner
|
|
|
|
# Print logo and banner for development
|
|
|
|
if environment == 'development' && $stdout.tty?
|
|
|
|
puts "\e[#{31}m"
|
|
|
|
puts Sidekiq::CLI.banner
|
|
|
|
puts "\e[0m"
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-01-29 14:19:36 -05:00
|
|
|
def daemonize
|
|
|
|
return unless options[:daemon]
|
|
|
|
|
|
|
|
raise ArgumentError, "You really should set a logfile if you're going to daemonize" unless options[:logfile]
|
|
|
|
files_to_reopen = []
|
|
|
|
ObjectSpace.each_object(File) do |file|
|
|
|
|
files_to_reopen << file unless file.closed?
|
|
|
|
end
|
|
|
|
|
2014-05-13 23:33:20 -04:00
|
|
|
::Process.daemon(true, true)
|
2013-01-29 14:19:36 -05:00
|
|
|
|
|
|
|
files_to_reopen.each do |file|
|
|
|
|
begin
|
|
|
|
file.reopen file.path, "a+"
|
|
|
|
file.sync = true
|
|
|
|
rescue ::Exception
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
[$stdout, $stderr].each do |io|
|
|
|
|
File.open(options[:logfile], 'ab') do |f|
|
|
|
|
io.reopen(f)
|
|
|
|
end
|
|
|
|
io.sync = true
|
|
|
|
end
|
|
|
|
$stdin.reopen('/dev/null')
|
|
|
|
|
|
|
|
initialize_logger
|
|
|
|
end
|
|
|
|
|
2013-01-18 23:57:26 -05:00
|
|
|
def set_environment(cli_env)
|
|
|
|
@environment = cli_env || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
|
|
|
|
end
|
|
|
|
|
2017-12-02 15:26:25 -05:00
|
|
|
def symbolize_keys_deep!(hash)
|
|
|
|
hash.keys.each do |k|
|
|
|
|
symkey = k.respond_to?(:to_sym) ? k.to_sym : k
|
|
|
|
hash[symkey] = hash.delete k
|
|
|
|
symbolize_keys_deep! hash[symkey] if hash[symkey].kind_of? Hash
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2014-11-12 11:19:45 -05:00
|
|
|
alias_method :die, :exit
|
|
|
|
alias_method :☠, :exit
|
2012-02-12 22:53:34 -05:00
|
|
|
|
2013-01-18 23:57:26 -05:00
|
|
|
def setup_options(args)
|
2013-12-23 10:32:53 -05:00
|
|
|
opts = parse_options(args)
|
|
|
|
set_environment opts[:environment]
|
2013-01-18 23:57:26 -05:00
|
|
|
|
2013-12-23 10:32:53 -05:00
|
|
|
cfile = opts[:config_file]
|
|
|
|
opts = parse_config(cfile).merge(opts) if cfile
|
2014-02-08 15:50:17 -05:00
|
|
|
|
2013-12-23 10:32:53 -05:00
|
|
|
opts[:strict] = true if opts[:strict].nil?
|
2016-08-01 12:33:12 -04:00
|
|
|
opts[:concurrency] = Integer(ENV["RAILS_MAX_THREADS"]) if !opts[:concurrency] && ENV["RAILS_MAX_THREADS"]
|
2013-01-18 23:57:26 -05:00
|
|
|
|
2013-12-23 10:32:53 -05:00
|
|
|
options.merge!(opts)
|
2013-01-18 23:57:26 -05:00
|
|
|
end
|
|
|
|
|
2012-02-19 16:02:32 -05:00
|
|
|
def options
|
|
|
|
Sidekiq.options
|
|
|
|
end
|
|
|
|
|
2012-02-09 23:32:59 -05:00
|
|
|
def boot_system
|
2013-01-18 23:57:26 -05:00
|
|
|
ENV['RACK_ENV'] = ENV['RAILS_ENV'] = environment
|
2012-02-09 23:32:59 -05:00
|
|
|
|
2012-02-19 16:02:32 -05:00
|
|
|
raise ArgumentError, "#{options[:require]} does not exist" unless File.exist?(options[:require])
|
2012-02-09 23:32:59 -05:00
|
|
|
|
2012-02-19 16:02:32 -05:00
|
|
|
if File.directory?(options[:require])
|
2014-07-05 08:29:20 -04:00
|
|
|
require 'rails'
|
|
|
|
if ::Rails::VERSION::MAJOR < 4
|
2017-01-17 16:02:06 -05:00
|
|
|
raise "Sidekiq no longer supports this version of Rails"
|
2016-11-22 12:32:36 -05:00
|
|
|
elsif ::Rails::VERSION::MAJOR == 4
|
2014-07-05 08:29:20 -04:00
|
|
|
# Painful contortions, see 1791 for discussion
|
2016-11-03 14:10:19 -04:00
|
|
|
# No autoloading, we want to force eager load for everything.
|
2014-07-05 08:29:20 -04:00
|
|
|
require File.expand_path("#{options[:require]}/config/application.rb")
|
|
|
|
::Rails::Application.initializer "sidekiq.eager_load" do
|
|
|
|
::Rails.application.config.eager_load = true
|
|
|
|
end
|
|
|
|
require 'sidekiq/rails'
|
|
|
|
require File.expand_path("#{options[:require]}/config/environment.rb")
|
2016-07-01 12:31:08 -04:00
|
|
|
else
|
|
|
|
require 'sidekiq/rails'
|
|
|
|
require File.expand_path("#{options[:require]}/config/environment.rb")
|
2014-06-24 11:37:33 -04:00
|
|
|
end
|
2012-11-15 12:53:52 -05:00
|
|
|
options[:tag] ||= default_tag
|
2012-02-09 23:32:59 -05:00
|
|
|
else
|
2016-08-30 03:10:16 -04:00
|
|
|
not_required_message = "#{options[:require]} was not required, you should use an explicit path: " +
|
|
|
|
"./#{options[:require]} or /path/to/#{options[:require]}"
|
|
|
|
|
|
|
|
require(options[:require]) || raise(ArgumentError, not_required_message)
|
2012-02-09 23:32:59 -05:00
|
|
|
end
|
2012-01-16 23:02:58 -05:00
|
|
|
end
|
|
|
|
|
2012-11-15 12:53:52 -05:00
|
|
|
def default_tag
|
|
|
|
dir = ::Rails.root
|
|
|
|
name = File.basename(dir)
|
|
|
|
if name.to_i != 0 && prevdir = File.dirname(dir) # Capistrano release directory?
|
|
|
|
if File.basename(prevdir) == 'releases'
|
|
|
|
return File.basename(File.dirname(prevdir))
|
|
|
|
end
|
|
|
|
end
|
|
|
|
name
|
|
|
|
end
|
|
|
|
|
2012-01-16 23:02:58 -05:00
|
|
|
def validate!
|
2012-02-19 16:02:32 -05:00
|
|
|
options[:queues] << 'default' if options[:queues].empty?
|
2012-02-07 20:22:05 -05:00
|
|
|
|
2012-02-19 16:02:32 -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 "=================================================================="
|
2017-11-12 01:51:29 -05:00
|
|
|
logger.info " Please point sidekiq to a Rails 4/5 application or a Ruby file "
|
2012-02-14 12:00:26 -05:00
|
|
|
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
|
2015-05-14 13:33:26 -04:00
|
|
|
|
2015-05-15 12:42:43 -04:00
|
|
|
[:concurrency, :timeout].each do |opt|
|
|
|
|
raise ArgumentError, "#{opt}: #{options[opt]} is not a valid value" if options.has_key?(opt) && options[opt].to_i <= 0
|
2015-05-14 13:33:26 -04: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|
|
2013-01-31 16:39:21 -05:00
|
|
|
o.on '-c', '--concurrency INT', "processor threads to use" do |arg|
|
|
|
|
opts[:concurrency] = Integer(arg)
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2013-01-29 14:19:36 -05:00
|
|
|
o.on '-d', '--daemon', "Daemonize process" do |arg|
|
|
|
|
opts[:daemon] = arg
|
|
|
|
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-10-31 13:29:32 -04:00
|
|
|
o.on '-g', '--tag TAG', "Process tag for procline" do |arg|
|
|
|
|
opts[:tag] = arg
|
2012-03-08 23:58:51 -05:00
|
|
|
end
|
|
|
|
|
2013-01-06 16:01:30 -05:00
|
|
|
o.on '-i', '--index INT', "unique process index on this machine" do |arg|
|
2013-04-24 14:48:22 -04:00
|
|
|
opts[:index] = Integer(arg.match(/\d+/)[0])
|
2013-01-06 16:01:30 -05:00
|
|
|
end
|
|
|
|
|
2013-12-25 07:30:20 -05:00
|
|
|
o.on "-q", "--queue QUEUE[,WEIGHT]", "Queues to process with optional weights" do |arg|
|
|
|
|
queue, weight = arg.split(",")
|
|
|
|
parse_queue opts, queue, weight
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
2012-02-15 13:56:36 -05:00
|
|
|
|
2013-01-31 16:39:21 -05:00
|
|
|
o.on '-r', '--require [PATH|DIR]', "Location of Rails application with workers or file to require" do |arg|
|
|
|
|
opts[:require] = arg
|
|
|
|
end
|
|
|
|
|
|
|
|
o.on '-t', '--timeout NUM', "Shutdown timeout" do |arg|
|
|
|
|
opts[:timeout] = Integer(arg)
|
|
|
|
end
|
|
|
|
|
|
|
|
o.on "-v", "--verbose", "Print more verbose output" do |arg|
|
|
|
|
opts[:verbose] = 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-03-30 11:57:30 -04:00
|
|
|
|
2012-12-11 06:32:22 -05:00
|
|
|
o.on '-L', '--logfile PATH', "path to writable logfile" do |arg|
|
|
|
|
opts[:logfile] = arg
|
|
|
|
end
|
|
|
|
|
2013-01-31 16:39:21 -05:00
|
|
|
o.on '-P', '--pidfile PATH', "path to pidfile" do |arg|
|
|
|
|
opts[:pidfile] = arg
|
|
|
|
end
|
|
|
|
|
2012-03-30 11:57:30 -04:00
|
|
|
o.on '-V', '--version', "Print version and exit" do |arg|
|
|
|
|
puts "Sidekiq #{Sidekiq::VERSION}"
|
|
|
|
die(0)
|
|
|
|
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)
|
2015-10-14 16:50:10 -04:00
|
|
|
|
|
|
|
%w[config/sidekiq.yml config/sidekiq.yml.erb].each do |filename|
|
|
|
|
opts[:config_file] ||= filename if File.exist?(filename)
|
|
|
|
end
|
|
|
|
|
2012-02-16 13:47:26 -05:00
|
|
|
opts
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2012-12-11 06:32:22 -05:00
|
|
|
def initialize_logger
|
2012-12-12 14:27:27 -05:00
|
|
|
Sidekiq::Logging.initialize_logger(options[:logfile]) if options[:logfile]
|
2012-12-11 06:32:22 -05:00
|
|
|
|
2014-02-24 23:47:44 -05:00
|
|
|
Sidekiq.logger.level = ::Logger::DEBUG if options[:verbose]
|
2012-12-11 06:32:22 -05:00
|
|
|
end
|
|
|
|
|
2012-02-15 13:56:36 -05:00
|
|
|
def write_pid
|
2012-02-19 16:02:32 -05:00
|
|
|
if path = options[:pidfile]
|
2014-04-03 14:08:32 -04:00
|
|
|
pidfile = File.expand_path(path)
|
|
|
|
File.open(pidfile, 'w') do |f|
|
2014-05-13 23:33:20 -04:00
|
|
|
f.puts ::Process.pid
|
2012-02-15 13:56:36 -05:00
|
|
|
end
|
2014-02-08 15:50:17 -05:00
|
|
|
end
|
2012-02-15 13:56:36 -05:00
|
|
|
end
|
|
|
|
|
2013-01-18 23:57:26 -05:00
|
|
|
def parse_config(cfile)
|
2012-02-16 13:47:26 -05:00
|
|
|
opts = {}
|
2013-01-18 23:57:26 -05:00
|
|
|
if File.exist?(cfile)
|
2014-08-18 11:59:14 -04:00
|
|
|
opts = YAML.load(ERB.new(IO.read(cfile)).result) || opts
|
2017-12-02 15:26:25 -05:00
|
|
|
|
|
|
|
if opts.respond_to? :deep_symbolize_keys!
|
|
|
|
opts.deep_symbolize_keys!
|
|
|
|
else
|
|
|
|
symbolize_keys_deep!(opts)
|
|
|
|
end
|
|
|
|
|
|
|
|
opts = opts.merge(opts.delete(environment.to_sym) || {})
|
2013-02-18 23:45:37 -05:00
|
|
|
parse_queues(opts, opts.delete(:queues) || [])
|
2013-01-18 23:57:26 -05:00
|
|
|
else
|
2013-02-19 13:52:30 -05:00
|
|
|
# allow a non-existent config file so Sidekiq
|
|
|
|
# can be deployed by cap with just the defaults.
|
2012-02-15 21:13:32 -05:00
|
|
|
end
|
2013-03-01 19:13:20 -05:00
|
|
|
ns = opts.delete(:namespace)
|
|
|
|
if ns
|
2013-11-14 00:33:44 -05:00
|
|
|
# logger hasn't been initialized yet, puts is all we have.
|
|
|
|
puts("namespace should be set in your ruby initializer, is ignored in config file")
|
|
|
|
puts("config.redis = { :url => ..., :namespace => '#{ns}' }")
|
2013-03-01 19:13:20 -05:00
|
|
|
end
|
2012-02-16 13:47:26 -05:00
|
|
|
opts
|
2012-02-15 21:13:32 -05:00
|
|
|
end
|
|
|
|
|
2012-11-07 01:54:31 -05:00
|
|
|
def parse_queues(opts, queues_and_weights)
|
2013-12-25 07:30:20 -05:00
|
|
|
queues_and_weights.each { |queue_and_weight| parse_queue(opts, *queue_and_weight) }
|
2012-11-07 01:54:31 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def parse_queue(opts, q, weight=nil)
|
2012-07-27 18:18:11 -04:00
|
|
|
[weight.to_i, 1].max.times do
|
2012-04-03 23:19:29 -04:00
|
|
|
(opts[:queues] ||= []) << q
|
|
|
|
end
|
2013-12-23 10:32:53 -05:00
|
|
|
opts[:strict] = false if weight.to_i > 0
|
2012-02-15 21:13:32 -05:00
|
|
|
end
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
end
|