def __daemon(self):
"""
Daemonizes the process; returns a non-zero exit code in case of failure.
"""
# Daemonize
try:
# Create and check PID file
oPidLockFile = make_pidlockfile(self.__oArguments.pid, 0)
if is_pidfile_stale(oPidLockFile):
oPidLockFile.break_lock()
if oPidLockFile.is_locked():
sys.stderr.write(
'ERROR[Daemon]: Daemon process already running; PID=%s\n' %
oPidLockFile.read_pid())
return errno.EEXIST
# Create daemon context
oDaemonContext = DaemonContext(pidfile=oPidLockFile)
oDaemonContext.signal_map = {signal.SIGTERM: self.__signal}
oDaemonContext.open()
emit_message('[%s]' % os.getpid())
# Redirect standard error to syslog
syslog.openlog('LogWatcher', syslog.LOG_PID, syslog.LOG_DAEMON)
sys.stderr = Logger(self.__syslog)
# Execute
return self.__spawnWatchers(self.__oConfigObj)
except Exception as e:
sys.stderr.write(
'ERROR[Daemon]: Failed to fork to background; %s\n' % str(e))
return errno.ESRCH
def __daemon(self):
"""
Daemonizes the process; returns a non-zero exit code in case of failure.
"""
# Daemonize
try:
# Create and check PID file
oPidLockFile = make_pidlockfile(self.__oArguments.pid, 0)
if is_pidfile_stale(oPidLockFile):
oPidLockFile.break_lock()
if oPidLockFile.is_locked():
iPid = oPidLockFile.read_pid()
logger.error(f"daemon: Process already running; PID={iPid}")
return errno.EEXIST
# Create daemon context
oDaemonContext = DaemonContext(pidfile=oPidLockFile)
oDaemonContext.signal_map = {signal.SIGTERM: self.__signal}
oDaemonContext.open()
emit_message(f"daemon: Forked to background; PID={os.getpid()}")
# Redirect standard error to syslog
oHandler = SysLogHandler(address="/dev/log")
oHandler.setLevel(logger.level)
oHandler.setFormatter(
logging.Formatter(
"%(name)s[%(process)d]: %(levelname)s: %(message)s"))
logger.addHandler(oHandler)
# Execute
return self.__updater()
except Exception as e:
logger.error(f"daemon: Failed to fork to background; {str(e)}")
return errno.ESRCH
def parse_args(self):
runner.DaemonRunner.parse_args(self)
# when action is "start", check if the 3rd argument is a file
if self.action == "start":
if len(sys.argv) != 3:
self._usage_exit(sys.argv)
if not os.path.isfile(sys.argv[2]):
message = u"The 3rd argument (" + sys.argv[2] + ") is not a file.\n"
runner.emit_message(message)
self._usage_exit(sys.argv)
def _usage_exit(self, argv):
try:
runner.DaemonRunner._usage_exit(self, argv)
# add usage message before sys.exit
except SystemExit:
message = u"\n"
message += u"options:\n"
message += u" env.file\tWhen the action is start, the argument represents the environment definition file name.\n"
message += u" server\tWhen the action is reload, the argument represents the server name to reload."
runner.emit_message(message)
raise
def _status(self):
pid = self.pidfile.read_pid()
message = []
if pid:
message += ['Daemon started with pid %s' % pid]
else:
message += ['Daemon not running']
tasks = self.app.models.Task.query.filter_by(
status=self.app.models.TASK_STATUS_WAITING).all()
message += ['Number of waiting tasks: %s' % len(tasks)]
runner.emit_message('\n'.join(message))
def _start(self):
""" Open the daemon context and run the application.
"""
if is_pidfile_stale(self.pidfile):
self.pidfile.break_lock()
try:
self.open()
except daemon.pidlockfile.AlreadyLocked:
pidfile_path = self.pidfile.path
raise DaemonRunnerStartFailureError(
"PID file %(pidfile_path)r already locked" % vars())
pid = os.getpid()
message = self.start_message % vars()
emit_message(message)
self.app.run()
def _start(self):
""" Open the daemon context and run the application.
"""
if is_pidfile_stale(self.pidfile):
self.pidfile.break_lock()
try:
self.open()
except daemon.pidlockfile.AlreadyLocked:
pidfile_path = self.pidfile.path
raise DaemonRunnerStartFailureError(
"PID file %(pidfile_path)r already locked" % vars())
pid = os.getpid()
message = self.start_message % vars()
emit_message(message)
self.app.run()
def start(self):
"""
Open the daemon context and run the application.
"""
if self.pidfile and is_pidfile_stale(self.pidfile):
self.pidfile.break_lock()
try:
self.daemon_context.open()
except lockfile.AlreadyLocked:
raise DaemonRunnerStartFailureError(
u"PID file %(pidfile_path)r already locked".format(
self.pidfile.path))
pid = os.getpid()
message = self.start_message.format(pid, self.app.name)
emit_message(message)
signal.signal(signal.SIGHUP, self.restart)
self.app.run()
def start(self):
"""
Open the daemon context and run the application.
"""
if self.pidfile and is_pidfile_stale(self.pidfile):
self.pidfile.break_lock()
try:
self.daemon_context.open()
except lockfile.AlreadyLocked:
raise DaemonRunnerStartFailureError(
u"PID file %(pidfile_path)r already locked".format(
self.pidfile.path))
pid = os.getpid()
message = self.start_message.format(pid, self.app.name)
emit_message(message)
signal.signal(signal.SIGHUP, self.restart)
self.app.run()
def main():
args = parse_args()
daemon_command = args.daemon_command
config = load_config_file(args.config_file)
logging_config = config.pop('logging', None)
daemon_config = config.pop('daemon')
seneschal_config = config.pop('seneschal')
try:
if daemon_command == 'start':
start(logging_config, daemon_config, seneschal_config)
else:
config_logging(logging_config)
if daemon_command == 'stop':
stop(daemon_config)
else:
engine = Engine(seneschal_config)
if daemon_command == 'sweep':
engine.sweep()
except Exception as e:
emit_message(e)
sys.exit(1)
finally:
logging.shutdown()
def _usage_exit(self, usage_exit_code):
""" Emit a usage message, then exit.
"""
emit_message(self.parser.print_usage())
sys.exit(usage_exit_code)
def _usage_exit(self, usage_exit_code):
""" Emit a usage message, then exit.
"""
emit_message(self.parser.print_usage())
sys.exit(usage_exit_code)
