Support power up target through IPMI.

Author: notsyncing

docker/Dockerfile

@@ -7,8 +7,8 @@ ENV UV_COMPILE_BYTECODE=1 UV_LINK_MODE=copy UV_NO_DEV=1 UV_PYTHON_DOWNLOADS=0
 WORKDIR /app
 
 RUN --mount=type=cache,target=/root/.cache/uv \
-    --mount=type=bind,source=uv.lock,target=uv.lock \
-    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    --mount=type=bind,source=uv.lock,target=uv.lock,relabel=private \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml,relabel=private \
     uv sync --locked --no-install-project
 
 COPY . /app

pyproject.toml

@@ -19,12 +19,26 @@ classifiers = [
 ]
 requires-python = ">=3.12"
 dependencies = [
+    "aiohttp==3.13.5",
     "dataclass-wizard==0.39.1",
     "icmplib==3.0.4",
     "redfish==3.3.5",
     "wakeonlan==3.1.0",
 ]
 
+[project.optional-dependencies]
+dev = [
+    "wolsocketproxy[lint]",
+    "wolsocketproxy[build]",
+]
+lint = [
+    "ty",
+    "ruff",
+]
+build = [
+    "build[virtualenv]==1.4.2",
+]
+
 [project.urls]
 source = "https://github.com/notsyncing/wolsocketproxy"
 issues = "https://github.com/notsyncing/wol-socket-proxy/issues"
@@ -48,6 +62,7 @@ lint.ignore = [
     "D203",
     "D211",
     "D213",
+    "S101",
     "EM102",
     "FBT001",
     "FBT003",

src/wolsocketproxy/monitor.py

@@ -1,48 +1,131 @@
+import asyncio
 import logging
-import time
-from collections.abc import Collection
+from dataclasses import dataclass
 from logging import Logger
 from threading import Thread
+from typing import Literal
 
-from icmplib import multiping
+from aiohttp import ClientConnectionError, ClientSession, ClientTimeout
+from icmplib.multiping import async_multiping
+
+
+@dataclass
+class MonitorConfig:
+    online_check_method: Literal["ping", "http"] = "ping"
+    online_check_ip_address: str | None = None
+    online_check_http_url: str | None = None
+    online_check_http_expected_code: int = 200
+    online_check_timeout: int = 60
 
 
 class Monitor:
     _log: Logger = logging.getLogger()
-    _ip_state: dict[str, bool]
+    _monitor_configs: dict[str, MonitorConfig]
+    _machine_states: dict[str, bool]
+    _stop: bool = False
 
-    def __init__(self, watching_ip_list: Collection[str]) -> None:
-        self._ip_state = {}
+    def __init__(self, watching_machines: dict[str, MonitorConfig]) -> None:
+        self._monitor_configs = {}
+        self._machine_states = {}
 
-        for ip in watching_ip_list:
-            self._ip_state[ip] = False
+        for name, config in watching_machines.items():
+            self._monitor_configs[name] = config
+            self._machine_states[name] = False
 
     def start(self) -> None:
-        t = Thread(target=self.__check_ip_state)
-        t.daemon = True
+        def _start() -> None:
+            asyncio.run(self.__check_machine_states())
+
+        t = Thread(target=_start, daemon=True)
         t.start()
 
-    def __check_ip_state(self) -> None:
-        self._log.info("IP monitor is started.")
+    def stop(self) -> None:
+        self._stop = True
+
+    async def __check_http_urls(self, configs: dict[str, MonitorConfig]) -> dict[str, bool]:
+        if len(configs) <= 0:
+            return {}
+
+        async def fetch(session: ClientSession, url: str, timeout: ClientTimeout) -> int:  # noqa: ASYNC109
+            try:
+                async with session.get(url, timeout=timeout) as resp:
+                    return resp.status
+            except ClientConnectionError:
+                return -1
+
+        results = {}
+        result_names = []
+        result_futures = []
+
+        async with ClientSession(timeout=ClientTimeout(total=30)) as session:
+            for name, conf in configs.items():
+                assert conf.online_check_method == "http"
+                assert conf.online_check_http_url is not None
+
+                resp_future = fetch(
+                    session,
+                    conf.online_check_http_url,
+                    timeout=ClientTimeout(total=conf.online_check_timeout)
+                )
+
+                result_names.append(name)
+                result_futures.append(resp_future)
+
+            http_results = await asyncio.gather(*result_futures)
 
-        while True:
-            ip_list = self._ip_state.keys()
-            results = multiping(ip_list, count=3, timeout=2, privileged=False)
+            for i, http_result in enumerate(http_results):
+                results[result_names[i]] = http_result == conf.online_check_http_expected_code
 
-            for result in results:
-                original_state = self._ip_state[result.address]
-                self._ip_state[result.address] = result.is_alive
+        return results
+
+    async def __check_machine_states(self) -> None:
+        self._log.info("Monitor started.")
+
+        while not self._stop:
+            ping_ip_list = [
+                conf.online_check_ip_address
+                for conf in self._monitor_configs.values()
+                if conf.online_check_method == "ping"
+            ]
+
+            if len(ping_ip_list) > 0:
+                ping_results_future = async_multiping(ping_ip_list, count=3, timeout=2, privileged=False)
+            else:
+                ping_results_future = asyncio.Future()
+                ping_results_future.set_result([])
+
+            http_results_future = self.__check_http_urls(
+                configs={
+                    name: conf for name, conf in self._monitor_configs.items() if conf.online_check_method == "http"
+                }
+            )
+
+            ping_results, http_results = await asyncio.gather(ping_results_future, http_results_future)
+
+            for result in ping_results:
+                original_state = self._machine_states[result.address]
+                self._machine_states[result.address] = result.is_alive
 
                 if original_state != result.is_alive:
                     if original_state is False:
-                        self._log.info("Target %s now online.", result.address)
+                        self._log.info("Target %s now online by ping.", result.address)
+                    else:
+                        self._log.info("Target %s now offline by ping.", result.address)
+
+            for ip, result in http_results.items():
+                original_state = self._machine_states[ip]
+                self._machine_states[ip] = result
+
+                if original_state != result:
+                    if original_state is False:
+                        self._log.info("Target %s now online by http.", ip)
                     else:
-                        self._log.info("Target %s now offline.", result.address)
+                        self._log.info("Target %s now offline by http.", ip)
 
-            time.sleep(1)
+            await asyncio.sleep(1)
 
-    def report_availablity(self, ip: str, available: bool) -> None:
-        self._ip_state[ip] = available
+    def report_availablity(self, machine_name: str, available: bool) -> None:
+        self._machine_states[machine_name] = available
 
-    def is_available(self, ip: str) -> bool:
-        return self._ip_state.get(ip, False)
+    def is_available(self, machine_name: str) -> bool:
+        return self._machine_states.get(machine_name, False)