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 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)