if pid_file is None: pid_file = conf.get("PROVISION_PID_FILE", "/var/run/beaker-lab-controller/beaker-provision.pid") # HubProxy will try to log some stuff, even though we # haven't configured our logging handlers yet. So we send logs to stderr # temporarily here, and configure it again below. log_to_stream(sys.stderr, level=logging.WARNING) try: poller = CommandQueuePoller(conf=conf) except Exception, ex: sys.stderr.write('Error starting beaker-provision: %s\n' % ex) sys.exit(1) if opts.foreground: log_to_stream(sys.stderr, level=logging.DEBUG) main_loop(poller=poller, conf=conf) else: # See BZ#977269 poller.close() with daemon.DaemonContext(pidfile=pidfile.TimeoutPIDLockFile( pid_file, acquire_timeout=0),detach_process=True): log_to_syslog('beaker-provision') try: main_loop(poller=poller, conf=conf) except Exception: logger.exception('Unhandled exception in main_loop') raise if __name__ == '__main__': main()
def start_daemon(): with daemon.DaemonContext( umask=0o002, # -rw-r--r-- pidfile=pidfile.TimeoutPIDLockFile(PID_FILE), working_directory=LOCAL_DIR) as context: run_jobs()
uuid = get_uuid() #inutile car uuid est global command = select_os(args) #inutile car uuid est global while True: send_cached_payloads() client() sleep(int(args.interval)) if __name__ == "__main__": args = parser.parse_args() select_logging_mode(args) dir_path = os.path.dirname( os.path.realpath(__file__)) ## Get the directory path of the file error_logs_file = open(dir_path + '/../logs/error_logs.txt', 'a') debug_logs_file = open(dir_path + '/../logs/debug_logs.txt', 'a') if args.mac_os: context = daemon.DaemonContext( working_directory=dir_path, stderr=error_logs_file, stdout=debug_logs_file, ) else: context = daemon.DaemonContext( working_directory=dir_path, stderr=error_logs_file, stdout=debug_logs_file, pidfile=pidfile.TimeoutPIDLockFile(PID_FILE)) with context: main()
# HubProxy will try to log some stuff, even though we # haven't configured our logging handlers yet. So we send logs to stderr # temporarily here, and configure it again below. log_to_stream(sys.stderr, level=logging.WARNING) try: watchdog = Watchdog(conf=conf) except Exception, ex: sys.stderr.write("Error starting beaker-watchdog: %s\n" % ex) sys.exit(1) if opts.foreground: log_to_stream(sys.stderr, level=logging.DEBUG) main_loop(watchdog, conf) else: # See BZ#977269 watchdog.close() with daemon.DaemonContext(pidfile=pidfile.TimeoutPIDLockFile( pid_file, acquire_timeout=0), detach_process=True): log_to_syslog('beaker-watchdog') try: main_loop(watchdog, conf) except Exception: logger.exception('Unhandled exception in main_loop') raise if __name__ == '__main__': main()
def start_daemon(pidf, logf): with daemon.DaemonContext( working_directory='/var/lib/remotfy_daemon', umask=0o002, pidfile=pidfile.TimeoutPIDLockFile(pidf)): process(logf)
def main(): """Run the daemon from the command line""" opts = parse_arguments(sys.argv[1:]) # Initialize logger lvl = logging.DEBUG if opts.debug else logging.INFO global logger logger = logging.getLogger("vncauthproxy") logger.setLevel(lvl) formatter = logging.Formatter(("%(asctime)s %(module)s[%(process)d] " " %(levelname)s: %(message)s"), "%Y-%m-%d %H:%M:%S") handler = logging.FileHandler(opts.log_file) handler.setFormatter(formatter) logger.addHandler(handler) try: # Create pidfile pidf = pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10) # Init ephemeral port pool ports = range(opts.min_port, opts.max_port + 1) # Init VncAuthProxy class attributes VncAuthProxy.server_timeout = opts.server_timeout VncAuthProxy.connect_retries = opts.connect_retries VncAuthProxy.retry_wait = opts.retry_wait VncAuthProxy.connect_timeout = opts.connect_timeout VncAuthProxy.ports = ports VncAuthProxy.authdb = parse_auth_file(opts.auth_file) VncAuthProxy.keyfile = opts.key_file VncAuthProxy.certfile = opts.cert_file VncAuthProxy.proxy_address = opts.proxy_listen_address VncAuthProxy.fqdn = socket.getfqdn() sockets = get_listening_sockets(opts.listen_port, opts.listen_address, reuse_addr=True) wrap_ssl = lambda sock: sock if opts.enable_ssl: ssl_prot = ssl.PROTOCOL_TLSv1 wrap_ssl = lambda sock: ssl.wrap_socket(sock, server_side=True, keyfile=opts.key_file, certfile=opts.cert_file, ssl_version=ssl_prot) # Become a daemon: # Redirect stdout and stderr to handler.stream to catch # early errors in the daemonization process [e.g., pidfile creation] # which will otherwise go to /dev/null. daemon_context = AllFilesDaemonContext(pidfile=pidf, umask=0022, stdout=handler.stream, stderr=handler.stream, files_preserve=[handler.stream]) # Remove any stale PID files, left behind by previous invocations if daemon.runner.is_pidfile_stale(pidf): logger.warning("Removing stale PID lock file %s", pidf.path) pidf.break_lock() try: daemon_context.open() except (AlreadyLocked, LockTimeout): raise InternalError(("Failed to lock PID file %s, another " "instance running?"), pidf.path) logger.info("Became a daemon") # A fork() has occured while daemonizing, # we *must* reinit gevent gevent.reinit() # Catch signals to ensure graceful shutdown, # # Uses gevent.signal so the handler fires even during # gevent.socket.accept() gevent.signal(SIGINT, fatal_signal_handler, "SIGINT") gevent.signal(SIGTERM, fatal_signal_handler, "SIGTERM") except InternalError as err: logger.critical(err) sys.exit(1) except Exception as err: logger.critical("Unexpected error:") logger.exception(err) sys.exit(1) while True: try: client = None rlist, _, _ = select(sockets, [], []) for ctrl in rlist: client, _ = ctrl.accept() client = wrap_ssl(client) logger.info("New control connection") VncAuthProxy.spawn(logger, client) continue except Exception as err: logger.error("Unexpected error:") logger.exception(err) if client: client.close() continue except SystemExit: break try: logger.info("Closing control sockets") while sockets: sock = sockets.pop() sock.close() daemon_context.close() sys.exit(0) except Exception as err: logger.critical("Unexpected error:") logger.exception(err) sys.exit(1)
if out: # Log the event logger.error(str(out)) # Send a message client.send_message(out) # Remove it from the list until the deamon is restarted # so it doesn't keep messaging me ping.remove_server(out) # Wait one hour time.sleep(60*30) if __name__ == "__main__": parser = argparse.ArgumentParser( description="Example daemon in Python") parser.add_argument('-t', '--test', dest='test', action='store_true') parser.add_argument('-p', '--pid-file', default='/var/run/DeadManText.pid') parser.add_argument('-l', '--log-file', default='/var/log/DeadManText.log') args = parser.parse_args() if args.test: main("local.out") else: with daemon.DaemonContext(working_directory='/var/lib/DeadManText', pidfile=pidfile.TimeoutPIDLockFile( args.pid_file), umask=0o002, ) as context: main(args.log_file)
def start_daemon(): with daemon.DaemonContext( working_directory='./', pidfile=pidfile.TimeoutPIDLockFile('daemon.pid'), ) as context: main()
formatter = logging.Formatter('%(name)-12s ' '%(asctime)s ' '%(levelname)-8s ' '%(message)s') lh.setFormatter(formatter) my_logger.addHandler(lh) rabbit_pwd = pwd.getpwnam('rabbitmq') uid = rabbit_pwd.pw_uid gid = rabbit_pwd.pw_gid env = os.environ.copy() env['USER'] = USER env['MAIL'] = MAIL env['PWD'] = PWD env['HOME'] = HOME env['LOGNAME'] = LOGNAME pidfilename = '/var/run/rabbitmq/rabbit-fence.pid' pidfile = daemon_pidfile.TimeoutPIDLockFile(pidfilename, 10) try: with daemon.DaemonContext(files_preserve=[lh.socket.fileno()], pidfile=pidfile, uid=uid, gid=gid, umask=0o022): main() except Exception: my_logger.exception("A generic exception caught!") sys.exit(1)
logger.error('Unhandled error:') logger.error(traceback.format_exc()) try: agent.stop() zwave_network.stop() except Exception: pass logger.debug('Restarting in 3 sec...') time.sleep(3) if __name__ == '__main__': arguments = docopt(__doc__) if arguments['--version']: print('Version: {}'.format(VERSION)) exit(0) if arguments['run']: if arguments['--daemon']: from daemon import pidfile, DaemonContext pid = pidfile.TimeoutPIDLockFile('/var/run/zeyeagent.pid', 10) ctx = DaemonContext(working_directory='.', pidfile=pid) ctx.open() start_agent(device=arguments['--device'], config_path=arguments['--config'], user_path=arguments['--user_path'], debug=arguments['--debug'] or arguments['--full-debug'], pyagentx_debug=arguments['--full-debug'])
def start(): """ Start backend, as a daemon :return bool: True """ # only one instance may be running at a time if lockfile.is_file(): with lockfile.open() as file: pid = int(file.read().strip()) if pid in psutil.pids(): print("...error: the 4CAT Backend Daemon is already running.") return False # start daemon in a separate process so we can continue doing stuff in this one afterwards new_pid = os.fork() if new_pid == 0: # create new daemon context and run bootstrapper inside it with daemon.DaemonContext( working_directory=os.path.abspath(os.path.dirname(__file__)), umask=0x002, stderr=open("4cat.stderr", "w"), pidfile=pidfile.TimeoutPIDLockFile(str(lockfile)), detach_process=True) as context: # clear module cache first so it will be regenerated # ideally we'd do this in ModuleLoader, but we need to do this # before that class is loaded... module_cache = Path(config.PATH_ROOT, "backend", "module_cache.pb") if module_cache.exists(): module_cache.unlink() import backend.bootstrap as bootstrap bootstrap.run(as_daemon=True) sys.exit(0) else: # wait a few seconds and see if PIDfile was created and refers to a running process now = time.time() while time.time() < now + 10: if lockfile.is_file(): break else: time.sleep(0.1) if not lockfile.is_file(): print( "...error while starting 4CAT Backend Daemon (lockfile not found)." ) else: with lockfile.open() as file: pid = int(file.read().strip()) if pid in psutil.pids(): print("...4CAT Backend Daemon started.") else: print("...error while starting 4CAT Backend Daemon.") if Path("4cat.stderr").is_file(): with open("4cat.stderr") as errfile: stderr = errfile.read() if stderr: print("---------------------------------\nstderr output:") print(stderr) return True
except Exception: print('error starting ros daemon: {}'.format(traceback.format_exc())) finally: if _daemon is not None: try: _daemon.close() except Exception: print('error closing ros daemon.') print('rosd complete.') # .............................................................................. with daemon.DaemonContext( stdout=sys.stdout, stderr=sys.stderr, # chroot_directory=None, working_directory='/home/pi/ros', umask=0o002, pidfile=pidfile.TimeoutPIDLockFile(PIDFILE), ) as context: # signal_map={ # signal.SIGTERM: shutdown, # signal.SIGTSTP: shutdown # }) as context: main() # call main .................................................................... #if __name__== "__main__": # main() #EOF
import os import sys import confparser import server import daemon import daemon.pidfile as pidlockfile DEFAULT_NAME = "config.json" pidfile = pidlockfile.TimeoutPIDLockFile("/var/run/gluten.pid") with daemon.DaemonContext(pidfile=pidfile): main() def main(): configParser = confparser.ConfigParser(DEFAULT_NAME) config = configParser.main_config server.serve(config) if __name__ == "__main__": main()
def main(): """The main entry point. """ parser = ArgumentParser() parser.add_argument('-a', '--unix-socket-name', default='/var/run/{}.sock'.format(DAEMON_NAME), help='Unix domain socket file name', metavar='UNIX_SOCKET_NAME') parser.add_argument('-d', '--daemonize', action='store_true', help='daemonize the server') parser.add_argument('-H', '--redis-host', default='127.0.0.1', help='Redis server host', metavar='REDIS_HOST') parser.add_argument('-l', '--log-file-prefix', default='', help='path prefix for log files', metavar='LOG_FILE_PREFIX') parser.add_argument('-n', '--channel-name', default='build_status_codes', help='channel which is used for publishing build ' 'status codes to', metavar='CHANNEL_NAME') parser.add_argument('-p', '--pid', default='/var/run/{}.pid'.format(DAEMON_NAME), help='server pid file name', metavar='PID_FILE_NAME') parser.add_argument('-P', '--redis-port', default='6379', help='server pid file name', metavar='REDIS_PORT', type=int) parser.add_argument('-v', '--verbose', action='store_true', help='turn on verbose mode') args = parser.parse_args() util.init_logger(LOGGER, logging.DEBUG if args.verbose else logging.INFO, args.log_file_prefix) if os.path.exists(args.unix_socket_name): LOGGER.fatal('Address already in use') sys.exit(1) else: test_write_perm(os.path.dirname(args.unix_socket_name)) if args.log_file_prefix: test_write_perm(os.path.dirname(args.log_file_prefix)) LOGGER.debug('All log records will be forwarded to %s', args.log_file_prefix) else: LOGGER.debug('No log file will be created') try: bscd = BSCServer(args.unix_socket_name, args.channel_name, redis_host=args.redis_host, redis_port=args.redis_port) except RedisError: LOGGER.fatal('Could not connect to Redis') sys.exit(1) if args.daemonize: test_write_perm(os.path.dirname(args.pid)) LOGGER.debug('Server will be daemonized') # Preserve the fds related to the logger to prevent closing when # daemonizing the server. preserved_fds = [] for handler in LOGGER.handlers: if hasattr(handler, 'stream'): preserved_fds.append(handler.stream.fileno()) # pylint: disable=no-member with DaemonContext(files_preserve=preserved_fds, pidfile=pidfile.TimeoutPIDLockFile(args.pid), working_directory=os.getcwd()): bscd.run() else: bscd.run()
def start(args): """Start an existing service. """ _setup_logging(args) if args.daemon: if os.path.exists(args.pid_file): logging.error("Server already running. Quitting.") sys.exit(1) logger = logging.getLogger() stdout = sys.stdout stderr = sys.stderr context = daemon.DaemonContext( working_directory=args.home, pidfile=pidlockfile.TimeoutPIDLockFile(args.pid_file, 1), files_preserve=[file.stream for file in logger.handlers], stdout=stdout, stderr=stderr, umask=022) try: context.open() except (lockfile.LockTimeout, lockfile.AlreadyLocked): logging.error("Can't obtain a lock on '%s'. Quitting." % args.pid_file) sys.exit(1) else: os.chdir(args.home) # This is our identification token. This will be sent to a core # and later used to verify if we talk between the same parties # or not (useful to determine if core/service was restarted). service_uuid = uuid.uuid4().hex application = tornado.web.Application([ (r"/", handlers.MainHandler), (r"/core/?", handlers.CoreHandler), (r"/engine/?", handlers.EngineHandler), ], service_uuid=service_uuid) server = tornado.httpserver.HTTPServer(application) server.listen(args.port) logging.info("Started service at localhost:%s (pid=%s)" % (args.port, os.getpid())) # We are ready for processing requests from a core server. However, # at this point no one knows about our existence, so lets tell a # selected core server that we exist and we would like to share our # computational resources. # # To achieve this, we will send notification (registration) request # to the selected core sever. The request consists of our URL, our # capabilities (e.g. what engine types we support) and a public key # that will allow later to authenticate the core server. def _on_registred_okay(args, result): """Gets executed when the core responds. """ logging.info("Service has been registered at %s" % args.core_url) def _registration_callback(args): """Gets executed when IOLoop is started. """ proxy = JSONRPCProxy(args.core_url, 'service') proxy.call( 'register', { 'url': args.service_url, 'uuid': service_uuid, 'provider': args.provider, 'description': args.description, }, functools.partial(_on_registred_okay, args)) ioloop = tornado.ioloop.IOLoop.instance() if args.core_url: ioloop.add_callback(functools.partial(_registration_callback, args)) else: logging.warning("Couldn't register this service at any core server.") try: ioloop.start() except KeyboardInterrupt: print # SIGINT prints '^C' so lets make logs more readable except SystemExit: pass # Make sure we clean up after this service here before we quit. It is # important that we explicitly terminate all child processes that were # spawned by this service. Note that in case of SIGKILL we can't do # much and those processes will be kept alive. processes.ProcessManager.instance().killall() logging.info("Stopped service at localhost:%s (pid=%s)" % (args.port, os.getpid()))
def main(): (opts, args) = parse_arguments(sys.argv[1:]) # Rename this process so 'ps' output looks like this is a native # executable. Can not seperate command-line arguments from actual name of # the executable by NUL bytes, so only show the name of the executable # instead. setproctitle.setproctitle("\x00".join(sys.argv)) setproctitle.setproctitle(sys.argv[0]) setup_logging(opts) # Special case for the clean up queues action if opts.purge_queues: purge_queues() return # Special case for the clean up exch action if opts.purge_exchanges: purge_exchanges() return if opts.drain_queue: drain_queue(opts.drain_queue) return # Debug mode, process messages without daemonizing if opts.debug: debug_mode() return # Create pidfile, pidf = pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10) if daemon.runner.is_pidfile_stale(pidf): log.warning("Removing stale PID lock file %s", pidf.path) pidf.break_lock() files_preserve = [] for handler in log.handlers: stream = getattr(handler, 'stream') if stream and hasattr(stream, 'fileno'): files_preserve.append(handler.stream) stderr_stream = None for handler in log.handlers: stream = getattr(handler, 'stream') if stream and hasattr(handler, 'baseFilename'): stderr_stream = stream break daemon_context = daemon.DaemonContext(pidfile=pidf, umask=0022, stdout=stderr_stream, stderr=stderr_stream, files_preserve=files_preserve) try: daemon_context.open() except (pidlockfile.AlreadyLocked, LockTimeout): log.critical("Failed to lock pidfile %s, another instance running?", pidf.path) sys.exit(1) log.info("Became a daemon") if 'gevent' in sys.modules: # A fork() has occured while daemonizing. If running in # gevent context we *must* reinit gevent log.debug("gevent imported. Reinitializing gevent") import gevent gevent.reinit() # Catch every exception, make sure it gets logged properly try: daemon_mode(opts) except Exception: log.exception("Unknown error") raise
def start(args): """Start an existing SDK server. """ _setup_logging(args) if args.daemon: if os.path.exists(args.pid_file): logging.error("Server already running. Quitting.") sys.exit(1) stdout = sys.stdout stderr = sys.stderr context = daemon.DaemonContext( working_directory=args.home, pidfile=pidlockfile.TimeoutPIDLockFile(args.pid_file, 1), files_preserve=list(_iter_logger_streams()), stdout=stdout, stderr=stderr, umask=022) try: context.open() except (lockfile.LockTimeout, lockfile.AlreadyLocked): logging.error("Can't obtain a lock on '%s'. Quitting." % args.pid_file) sys.exit(1) else: os.chdir(args.home) def walk(path): n = len(args.static_path) if not args.static_path.endswith('/'): n += 1 for root, dirs, files in os.walk(path): has_hidden = True while has_hidden: for name in dirs: if name.startswith('.') or name.startswith('_'): dirs.remove(name) break else: has_hidden = False for name in files: if not name.startswith('.') and not name.startswith('_'): yield os.path.join(root[n:], name) modules_css_path = os.path.join(args.static_path, 'css/modules') modules_js_path = os.path.join(args.static_path, 'js/modules') modules = [] for module, cls in args.modules: css_files = sorted(walk(os.path.join(modules_css_path, module))) js_files = sorted(walk(os.path.join(modules_js_path, module))) modules.append((module, cls, css_files, js_files)) logging.info("Enabled module '%s'" % module) app_settings = { 'modules': modules, 'static_path': args.static_path, 'template_loader': tornado.template.Loader(args.templates_path), } from handlers import main, async, client, restful application = tornado.web.Application([ (r"/", main.MainHandler, dict(debug=False)), (r"/debug/?", main.MainHandler, dict(debug=True)), (r"/async/?", async .AsyncHandler), (r"/client/?", client.ClientHandler), (r"/worksheets/([0-9a-f]+)/?", restful.PublishedWorksheetHandler), ], **app_settings) server = tornado.httpserver.HTTPServer(application) server.listen(args.port) logging.info("Started SDK at localhost:%s (pid=%s)" % (args.port, os.getpid())) ioloop = tornado.ioloop.IOLoop.instance() try: ioloop.start() except KeyboardInterrupt: print # SIGINT prints '^C' so lets make logs more readable except SystemExit: pass ProcessManager.instance().killall() logging.info("Stopped SDK at localhost:%s (pid=%s)" % (args.port, os.getpid()))