discourse/lib/demon/base.rb

236 lines
4.2 KiB
Ruby

# frozen_string_literal: true
module Demon; end
# intelligent fork based demonizer
class Demon::Base
def self.demons
@demons
end
def self.start(count = 1, verbose: false)
@demons ||= {}
count.times do |i|
(@demons["#{prefix}_#{i}"] ||= new(i, verbose: verbose)).start
end
end
def self.stop
return unless @demons
@demons.values.each do |demon|
demon.stop
end
end
def self.restart
return unless @demons
@demons.values.each do |demon|
demon.stop
demon.start
end
end
def self.ensure_running
@demons.values.each do |demon|
demon.ensure_running
end
end
def self.kill(signal)
return unless @demons
@demons.values.each do |demon|
demon.kill(signal)
end
end
attr_reader :pid, :parent_pid, :started, :index
attr_accessor :stop_timeout
def initialize(index, rails_root: nil, parent_pid: nil, verbose: false)
@index = index
@pid = nil
@parent_pid = parent_pid || Process.pid
@started = false
@stop_timeout = 10
@rails_root = rails_root || Rails.root
@verbose = verbose
end
def pid_file
"#{@rails_root}/tmp/pids/#{self.class.prefix}_#{@index}.pid"
end
def alive?(pid = nil)
pid ||= @pid
if pid
Demon::Base.alive?(pid)
else
false
end
end
def kill(signal)
Process.kill(signal, @pid)
end
def stop_signal
"HUP"
end
def stop
@started = false
if @pid
Process.kill(stop_signal, @pid)
wait_for_stop = lambda {
timeout = @stop_timeout
while alive? && timeout > 0
timeout -= (@stop_timeout / 10.0)
sleep(@stop_timeout / 10.0)
Process.waitpid(@pid, Process::WNOHANG) rescue -1
end
Process.waitpid(@pid, Process::WNOHANG) rescue -1
}
wait_for_stop.call
if alive?
STDERR.puts "Process would not terminate cleanly, force quitting. pid: #{@pid} #{self.class}"
Process.kill("KILL", @pid)
end
wait_for_stop.call
@pid = nil
@started = false
end
end
def ensure_running
return unless @started
if !@pid
@started = false
start
return
end
dead = Process.waitpid(@pid, Process::WNOHANG) rescue -1
if dead
STDERR.puts "Detected dead worker #{@pid}, restarting..."
@pid = nil
@started = false
start
end
end
def start
return if @pid || @started
if existing = already_running?
# should not happen ... so kill violently
STDERR.puts "Attempting to kill pid #{existing}"
Process.kill("TERM", existing)
end
@started = true
run
end
def run
@pid = fork do
Process.setproctitle("discourse #{self.class.prefix}")
monitor_parent
establish_app
after_fork
end
write_pid_file
end
def already_running?
if File.exists? pid_file
pid = File.read(pid_file).to_i
if Demon::Base.alive?(pid)
return pid
end
end
nil
end
def self.alive?(pid)
Process.kill(0, pid)
true
rescue
false
end
private
def verbose(msg)
if @verbose
puts msg
end
end
def write_pid_file
verbose("writing pid file #{pid_file} for #{@pid}")
FileUtils.mkdir_p(@rails_root + "tmp/pids")
File.open(pid_file, 'w') do |f|
f.write(@pid)
end
end
def delete_pid_file
File.delete(pid_file)
end
def monitor_parent
Thread.new do
while true
begin
unless alive?(@parent_pid)
Process.kill "TERM", Process.pid
sleep 10
Process.kill "KILL", Process.pid
end
rescue => e
STDERR.puts "URGENT monitoring thread had an exception #{e}"
end
sleep 1
end
end
end
def suppress_stdout
true
end
def suppress_stderr
true
end
def establish_app
Discourse.after_fork if defined?(Discourse)
Signal.trap("HUP") do
begin
delete_pid_file
ensure
# TERM is way cleaner than exit
Process.kill("TERM", Process.pid)
end
end
# keep stuff simple for now
$stdout.reopen("/dev/null", "w") if suppress_stdout
$stderr.reopen("/dev/null", "w") if suppress_stderr
end
def after_fork
end
end