From 3a09e81b9a97488bed5e345893916e311f6784d1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Vinot?= Date: Wed, 7 Aug 2024 13:47:55 +0200 Subject: [PATCH] new: controller to list/stop/restart scripts indiviually --- bin/async_capture.py | 16 ++++---- bin/scripts_controller.py | 63 +++++++++++++++++++++++++++++ lookyloo/default/abstractmanager.py | 23 ++++------- pyproject.toml | 1 + tools/monitoring.py | 4 +- 5 files changed, 81 insertions(+), 26 deletions(-) create mode 100755 bin/scripts_controller.py diff --git a/bin/async_capture.py b/bin/async_capture.py index bcaff971..070c5471 100755 --- a/bin/async_capture.py +++ b/bin/async_capture.py @@ -7,6 +7,7 @@ import logging import logging.config import signal +from asyncio import Task from pathlib import Path from lacuscore import LacusCore, CaptureStatus as CaptureStatusCore, CaptureResponse as CaptureResponseCore @@ -43,6 +44,10 @@ class AsyncCapture(AbstractManager): async def _trigger_captures(self) -> None: # Only called if LacusCore is used + def clear_list_callback(task: Task) -> None: # type: ignore[type-arg] + self.captures.discard(task) + self.unset_running() + max_new_captures = get_config('generic', 'async_capture_processes') - len(self.captures) self.logger.debug(f'{len(self.captures)} ongoing captures.') if max_new_captures <= 0: @@ -50,7 +55,8 @@ class AsyncCapture(AbstractManager): return None for capture_task in self.lookyloo.lacus.consume_queue(max_new_captures): # type: ignore[union-attr] self.captures.add(capture_task) - capture_task.add_done_callback(self.captures.discard) + self.set_running() + capture_task.add_done_callback(clear_list_callback) def uuids_ready(self) -> list[str]: '''Get the list of captures ready to be processed''' @@ -115,7 +121,6 @@ class AsyncCapture(AbstractManager): # make sure to expire the key if nothing was processed for a while (= queues empty) lazy_cleanup.expire('queues', 600) lazy_cleanup.execute() - self.unset_running() self.logger.info(f'Done with {uuid}') async def _to_run_forever_async(self) -> None: @@ -125,10 +130,6 @@ class AsyncCapture(AbstractManager): try: if isinstance(self.lookyloo.lacus, LacusCore): await self._trigger_captures() - # NOTE: +1 because running this method also counts for one and will - # be decremented when it finishes - self.set_running(len(self.captures) + 1) - self.process_capture_queue() except LacusUnreachable: self.logger.error('Lacus is unreachable, retrying later.') @@ -139,10 +140,7 @@ class AsyncCapture(AbstractManager): while self.captures: self.logger.info(f'Waiting for {len(self.captures)} capture(s) to finish...') await asyncio.sleep(5) - # NOTE: +1 so we don't quit before the final process capture queue - self.set_running(len(self.captures) + 1) self.process_capture_queue() - self.unset_running() self.logger.info('No more captures') except LacusUnreachable: self.logger.error('Lacus is unreachable, nothing to wait for') diff --git a/bin/scripts_controller.py b/bin/scripts_controller.py new file mode 100755 index 00000000..8b194608 --- /dev/null +++ b/bin/scripts_controller.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 + +from __future__ import annotations + +import argparse + +import time + +from subprocess import Popen + +from psutil import Process +from redis import Redis + +from lookyloo.default import get_homedir, get_socket_path, AbstractManager + + +def _get_cmdline(pid: str) -> list[str]: + process = Process(int(pid)) + return process.cmdline() + + +def main() -> None: + parser = argparse.ArgumentParser(description='Manage the scripts.') + parser.add_argument('action', choices=['list', 'stop', 'restart'], help='The action to perform.', default='list') + parser.add_argument('script', help='The script to manage.', nargs='?') + args = parser.parse_args() + # Just fail if the env isn't set. + get_homedir() + if args.action == 'list': + try: + print(AbstractManager.is_running()) + except FileNotFoundError: + print('Redis is down.') + else: + if args.action == 'restart': + # we need to keep the cmdline for the restart + try: + running_services = AbstractManager.is_running() + except KeyError: + print(f'{args.script} is not running.') + return + for name, numbers, pids in running_services: + if name == args.script: + to_restart = _get_cmdline(pids.pop()) + break + + print(f'Request {args.script} to {args.action}...') + r = Redis(unix_socket_path=get_socket_path('cache'), db=1) + r.sadd('shutdown_manual', args.script) + while r.zscore('running', args.script) is not None: + print(f'Wait for {args.script} to stop...') + time.sleep(1) + print('done.') + r.srem('shutdown_manual', args.script) + + if args.action == 'restart': + print(f'Start {args.script}...') + Popen(to_restart) + print('done.') + + +if __name__ == '__main__': + main() diff --git a/lookyloo/default/abstractmanager.py b/lookyloo/default/abstractmanager.py index 70d85ad9..9dcc6851 100644 --- a/lookyloo/default/abstractmanager.py +++ b/lookyloo/default/abstractmanager.py @@ -33,9 +33,10 @@ class AbstractManager(ABC): self.force_stop = False @staticmethod - def is_running() -> list[tuple[str, float]]: + def is_running() -> list[tuple[str, float, set[str]]]: try: r = Redis(unix_socket_path=get_socket_path('cache'), db=1, decode_responses=True) + running_scripts: dict[str, set[str]] = {} for script_name, score in r.zrangebyscore('running', '-inf', '+inf', withscores=True): for pid in r.smembers(f'service|{script_name}'): try: @@ -48,7 +49,8 @@ class AbstractManager(ABC): r.zadd('running', {script_name: other_same_services}) else: r.zrem('running', script_name) - return r.zrangebyscore('running', '-inf', '+inf', withscores=True) + running_scripts[script_name] = r.smembers(f'service|{script_name}') + return [(name, rank, running_scripts[name] if name in running_scripts else set()) for name, rank in r.zrangebyscore('running', '-inf', '+inf', withscores=True)] except RedisConnectionError: print('Unable to connect to redis, the system is down.') return [] @@ -104,7 +106,8 @@ class AbstractManager(ABC): def shutdown_requested(self) -> bool: try: - return bool(self.__redis.exists('shutdown')) + return (bool(self.__redis.exists('shutdown')) + or bool(self.__redis.sismember('shutdown_manual', self.script_name))) except ConnectionRefusedError: return True except RedisConnectionError: @@ -133,6 +136,7 @@ class AbstractManager(ABC): def run(self, sleep_in_sec: int) -> None: self.logger.info(f'Launching {self.__class__.__name__}') try: + self.set_running() while not self.force_stop: if self.shutdown_requested(): break @@ -142,15 +146,9 @@ class AbstractManager(ABC): self.logger.critical(f'Unable to start {self.script_name}.') break else: - self.set_running() self._to_run_forever() except Exception: # nosec B110 self.logger.exception(f'Something went terribly wrong in {self.__class__.__name__}.') - finally: - if not self.process: - # self.process means we run an external script, all the time, - # do not unset between sleep. - self.unset_running() if not self.long_sleep(sleep_in_sec): break except KeyboardInterrupt: @@ -187,6 +185,7 @@ class AbstractManager(ABC): async def run_async(self, sleep_in_sec: int) -> None: self.logger.info(f'Launching {self.__class__.__name__}') try: + self.set_running() while not self.force_stop: if self.shutdown_requested(): break @@ -196,15 +195,9 @@ class AbstractManager(ABC): self.logger.critical(f'Unable to start {self.script_name}.') break else: - self.set_running() await self._to_run_forever_async() except Exception: # nosec B110 self.logger.exception(f'Something went terribly wrong in {self.__class__.__name__}.') - finally: - if not self.process: - # self.process means we run an external script, all the time, - # do not unset between sleep. - self.unset_running() if not await self.long_sleep_async(sleep_in_sec): break except KeyboardInterrupt: diff --git a/pyproject.toml b/pyproject.toml index a514c5c3..0ffc94d8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,6 +34,7 @@ background_full_indexer = "bin.background_indexer:main_full_indexer" archiver = "bin.archiver:main" processing = "bin.background_processing:main" start_website = "bin.start_website:main" +scripts_controller = "bin.scripts_controller:main" [tool.poetry.dependencies] diff --git a/tools/monitoring.py b/tools/monitoring.py index c057d4ee..1be9e96b 100755 --- a/tools/monitoring.py +++ b/tools/monitoring.py @@ -123,8 +123,8 @@ if __name__ == '__main__': console.print('Services currently running:') running = AbstractManager.is_running() - for service, number in running: - s = Padding(f'{service} ({int(number)} service(s))', (0, 2)) + for service, number, pids in running: + s = Padding(f'{service} ({int(number)} service(s)) - PIDs: {", ".join(pids)}', (0, 2)) console.print(s) console.print('Current cache status:')