def _try_lock(self, requirements, candidate): """ Function that tries to lock given candidate resource """ resource_id = candidate.get("id") try: pid_file = f"{resource_id}.pid" self.logger.debug('Trying lock using: %s', os.path.join(self._lock_folder, pid_file)) _lockable = PidFile(pidname=pid_file, piddir=self._lock_folder) _lockable.create() self.logger.info('Allocated: %s, lockfile: %s', resource_id, pid_file) def release(): nonlocal self, resource_id, _lockable self.logger.info('Release resource: %s', resource_id) _lockable.close() del self._allocations[resource_id] return Allocation(requirements=requirements, resource_info=candidate, _release=release, pid_file=_lockable.filename) except PidFileError as error: raise AssertionError('no success') from error
def acquire_lock(name): """ Attempts to acquire a lock for the name provided. """ lock = PidFile( pidname="%s.LOCK" % name, piddir=LOCK_ROOT, enforce_dotpid_postfix=False) lock.create()
class Index: """ There's a file on disc called "local state file" and it says when was the last timestamp pulled from Slack. """ def __init__(self, index_path: Path): self._index_path = index_path self._data = None self._pidfile = PidFile("index", piddir="/tmp", lock_pidfile=True) def __enter__(self): if self._data is not None: raise Exception("can only enter once") self._index_path.parent.mkdir(exist_ok=True, parents=True) self._pidfile.create() if not self._index_path.exists(): self._index_path.write_text("{}") self._data = json.load(self._index_path.open("r")) return self def __exit__(self, exception_type, exception_value, traceback): if exception_type is None: json.dump(self._data, self._index_path.open("w"), indent=4) self._pidfile.close() self._data = None def ts(self, channel: Conversation) -> Optional[datetime.datetime]: serialized = self._timestamps.get(repr(channel)) if serialized: return self._str_to_ts(serialized) def set_ts(self, channel: Conversation, ts: datetime.datetime) -> None: self._timestamps[repr(channel)] = self._ts_to_str(ts) def set_all(self, ts): for k in self._timestamps: self._timestamps[k] = self._ts_to_str(ts) @classmethod def _ts_to_str(cls, ts: datetime.datetime) -> str: return ts.strftime(cls.datetime_format) @classmethod def _str_to_ts(cls, str_datetime: str) -> datetime.datetime: return datetime.datetime.strptime(str_datetime, cls.datetime_format) @property def _timestamps(self): return self._data.setdefault('timestamps', {}) datetime_format = "%Y-%m-%d_%H:%M:%S.%f_%z"
class Pid(object): def __init__(self): self.pid = PidFile(piddir=LOCKFILE_DIR) def __enter__(self): try: self.pid.__enter__() except PidFileAlreadyLockedError: logging.getLogger(__name__).warning('%s is locked', self.pid.filename) raise SystemExit() return self def __exit__(self, exc_type=None, exc_value=None, exc_tb=None): self.pid.__exit__()
def run(**kwargs): params = get_params(kwargs) configure_logging(params) try: with PidFile(get_pidfile_key(params['query_folder'])): logging.info('Starting execution.') current_exec_time = utcnow() config = load_config(params['config_path']) config['current_exec_time'] = current_exec_time config['query_folder'] = params['query_folder'] config['output_folder'] = params['output_folder'] config['reruns'], rerun_files = read_reruns(params['query_folder']) reader = Reader(config) selector = Selector(reader, config) executor = Executor(selector, config) writer = Writer(executor, config, configure_graphite(config, params)) writer.run() delete_reruns( rerun_files) # delete rerun files that have been processed logging.info('Execution complete.') except PidFileError: logging.warning( 'A job with folder {} is already running, exiting successfully.'. format(params['query_folder']))
def main(): try: with PidFile("zapret_ipfile.py.pid"): __start() __gen_ipfile() except PidFileError: __edr.printt("Уже запущено обновление.")
def check_pod_status(): """Background Task to update status/phase of known pods """ from api.models.kubepod import KubePod try: with PidFile('pod_status') as p: print(p.pidname) ns = os.environ.get('MLBENCH_NAMESPACE') config.load_incluster_config() v1 = client.CoreV1Api() pods = pods = KubePod.objects.all() for pod in pods: ret = v1.read_namespaced_pod(pod.name, ns) phase = ret.status.phase if phase != pod.phase: pod.phase = phase pod.save() except PidFileError: return
def launch_app(name, pidname, appid, wxapp, **app_kwargs): print(f"Starting {name}") pid_dir = make_pid_dir() print('My PID is:', os.getpid()) try: with PidFile(pidname=pidname, piddir=str(pid_dir)) as p: print("###") print(wx.Colour(wx.SYS_COLOUR_BACKGROUND)) print(wx.Colour(240, 240, 240)) print("###") if sys.platform == "win32": import ctypes ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID( appid) # wx.html2.WebView.MSWSetEmulationLevel(level=wx.html2.WEBVIEW_EMU_DEFAULT) App = wxapp(**app_kwargs) App.MainLoop() print("Goodbye :)") return 0 except (BlockingIOError, PidFileAlreadyLockedError): switch_process(name, pid_dir / f"{pidname}.pid") return 1
def main(): arguments = parse_arguments() logger = log(arguments.loglevel) logger.warning('Starting json2mqtt') try: with PidFile('json2mqtt', piddir='/var/tmp'): logger.info("Reading configuration file {}".format( arguments.filename)) settings = Settings(filename=arguments.filename) logger.info("Reading schema files {}".format(arguments.filename)) schemas = Schemas(logger=logger, schema_dir=settings.schema_dir) schemas.import_all() logger.info("Starting MQTT Listener server") server = MQTTListener( settings=settings, schemas=schemas, logger=logger, ) server.run() except ConfigError as e: logger.error("Config file contains errors: {}".format(e)) sys.exit(1) except PidFileAlreadyLockedError: logger.error("Another instance of this service is already running") sys.exit(1)
def work(self): """run the sequence, emit the finish-line""" # print('I will now start to work!') # print('data from main:' ,zmqquery(self.zmq_sSeq, 'data')) try: with PidFile("zmqLogger"): msg = "zmqLogger is not running, no data available, aborting" self._logger.error(msg) self.sig_finished.emit(msg) return except PidFileError: pass try: with self.controlsLock: fin = self.running() except problemAbort as e: fin = f"Error occurred, aborting sequence! Error: {e}" self._logger.error(fin) finally: try: self.sig_finished.emit(fin) except NameError: self.sig_finished.emit( "An Error occurred! Aborted sequence completely!") self._logger.error( "An Error occurred! Aborted sequence completely!")
def run(): conf = { '/': { 'tools.sessions.on': True, 'tools.caching.on': False, # 'tools.auth_basic.on': True, # 'tools.auth_basic.realm':'admin', # 'tools.auth_basic.checkpassword':encrypt_pwd, 'tools.staticdir.root': config._ROOT_DIR_ }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': config._STATIC_DIR_ }, '/bootstrap': { 'tools.staticdir.on': True, 'tools.staticdir.dir': config._STATIC_DIR_ + 'bootstrap/css/' }, '/favicon.ico': { 'tools.staticfile.on': True, 'tools.staticfile.filename': favicon() } } with PidFile('server.pid') as spid: print(spid.pidname) print(spid.piddir) portNumber = config.port() cherrypy.config.update({ 'server.socket_host': '0.0.0.0', 'server.socket_port': portNumber, }) cherrypy.quickstart(Notes(), '/', conf)
def __configure_daemon(detach: bool, camguard: Any) -> DaemonContext: """in case of running daemonized, this configures daemon as described in PEP 3143 Args: detach (bool): set to true to detach from terminal camguard (Any): the camguard instance to run Returns: DaemonContext: daemon context which handles turning program into a daemon process """ signal_map: Dict[Signals, Any] = { # lambda type couldn't be inferred SIGTERM: lambda sig, _: __shutdown(camguard, sig), # type: ignore SIGINT: lambda sig, _: __shutdown(camguard, sig) # type: ignore } # setup pid file context (/var/run/camguard.pid) pid_file: Optional[PidFile] = PidFile( pidname='camguard') if detach else None work_dir: str = '/' if detach else '.' return DaemonContext(detach_process=detach, pidfile=pid_file, signal_map=signal_map, stderr=sys.stderr, stdout=sys.stdout, working_directory=work_dir)
def main(): try: with PidFile("zapretdelete_duple.py.pid"): __start() __genereate() except PidFileError: __edr.printt("Уже запущено обновление.")
async def fetch_list(self): '''Fetch & store the list''' if not self.fetcher: return set_running(f'{self.__class__.__name__}-{self.vendor}-{self.listname}') try: with PidFile(f'{self.listname}.pid', piddir=self.meta): if not await self.__newer(): unset_running( f'{self.__class__.__name__}-{self.vendor}-{self.listname}' ) return async with aiohttp.ClientSession() as session: async with session.get(self.url) as r: content = await r.content.read() if self.__same_as_last(content): return self.logger.info('Got a new file \o/') with (self.directory / '{}.txt'.format( datetime.now().isoformat())).open('wb') as f: f.write(content) unset_running( f'{self.__class__.__name__}-{self.vendor}-{self.listname}' ) except PidFileError: self.logger.info('Fetcher already running') finally: unset_running( f'{self.__class__.__name__}-{self.vendor}-{self.listname}')
def check_pod_status(): """Background Task to update status/phase of known pods""" try: with PidFile("pod_status") as p: _check_and_update_pod_phase() except PidFileError: return
def main(): args = parse_arguments() if args.pid is not None: with PidFile(args.pid): return start_sync(args) else: return start_sync(args)
def main(**kwargs): if __edr.str2bool(__edr.config('Main')['nginx']): __start() try: with PidFile("zapretnginx.py.pid"): __genereate(**kwargs) except PidFileError: __edr.printt("Идёт обновление базы, выполненние невозможно.") __edr.LogWrite("Идёт обновление базы, выполненние невозможно.")
def run_flask(debug): sys.stderr = sys.stdout pid_dir = pathlib.Path(user_config_dir("GunShotMatch")) / ".pid" if not pid_dir.exists(): pid_dir.mkdir() with PidFile(pidname="DataViewer", piddir=str(pid_dir)) as p: app.run(debug=debug)
def main(args): if args.daemon: import daemon from pid import PidFile pidfile = PidFile(conf.serv_pidfile) with daemon.DaemonContext(pidfile=pidfile): start_server() else: start_server()
def main(): settings_folder = r"/home/downloader_settings" set_logger(os.path.join(settings_folder, "uploader.log")) with PidFile(): for file in os.listdir(settings_folder): settings_file = os.path.join(settings_folder, file) _, file_extension = os.path.splitext(settings_file) if file_extension == ".json" and "installation_history.json" not in settings_file: upload_to_sharepoint(settings_file)
def get_context(self): return DaemonContext(uid=self.uid, gid=self.gid, files_preserve=[ self.log_handler.stream, ], pidfile=PidFile(self.pid_file), stderr=self.log_handler.stream, stdout=self.log_handler.stream, signal_map=self.sig_map)
def check_new_pods(): """Background task to look for new pods available in cluster. Creates corresponding `KubePod` objects in db. """ try: with PidFile("new_pods") as p: _check_and_create_new_pods() except PidFileError: return
def main() -> None: try: with PidFile( 'nice-bot', piddir='/var/lib/nice-bot' ): Service().start() except PidFileError: logging.error('Nice-bot is already running') raise
def decorated_function(**values): site_id = values['site_id'] local_tries, local_delay = tries, delay while local_tries > 0: try: with PidFile(piddir='/var/www/jekylledit', pidname=site_id + '.lock'): return f(**values) except PidFileAlreadyLockedError: local_tries -= 1 local_delay *= 2
def payout_voters(ctx, network, cover_fees, max_weight, share, min_share, message, password): """ Calculate and transmit payments to the voters. """ config = ctx.obj['config'] printer = ctx.obj["printer"] Crypt().decrypt_config(config, password, printer) setting = config[network] if cover_fees is None: cover_fees = setting["cover_fees"] if min_share is None: min_share = setting["min_share"] if max_weight is None: max_weight = setting["max_weight"] if message is None: message = setting["message"] if share is None: share = setting["share"] with PidFile(piddir='/tmp/'): printer.log("starting payment run") payer = Payouts( db_name=setting["db_name"], db_host=setting["db_host"], db_pw=setting["db_password"], db_user=setting["db_user"], network=network, delegate_address=setting["delegate_address"], pubkey=setting["delegate_pubkey"], rewardswallet=setting["rewardswallet"], passphrase=setting["delegate_passphrase"][0], second_passphrase=setting["delegate_second_passphrase"][0] if setting["delegate_second_passphrase"][0] else None, printer=printer, arky_network_name=setting["arky"]) max_weight *= setting["coin_in_sat"] printer.info("Calculating payments") payouts = payer.calculate_payouts(cover_fees=cover_fees, max_weight=max_weight, share=share) printer.info("transmitting payments") payer.transmit_payments( payouts, message=message, min_share=min_share, ) printer.log("Payment run done!")
def check_running(pid_file): if not os.path.exists('/var/run/' + pid_file + '.pid'): return False else: print('pid file found: /var/run/{0}.pid'.format(pid_file)) # try a lock, if succesful, it's a stale pid file, and we'll delete it try: with PidFile(pid_file) as p: print('Checking if we\'re already runnning') return False except: print('Already runnning! Stopping.') return True
def run_args(args): config_path = None # Must be replaced by dynamic default value pidfile_path = None # Must be replaced by dynamic default value is_debug = False while len(args) > 0: if args[0] == '--debug': if is_debug: print('Duplicate option --debug!', file=sys.stderr) exit(1) is_debug = True args = args[1:] elif args[0] == '--pidfile': if pidfile_path is not None: print('Duplicate option --pidfile!', file=sys.stderr) exit(1) if len(args) < 2: print('Missing argument to --pidfile!', file=sys.stderr) exit(1) pidfile_path = args[1] args = args[2:] elif args[0] == '--config': if config_path is not None: print('Duplicate option --config!', file=sys.stderr) exit(1) if len(args) < 2: print('Missing argument to --config!', file=sys.stderr) exit(1) config_path = args[1] args = args[2:] # TODO: How about '--help'? else: print('Unknown option {}!'.format(args[0]), file=sys.stderr) exit(1) if config_path is None: config_path = 'briar_rose.config' if pidfile_path is None: pidfile_path = default_pidfile_path() if is_debug: print('Would use pidfile at {}'.format(pidfile_path)) print('Loading configuration from {}'.format(config_path)) run_debug(config_path) else: with PidFile(pidname=basename(pidfile_path), piddir=dirname(pidfile_path), enforce_dotpid_postfix=False): run_daemon(config_path)
def main(): description = """IRRd main process""" parser = argparse.ArgumentParser(description=description) parser.add_argument( '--config', dest='config_file_path', type=str, help= f'use a different IRRd config file (default: {CONFIG_PATH_DEFAULT})') parser.add_argument('--foreground', dest='foreground', action='store_true', help=f"run IRRd in the foreground, don't detach") args = parser.parse_args() mirror_frequency = int(os.environ.get('IRRD_SCHEDULER_TIMER_OVERRIDE', 15)) daemon_kwargs = { 'umask': 0o022, } if args.foreground: daemon_kwargs['detach_process'] = False daemon_kwargs['stdout'] = sys.stdout daemon_kwargs['stderr'] = sys.stderr # config_init w/ commit may only be called within DaemonContext config_init(args.config_file_path, commit=False) with daemon.DaemonContext(**daemon_kwargs): config_init(args.config_file_path) piddir = get_setting('piddir') logger.info('IRRd attempting to secure PID') try: with PidFile(pidname='irrd', piddir=piddir): logger.info( f'IRRd {__version__} starting, PID {os.getpid()}, PID file in {piddir}' ) run_irrd(mirror_frequency) except PidFileError as pfe: logger.error( f'Failed to start IRRd, unable to lock PID file irrd.pid in {piddir}: {pfe}' ) except Exception as e: logger.error( f'Error occurred in main process, terminating. Error follows:') logger.exception(e) os.kill(os.getpid(), signal.SIGTERM)
def run_forever(self): with PidFile(pidname="crypto_com_market_data_worker", piddir="./logs") as pidfile: try: loop = asyncio.get_event_loop() loop.run_until_complete(self.run()) except KeyboardInterrupt: self.logger.info("Interrupted") pidfile.close(fh=pidfile.fh, cleanup=True) try: sys.exit(0) except SystemExit: os._exit(0) except Exception as e: self.logger.exception(e) finally: pidfile.close(fh=pidfile.fh, cleanup=True) self.logger.info("Bye bye!")
def main(): arguments = parse_arguments() logger = get_logger(verbosity=arguments.verbosity, log_file=arguments.log_file) try: with PidFile('mqtt_alarm_server', piddir='/var/tmp'): logger.info("Reading configuration file {}".format(arguments.config)) settings = Settings(filename=arguments.config) logger.info("Starting MQTT Listener server") mqtt_server = AlarmMQTTListener(settings=settings, logger=logger) mqtt_server.run() except ConfigError as e: logger.error("Config file contains errors: {}".format(e)) sys.exit(1) except PidFileAlreadyLockedError: logger.error("Another instance of this service is already running") sys.exit(1)