devboxbackup / miniconda3 /envs /active_proaction /lib /python3.10 /site-packages /backgrounds /backgrounds.py
| # coding: utf-8 | |
| from __future__ import absolute_import, division, print_function, unicode_literals | |
| import functools | |
| import logging | |
| import threading | |
| import time | |
| from typing import Callable, Optional | |
| import bytedenv | |
| import schedule | |
| metrics_enabled = None | |
| logger = logging.getLogger(__name__) | |
| logging.getLogger('schedule').setLevel(logging.ERROR) | |
| class Backgrounds(object): | |
| def __init__(self): # type: () -> None | |
| self.scheduler = schedule.Scheduler() | |
| self.lock = threading.Lock() | |
| self.init_closures = [] | |
| self.stop_event = threading.Event() | |
| def register(self, schedule_seconds, closure, init_closure=None): | |
| # type: (int, Callable[[], None], Optional[Callable[[], None]]) -> None | |
| """ Register a background task. | |
| :param schedule_seconds: The schedule time in seconds for this task. | |
| :param closure: Closure for the task, will running periodically. If this closure raised any error, the error | |
| will be handled by a logger. | |
| :param init_closure: Closure for task's initialize, will be called once after start(). If this closure raised | |
| any error, the error will popuped to the start() method. | |
| """ | |
| def wrapper(): | |
| start = time.time() | |
| try: | |
| closure() | |
| except Exception: | |
| logger.exception('run %s in background raised an error, the backtrace is:', closure) | |
| time_usage = time.time() - start | |
| logger.debug('run %s in background, time usage in seconds: %f', closure, time_usage) | |
| if time_usage > 3: | |
| logger.warning( | |
| 'time usage in seconds for run %s in background is %f, this may cause other task delay', | |
| closure, time_usage | |
| ) | |
| tags = {'task_name': getattr(closure, '__name__', 'unknown')} | |
| global metrics_enabled | |
| if metrics_enabled is None: | |
| try: | |
| from bytedance import metrics | |
| metrics_enabled = True | |
| except ImportError: | |
| metrics_enabled = False | |
| if metrics_enabled: | |
| from bytedance import metrics | |
| metrics.emit_counter('python.backgrounds.%s.delay' % bytedenv.get_psm(), 1, tags=tags) | |
| with self.lock: | |
| self.scheduler.every(schedule_seconds).seconds.do(wrapper) | |
| if init_closure: | |
| self.init_closures.append(init_closure) | |
| def _target(self): # type: () -> None | |
| while True: | |
| if self.stop_event.is_set(): | |
| break | |
| self.scheduler.run_pending() | |
| time.sleep(1) | |
| def start(self): # type: () -> None | |
| """Start the backgrounds. **NOTICE**: you should call the start AFTER FORK! | |
| """ | |
| for closure in self.init_closures: | |
| closure() | |
| self.worker_thread = threading.Thread(target=self._target) | |
| self.worker_thread.setDaemon(True) | |
| self.worker_thread.setName('backgrounds') | |
| self.worker_thread.start() | |
| def stop(self): # type: () -> None | |
| """Stop the backgrounds. | |
| """ | |
| self.stop_event.set() | |
| def join(self): # type: () -> None | |
| """Join the backgrounds' thread, will be blocked until stop() is called. | |
| """ | |
| return self.worker_thread.join() | |