2016-11-22 23:39:00 -05:00
|
|
|
# frozen_string_literal: true
|
2019-04-01 12:20:41 -04:00
|
|
|
|
2012-06-19 11:41:41 -04:00
|
|
|
$stdout.sync = true
|
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
require "yaml"
|
|
|
|
require "singleton"
|
|
|
|
require "optparse"
|
|
|
|
require "erb"
|
|
|
|
require "fileutils"
|
2012-03-31 15:45:24 -04:00
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
require "sidekiq"
|
|
|
|
require "sidekiq/launcher"
|
|
|
|
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
|
|
|
|
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
|
|
|
|
2018-12-13 11:30:29 -05:00
|
|
|
def parse(args = ARGV)
|
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!
|
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.
|
2020-07-21 12:57:56 -04:00
|
|
|
def run(boot_app: true)
|
|
|
|
boot_application if boot_app
|
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
if environment == "development" && $stdout.tty? && Sidekiq.log_formatter.is_a?(Sidekiq::Logger::Formatters::Pretty)
|
2019-02-11 16:59:52 -05:00
|
|
|
print_banner
|
|
|
|
end
|
2019-11-17 20:50:01 -05:00
|
|
|
logger.info "Booted Rails #{::Rails.version} application in #{environment} environment" if rails_app?
|
2014-03-22 17:41:53 -04:00
|
|
|
|
2013-03-09 12:19:17 -05:00
|
|
|
self_read, self_write = IO.pipe
|
2019-04-01 12:20:41 -04:00
|
|
|
sigs = %w[INT TERM TTIN TSTP]
|
2019-10-11 16:30:30 -04:00
|
|
|
# USR1 and USR2 don't work on the JVM
|
2020-07-27 14:51:10 -04:00
|
|
|
sigs << "USR2" if Sidekiq.pro? && !jruby?
|
2017-01-03 18:24:48 -05:00
|
|
|
sigs.each do |sig|
|
2021-09-13 12:30:05 -04:00
|
|
|
old_handler = Signal.trap(sig) do
|
|
|
|
if old_handler.respond_to?(:call)
|
|
|
|
begin
|
|
|
|
old_handler.call
|
2021-09-13 12:33:57 -04:00
|
|
|
rescue Exception => exc
|
|
|
|
# signal handlers can't use Logger so puts only
|
|
|
|
puts ["Error in #{sig} handler", exc].inspect
|
2021-09-13 12:30:05 -04:00
|
|
|
end
|
|
|
|
end
|
2019-09-05 09:02:55 -04:00
|
|
|
self_write.puts(sig)
|
2013-03-09 12:19:17 -05:00
|
|
|
end
|
2019-04-01 12:20:41 -04:00
|
|
|
rescue ArgumentError
|
|
|
|
puts "Signal #{sig} not supported"
|
2013-03-09 12:19:17 -05:00
|
|
|
end
|
|
|
|
|
2012-09-03 14:34:07 -04:00
|
|
|
logger.info "Running in #{RUBY_DESCRIPTION}"
|
|
|
|
logger.info Sidekiq::LICENSE
|
2020-03-31 10:03:03 -04:00
|
|
|
logger.info "Upgrade to Sidekiq Pro for more features and support: https://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.
|
2020-12-02 12:27:14 -05:00
|
|
|
info = Sidekiq.redis_info
|
|
|
|
ver = info["redis_version"]
|
2019-10-16 16:49:08 -04:00
|
|
|
raise "You are connecting to Redis v#{ver}, Sidekiq requires Redis v4.0.0 or greater" if ver < "4"
|
2015-10-20 18:48:36 -04:00
|
|
|
|
2020-12-02 12:27:14 -05:00
|
|
|
maxmemory_policy = info["maxmemory_policy"]
|
2020-12-02 11:50:00 -05:00
|
|
|
if maxmemory_policy != "noeviction"
|
2020-12-02 12:27:14 -05:00
|
|
|
logger.warn <<~EOM
|
|
|
|
|
|
|
|
|
|
|
|
WARNING: Your Redis instance will evict Sidekiq data under heavy load.
|
|
|
|
The 'noeviction' maxmemory policy is recommended (current policy: '#{maxmemory_policy}').
|
|
|
|
See: https://github.com/mperham/sidekiq/wiki/Using-Redis#memory
|
|
|
|
|
|
|
|
EOM
|
2020-12-02 11:50:00 -05:00
|
|
|
end
|
|
|
|
|
2018-08-07 11:17:59 -04:00
|
|
|
# Since the user can pass us a connection pool explicitly in the initializer, we
|
|
|
|
# need to verify the size is large enough or else Sidekiq's performance is dramatically slowed.
|
|
|
|
cursize = Sidekiq.redis_pool.size
|
|
|
|
needed = Sidekiq.options[:concurrency] + 2
|
|
|
|
raise "Your pool of #{cursize} Redis connections is too small, please increase the size to at least #{needed}" if cursize < needed
|
|
|
|
|
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
|
|
|
|
2019-04-01 12:20:41 -04: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
|
|
|
|
2018-12-07 11:59:42 -05:00
|
|
|
launch(self_read)
|
|
|
|
end
|
|
|
|
|
|
|
|
def launch(self_read)
|
2019-04-01 12:20:41 -04:00
|
|
|
if environment == "development" && $stdout.tty?
|
|
|
|
logger.info "Starting processing, hit Ctrl-C to stop"
|
2013-01-29 14:19:36 -05:00
|
|
|
end
|
|
|
|
|
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
|
|
|
|
2019-04-01 12:20:41 -04: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
|
2019-04-01 12:20:41 -04:00
|
|
|
logger.info "Shutting down"
|
2013-01-29 11:15:34 -05:00
|
|
|
launcher.stop
|
2015-10-30 18:19:19 -04:00
|
|
|
logger.info "Bye!"
|
2019-08-28 12:59:28 -04:00
|
|
|
|
|
|
|
# Explicitly exit so busy Processor threads won't block process shutdown.
|
|
|
|
#
|
|
|
|
# NB: slow at_exit handlers will prevent a timely exit if they take
|
|
|
|
# a while to run. If Sidekiq is getting here but the process isn't exiting,
|
|
|
|
# use the TTIN signal to determine where things are stuck.
|
2012-04-06 23:53:03 -04:00
|
|
|
exit(0)
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-02-07 15:23:30 -05:00
|
|
|
def self.w
|
2019-04-01 12:20:41 -04:00
|
|
|
"\e[37m"
|
2019-02-07 15:23:30 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def self.r
|
2019-04-01 12:20:41 -04:00
|
|
|
"\e[31m"
|
2019-02-07 15:23:30 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def self.b
|
2019-04-01 12:20:41 -04:00
|
|
|
"\e[30m"
|
2019-02-07 15:23:30 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def self.reset
|
2019-04-01 12:20:41 -04:00
|
|
|
"\e[0m"
|
2019-02-07 15:23:30 -05:00
|
|
|
end
|
|
|
|
|
2014-06-12 23:28:28 -04:00
|
|
|
def self.banner
|
2019-04-01 12:20:41 -04:00
|
|
|
%{
|
|
|
|
#{w} m,
|
|
|
|
#{w} `$b
|
|
|
|
#{w} .ss, $$: .,d$
|
|
|
|
#{w} `$$P,d$P' .,md$P"'
|
|
|
|
#{w} ,$$$$$b#{b}/#{w}md$$$P^'
|
|
|
|
#{w} .d$$$$$$#{b}/#{w}$$$P'
|
|
|
|
#{w} $$^' `"#{b}/#{w}$$$' #{r}____ _ _ _ _
|
|
|
|
#{w} $: ,$$: #{r} / ___|(_) __| | ___| | _(_) __ _
|
|
|
|
#{w} `b :$$ #{r} \\___ \\| |/ _` |/ _ \\ |/ / |/ _` |
|
|
|
|
#{w} $$: #{r} ___) | | (_| | __/ <| | (_| |
|
|
|
|
#{w} $$ #{r}|____/|_|\\__,_|\\___|_|\\_\\_|\\__, |
|
|
|
|
#{w} .d$$ #{r} |_|
|
|
|
|
#{reset}}
|
2014-06-12 23:28:28 -04:00
|
|
|
end
|
|
|
|
|
2018-01-29 15:20:08 -05:00
|
|
|
SIGNAL_HANDLERS = {
|
|
|
|
# Ctrl-C in terminal
|
2019-04-01 12:20:41 -04:00
|
|
|
"INT" => ->(cli) { raise Interrupt },
|
2018-01-29 15:20:08 -05:00
|
|
|
# TERM is the signal that Sidekiq must exit.
|
|
|
|
# Heroku sends TERM and then waits 30 seconds for process to exit.
|
2019-04-01 12:20:41 -04:00
|
|
|
"TERM" => ->(cli) { raise Interrupt },
|
|
|
|
"TSTP" => ->(cli) {
|
2017-01-03 18:24:48 -05:00
|
|
|
Sidekiq.logger.info "Received TSTP, no longer accepting new work"
|
2018-01-29 15:20:08 -05:00
|
|
|
cli.launcher.quiet
|
|
|
|
},
|
2019-04-01 12:20:41 -04:00
|
|
|
"TTIN" => ->(cli) {
|
2013-03-08 08:39:33 -05:00
|
|
|
Thread.list.each do |thread|
|
2019-08-02 12:54:52 -04:00
|
|
|
Sidekiq.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread.name}"
|
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
|
2020-03-17 16:38:48 -04:00
|
|
|
}
|
2018-01-29 15:20:08 -05:00
|
|
|
}
|
2019-09-05 09:02:55 -04:00
|
|
|
UNHANDLED_SIGNAL_HANDLER = ->(cli) { Sidekiq.logger.info "No signal handler registered, ignoring" }
|
|
|
|
SIGNAL_HANDLERS.default = UNHANDLED_SIGNAL_HANDLER
|
2018-01-29 15:20:08 -05:00
|
|
|
|
|
|
|
def handle_signal(sig)
|
|
|
|
Sidekiq.logger.debug "Got #{sig} signal"
|
2019-09-05 09:02:55 -04:00
|
|
|
SIGNAL_HANDLERS[sig].call(self)
|
2012-05-21 14:13:20 -04:00
|
|
|
end
|
|
|
|
|
2014-12-10 17:42:03 -05:00
|
|
|
private
|
|
|
|
|
|
|
|
def print_banner
|
2019-04-01 12:20:41 -04:00
|
|
|
puts "\e[31m"
|
2018-12-07 11:59:42 -05:00
|
|
|
puts Sidekiq::CLI.banner
|
|
|
|
puts "\e[0m"
|
2014-12-10 17:42:03 -05:00
|
|
|
end
|
|
|
|
|
2013-01-18 23:57:26 -05:00
|
|
|
def set_environment(cli_env)
|
2020-01-13 19:56:53 -05:00
|
|
|
# See #984 for discussion.
|
|
|
|
# APP_ENV is now the preferred ENV term since it is not tech-specific.
|
|
|
|
# Both Sinatra 2.0+ and Sidekiq support this term.
|
2020-03-16 17:32:46 -04:00
|
|
|
# RAILS_ENV and RACK_ENV are there for legacy support.
|
|
|
|
@environment = cli_env || ENV["APP_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
|
2013-01-18 23:57:26 -05:00
|
|
|
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
|
2019-04-01 12:20:41 -04:00
|
|
|
symbolize_keys_deep! hash[symkey] if hash[symkey].is_a? Hash
|
2017-12-02 15:26:25 -05:00
|
|
|
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)
|
2018-12-13 11:30:29 -05:00
|
|
|
# parse CLI options
|
2013-12-23 10:32:53 -05:00
|
|
|
opts = parse_options(args)
|
2018-12-13 11:30:29 -05:00
|
|
|
|
2013-12-23 10:32:53 -05:00
|
|
|
set_environment opts[:environment]
|
2013-01-18 23:57:26 -05:00
|
|
|
|
2018-12-13 11:30:29 -05:00
|
|
|
# check config file presence
|
|
|
|
if opts[:config_file]
|
2019-09-05 09:02:55 -04:00
|
|
|
unless File.exist?(opts[:config_file])
|
2018-12-13 11:30:29 -05:00
|
|
|
raise ArgumentError, "No such file #{opts[:config_file]}"
|
|
|
|
end
|
|
|
|
else
|
2019-01-08 12:20:59 -05:00
|
|
|
config_dir = if File.directory?(opts[:require].to_s)
|
2019-04-01 12:20:41 -04:00
|
|
|
File.join(opts[:require], "config")
|
2019-01-08 12:20:59 -05:00
|
|
|
else
|
2019-04-01 12:20:41 -04:00
|
|
|
File.join(options[:require], "config")
|
2019-01-08 12:20:59 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
%w[sidekiq.yml sidekiq.yml.erb].each do |config_file|
|
|
|
|
path = File.join(config_dir, config_file)
|
|
|
|
opts[:config_file] ||= path if File.exist?(path)
|
2018-12-13 11:30:29 -05:00
|
|
|
end
|
|
|
|
end
|
2018-12-03 16:24:37 -05:00
|
|
|
|
2018-12-13 11:30:29 -05:00
|
|
|
# parse config file options
|
|
|
|
opts = parse_config(opts[:config_file]).merge(opts) if opts[:config_file]
|
2014-02-08 15:50:17 -05:00
|
|
|
|
2019-01-08 12:20:59 -05:00
|
|
|
# set defaults
|
2020-05-05 15:57:21 -04:00
|
|
|
opts[:queues] = ["default"] if opts[:queues].nil?
|
2018-12-13 11:30:29 -05:00
|
|
|
opts[:concurrency] = Integer(ENV["RAILS_MAX_THREADS"]) if opts[:concurrency].nil? && ENV["RAILS_MAX_THREADS"]
|
2013-01-18 23:57:26 -05:00
|
|
|
|
2018-12-13 11:30:29 -05:00
|
|
|
# merge with defaults
|
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
|
|
|
|
|
2020-07-21 12:57:56 -04:00
|
|
|
def boot_application
|
2019-04-01 12:20:41 -04:00
|
|
|
ENV["RACK_ENV"] = ENV["RAILS_ENV"] = environment
|
2012-02-09 23:32:59 -05:00
|
|
|
|
2012-02-19 16:02:32 -05:00
|
|
|
if File.directory?(options[:require])
|
2019-04-01 12:20:41 -04:00
|
|
|
require "rails"
|
2018-12-28 13:16:50 -05:00
|
|
|
if ::Rails::VERSION::MAJOR < 5
|
2017-01-17 16:02:06 -05:00
|
|
|
raise "Sidekiq no longer supports this version of Rails"
|
2016-07-01 12:31:08 -04:00
|
|
|
else
|
2019-04-01 12:20:41 -04:00
|
|
|
require "sidekiq/rails"
|
2016-07-01 12:31:08 -04:00
|
|
|
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
|
2018-12-07 11:59:42 -05:00
|
|
|
require options[:require]
|
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)
|
2019-04-01 12:20:41 -04:00
|
|
|
prevdir = File.dirname(dir) # Capistrano release directory?
|
|
|
|
if name.to_i != 0 && prevdir
|
|
|
|
if File.basename(prevdir) == "releases"
|
2012-11-15 12:53:52 -05:00
|
|
|
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
|
|
|
if !File.exist?(options[:require]) ||
|
2019-04-01 12:20:41 -04:00
|
|
|
(File.directory?(options[:require]) && !File.exist?("#{options[:require]}/config/application.rb"))
|
2012-02-14 12:00:26 -05:00
|
|
|
logger.info "=================================================================="
|
2019-08-28 12:59:28 -04:00
|
|
|
logger.info " Please point Sidekiq to a Rails 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|
|
2019-04-01 12:20:41 -04:00
|
|
|
raise ArgumentError, "#{opt}: #{options[opt]} is not a valid value" if options.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 = {}
|
2019-09-25 16:14:57 -04:00
|
|
|
@parser = option_parser(opts)
|
|
|
|
@parser.parse!(argv)
|
|
|
|
opts
|
|
|
|
end
|
2012-01-16 19:14:47 -05:00
|
|
|
|
2019-09-25 16:14:57 -04:00
|
|
|
def option_parser(opts)
|
|
|
|
parser = OptionParser.new { |o|
|
2019-04-01 12:20:41 -04:00
|
|
|
o.on "-c", "--concurrency INT", "processor threads to use" do |arg|
|
2013-01-31 16:39:21 -05:00
|
|
|
opts[:concurrency] = Integer(arg)
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
o.on "-d", "--daemon", "Daemonize process" do |arg|
|
2019-08-28 12:59:28 -04:00
|
|
|
puts "ERROR: Daemonization mode was removed in Sidekiq 6.0, please use a proper process supervisor to start and manage your services"
|
2013-01-29 14:19:36 -05:00
|
|
|
end
|
|
|
|
|
2019-04-01 12:20:41 -04: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
|
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
o.on "-g", "--tag TAG", "Process tag for procline" do |arg|
|
2012-10-31 13:29:32 -04:00
|
|
|
opts[:tag] = arg
|
2012-03-08 23:58:51 -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
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
o.on "-r", "--require [PATH|DIR]", "Location of Rails application with workers or file to require" do |arg|
|
2013-01-31 16:39:21 -05:00
|
|
|
opts[:require] = arg
|
|
|
|
end
|
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
o.on "-t", "--timeout NUM", "Shutdown timeout" do |arg|
|
2013-01-31 16:39:21 -05:00
|
|
|
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
|
|
|
|
2019-04-01 12:20:41 -04: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
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
o.on "-L", "--logfile PATH", "path to writable logfile" do |arg|
|
2019-08-28 12:59:28 -04:00
|
|
|
puts "ERROR: Logfile redirection was removed in Sidekiq 6.0, Sidekiq will only log to STDOUT"
|
2012-12-11 06:32:22 -05:00
|
|
|
end
|
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
o.on "-P", "--pidfile PATH", "path to pidfile" do |arg|
|
2019-08-28 12:59:28 -04:00
|
|
|
puts "ERROR: PID file creation was removed in Sidekiq 6.0, please use a proper process supervisor to start and manage your services"
|
2013-01-31 16:39:21 -05:00
|
|
|
end
|
|
|
|
|
2019-04-01 12:20:41 -04:00
|
|
|
o.on "-V", "--version", "Print version and exit" do |arg|
|
2012-03-30 11:57:30 -04:00
|
|
|
puts "Sidekiq #{Sidekiq::VERSION}"
|
|
|
|
die(0)
|
|
|
|
end
|
2019-04-01 12:20:41 -04:00
|
|
|
}
|
2012-01-16 19:14:47 -05:00
|
|
|
|
2019-09-25 16:14:57 -04:00
|
|
|
parser.banner = "sidekiq [options]"
|
|
|
|
parser.on_tail "-h", "--help", "Show help" do
|
|
|
|
logger.info parser
|
2012-02-12 22:53:34 -05:00
|
|
|
die 1
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
2015-10-14 16:50:10 -04:00
|
|
|
|
2019-09-25 16:14:57 -04:00
|
|
|
parser
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
|
2012-12-11 06:32:22 -05:00
|
|
|
def initialize_logger
|
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
|
|
|
|
|
2018-12-28 18:05:51 -05:00
|
|
|
def parse_config(path)
|
2021-11-16 00:08:27 -05:00
|
|
|
erb = ERB.new(File.read(path))
|
|
|
|
erb.filename = File.expand_path(path)
|
|
|
|
opts = YAML.load(erb.result) || {}
|
2017-12-02 15:26:25 -05:00
|
|
|
|
2018-12-13 11:30:29 -05:00
|
|
|
if opts.respond_to? :deep_symbolize_keys!
|
|
|
|
opts.deep_symbolize_keys!
|
2013-01-18 23:57:26 -05:00
|
|
|
else
|
2018-12-13 11:30:29 -05:00
|
|
|
symbolize_keys_deep!(opts)
|
2012-02-15 21:13:32 -05:00
|
|
|
end
|
2018-12-13 11:30:29 -05:00
|
|
|
|
|
|
|
opts = opts.merge(opts.delete(environment.to_sym) || {})
|
2020-07-13 10:51:52 -04:00
|
|
|
opts.delete(:strict)
|
2020-05-07 12:00:19 -04:00
|
|
|
|
2018-12-13 11:30:29 -05:00
|
|
|
parse_queues(opts, opts.delete(:queues) || [])
|
|
|
|
|
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
|
|
|
|
|
2018-12-13 11:30:29 -05:00
|
|
|
def parse_queue(opts, queue, weight = nil)
|
2018-08-24 14:35:07 -04:00
|
|
|
opts[:queues] ||= []
|
2020-05-05 16:00:48 -04:00
|
|
|
opts[:strict] = true if opts[:strict].nil?
|
2018-12-13 11:30:29 -05:00
|
|
|
raise ArgumentError, "queues: #{queue} cannot be defined twice" if opts[:queues].include?(queue)
|
2021-09-30 15:09:15 -04:00
|
|
|
[weight.to_i, 1].max.times { opts[:queues] << queue.to_s }
|
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
|
2019-11-17 20:50:01 -05:00
|
|
|
|
|
|
|
def rails_app?
|
2020-01-08 11:46:49 -05:00
|
|
|
defined?(::Rails) && ::Rails.respond_to?(:application)
|
2019-11-17 20:50:01 -05:00
|
|
|
end
|
2012-01-16 19:14:47 -05:00
|
|
|
end
|
|
|
|
end
|
2020-03-17 13:12:25 -04:00
|
|
|
|
|
|
|
require "sidekiq/systemd"
|