class Daemons::Application
Constants
- SIGNAL
Attributes
the ApplicationGroup
the application belongs to
my private options
Public Class Methods
Source
# File lib/daemons/application.rb, line 26 def initialize(group, add_options = {}, pid = nil) @group = group @options = group.options.dup @options.update(add_options) ['dir', 'log_dir', 'logfilename', 'output_logfilename'].each do |k| @options[k] = File.expand_path(@options[k]) if @options.key?(k) end @dir_mode = @dir = @script = nil @force_kill_waittime = @options[:force_kill_waittime] || 20 @signals_and_waits = parse_signals_and_waits(@options[:signals_and_waits]) @show_status_callback = method(:default_show_status) @report = Reporter.new(@options) unless @pid = pid if @options[:no_pidfiles] @pid = PidMem.new elsif dir = pidfile_dir @pid = PidFile.new(dir, @group.app_name, @group.multiple, @options[:pid_delimiter]) else @pid = PidMem.new end end end
Public Instance Methods
Source
# File lib/daemons/application.rb, line 65 def change_privilege user = options[:user] group = options[:group] if user @report.changing_process_privilege(user, group) CurrentProcess.change_privilege(user, group) end end
Source
# File lib/daemons/application.rb, line 438 def default_show_status(daemon = self) running = daemon.running? @report.status(group.app_name, running, daemon.pid.exist?, daemon.pid.pid.to_s) end
Source
# File lib/daemons/application.rb, line 341 def exception_log return unless logfile require 'logger' l_file = Logger.new(logfile) # the code below finds the last exception e = nil ObjectSpace.each_object do |o| if ::Exception === o e = o end end l_file.info '*** below you find the most recent exception thrown, this will be likely (but not certainly) the exception that made the application exit abnormally ***' l_file.error e l_file.info '*** below you find all exception objects found in memory, some of them may have been thrown in your application, others may just be in memory because they are standard exceptions ***' # this code logs every exception found in memory ObjectSpace.each_object do |o| if ::Exception === o l_file.error o end end l_file.close end
This is a nice little function for debugging purposes: In case a multi-threaded ruby script exits due to an uncaught exception it may be difficult to find out where the exception came from because one cannot catch exceptions that are thrown in threads other than the main thread.
This function searches for all exceptions in memory and outputs them to $stderr (if it is connected) and to a log file in the pid-file directory.
Source
# File lib/daemons/application.rb, line 82 def logdir options[:log_dir] or options[:dir_mode] == :system ? '/var/log' : pidfile_dir end
Source
# File lib/daemons/application.rb, line 103 def logfile if logdir File.join logdir, logfilename end end
Source
# File lib/daemons/application.rb, line 99 def logfilename options[:logfilename] or "#{@group.app_name}.log" end
Source
# File lib/daemons/application.rb, line 91 def output_logfile if log_output_syslog? 'SYSLOG' elsif log_output? File.join logdir, output_logfilename end end
Source
# File lib/daemons/application.rb, line 87 def output_logfilename options[:output_logfilename] or "#{@group.app_name}.output" end
Source
# File lib/daemons/application.rb, line 78 def pidfile_dir Pid.dir dir_mode, dir, script end
Source
# File lib/daemons/application.rb, line 319 def reload if @pid.pid == 0 zap start else begin Process.kill('HUP', @pid.pid) rescue # ignore end end end
Source
# File lib/daemons/application.rb, line 451 def running? @pid.exist? and Pid.running? @pid.pid end
This function implements a (probably too simle) method to detect whether the program with the pid found in the pid-file is still running. It just searches for the pid in the output of ps ax
, which is probably not a good idea in some cases. Alternatives would be to use a direct access method the unix process control system.
Source
# File lib/daemons/application.rb, line 434 def show_status @show_status_callback.call(self) end
Source
# File lib/daemons/application.rb, line 56 def show_status_callback=(function) @show_status_callback = if function.respond_to?(:call) function else method(function) end end
Source
# File lib/daemons/application.rb, line 291 def start(restart = false) change_privilege unless restart @group.create_monitor(self) unless options[:ontop] # we don't monitor applications in the foreground end case options[:mode] when :none # this is only used to daemonize the currently running process start_none when :exec start_exec when :load start_load when :proc start_proc else start_load end end
Source
# File lib/daemons/application.rb, line 152 def start_exec if options[:backtrace] @report.backtrace_not_supported end unless options[:ontop] Daemonize.daemonize(output_logfile, @group.app_name) else Daemonize.simulate(output_logfile) end # note that we cannot remove the pid file if we run in :ontop mode (i.e. 'ruby ctrl_exec.rb run') @pid.pid = Process.pid ENV['DAEMONS_ARGV'] = @controller_argv.join(' ') started Kernel.exec(script, *(@app_argv || [])) end
Source
# File lib/daemons/application.rb, line 172 def start_load unless options[:ontop] Daemonize.daemonize(output_logfile, @group.app_name) else Daemonize.simulate(output_logfile) end @pid.pid = Process.pid # We need this to remove the pid-file if the applications exits by itself. # Note that <tt>at_exit</tt> will only be run if the applications exits by calling # <tt>exit</tt>, and not if it calls <tt>exit!</tt> (so please don't call <tt>exit!</tt> # in your application! # at_exit do begin; @pid.cleanup; rescue ::Exception; end # If the option <tt>:backtrace</tt> is used and the application did exit by itself # create a exception log. if options[:backtrace] && !options[:ontop] && !$daemons_sigterm begin; exception_log; rescue ::Exception; end end end # This part is needed to remove the pid-file if the application is killed by # daemons or manually by the user. # Note that the applications is not supposed to overwrite the signal handler for # 'TERM'. # $daemons_stop_proc = options[:stop_proc] trap(SIGNAL) do begin if $daemons_stop_proc $daemons_stop_proc.call end rescue ::Exception end begin; @pid.cleanup; rescue ::Exception; end $daemons_sigterm = true if options[:hard_exit] exit! else exit end end # Now we really start the script... $DAEMONS_ARGV = @controller_argv ENV['DAEMONS_ARGV'] = @controller_argv.join(' ') ARGV.clear ARGV.concat @app_argv if @app_argv started # TODO: exception logging load script end
Source
# File lib/daemons/application.rb, line 110 def start_none unless options[:ontop] Daemonize.daemonize(output_logfile, @group.app_name) else Daemonize.simulate(output_logfile) end @pid.pid = Process.pid # We need this to remove the pid-file if the applications exits by itself. # Note that <tt>at_text</tt> will only be run if the applications exits by calling # <tt>exit</tt>, and not if it calls <tt>exit!</tt> (so please don't call <tt>exit!</tt> # in your application! # at_exit do begin; @pid.cleanup; rescue ::Exception; end # If the option <tt>:backtrace</tt> is used and the application did exit by itself # create a exception log. if options[:backtrace] && !options[:ontop] && !$daemons_sigterm begin; exception_log; rescue ::Exception; end end end # This part is needed to remove the pid-file if the application is killed by # daemons or manually by the user. # Note that the applications is not supposed to overwrite the signal handler for # 'TERM'. # trap(SIGNAL) do begin; @pid.cleanup; rescue ::Exception; end $daemons_sigterm = true if options[:hard_exit] exit! else exit end end end
this function is only used to daemonize the currently running process (Daemons.daemonize
)
Source
# File lib/daemons/application.rb, line 233 def start_proc return unless p = options[:proc] myproc = proc do # We need this to remove the pid-file if the applications exits by itself. # Note that <tt>at_text</tt> will only be run if the applications exits by calling # <tt>exit</tt>, and not if it calls <tt>exit!</tt> (so please don't call <tt>exit!</tt> # in your application! # at_exit do begin; @pid.cleanup; rescue ::Exception; end # If the option <tt>:backtrace</tt> is used and the application did exit by itself # create a exception log. if options[:backtrace] && !options[:ontop] && !$daemons_sigterm begin; exception_log; rescue ::Exception; end end end # This part is needed to remove the pid-file if the application is killed by # daemons or manually by the user. # Note that the applications is not supposed to overwrite the signal handler for # 'TERM'. # $daemons_stop_proc = options[:stop_proc] trap(SIGNAL) do begin if $daemons_stop_proc $daemons_stop_proc.call end rescue ::Exception end begin; @pid.cleanup; rescue ::Exception; end $daemons_sigterm = true if options[:hard_exit] exit! else exit end end p.call end unless options[:ontop] @pid.pid = Daemonize.call_as_daemon(myproc, output_logfile, @group.app_name) else Daemonize.simulate(output_logfile) myproc.call end started end
Source
# File lib/daemons/application.rb, line 313 def started if pid = @pid.pid @report.process_started(group.app_name, pid) end end
Source
# File lib/daemons/application.rb, line 372 def stop(no_wait = false) unless running? zap return end # confusing: pid is also a attribute_reader pid = @pid.pid # Catch errors when trying to kill a process that doesn't # exist. This happens when the process quits and hasn't been # restarted by the monitor yet. By catching the error, we allow the # pid file clean-up to occur. begin wait_and_retry_kill_harder(pid, @signals_and_waits, no_wait) rescue Errno::ESRCH => e @report.output_message("#{e} #{pid}") @report.output_message('deleting pid-file.') end sleep(0.1) unless Pid.running?(pid) # We try to remove the pid-files by ourselves, in case the application # didn't clean it up. zap! @report.stopped_process(group.app_name, pid) end end
Source
# File lib/daemons/application.rb, line 404 def wait_and_retry_kill_harder(pid, remaining_signals, no_wait = false) sig_wait = remaining_signals.shift sig = sig_wait[:sig] wait = sig_wait[:wait] Process.kill(sig, pid) return if no_wait || !wait.positive? @report.stopping_process(group.app_name, pid, sig, wait) begin Timeout.timeout(wait, TimeoutError) do sleep(0.2) while Pid.running?(pid) end rescue TimeoutError if remaining_signals.any? wait_and_retry_kill_harder(pid, remaining_signals) else @report.cannot_stop_process(group.app_name, pid) end end end
@param Hash remaing_signals @param Boolean no_wait Send first Signal and return
Source
# File lib/daemons/application.rb, line 430 def zap! begin; @pid.zap; rescue ::Exception; end end
Private Instance Methods
Source
# File lib/daemons/application.rb, line 465 def dir_mode @dir_mode or group.dir_mode end
Source
# File lib/daemons/application.rb, line 457 def log_output? options[:log_output] && logdir end
Source
# File lib/daemons/application.rb, line 461 def log_output_syslog? options[:log_output_syslog] end
Source
# File lib/daemons/application.rb, line 473 def parse_signals_and_waits(argv) unless argv return [ { sig: 'TERM', wait: @force_kill_waittime }, { sig: 'KILL', wait: 20 } ] end argv.split('|').collect{ |part| splitted = part.split(':'); {sig: splitted[0], wait: splitted[1].to_i}} end