lib/miga/common/with_daemon.rb
require 'daemons'
require 'miga/common/with_daemon_class'
##
# Helper module with specific functions to handle objects that have daemons.
# The class including it must +extend MiGA::Common::WithDaemonClass+ and define:
# - +#daemon_home+ Path to the daemon's home
# - +#daemon_name+ Name of the daemon
# - +#daemon_loop+ One loop of the daemon to be repeatedly called
# - +#daemon_first_loop+ To be executed before the first call to +#daemon_loop+
module MiGA::Common::WithDaemon
# Process ID of the forked process declaring the daemon alive
attr :declare_alive_pid
# Loop counter
attr :loop_i
def pid_file
File.join(daemon_home, "#{daemon_name}.pid")
end
def output_file
File.join(daemon_home, "#{daemon_name}.output")
end
def terminate_file
File.join(daemon_home, 'terminate-daemon')
end
def alive_file
self.class.alive_file(daemon_home)
end
def terminated_file
self.class.terminated_file(daemon_home)
end
##
# When was the daemon last seen active?
def last_alive
self.class.last_alive(daemon_home)
end
##
# Is the daemon active?
def active?
return false unless File.exist? alive_file
(last_alive || Time.new(0)) > Time.now - 60
end
##
# Tell the world that you're alive.
def declare_alive
if active?
raise "Trying to declare alive an active daemon, if you think this is a" \
" mistake please remove #{alive_file} or try again in 1 minute"
end
@declare_alive_pid = fork { declare_alive_loop }
sleep(1) # <- to wait for the process check
end
##
# Loop checking if the process with PID +pid+ is still alive.
# By default, the parent process.
# Do not use directly, use +declare_alive+ instead.
# Returns a symbol indicating the reason to stop:
# - +:no_home+ Daemon's home does not exist
# - +:no_process_alive+ Process is not currently running
# - +:termination_file+ Found termination file
def declare_alive_loop(pid = Process.ppid)
i = -1
loop do
i += 1
return :no_home unless Dir.exist? daemon_home
return :no_process_alive unless process_alive? pid
write_alive_file if i % 30 == 0
return :termination_file if termination_file? pid
sleep(1)
end
end
def write_alive_file
File.open(alive_file, 'w') { |fh| fh.print Time.now.to_s }
end
##
# Check if the process with PID +pid+ is still alive,
# call +terminate+ otherwise.
def process_alive?(pid)
Process.kill(0, pid)
true
rescue Errno::ESRCH, Errno::EPERM, Errno::ENOENT
terminate
false
end
##
# Check if a termination file exists and terminate process with PID +pid+
# if it does. Do not kill any process if +pid+ is +nil+
def termination_file?(pid)
return false unless File.exist? terminate_file
say 'Found termination file, terminating'
File.unlink(terminate_file)
terminate
Process.kill(9, pid) unless pid.nil?
true
end
##
# Returns Hash containing the default options for the daemon.
def default_options
{
dir_mode: :normal, dir: daemon_home, multiple: false, log_output: true,
stop_proc: :terminate
}
end
##
# Launches the +task+ with options +opts+ (as command-line arguments) and
# returns the process ID as an Integer. If +wait+ it waits for the process to
# complete, immediately returns otherwise.
# Supported tasks: start, run, stop, status.
def daemon(task, opts = [], wait = true)
MiGA::MiGA.DEBUG "#{self.class}#daemon #{task} #{opts}"
task = task.to_sym
raise "Unsupported task: #{task}" unless respond_to? task
return send(task, opts, wait) unless %i[start run].include? task
# start & run:
options = default_options
opts.unshift(task.to_s)
options[:ARGV] = opts
# This additional degree of separation below was introduced so the Daemons
# package doesn't kill the parent process in workflows.
pid = fork { launch_daemon_proc(options) }
Process.wait(pid) if wait
pid
end
##
# Stops the daemon with +opts+
def stop(opts = [], wait = true)
if active?
say 'Sending termination message'
FileUtils.touch(terminate_file)
sleep(0.5) while active? if wait
File.unlink(pid_file) if File.exist?(pid_file)
else
say 'No running instances'
end
end
##
# Returns the status of the daemon with +opts+
def status(opts = [], wait = true)
if active?
say "Running with pid #{File.size?(pid_file) ? File.read(pid_file) : '?'}"
else
say 'Not running'
end
end
##
# Pass daemon options to +Daemons+. Do not use directly, use +daemon+ instead.
def launch_daemon_proc(options)
Daemons.run_proc("#{daemon_name}", options) { while in_loop; end }
end
##
# Initializes the daemon with +opts+
def start(opts = [], wait = true)
daemon(:start, opts, wait)
end
##
# Initializes the daemon on top with +opts+
def run(opts = [], wait = true)
daemon(:run, opts, wait)
end
##
# One loop, returns a boolean indicating if the execution should continue
def in_loop
if loop_i.nil?
declare_alive
daemon_first_loop
@loop_i = -1
end
@loop_i += 1
daemon_loop
end
##
# Declares a daemon termination. Do not use, directly, use #stop instead.
def terminate
unless declare_alive_pid.nil?
Process.kill(9, declare_alive_pid)
@declare_alive_pid = nil
end
File.rename(alive_file, terminated_file) if File.exist? alive_file
end
end