add script for writing to the pipe

src/lego_monitoring/main.py

@@ -0,0 +1,158 @@
+import argparse
+import asyncio
+import datetime
+import logging
+import signal
+from typing import Coroutine
+
+from . import checks
+from .alerting import sender
+from .alerting.commands import CommandHandlerManager
+from .checks.temp.sensors import print_readings
+from .config import enums as config_enums
+from .config import load_config
+from .core import cvars
+from .core.checkers import (
+    BaseChecker,
+    IntervalChecker,
+    PipeIntervalChecker,
+    ScheduledChecker,
+)
+from .core.const import UPS_PIPE_NAME
+
+stopping = False
+
+
+def stop_gracefully(signum, frame):
+    global stopping
+    stopping = True
+
+
+def main() -> None:
+    asyncio.run(async_main())
+
+
+async def async_main():
+    parser = argparse.ArgumentParser(
+        prog="lego-monitoring",
+        description="Lego-monitoring service",
+    )
+    parser.add_argument("-c", "--config", help="config file")
+    parser.add_argument("--print-temp", help="print temp sensor readings and exit", action="store_true")
+    args = parser.parse_args()
+
+    if args.config:
+        config_path = parser.parse_args().config
+        config = load_config(config_path)
+        cvars.config.set(config)
+
+    if args.print_temp:
+        print_readings()
+        raise SystemExit
+
+    if not args.config:
+        raise RuntimeError("--config must be specified in standard operating mode")
+
+    logging.basicConfig(level=config.log_level)
+
+    check_sets = config_enums.CheckSet
+
+    checker_sets: dict[config_enums.CheckSet, list[Coroutine | BaseChecker]] = {
+        check_sets.SELF: [
+            sender.send_alert(checks.generate_start_alert()),
+            IntervalChecker(checks.self_check, interval=datetime.timedelta(minutes=5), persistent=False),
+        ],
+        check_sets.CPU: [
+            IntervalChecker(
+                checks.cpu_check, interval=datetime.timedelta(minutes=3), persistent=True, ignore_first_run=True
+            )
+        ],
+        check_sets.RAM: [IntervalChecker(checks.ram_check, interval=datetime.timedelta(minutes=1), persistent=True)],
+        check_sets.TEMP: [IntervalChecker(checks.temp_check, interval=datetime.timedelta(minutes=5), persistent=True)],
+        check_sets.VULNIX: [
+            IntervalChecker(
+                checks.vulnix_check,
+                interval=datetime.timedelta(days=3),
+                persistent=True,
+                send_any_state=True,
+                # As those are checked less often than daily, reminds could lead to awkward situations
+                # when the vuln is fixed but you still get reminders about it for 2 more days.
+                remind=False,
+            )
+        ],
+        check_sets.REMIND: [
+            ScheduledChecker(
+                checks.remind_check,
+                period=datetime.timedelta(days=1),
+                when=datetime.time(hour=0, minute=0),
+                persistent=False,
+                is_reminder=True,
+            )
+        ],
+        check_sets.NET: [
+            IntervalChecker(checks.NetIOTracker().net_check, interval=datetime.timedelta(minutes=5), persistent=True)
+        ],
+        check_sets.UPS: [
+            PipeIntervalChecker(
+                checks.UPSTracker().ups_check,
+                interval=datetime.timedelta(minutes=5),
+                persistent=True,
+                pipe=UPS_PIPE_NAME,
+                owner_group=config.checks.ups.upsmon_group,
+            )
+        ],
+    }
+
+    checkers = []
+    for enabled_set in config.enabled_check_sets:
+        for checker in checker_sets[enabled_set]:
+            checkers.append(checker)
+
+    checker_sets[check_sets.REMIND][0].check_args = [checkers]
+
+    if config.alert_channels.telegram is not None:
+        tg_client = await sender.get_tg_client()
+        my_username = (await tg_client.get_me()).username
+        logging.info(f"Logged in as @{my_username}")
+
+        command_manager = CommandHandlerManager(checkers)
+        await command_manager.attach_handlers(tg_client)
+    else:
+        logging.info("Telegram integration is disabled")
+        tg_client = None
+
+    cvars.tg_client.set(tg_client)
+
+    if config.alert_channels.healthchecks is not None:
+        healthchecks_client = sender.get_healthchecks_client()
+        logging.info("Ready to send pings to healthchecks")
+        cvars.healthchecks_client.set(healthchecks_client)
+    else:
+        logging.info("Healthchecks integration is disabled")
+
+    signal.signal(signal.SIGTERM, stop_gracefully)
+
+    async with asyncio.TaskGroup() as tg:
+        checker_tasks: set[asyncio.Task] = set()
+        for c in checkers:
+            if isinstance(c, BaseChecker):
+                c = c.run_checker()
+            task = tg.create_task(c)
+            checker_tasks.add(task)
+        while True:
+            if stopping:
+                if "self" in config.enabled_check_sets:
+                    alert = checks.generate_stop_alert()
+                    async with asyncio.TaskGroup() as tg:
+                        tg.create_task(sender.send_alert(alert))
+                        tg.create_task(sender.send_healthchecks_status(alert))
+                for c in checkers:
+                    try:
+                        await c.graceful_stop()
+                    except AttributeError:
+                        continue
+                if tg_client:
+                    await tg_client.disconnect()
+                raise SystemExit
+            else:
+                await asyncio.sleep(3)