def run(self) -> None: logger.debug('Running Daemon: {}'.format(self._isAlive)) set_proctitle('UDSActorDaemon') # Linux daemon will continue running unless something is requested to # Unmanaged services does not initializes "on start", but rather when user logs in (because userservice does not exists "as such" before that) if self.isManaged(): if not self.initialize(): self.finish() return # Stop daemon if initializes told to do so # logger.debug('Initialized, setting ready') # Initialization is done, set machine to ready for UDS, communicate urls, etc... self.setReady() # Start listening for petitions self.startHttpServer() # ********************* # * Main Service loop * # ********************* # Counter used to check ip changes only once every 10 seconds, for # example counter = 0 while self._isAlive: counter += 1 try: if counter % 5 == 0: self.loop() except Exception as e: logger.error('Got exception on main loop: %s', e) # In milliseconds, will break self.doWait(1000) self.finish()
def run(self) -> None: logger.debug('Running Daemon: {}'.format(self._isAlive)) set_proctitle('UDSActorDaemon') # Linux daemon will continue running unless something is requested to if not self.initialize(): self.finish() return # Stop daemon if initializes told to do so # logger.debug('Initialized, setting ready') # Initialization is done, set machine to ready for UDS, communicate urls, etc... self.setReady() # ********************* # * Main Service loop * # ********************* # Counter used to check ip changes only once every 10 seconds, for # example counter = 0 while self._isAlive: counter += 1 try: if counter % 5 == 0: self.loop() except Exception as e: logger.error('Got exception on main loop: %s', e) # In milliseconds, will break self.doWait(1000) self.finish()
def run(self): logger.debug('** Running Daemon **') set_proctitle('OGAgent') self.initialize() # Call modules initialization # They are called in sequence, no threading is done at this point, so ensure modules onActivate always returns # ********************* # * Main Service loop * # ********************* # Counter used to check ip changes only once every 10 seconds, for # example try: while self.isAlive: # In milliseconds, will break self.doWait(1000) except (KeyboardInterrupt, SystemExit) as e: logger.error('Requested exit of main loop') except Exception as e: logger.exception() logger.error('Caught exception on main loop: {}'.format(e)) self.terminate() self.notifyStop()
async def valami(nev): prctl.set_proctitle(nev) print(f"{nev} start") await asyncio.sleep(10) for i in range(2**32): prctl.set_proctitle(f"{nev}{i}") print(f"{nev} stop")
def worker(self): lock = lockfile.FileLock(self.pidfile_path()) lock.acquire(0) try: self.pidfile_create() try: import prctl prctl.set_proctitle('CONTROL/defer/%s' % config.main.product_name) except ImportError: pass env = os.environ env['PYTHONPATH'] = config.main.basedir params = ['celery', 'worker', '--pool=gevent', '--loader=util.defer.Loader', '--logfile=logs/defer.log', '--loglevel=INFO', ] stdin = open('/dev/null', 'r') stdout = open(os.path.join(config.main.basedir, config.main.log_dir, 'service_defer.out'), 'a+') stderr = open(os.path.join(config.main.basedir, config.main.log_dir, 'service_defer.err'), 'a+') self.defer_process = subprocess.Popen(params, stdin=stdin, stdout=stdout, stderr=stderr, cwd=config.main.basedir, env=env) stdin.close() stdout.close() stderr.close() self.defer_process.wait() del self.defer_process finally: self.pidfile_destroy() lock.release()
def set_proc_name(new_name): # {{{ try: import prctl prctl.set_proctitle(new_name) prctl.set_name(new_name) except: logging.warning("Unable to set proc name %s:"%new_name, exc_info=True)
def worker(self): lock = lockfile.FileLock(self.pidfile_path()) lock.acquire(0) try: self.pidfile_create() try: import prctl prctl.set_proctitle('CONTROL/db_mongo/%s' % config.main.product_name) except ImportError: pass env = os.environ params = ['mongod', '--nohttpinterface', '--auth', '--logpath', os.path.join(config.main.basedir, config.main.log_dir, 'service_db_mongo.log'), '--logappend', '--dbpath', config.main.db_mongo['dir'], '--port', str(config.main.db_mongo['port'])] if (not config.stage or config.stage == ('live', )) and config.main.db_mongo['journal']: params.append('--journal') stdin = open('/dev/null', 'r') stdout = open('/dev/null', 'a+') stderr = open('/dev/null', 'a+') self.db_mongo_process = subprocess.Popen(params, stdin=stdin, stdout=stdout, stderr=stderr, cwd=config.main.basedir, env=env) stdin.close() stdout.close() stderr.close() self.db_mongo_process.wait() del self.db_mongo_process finally: self.pidfile_destroy() lock.release()
def set_process_cmdline(proc_title): """Sets custom title to current process Requires installed python-prctl module - http://pythonhosted.org/python-prctl/ """ try: import prctl prctl.set_proctitle(proc_title) return True except (ImportError, AttributeError): return False
def set_process_title(proc_title): """Sets custom title to current process Requires installed python-prctl module - http://pythonhosted.org/python-prctl/ """ try: import prctl prctl.set_name(proc_title) prctl.set_proctitle(proc_title) return True except (ImportError, AttributeError): return False
def test_proctitle(self): """Test setting the process title, including too long titles""" title = "This is a test!" prctl.set_proctitle(title) ps_output = subprocess.Popen(['ps', '-f', '-p', '%d' % os.getpid()], stdout=subprocess.PIPE).communicate()[0].decode('ascii') self.assertTrue(ps_output.strip().endswith(title)) # This should not segfault but truncate title2 = "And this is a test too! Don't segfault." prctl.set_proctitle(title2) ps_output = subprocess.Popen(['ps', '-f', '-p', '%d' % os.getpid()], stdout=subprocess.PIPE).communicate()[0].decode('ascii') self.assertTrue(ps_output.strip().endswith(title2[:len(title)]))
def main(): # noinspection PyUnresolvedReferences prctl.set_name('networkd_main') prctl.set_proctitle('networkd') options.parse_command_line() dm = DeviceManager() application = Application([ (r"/devices", DeviceInfoHandler, dict(ethmanager=dm)), (r"/devices/([0-9]+)", DeviceInfoHandler, dict(ethmanager=dm)), (r"/devices/actions/(.+)", DevicesActionHandler, dict(ethmanager=dm)), (r"/devices/([0-9]+)/actions/(.+)", DeviceActionHandler, dict(ethmanager=dm)), ]) application.listen(8888) IOLoop.instance().start()
def test_proctitle(self): """Test setting the process title, including too long titles""" with open('/proc/self/cmdline') as fd: orig = len(fd.read()) title = "This is a test!" prctl.set_proctitle(title) with open('/proc/self/cmdline') as fd: cmdline = fd.read().rstrip('\n\0') self.assertEqual(cmdline, title) # This should not segfault title2 = "And this is a test too! Don't segfault." * 3 prctl.set_proctitle(title2) with open('/proc/self/cmdline') as fd: cmdline = fd.read().rstrip('\n\0') self.assertEqual(cmdline, title2[:orig-1])
def main(): #if __name__ == "__main__": try: import prctl if len(sys.argv) == 1: prctl.set_proctitle("mantid") else: prctl.set_proctitle("mantid " + " ".join(sys.argv[1:])) except: pass global app Gtk.init() app = App() app.setup() Gtk.main()
def start_process(cycle, name_list, ip_list): """ 启动子进程,执行主进程循环,清理过期日志文件。 :param cycle: 整型,保存多少天的log。 :param name_list: 字符串列表,主机名称列表。 :param ip_list: 字符串列表,IP地址列表。 :return: """ process_list = [] logging.info("Check logs directory structure.") logging.debug("Turn to check_logs_path().") if check_logs_path(name_list): logging.info("Check logs directory structure OK.") logging.info("Begin to start subprocess.") ppid = str(os.getpid()) for (i, n) in enumerate(name_list): process = multiprocessing.Process(name=n, target=ping_write_log, args=(n, ip_list[i], ppid)) process.daemon = True process.start() logging.info("Start subprocess, PPID:%s, PID:%s, HOST:%s, IP:%s." % (ppid, str(process.pid), n, ip_list[i])) process_list.append(process) logging.debug("Turn to create_pid_file().") create_pid_file(name_list, ppid, process_list) first_day = datetime.datetime.now().date() prctl.set_proctitle(prctl.get_name() + " " + sys.argv[0] + " -d") logging.info("Main process run loop task.") while True: day_temp = datetime.datetime.now().date() if day_temp > first_day: first_day = day_temp logging.info("Clean expired logs.") clean_log(cycle, name_list) logging.info("Clean expired logs OK.") else: time.sleep(3600) else: logging.error("Check logs directory structure error. Program exit.")
def setprocname(name): """Set the process name if possible. Requires setproctitle (python-setproctitle) from https://github.com/dvarrazzo/py-setproctitle (preferred) or python-prctl (debian package) from https://github.com/seveas/python-prctl . """ try: import setproctitle setproctitle.setproctitle(name) except ImportError: try: import prctl # for ps and top, up to 16 bytes long prctl.set_name(name) # for ps aux and top -c # will silently truncate to **argv (see docs) prctl.set_proctitle(name) except ImportError: return
def __init__(self, ID, connections_filename): super(AbstractKnot, self).__init__() prctl.set_proctitle(self._name + '-' + str(ID)) self._ID = str(ID) self.__connections_filename = connections_filename self._ips_and_ports = None self.__ip = None self.__port = None self._listeningSocket = None self._neighbours = {} self._system_random = SystemRandom() #init logging self.logger = Logger(__name__ + '-' + str(ID)) formatter = logging.Formatter('%(name)s %(levelname)s %(asctime)s: %(message)s') filehandler = FileHandler('./Logging/' + self._name + '-' + str(ID) + '.log', 'w') filehandler.setFormatter(formatter) filehandler.setLevel(logging.NOTSET) for hdlr in self.logger.handlers: # remove all old handlers self.logger.removeHandler(hdlr) self.logger.addHandler(filehandler)
def worker(self): lock = lockfile.FileLock(self.pidfile_path()) lock.acquire(0) try: self.pidfile_create() try: import prctl prctl.set_proctitle('CONTROL/web/%s' % config.main.product_name) except ImportError: pass import multiprocessing try: proc_count = multiprocessing.cpu_count() except NotImplementedError: proc_count = 1 env = os.environ env['PYTHONPATH'] = config.main.basedir params = ['gunicorn', '--workers=%d' % (proc_count + 1), '--max-requests=1000', '--bind=:%d' % config.main.port_web, '--worker-class=gevent', 'util.web.publisher:Request', ] stdin = open('/dev/null', 'r') stdout = open(os.path.join(config.main.basedir, config.main.log_dir, 'service_web.out'), 'a+') stderr = open(os.path.join(config.main.basedir, config.main.log_dir, 'service_web.err'), 'a+') self.web_process = subprocess.Popen(params, stdin=stdin, stdout=stdout, stderr=stderr, cwd=config.main.basedir, env=env, ) stdin.close() stdout.close() stderr.close() self.web_process.wait() del self.web_process finally: self.pidfile_destroy() lock.release()
def run(self): initCfg() logger.debug('Running Daemon') set_proctitle('UDSActorDaemon') # Linux daemon will continue running unless something is requested to if self.interactWithBroker() is False: logger.debug('Interact with broker returned false, stopping service after a while') return if self.isAlive is False: logger.debug('The service is not alive after broker interaction, stopping it') return if self.rebootRequested is True: logger.debug('Reboot has been requested, stopping service') return self.initIPC() # ********************* # * Main Service loop * # ********************* # Counter used to check ip changes only once every 10 seconds, for # example counter = 0 while self.isAlive: counter += 1 if counter % 10 == 0: self.checkIpsChanged() # In milliseconds, will break self.doWait(1000) self.endIPC() self.endAPI() self.notifyStop()
sys.excepthook = MailException reactor.run() def daemon_reload(self): rpc_server.load_lists() def daemon_shutdown(self): global quitting global subprocesses quitting = True for pid in subprocesses: os.kill(pid, signal.SIGINT) subprocesses = [] prctl.set_proctitle("tor2web") t2w_daemon = T2WDaemon() t2w_daemon.daemon_init = daemon_init t2w_daemon.daemon_main = daemon_main t2w_daemon.daemon_reload = daemon_reload t2w_daemon.daemon_shutdown = daemon_shutdown t2w_daemon.run(config.datadir) exit(0)
def run(self): cfg = initCfg() # Gets a local copy of config to get "reboot" logger.debug('CFG: {}'.format(cfg)) if cfg is not None: self.rebootMachineAfterOp = cfg.get('reboot', True) else: self.rebootMachineAfterOp = False logger.info('Reboot after is {}'.format(self.rebootMachineAfterOp)) logger.debug('Running Daemon') set_proctitle('UDSActorDaemon') # Linux daemon will continue running unless something is requested to while True: brokerConnected = self.interactWithBroker() if brokerConnected is False: logger.debug('Interact with broker returned false, stopping service after a while') return elif brokerConnected is True: break # If brokerConnected returns None, repeat the cycle self.doWait(16000) # Wait for a looong while if self.isAlive is False: logger.debug('The service is not alive after broker interaction, stopping it') return if self.rebootRequested is True: logger.debug('Reboot has been requested, stopping service') return # Execute script in /etc/udsactor/post after interacting with broker, if no reboot is requested ofc # This will be executed only when machine gets "ready" try: if os.path.isfile(POST_CMD): if (os.stat(POST_CMD).st_mode & stat.S_IXUSR) != 0: subprocess.call([POST_CMD, ]) else: logger.info('POST file exists but it it is not executable (needs execution permission by root)') else: logger.info('POST file not found & not executed') except Exception as e: # Ignore output of execution command logger.error('Executing post command give') self.initIPC() # ********************* # * Main Service loop * # ********************* # Counter used to check ip changes only once every 10 seconds, for # example counter = 0 while self.isAlive: counter += 1 if counter % 10 == 0: self.checkIpsChanged() # In milliseconds, will break self.doWait(1000) self.endIPC() self.endAPI() self.notifyStop()
def set_processname(name): '''Set Process Name :: Linux''' prctl.set_name(name) prctl.set_proctitle(name)
def worker(self): lock = lockfile.FileLock(self.pidfile_path()) lock.acquire(0) try: self.pidfile_create() try: import prctl prctl.set_proctitle('CONTROL/db_cache/%s' % config.main.product_name) except ImportError: pass env = os.environ params = ['redis-server', '-'] stdin = open('/dev/null', 'r') stdout = open(os.path.join(config.main.basedir, config.main.log_dir, 'service_cache.out'), 'a+') stderr = open(os.path.join(config.main.basedir, config.main.log_dir, 'service_cache.err'), 'a+') self.db_cache_process = subprocess.Popen(params, stdin=subprocess.PIPE, stdout=stdout, stderr=stderr, cwd=config.main.basedir, env=env) self.db_cache_process.stdin.write('\ port %(port)d\n\ timeout 300\n\ \ loglevel notice\n\ logfile stdout\n\ \ databases 16\n\ \ save 900 1\n\ save 300 10\n\ save 60 10000\n\ \ rdbcompression yes\n\ \ dir %(dir)s\n\ dbfilename dump.rdb\n\ \ slave-serve-stale-data yes\n\ \ appendonly no\n\ appendfsync everysec\n\ no-appendfsync-on-rewrite no\n\ vm-enabled no\n\ \ vm-swap-file redis.swap\n\ \ vm-max-memory 0\n\ vm-page-size 32\n\ vm-pages 134217728\n\ vm-max-threads 4\n\ hash-max-zipmap-entries 512\n\ hash-max-zipmap-value 64\n\ list-max-ziplist-entries 512\n\ list-max-ziplist-value 64\n\ set-max-intset-entries 512\n\ activerehashing yes\n\ ' % {'port': config.main.db_cache['port'], 'dir': os.path.join(config.main.basedir, config.main.db_cache['dir'])}) self.db_cache_process.stdin.close() stdout.close() stderr.close() self.db_cache_process.wait() del self.db_cache_process finally: self.pidfile_destroy() lock.release()
log("Opening DB") initdb() server = dbus.Interface( bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ), avahi.DBUS_INTERFACE_SERVER ) log("Advertisement setup done") print serviceType server.connect_to_signal( "StateChanged", server_state_changed ) server_state_changed( server.GetState() ) sbrowser = dbus.Interface( bus.get_object(avahi.DBUS_NAME, server.ServiceBrowserNew( avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, serviceType, 'local', dbus.UInt32(0))), avahi.DBUS_INTERFACE_SERVICE_BROWSER) sbrowser.connect_to_signal("ItemNew", new_service) sbrowser.connect_to_signal("ItemRemove", remove_service) log("Discovery setup done") prctl.set_proctitle(prosessinimi) #Kun saadaan sigTERM, lopetetaan signal.signal(signal.SIGTERM, stop) gobject.MainLoop().run() group.Free()
log.startLogging(sys.stdout) else: log.startLogging(log.NullFile) sys.excepthook = MailException reactor.run() def daemon_reload(self): rpc_server.load_lists() def daemon_shutdown(self): global quitting quitting = True prctl.set_proctitle("tor2web") t2w_daemon = T2WDaemon() t2w_daemon.daemon_init = daemon_init t2w_daemon.daemon_main = daemon_main t2w_daemon.daemon_reload = daemon_reload t2w_daemon.daemon_shutdown = daemon_shutdown t2w_daemon.run(config.datadir) exit(0)
# we do not want all workers to die in the same moment requests_countdown = config['requests_per_process'] / random.randint(3, 5) sys.excepthook = MailException def SigQUIT(SIG, FRM): reactor.stop() args = sys.argv[1:] if len(sys.argv[1:]) != 2: exit(1) ports = [] requests_countdown = 10000 / random.randint(3, 5) rpc_factory = pb.PBClientFactory() reactor.connectTCP("127.0.0.1", 8789, rpc_factory) signal.signal(signal.SIGUSR1, SigQUIT) signal.signal(signal.SIGTERM, SigQUIT) signal.signal(signal.SIGINT, SigQUIT) prctl.set_pdeathsig(signal.SIGINT) prctl.set_proctitle("tor2web-worker") start() reactor.run() exit(0)
def start(args): prctl.set_proctitle('mg-main') prctl.set_name('mg-main') if args.config: settings.load(args.config) if args.debug: settings.log_level = 'debug' configure_logging(settings) settings.create_dirs() from mg.fluidsynth.api import FluidSynth from mg.state import State from mg.controller import SynthController, SystemController, MIDIController state = State(settings) menu, input_manager, event_handler = start_ui(state, settings, args.debug) fluid = FluidSynth(settings.sound_dir) synth_ctrl = SynthController(fluid, state) synth_ctrl.start_listening() system_ctrl = SystemController(state, settings) system_ctrl.start_listening() system_ctrl.set_string_led(0, False) system_ctrl.set_string_led(1, False) system_ctrl.set_string_led(2, False) system_ctrl.update_udc_configuration() midi_ctrl = MIDIController(input_manager) midi_ctrl.start_listening() menu.message('Starting synthesizer') start_fluidsynth( fluid, dump_midi=args.dump_midi, debug=args.debug_fs) menu.message('Starting core') from mg.mglib import mgcore mgcore.start() mgcore.add_fluid_output(fluid.synth) mgcore.enable_fluid_output() menu.message('Opening database') from mg import db import logging log = logging.getLogger() db_path = os.path.join(settings.data_dir, 'mg.db') try: db.initialize(db_path) except Exception: log.exception('Unable to initialize database!') db.migrate(db_path) # restore key calibration from mg.input import calibration key_calib = calibration.load_keys() calibration.commit_keys(key_calib) # restore mapping ranges for name in mgcore.get_mapping_configs().keys(): ranges = db.load_mapping_ranges(name) if ranges: mgcore.set_mapping_ranges(name, ranges) # set default global settings state.main_volume = 120 state.reverb_volume = 25 state.preset.keynoise[0].volume = 25 state.coarse_tune = 0 state.fine_tune = 0 state.ui.brightness = 80 state.synth.gain = 50 state.pitchbend_range = 100 # restore misc config misc = db.load_misc_config() if misc: state.from_misc_dict(misc) try: preset = db.Preset.get() # noqa menu.message(f'Loading preset {preset.number}...') with state.lock(): state.load_preset(preset.id) except db.Preset.DoesNotExist: pass menu.message('Starting server') start_server(state, menu) menu.goto('home') input_manager.start() event_handler.mainloop()
def main(): global daemon global verbose # Parse command line arguments try: opts, cmds = getopt.getopt(sys.argv[1:], 'dhv', ['daemon', 'help', 'verbose']) except getopt.GetoptError as e: print(f'{SCRIPT_NAME}:', e, file=sys.stderr, flush=True) print(f"Try '{SCRIPT_NAME} --help' for more information", file=sys.stderr, flush=True) sys.exit(1) # Process options (e.g. -h, --verbose) for o, v in opts: if o in ('-d', '--daemon'): daemon = True elif o in ('-h', '--help'): usage() elif o in ('-v', '--verbose'): verbose = True else: # This shouldn't ever happen unless we forget to handle an # option we've added print(f'{SCRIPT_NAME}: internal error: unhandled option {o}', file=sys.stderr, flush=True) sys.exit(1) # Process commands # This script does not use any commands so we will exit if one is # incorrectly provided if len(cmds) > 0: print(f"{SCRIPT_NAME}: command '{c}' not recognized", file=sys.stderr, flush=True) print(f"Try '{SCRIPT_NAME} --help' for more information", file=sys.stderr, flush=True) sys.exit(1) # Set process name and title # This allows commands like `killall SCRIPT_NAME` to function # correctly try: import prctl if verbose: print(f'setting process name to \'{SCRIPT_NAME}\'', flush=True) prctl.set_name(SCRIPT_NAME) prctl.set_proctitle(' '.join(sys.argv)) except ImportError: if verbose: print(f'failed to load module \'prctl\'', flush=True) print(f'process name not set', flush=True) if daemon: # Listen for changes on the BlueZ dbus interface # This is a catch all listener (no path specified) because we # want to get notified for all adapters without keeping a list # of them and managing signal handlers independantly bus.add_signal_receiver( properties_changed_handler, signal_name='PropertiesChanged', dbus_interface='org.freedesktop.DBus.Properties', bus_name='org.bluez', path=None, path_keyword='path') # Attempt to connect to devices on all existing adapters connect_devices_for_all_adapters() # Start the mainloop loop.run() else: # Attempt to connect to devices on all existing adapters connect_devices_for_all_adapters() # If we're waiting for connection attemps to finish, start the # mainloop. We will automatically exit the loop once everything # is finished if len(pending_connections) > 0: loop.run()
def main() -> None: prctl.set_name('odrd') prctl.set_proctitle(' '.join(sys.argv)) parser = OptionParser() parser.add_option( "-c", "--config", dest="config_file", help="Configuration file", default=CONFIG_FILE, ) parser.add_option( "--debug", dest="debug", action="store_true", help="Activate debug logging", default=False, ) parser.add_option( "--keep-user", dest="keep_user", action="store_true", help="Do not switch to a different UID / GID; ignore capabilities", default=False, ) (options, args) = parser.parse_args() if len(args) != 0: parser.error("incorrect number of arguments") cfg = ConfigParser() cfg.read(options.config_file) loglevel = logging.INFO if options.debug: loglevel = logging.DEBUG setup_logging(loglevel, cfg.getboolean('daemon', 'syslog', fallback=False)) prom_port = cfg.getint("daemon", "prometheus_port", fallback=0) if prom_port: logging.debug("starting prometheus exporter on port %s", prom_port) start_http_server(prom_port) if not options.keep_user: # Capability net_raw is needed for binding to network devices. # Capability net_bind_service is needed for binding to the DHCP port. drop_caps( user=cfg.get('daemon', 'user', fallback=None), group=cfg.get('daemon', 'group', fallback=None), caps=['net_raw', 'net_bind_service'], ) default_dhcp_device = cfg.get('daemon', 'default_dhcp_listening_device', fallback=None) realms_data = read_realms(cfg, default_dhcp_device) if realms_data is None: sys.exit(1) sloop = SocketLoop() def exit_daemon(*args) -> None: """Signal handler performing a soft shutdown of the loop. """ logging.info('exiting on signal') sloop.quit() signal.signal(signal.SIGTERM, exit_daemon) signal.signal(signal.SIGHUP, signal.SIG_IGN) timeout_mgr = TimeoutManager() sloop.add_idle_handler(timeout_mgr.check_timeouts) requestor_mgr = odr.dhcprequestor.DhcpAddressRequestorManager() servers = read_servers(cfg, sloop) for server in servers.values(): ovpn.OvpnServerSupervisor( timeout_mgr=weakref.proxy(timeout_mgr), server=weakref.proxy(server), timeout=30, ) def start_dhcp_address_request(device, local_ip, **kwargs) -> None: requestor = requestor_mgr.get_requestor(device, local_ip) if requestor is None: return request = odr.dhcprequestor.DhcpAddressInitialRequest( timeout_mgr=weakref.proxy(timeout_mgr), requestor=weakref.proxy(requestor), local_ip=local_ip, **kwargs) requestor.add_request(request) def start_dhcp_refresh_request(device, local_ip, **kwargs) -> None: requestor = requestor_mgr.get_requestor(device, local_ip) if requestor is None: return request = odr.dhcprequestor.DhcpAddressRefreshRequest( timeout_mgr=weakref.proxy(timeout_mgr), requestor=weakref.proxy(requestor), local_ip=local_ip, **kwargs) requestor.add_request(request) parse_username = ParseUsername( default_realm=cfg.get('daemon', 'default_realm')) client_mgr = OvpnClientManager( timeout_mgr=timeout_mgr, servers=servers, refresh_lease_clb=start_dhcp_refresh_request, realms_data=realms_data, parse_username_clb=parse_username.parse_username, ) def create_vpn_cmd_conn(sloop, sock) -> OvpnCmdConn: return OvpnCmdConn( sloop, sock, realms_data=realms_data, servers=servers, secret=cfg.get('daemon', 'secret', fallback=None), create_client_clb=client_mgr.create_client, remove_client_clb=client_mgr.client_disconnected, add_request_clb=start_dhcp_address_request, parse_username_clb=parse_username.parse_username, ) cmd_socket_uids = [ user_to_uid(user) for user in split_cfg_list( cfg.get('daemon', 'cmd_socket_uids', fallback='')) ] cmd_socket_gids = [ group_to_gid(group) for group in split_cfg_list( cfg.get('daemon', 'cmd_socket_gids', fallback='')) ] def cmd_conn_auth_check(sock, pid, uid, gid) -> bool: if uid in cmd_socket_uids: return True if gid in cmd_socket_gids: return True return False cmd_socket_perms = int( cfg.get('daemon', 'cmd_socket_perms', fallback='0666'), 8) for unix_socket_fn in split_cfg_list( cfg.get('daemon', 'cmd_sockets', fallback='')): cmd_listener = CommandConnectionListener( sloop=weakref.proxy(sloop), socket_path=unix_socket_fn, cmd_conn_factory=create_vpn_cmd_conn, socket_perm_mode=cmd_socket_perms, auth_check=cmd_conn_auth_check, ) sloop.add_socket_handler(cmd_listener) if not load_requestors(sloop, requestor_mgr, realms_data): sys.exit(1) if not options.keep_user: # Special capabilities no longer necessary. drop_caps() try: sloop.run() except Exception: logging.exception('Caught exception in main loop, exiting.') sys.exit(1)
assemble(job1, debug=True) quit() #update options for (assembler_name, assembler_module) in assembler_dict.items(): if not query("SELECT option_value FROM assembly_options WHERE option_value = '{}';".format(assembler_name)): query("INSERT INTO assembly_options (option_type, option_value, option_description) VALUES ('assembler', '{}', '{} (Supports {})');".format(assembler_name, assembler_module.description.encode('string_escape'), ', '.join(assembler_module.supports))) for (trimmer, trim_func) in trimmer_dict.items(): if not query("SELECT option_value FROM assembly_options WHERE option_value = '{}';".format(trimmer)): query("INSERT INTO assembly_options (option_type, option_value, option_description, option_supports) VALUES ('trimmer', '{}', '{}', 'All');".format(trimmer, str(trim_func.__doc__).encode('string_escape'))) #run assemblies try: import prctl prctl.set_proctitle('Assem_dispatch') if '-nodaemon' in sys.argv: #raise ValueError main() quit() raise ValueError() import daemon print "Daemon module successfully imported; running in daemon mode." with daemon.DaemonContext(working_directory='/', detach_process=True, stdout=open('/data/Pipeline_jobs/assembly.log', 'a')): main(True) except (ImportError, ValueError) as e: print "Daemon module not found; running in normal mode." print e main(False)
def daemonize(self): """ do the UNIX double-fork magic, see Stevens' "Advanced Programming in the UNIX Environment" for details (ISBN 0201563177) http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16 """ if self.interactive: return try: pid = os.fork() if pid > 0: # exit first parent sys.exit(0) except OSError as e: sys.stderr.write("fork #1 failed: {0:d} ({1})\n".format(e.errno, e.strerror)) raise DaemonError("Fork #1 failed") # decouple from parent environment os.chdir("/") os.setsid() os.umask(0) # do second fork try: pid = os.fork() if pid > 0: # exit from second parent sys.exit(0) except OSError as e: sys.stderr.write("fork #2 failed: {0:d} ({1})\n".format(e.errno, e.strerror)) raise DaemonError("Fork #2 failed") # redirect standard file descriptors sys.stdout.flush() sys.stderr.flush() self.stderr_mode = 'w+' si = open(self.stdin, 'r') so = open(self.stdout, self.stdout_mode) if 'b' in self.stderr_mode.lower(): se = open(self.stderr, self.stderr_mode, 0) else: se = open(self.stderr, self.stderr_mode) os.dup2(si.fileno(), sys.stdin.fileno()) os.dup2(so.fileno(), sys.stdout.fileno()) os.dup2(se.fileno(), sys.stderr.fileno()) # set name if self.name is not None: try: if HAS_PRCTL: prctl.set_name(self.name) prctl.set_proctitle(self.name) else: from ctypes import cdll libc = cdll.LoadLibrary("libc.so.6") libc.prctl(15, self.name, 0, 0, 0) except: pass # write lock atexit.register(self._release_lock) self.lock_file.acquire(blocking=self.lock_blocking, timeout=self.lock_timeout) self._write_lock_data()
def ping_write_log(name, dst_ip, ppid): """ 子进程函数,ping目标IP,并写入log文件,log文件为 名称_日期.log,例如:test1_20160815.log。 :param name:字符串,配置文件里IP地址列表的名称。 :param dst_ip:字符串,需要ping的目标IP地址。 :param ppid: 字符串,父进程的PID。 :return: """ first_day = datetime.datetime.now().date() prctl.set_proctitle("ping " + name) while True: if check_pid(ppid): day_temp = datetime.datetime.now().date() log_path = LOGS_PATH + os.sep + name + os.sep + name + "_" + datetime.datetime.now( ).strftime("%Y%m%d") + ".log" with open(log_path, mode="a") as log_file: before = datetime.datetime.now() while first_day == day_temp: if check_pid(ppid): after = datetime.datetime.now() if (after.hour * 3600 + after.minute * 60 + after.second) > (before.hour * 3600 + before.minute * 60 + before.second): time_str = after.strftime("%Y-%m-%d %X") delay = ping.do_one(dst_ip, timeout=0.7, psize=64) if delay is None or delay > 4.0: if os.path.exists(log_path): log_file.write(time_str + " " + dst_ip + " timeout\n") log_file.flush() else: break else: delay_ms = delay * 1000 if os.path.exists(log_path): log_file.write( time_str + " " + dst_ip + " " + str(format(delay_ms, ".1f")) + "\n") log_file.flush() else: break before = datetime.datetime.now() else: before = datetime.datetime.now() time.sleep(0.1) day_temp = datetime.datetime.now().date() else: logging.info("Main process exit.") logging.info( "Subprocess exit. PPID:%s, PID:%s, HOST:%s, IP:%s" % (ppid, os.getpid(), name, dst_ip)) return if day_temp >= first_day: first_day = day_temp else: logging.error( "Wrong date. Subprocess exit. PPID:%s, PID:%s, HOST:%s, IP:%s" % (ppid, os.getpid(), name, dst_ip)) return else: logging.info("Main process exit.") logging.info("Subprocess exit. PPID:%s, PID:%s, HOST:%s, IP:%s" % (ppid, os.getpid(), name, dst_ip)) return
def __init__(self, environment: str, cmdline_args: NamedTuple = None): settings.init_module(environment, cmdline_args) prctl.set_proctitle(SETTINGS.instance_name)
def SigQUIT(SIG, FRM): reactor.stop() args = sys.argv[1:] if len(sys.argv[1:]) != 2: exit(1) access_list = [] blocked_ua_list = [] tor_exits_list = [] ports = [] rpc_factory = pb.PBClientFactory() reactor.connectUNIX(os.path.join("/var/run/tor2web/rpc.socket"), rpc_factory) signal.signal(signal.SIGUSR1, SigQUIT) signal.signal(signal.SIGTERM, SigQUIT) signal.signal(signal.SIGINT, SigQUIT) prctl.set_pdeathsig(signal.SIGINT) prctl.set_proctitle("tor2web-worker") start() reactor.run() exit(0)