def _run_swarm_manager(args): containers_config_file = _containers_config_file(args) containers_conf = parse_containers_config(containers_config_file) container_conf = _container_conf(containers_conf, args.swarm) swarm_manager_conf = _swarm_manager_conf(container_conf) _configure_logging(args, swarm_manager_conf) docker_interface = build_container_interfaces(containers_config_file, containers_conf=containers_conf)[args.swarm] pidfile = _swarm_manager_pidfile(swarm_manager_conf) if not args.foreground: _swarm_manager_daemon(pidfile, swarm_manager_conf['log_file'], swarm_manager_conf, docker_interface) else: if swarm_manager_conf['terminate_when_idle']: log.info('running in the foreground, disabling automatic swarm manager termination') swarm_manager_conf['terminate_when_idle'] = False else: log.info("running in the foreground") try: pidfile.acquire() except lockfile.AlreadyLocked: pid = pidfile.read_pid() try: os.kill(pid, 0) log.warning("swarm manager is already running in pid %s", pid) return except OSError: log.warning("removing stale lockfile: %s", pidfile.path) pidfile.break_lock() pidfile.acquire() try: _swarm_manager(swarm_manager_conf, docker_interface) finally: pidfile.release()
def _run_swarm_manager(args): containers_config_file = _containers_config_file(args) containers_conf = parse_containers_config(containers_config_file) container_conf = _container_conf(containers_conf, args.swarm) swarm_manager_conf = _swarm_manager_conf(container_conf) _configure_logging(args, swarm_manager_conf) docker_interface = build_container_interfaces( containers_config_file, containers_conf=containers_conf)[args.swarm] pidfile = _swarm_manager_pidfile(swarm_manager_conf) if not args.foreground: _swarm_manager_daemon(pidfile, swarm_manager_conf['log_file'], swarm_manager_conf, docker_interface) else: if swarm_manager_conf['terminate_when_idle']: log.info( 'running in the foreground, disabling automatic swarm manager termination' ) swarm_manager_conf['terminate_when_idle'] = False else: log.info("running in the foreground") pidfile.acquire() try: _swarm_manager(swarm_manager_conf, docker_interface) finally: pidfile.release()
def start_daemon(): # 전역변수로 처리 필요 config = configparser.ConfigParser() config.read('./config.cfg') cfg_server = config['SERVER_INFO'] cfg_default = config['DEFAULT_INFO'] # make logger instance logger = logging.getLogger("DA_daemonLog") # make formatter formatter = logging.Formatter( '[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s > %(message)s') # make handler to output Log for stream and file fileMaxByte = 1024 * 1024 * 100 #100MB fileHandler = logging.handlers.RotatingFileHandler( cfg_default['test_path'], maxBytes=fileMaxByte, backupCount=10) # fileHandler = logging.FileHandler(cfg_default['logging_path']) streamHandler = logging.StreamHandler() # specify formatter to each handler fileHandler.setFormatter(formatter) streamHandler.setFormatter(formatter) # attach stream and file handler to logger instance logger.addHandler(fileHandler) logger.addHandler(streamHandler) pidfile = PIDLockFile(cfg_default['test_pid_path']) try: pidfile.acquire() except AlreadyLocked: try: os.kill(pidfile.read_pid(), 0) print('Process already running!') exit(1) except OSError: #No process with locked PID pidfile.break_lock() daemon_context = daemon.DaemonContext( working_directory='/home/Toven/da/elda', umask=0o002, pidfile=PIDLockFile('/home/Toven/da/elda_daemon.pid'), ) print("Start daemon for EyeLink in python") with daemon_context: while True: logger.setLevel(logging.INFO) logger.info("==========================") logger.debug("Debug message") logger.info("Info message") logger.warn("Warning message") logger.error("Error message") logger.critical("critical debug message") logger.info("==========================")
def _run_swarm_manager(args): containers_config_file = _containers_config_file(args) containers_conf = parse_containers_config(containers_config_file) container_conf = _container_conf(containers_conf, args.swarm) swarm_manager_conf = _swarm_manager_conf(container_conf) _configure_logging(args, swarm_manager_conf) docker_interface = build_container_interfaces(containers_config_file, containers_conf=containers_conf)[args.swarm] pidfile = _swarm_manager_pidfile(swarm_manager_conf) if not args.foreground: _swarm_manager_daemon(pidfile, swarm_manager_conf['log_file'], swarm_manager_conf, docker_interface) else: if swarm_manager_conf['terminate_when_idle']: log.info('running in the foreground, disabling automatic swarm manager termination') swarm_manager_conf['terminate_when_idle'] = False else: log.info("running in the foreground") pidfile.acquire() try: _swarm_manager(swarm_manager_conf, docker_interface) finally: pidfile.release()
def start(params): stdout = open(params.stdout, 'w') stderr = open(params.stderr, 'w') pidfile = daemon.pidfile.PIDLockFile(params.pidfile) try: pidfile.acquire() print("DaemonContext before") with daemon.DaemonContext(stdout=stdout, stderr=stderr, working_directory=params.wd): print("DaemonContext Starts") print(f"Pidfile aquired {pidfile.path} {pidfile.read_pid()}") cherrypy.quickstart(HelloServer(params)) stdout.close() stderr.close() #pidfile.release() print(f"Exiting DaemonContext {pidfile.path} {pidfile.read_pid()}") print("DaemonContext Ends") print("DaemonContext after") print(f"Pidfile {pidfile.path} {pidfile.read_pid()}") except IOError: print( f"Could not start {params.name} already running as pid {pidfile.read_pid()}" )
directory )) config = yaml.load(file('rtmbot.conf', 'r')) debug = config["DEBUG"] bot = RtmBot(config["SLACK_TOKEN"]) site_plugins = [] files_currently_downloading = [] job_hash = {} if config.has_key("DAEMON"): if config["DAEMON"]: import daemon pidfile = daemon.pidfile.PIDLockFile('/tmp/alfred.pid') pidfile.timeout = 2 try: pidfile.acquire() except LockTimeout: try: os.kill(pidfile.read_pid(), 0) print 'Process already running!' exit(1) except OSError: pidfile.break_lock() with daemon.DaemonContext(pidfile=pidfile ,working_directory=os.getcwd()): main_loop() main_loop()
def main(): # Option handling parser = argparse.ArgumentParser( epilog='ELM327-emulator v' + __version__ + ' - ELM327 OBD-II adapter emulator') parser.prog = "elm" parser.add_argument( '-V', "--version", dest='version', action='store_true', help="print ELM327-emulator version and exit") if os.name != 'nt': parser.add_argument( '-t', "--terminate", dest='terminate', action='store_true', help="terminate the daemon process sending SIGTERM") parser.add_argument( "-d", "--daemon", dest = "daemon_mode", action='store_true', help = "Run ELM327-emulator in daemon mode. ") parser.add_argument( "-b", "--batch", dest="batch_mode", type=argparse.FileType('w'), help="Run ELM327-emulator in batch mode. " "Argument is the output file. " "The first line in that file will be the virtual serial device", default=0, nargs=1, metavar='FILE') parser.add_argument( '-p', '--port', dest = 'serial_port', help = "Set the com0com serial port listened by ELM327-emulator " "when running under windows OS. Default is COM3.", default = ['COM3'], nargs = 1, metavar = 'PORT' ) parser.add_argument( '-a', '--baudrate', dest = 'serial_baudrate', type=int, help = "Set the serial device baud rate used by ELM327-emulator.", default = None, nargs = 1, metavar = 'BAUDRATE' ) parser.add_argument( '-s', '--scenario', dest = 'scenario', help = "Set the scenario used by ELM327-emulator.", default = [''], nargs = 1, metavar = 'SCENARIO' ) parser.add_argument( '-n', '--net', dest = 'net_port', type=int, help = "Set the INET socket port used by ELM327-emulator.", default = None, nargs = 1, metavar = 'INET_PORT' ) parser.add_argument( '-H', '--forward_host', dest = 'forward_net_host', help = "Set the INET host used by ELM327-emulator." "when forwarding the client interaction to a remote OBD-II port.", default = None, nargs = 1, metavar = 'INET_FORWARD_HOST' ) parser.add_argument( '-N', '--forward_port', dest = 'forward_net_port', type=int, help = "Set the INET socket port used by ELM327-emulator " "when forwarding the client interaction to a remote OBD-II port.", default = None, nargs = 1, metavar = 'INET_FORWARD_PORT' ) parser.add_argument( '-S', '--forward_serial_port', dest = 'forward_serial_port', help = "Set the serial device port used by ELM327-emulator " "when forwarding the client interaction to a serial device.", default = None, nargs = 1, metavar = 'FORWARD_SERIAL_PORT' ) parser.add_argument( '-B', '--forward_serial_baudrate', dest = 'forward_serial_baudrate', type=int, help = "Set the device baud rate used by ELM327-emulator " "when forwarding the client interaction to a serial device.", default = None, nargs = 1, metavar = 'FORWARD_SERIAL_BAUDRATE' ) parser.add_argument( '-T', '--forward_timeout', dest = 'forward_timeout', type=float, help = "Set forward timeout as floating number " "(default is 5 seconds).", default = None, nargs = 1, metavar = 'FORWARD_TIMEOUT' ) args = parser.parse_args() if args.version: print(f'ELM327-emulator version {__version__}.') sys.exit(0) # Redirect stdout if args.batch_mode and not args.batch_mode[0].isatty(): sys.stdout = args.batch_mode[0] # Instantiate the class if os.name == 'nt': args.daemon_mode = False args.terminate = False emulator = Elm( batch_mode=args.batch_mode or args.daemon_mode, serial_port=args.serial_port[0], serial_baudrate=args.serial_baudrate[0] if args.serial_baudrate else None, net_port=args.net_port[0] if args.net_port else None, forward_net_host=args.forward_net_host[0] if args.forward_net_host else None, forward_net_port=args.forward_net_port[0] if args.forward_net_port else None, forward_serial_port=args.forward_serial_port[0] if args.forward_serial_port else None, forward_serial_baudrate = args.forward_serial_baudrate[0] if args.forward_serial_baudrate else None, forward_timeout = args.forward_timeout[0] if args.forward_timeout else None) if os.name != 'nt': if os.getuid() == 0: daemon_pid_fname = DAEMON_PIDFILE_DIR_ROOT + DAEMON_PIDFILE else: daemon_pid_fname = DAEMON_PIDFILE_DIR_NON_ROOT + DAEMON_PIDFILE pidfile = daemon.pidfile.PIDLockFile(daemon_pid_fname) pid = pidfile.read_pid() if args.terminate: if pid: print(f'Terminating daemon process {pid}.') try: Ret = os.kill(pid, signal.SIGTERM) except Exception as e: print(f'Error while terminating daemon process {pid}: {e}.') sys.exit(1) if Ret: print(f'Error while terminating daemon process {pid}.') sys.exit(1) else: sys.exit(0) else: print('Cannot terminate daemon process: not running.') sys.exit(0) if args.batch_mode and args.daemon_mode: try: print(emulator.get_pty()) print('ELM327-emulator service STARTED') if args.scenario[0]: set_scenario(emulator, args.scenario[0]) emulator.run() except (KeyboardInterrupt, SystemExit): emulator.terminate() print("\nELM327-emulator service ENDED") sys.exit(0) if args.daemon_mode and not args.batch_mode: if pid: try: pidfile.acquire() pidfile.release() # this might occur only in rare contention cases except AlreadyLocked: try: os.kill(pid, 0) print(f'Process {pid} already running. ' f'Check lockfile "{daemon_pid_fname}".') sys.exit(1) except OSError: #No process with locked PID pidfile.break_lock() print(f"Previous process {pid} terminated abnormally.") except NotLocked: print("Internal error: lockfile", daemon_pid_fname) context = daemon.DaemonContext( working_directory=DAEMON_DIR, umask=DAEMON_UMASK, pidfile=pidfile, detach_process=True, stdout=sys.stdout, stderr=sys.stderr, signal_map={ signal.SIGTERM: lambda signum, frame: emulator.terminate(), signal.SIGINT: lambda signum, frame: emulator.terminate() } ) try: with context: print('ELM327-emulator daemon service STARTED on ', emulator.get_pty()) if args.scenario[0]: set_scenario(emulator, args.scenario[0]) emulator.run() print("\nELM327-emulator daemon service ENDED") except LockFailed as e: print('Internal error: cannot start daemon', e) sys.exit(1) sys.exit(0) if os.name != 'nt' and pid: print(f'Warning: lockfile "{daemon_pid_fname}" reports pid {pid}.') p_elm = None pty_name = None try: with emulator as session: while session.threadState == session.THREAD.STARTING: time.sleep(0.1) if args.net_port: pty_name = "TCP network port " + str(args.net_port[0]) + "." else: pty_name = session.get_pty() if args.batch_mode: print(pty_name) sys.stdout.flush() if session.threadState == session.THREAD.TERMINATED: print('\nELM327-emulator cannot run. Exiting.\n') os._exit(1) # does not raise SystemExit if args.scenario[0]: set_scenario(session, args.scenario[0]) if pty_name == None: print("\nCannot start ELM327-emulator.\n") os._exit(1) # does not raise SystemExit p_elm = Interpreter(session, args) if args.batch_mode: p_elm.cmdloop_with_keyboard_interrupt( 'ELM327-emulator batch mode STARTED\n' 'Begin batch commands.') else: p_elm.cmdloop_with_keyboard_interrupt( 'Welcome to the ELM327 OBD-II adapter emulator.\n' 'ELM327-emulator is running on %s\n' 'Type help or ? to list commands.\n' % pty_name) except (KeyboardInterrupt, SystemExit): if not args.batch_mode and p_elm: p_elm.postloop() print('\n\nExiting.\n') else: print("\nELM327-emulator batch mode ENDED") sys.exit(1)
def main(): # Option handling parser = argparse.ArgumentParser( epilog=f"hostp2pd v.{__version__} - The Wi-Fi Direct " " Session Manager. wpa_cli controller of Wi-Fi " " Direct connections handled by wpa_supplicant.") parser.prog = "hostp2pd" parser.add_argument( "-V", "--version", dest="version", action="store_true", help="print hostp2pd version and exit", ) parser.add_argument( "-v", "--verbosity", dest="verbosity", action="store_true", help="print execution logging", ) parser.add_argument( "-vv", "--debug", dest="debug", action="store_true", help="print debug logging information", ) parser.add_argument( "-t", "--terminate", dest="terminate", action="store_true", help="terminate a daemon process sending SIGTERM", ) parser.add_argument( "-r", "--reload", dest="reload", action="store_true", help="reload configuration of a daemon process sending SIGHUP", ) parser.add_argument( "-c", "--config", dest="config_file", type=argparse.FileType("r"), help="Configuration file.", default=0, nargs=1, metavar="CONFIG_FILE", ) parser.add_argument( "-d", "--daemon", dest="daemon_mode", action="store_true", help="Run hostp2pd in daemon mode. ", ) parser.add_argument( "-b", "--batch", dest="batch_mode", type=argparse.FileType("w"), help="Run hostp2pd in batch mode. " "Argument is the output file. " "Use an hyphen (-) for standard output.", default=0, nargs=1, metavar="FILE", ) parser.add_argument( "-i", "--interface", dest="interface", help="Set the interface managed by hostp2pd.", default=["auto"], nargs=1, metavar="INTERFACE", ) parser.add_argument( "-p", "--run_program", dest="run_program", help="Name of the program to run with start and stop arguments. ", default=[""], nargs=1, metavar="RUN_PROGRAM", ) args = parser.parse_args() if args.version: print(f"hostp2pd version {__version__}.") sys.exit(0) # Redirect stdout if args.batch_mode and not args.batch_mode[0].isatty(): sys.stdout = args.batch_mode[0] # Configuration file if args.config_file and args.config_file[0].name: config_file = args.config_file[0].name else: config_file = None # Debug force_logging = None if args.verbosity: force_logging = logging.INFO if args.debug: force_logging = logging.DEBUG # Instantiate the class hostp2pd = HostP2pD(config_file, args.interface[0], args.run_program[0], force_logging) if os.getuid() == 0: daemon_pid_fname = (DAEMON_PIDFILE_DIR_ROOT + DAEMON_PIDFILE_BASE + args.interface[0] + ".pid") else: daemon_pid_fname = (DAEMON_PIDFILE_DIR_NON_ROOT + DAEMON_PIDFILE_BASE + args.interface[0] + ".pid") pidfile = daemon.pidfile.PIDLockFile(daemon_pid_fname) pid = pidfile.read_pid() if args.terminate: if pid: print(f"Terminating daemon process {pid}.") try: Ret = os.kill(pid, signal.SIGTERM) except Exception as e: print(f"Error while terminating daemon process {pid}: {e}.") sys.exit(1) if Ret: print(f"Error while terminating daemon process {pid}.") sys.exit(1) else: sys.exit(0) else: print("Cannot terminate daemon process: not running.") sys.exit(0) if args.reload: if pid: print(f"Reloading configuration file for daemon process {pid}.") try: Ret = os.kill(pid, signal.SIGHUP) except Exception as e: print(f"Error while reloading configuration file " f"for daemon process {pid}: {e}.") sys.exit(1) if Ret: print(f"Error while reloading configuration file " f"for daemon process {pid}.") sys.exit(1) else: sys.exit(0) else: print("Cannot reload the configuration of the daemon process: " "not running.") sys.exit(0) if args.daemon_mode and not args.batch_mode: if pid: try: pidfile.acquire() pidfile.release( ) # this might occur only in rare contention cases except AlreadyLocked: try: os.kill(pid, 0) print(f"Process {pid} already running" f' on the same interface "{args.interface[0]}". ' f'Check lockfile "{daemon_pid_fname}".') sys.exit(1) except OSError: # No process with locked PID pidfile.break_lock() print(f"Previous process {pid} terminated abnormally.") except NotLocked: print("Internal error: lockfile", daemon_pid_fname) context = daemon.DaemonContext( working_directory=DAEMON_DIR, umask=DAEMON_UMASK, pidfile=pidfile, detach_process=True, stdin=sys.stdin if args.debug else None, stdout=sys.stdout if args.debug else None, stderr=sys.stderr if args.debug else None, signal_map={ signal.SIGTERM: lambda signum, frame: hostp2pd.terminate(), signal.SIGINT: lambda signum, frame: hostp2pd.terminate(), signal.SIGHUP: lambda signum, frame: hostp2pd.read_configuration( configuration_file=hostp2pd.config_file, do_activation=True), }, ) try: with context: print("hostp2pd daemon service STARTED") hostp2pd.run() print("\nhostp2pd daemon service ENDED") except LockFailed as e: print("Internal error: cannot start daemon", e) sys.exit(1) sys.exit(0) if pid: print(f'Warning: lockfile "{daemon_pid_fname}" reports pid {pid}.') if args.batch_mode and args.daemon_mode: print("hostp2pd service STARTED") signal.signal( signal.SIGHUP, lambda signum, frame: hostp2pd.read_configuration( configuration_file=hostp2pd.config_file, do_activation=True), ) try: hostp2pd.run() except (KeyboardInterrupt, SystemExit): hostp2pd.terminate() print("\nhostp2pd service ENDED") sys.exit(0) else: w_p2p_interpreter = None try: with hostp2pd as session: if hostp2pd.process == None or hostp2pd.process.pid == None: print("\nCannot start hostp2pd.\n") os._exit(1) # does not raise SystemExit while hostp2pd.threadState == hostp2pd.THREAD.STARTING: time.sleep(0.1) if not args.batch_mode: logging.info(f"\n\nhostp2pd (v{__version__}) " "started in interactive mode.\n") sys.stdout.flush() w_p2p_interpreter = Interpreter(hostp2pd, args) if args.batch_mode: w_p2p_interpreter.cmdloop_with_keyboard_interrupt( "hostp2pd batch mode STARTED\n" "Begin batch commands.") else: w_p2p_interpreter.cmdloop_with_keyboard_interrupt( "Welcome to hostp2pd - " "The Wi-Fi Direct Session Manager.\n" "Copyright (c) Ircama 2021 - CC BY-NC-SA 4.0.\n" "https://github.com/Ircama/hostp2pd\n" "hostp2pd is running in interactive mode.\n" "Type help or ? to list commands.\n") except (KeyboardInterrupt, SystemExit): if not args.batch_mode and w_p2p_interpreter: w_p2p_interpreter.postloop() print("\nExiting.\n") else: print("hostp2pd batch mode ENDED.") sys.exit(1)