Class: Daemons::Application
- Inherits:
-
Object
- Object
- Daemons::Application
- Defined in:
- lib/daemons/application.rb
Constant Summary collapse
- SIGNAL =
(RUBY_PLATFORM =~ /win32/ ? 'KILL' : 'TERM')
Instance Attribute Summary collapse
-
#app_argv ⇒ Object
Returns the value of attribute app_argv.
-
#controller_argv ⇒ Object
Returns the value of attribute controller_argv.
-
#group ⇒ Object
readonly
the ApplicationGroup the application belongs to.
-
#options ⇒ Object
readonly
my private options.
-
#pid ⇒ Object
readonly
the Pid instance belonging to this application.
Instance Method Summary collapse
- #change_privilege ⇒ Object
-
#exception_log ⇒ Object
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.
-
#initialize(group, add_options = {}, pid = nil) ⇒ Application
constructor
A new instance of Application.
- #logdir ⇒ Object
- #logfile ⇒ Object
- #output_logfile ⇒ Object
- #pidfile_dir ⇒ Object
-
#reload ⇒ Object
def run if @group.controller.options run_via_exec() else run_via_load() end end def run_via_exec end def run_via_load end.
-
#running? ⇒ Boolean
This function implements a (probably too simle) method to detect whether the program with the pid found in the pid-file is still running.
- #script ⇒ Object
- #show_status ⇒ Object
- #start ⇒ Object
- #start_exec ⇒ Object
- #start_load ⇒ Object
-
#start_none ⇒ Object
this function is only used to daemonize the currently running process (Daemons.daemonize).
- #start_proc ⇒ Object
- #started ⇒ Object
- #stop(no_wait = false) ⇒ Object
- #zap ⇒ Object
- #zap! ⇒ Object
Constructor Details
#initialize(group, add_options = {}, pid = nil) ⇒ Application
Returns a new instance of Application.
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
# File 'lib/daemons/application.rb', line 29 def initialize(group, = {}, pid = nil) @group = group @options = group..dup @options.update() @dir_mode = @dir = @script = nil @force_kill_waittime = @options[:force_kill_waittime] || 20 unless @pid = pid if @options[:no_pidfiles] @pid = PidMem.new elsif dir = pidfile_dir @pid = PidFile.new(dir, @group.app_name, @group.multiple) else @pid = PidMem.new end end end |
Instance Attribute Details
#app_argv ⇒ Object
Returns the value of attribute app_argv.
13 14 15 |
# File 'lib/daemons/application.rb', line 13 def app_argv @app_argv end |
#controller_argv ⇒ Object
Returns the value of attribute controller_argv.
14 15 16 |
# File 'lib/daemons/application.rb', line 14 def controller_argv @controller_argv end |
#group ⇒ Object (readonly)
the ApplicationGroup the application belongs to
20 21 22 |
# File 'lib/daemons/application.rb', line 20 def group @group end |
#options ⇒ Object (readonly)
my private options
23 24 25 |
# File 'lib/daemons/application.rb', line 23 def @options end |
#pid ⇒ Object (readonly)
the Pid instance belonging to this application
17 18 19 |
# File 'lib/daemons/application.rb', line 17 def pid @pid end |
Instance Method Details
#change_privilege ⇒ Object
49 50 51 52 53 |
# File 'lib/daemons/application.rb', line 49 def change_privilege user = [:user] group = [:group] CurrentProcess.change_privilege(user, group) if user end |
#exception_log ⇒ Object
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.
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 |
# File 'lib/daemons/application.rb', line 348 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 {|o| if ::Exception === o e = o 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 {|o| if ::Exception === o l_file.error o end } l_file.close end |
#logdir ⇒ Object
63 64 65 66 67 68 69 |
# File 'lib/daemons/application.rb', line 63 def logdir logdir = [:log_dir] unless logdir logdir = [:dir_mode] == :system ? '/var/log' : pidfile_dir end logdir end |
#logfile ⇒ Object
75 76 77 |
# File 'lib/daemons/application.rb', line 75 def logfile logdir ? File.join(logdir, @group.app_name + '.log') : nil end |
#output_logfile ⇒ Object
71 72 73 |
# File 'lib/daemons/application.rb', line 71 def output_logfile ([:log_output] && logdir) ? File.join(logdir, @group.app_name + '.output') : nil end |
#pidfile_dir ⇒ Object
59 60 61 |
# File 'lib/daemons/application.rb', line 59 def pidfile_dir Pid.dir(@dir_mode || @group.dir_mode, @dir || @group.dir, @script || @group.script) end |
#reload ⇒ Object
def run
if @group.controller.options[:exec]
run_via_exec()
else
run_via_load()
end
end
def run_via_exec
end
def run_via_load
end
326 327 328 329 330 331 332 333 334 335 336 337 |
# File 'lib/daemons/application.rb', line 326 def reload if @pid.pid == 0 zap start else begin Process.kill('HUP', @pid.pid) rescue # ignore end end end |
#running? ⇒ Boolean
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.
468 469 470 471 472 473 474 |
# File 'lib/daemons/application.rb', line 468 def running? if @pid.exist? return Pid.running?(@pid.pid) end return false end |
#script ⇒ Object
55 56 57 |
# File 'lib/daemons/application.rb', line 55 def script @script || @group.script end |
#show_status ⇒ Object
455 456 457 458 459 |
# File 'lib/daemons/application.rb', line 455 def show_status running = self.running? puts "#{self.group.app_name}: #{running ? '' : 'not '}running#{(running and @pid.exist?) ? ' [pid ' + @pid.pid.to_s + ']' : ''}#{(@pid.exist? and not running) ? ' (but pid-file exists: ' + @pid.pid.to_s + ')' : ''}" end |
#start ⇒ Object
283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 |
# File 'lib/daemons/application.rb', line 283 def start change_privilege @group.create_monitor(@group.applications[0] || self) unless [:ontop] # we don't monitor applications in the foreground case [: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 |
#start_exec ⇒ Object
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 |
# File 'lib/daemons/application.rb', line 123 def start_exec if [:backtrace] puts "option :backtrace is not supported with :mode => :exec, ignoring" end unless [: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(' ') # haven't tested yet if this is really passed to the exec'd process... started() Kernel.exec(script(), *(@app_argv || [])) end |
#start_load ⇒ Object
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 |
# File 'lib/daemons/application.rb', line 144 def start_load unless [: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 { 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 [:backtrace] and not [:ontop] and not $daemons_sigterm begin; exception_log(); rescue ::Exception; 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 = [:stop_proc] trap(SIGNAL) { begin if $daemons_stop_proc $daemons_stop_proc.call end rescue ::Exception end begin; @pid.cleanup; rescue ::Exception; end $daemons_sigterm = true if [:hard_exit] exit! else exit 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: begin - rescue - end around this and exception logging load script() end |
#start_none ⇒ Object
this function is only used to daemonize the currently running process (Daemons.daemonize)
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
# File 'lib/daemons/application.rb', line 80 def start_none unless [: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 { 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 [:backtrace] and not [:ontop] and not $daemons_sigterm begin; exception_log(); rescue ::Exception; 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) { begin; @pid.cleanup; rescue ::Exception; end $daemons_sigterm = true if [:hard_exit] exit! else exit end } end |
#start_proc ⇒ Object
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 |
# File 'lib/daemons/application.rb', line 206 def start_proc return unless p = [:proc] myproc = proc do @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 { 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 [:backtrace] and not [:ontop] and not $daemons_sigterm begin; exception_log(); rescue ::Exception; 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 = [:stop_proc] trap(SIGNAL) { begin if $daemons_stop_proc $daemons_stop_proc.call end rescue ::Exception end begin; @pid.cleanup; rescue ::Exception; end $daemons_sigterm = true if [:hard_exit] exit! else exit end } started() p.call() end unless [:ontop] Daemonize.call_as_daemon(myproc, output_logfile, @group.app_name) else Daemonize.simulate(output_logfile) myproc.call # why did we use this?? # Thread.new(&options[:proc]) # why did we use the code below?? # unless pid = Process.fork # @pid.pid = pid # Daemonize.simulate(logfile) # options[:proc].call # exit # else # Process.detach(@pid.pid) # end end end |
#started ⇒ Object
302 303 304 305 306 307 |
# File 'lib/daemons/application.rb', line 302 def started if pid = @pid.pid puts "#{self.group.app_name}: process with pid #{pid} started." STDOUT.flush end end |
#stop(no_wait = false) ⇒ Object
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 |
# File 'lib/daemons/application.rb', line 380 def stop(no_wait = false) if not running? self.zap return end 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 Process.kill(SIGNAL, pid) rescue Errno::ESRCH => e puts "#{e} #{pid}" puts "deleting pid-file." end if not no_wait if @force_kill_waittime > 0 puts "#{self.group.app_name}: trying to stop process with pid #{pid}..." STDOUT.flush begin Timeout::timeout(@force_kill_waittime) { while Pid.running?(pid) sleep(0.2) end } rescue Timeout::Error puts "#{self.group.app_name}: process with pid #{pid} won't stop, we forcefully kill it..." STDOUT.flush begin Process.kill('KILL', pid) rescue Errno::ESRCH end begin Timeout::timeout(20) { while Pid.running?(pid) sleep(1) end } rescue Timeout::Error puts "#{self.group.app_name}: unable to forcefully kill process with pid #{pid}." STDOUT.flush end end end 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. begin; @pid.cleanup; rescue ::Exception; end puts "#{self.group.app_name}: process with pid #{pid} successfully stopped." STDOUT.flush end end |
#zap ⇒ Object
447 448 449 |
# File 'lib/daemons/application.rb', line 447 def zap @pid.cleanup end |
#zap! ⇒ Object
451 452 453 |
# File 'lib/daemons/application.rb', line 451 def zap! begin; @pid.cleanup; rescue ::Exception; end end |