95 lines
3.0 KiB
Nim
95 lines
3.0 KiB
Nim
import posix
|
|
import os except sleep
|
|
|
|
## Daemonize
|
|
var
|
|
pidFileInner: string
|
|
fi, fo, fe: File
|
|
|
|
proc onStop(sig: cint) {.noconv.} =
|
|
close(fi)
|
|
close(fo)
|
|
close(fe)
|
|
removeFile(pidFileInner)
|
|
|
|
quit(QuitSuccess)
|
|
|
|
proc daemonize*(pidfile, si, so, se: string, daemonMain: proc(): void): Pid =
|
|
|
|
if fileExists(pidfile):
|
|
raise newException(IOError, "pidfile " & pidfile & " already exists, daemon already running?")
|
|
|
|
# We're about to do a little dance to end up with a process that is
|
|
# disconnected from the calling program's process group and is not a session
|
|
# leader (a daemon process).
|
|
#
|
|
# Remember, after a call to fork the code is now running in two processes,
|
|
# the parent process and the child process. So the returned PID will be a
|
|
# positive value if we are still on the parent process, and represents the
|
|
# PID of the newly created process. If we are on the newly created process,
|
|
# the PID returned with be 0.
|
|
|
|
let pid1 = fork()
|
|
|
|
# Are we the child process?
|
|
if pid1 == 0:
|
|
# Yes, so let's get ready to execute the main code given to us. Note that
|
|
# this child process will not actually live long. As part of our setup,
|
|
# we're going to create a new process session, resulting in this child
|
|
# process being the process group owner and session leader. We don't our
|
|
# daemon process to be a session leader because that allows it to be
|
|
# connected to a terminal. So after we've setup the new process group we
|
|
# will fork again and actually run the logic we're daemonizing in the
|
|
# grandchild process.
|
|
|
|
# Ignore whatever the original working directory was.
|
|
discard chdir("/")
|
|
|
|
# Create a new session to decouple us from the original terminal.
|
|
discard setsid()
|
|
|
|
# Set the process file mode creation mask to 0000
|
|
discard umask(0)
|
|
|
|
# Fork again so the grandchild process will not be the session leader.
|
|
let pid2 = fork()
|
|
|
|
# If we're still on the child process, we're done.
|
|
if pid2 > 0: quit(QuitSuccess)
|
|
|
|
# Otherwise, if we are the grandchild let's finish setting up our
|
|
# environment.
|
|
flushFile(stdout)
|
|
flushFile(stderr)
|
|
|
|
# Setup our STDIN, STDERR, and STDOUT pipes (if given)
|
|
if si.len > 0:
|
|
fi = open(si, fmRead)
|
|
discard dup2(getFileHandle(fi), getFileHandle(stdin))
|
|
|
|
if so.len > 0:
|
|
fo = open(so, fmAppend)
|
|
discard dup2(getFileHandle(fo), getFileHandle(stdout))
|
|
|
|
if se.len > 0:
|
|
fe = open(se, fmAppend)
|
|
discard dup2(getFileHandle(fe), getFileHandle(stderr))
|
|
|
|
# Keep a record of the PID filename in our process memory so we can
|
|
# reference it in our cleanup hooks.
|
|
pidFileInner = pidfile
|
|
|
|
# Add hooks to cleanup after ourselves when we're asked to die.
|
|
signal(SIGINT, onStop)
|
|
signal(SIGTERM, onStop)
|
|
|
|
# Find out what our actual PID is and save it to the PID file.
|
|
let childPid = getpid()
|
|
writeFile(pidfile, $childPid)
|
|
|
|
# Finally, execute the logic given to us to daemonize
|
|
daemonMain()
|
|
|
|
# If we're not the child proces, return the new PID of the daemonized process
|
|
return pid1
|