wolsocketproxy 0.2.0__tar.gz → 0.3.1__tar.gz

{wolsocketproxy-0.2.0/src/wolsocketproxy.egg-info → wolsocketproxy-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolsocketproxy
-Version: 0.2.0
+Version: 0.3.1
 Summary: A socket proxy with wake-on-lan feature.
 Author-email: Song Fuchang <song.fc@gmail.com>
 License-Expression: Apache-2.0
@@ -17,6 +17,7 @@ Requires-Dist: aiohttp==3.13.5
 Requires-Dist: dataclass-wizard==0.39.1
 Requires-Dist: icmplib==3.0.4
 Requires-Dist: redfish==3.3.5
+Requires-Dist: setproctitle==1.3.7
 Requires-Dist: wakeonlan==3.1.0
 Provides-Extra: dev
 Requires-Dist: wolsocketproxy[lint]; extra == "dev"
@@ -25,7 +26,7 @@ Provides-Extra: lint
 Requires-Dist: ty; extra == "lint"
 Requires-Dist: ruff; extra == "lint"
 Provides-Extra: build
-Requires-Dist: build[virtualenv]==1.4.2; extra == "build"
+Requires-Dist: build[virtualenv]==1.5.0; extra == "build"
 Dynamic: license-file
 
 # wol-socket-proxy
@@ -96,10 +97,13 @@ The `wolsocketproxy.conf` has the following structure:
                                                                         //   "http" - You must specify "online_check_http_url"
                                                                         //   "ping" - You must specify "ip_address"
             "online_check_http_url": "http://192.168.1.124/health",     // The URL used to check if machine is online, optional
-            "online_check_timeout": 300,                                // Timeout when checking machine is online, seconds, optional, default is 300
+            "online_check_timeout": 300,                                // Timeout when checking machine is online, seconds, optional, default is 60
             "online_check_http_expected_code": 200,                     // Expected HTTP status code when using "http" method, optional, default is 200
             "ipmi_force_reset_if_power_up_failed": true,                // Use IPMI power reset if this machine is not online after timeout, optional, default is false
-            "ipmi_max_reset_try_count": 3                               // Max IPMI power reset retry count before giving-up, optional, default is 3
+            "ipmi_max_reset_try_count": 3,                              // Max IPMI power reset retry count before giving-up, optional, default is 3
+            "keep_alive_mode": true,                                    // Indicates whether this machine has a keep-alive daemon, optional, default is false
+                                                                        // If you enable this, wolsocketproxy will send a request when there is any traffic
+            "keep_alive_mode_base_url": "http://192.168.1.124:8080"     // Keep-alive daemon provided URL, optional
         },
         // ... more machines ...
     },
@@ -129,3 +133,37 @@ The `wolsocketproxy.conf` has the following structure:
     ]
 }
 ```
+
+## Additional modes
+
+### Keep-alive daemon mode
+
+This mode is used for running on target machine with auto-suspend (e.g. running `circadian` or similar), to keep the target
+machine from auto suspending when running tasks.
+
+Use the following command on the target machine to enter this mode:
+
+```bash
+wolsocketproxy -k
+```
+
+The config file `wolsocketproxy.conf` should look like the following:
+
+
+```json5
+// Keep-alive daemon mode
+{
+    "listen_address": "0.0.0.0",                // The address to listen for HTTP server, default is 127.0.0.1
+    "listen_port": 18080,                       // The port to listen for HTTP server, default is 18080
+    "watchdog_feed_interval": 60,               // Watchdog feed interval, seconds, default is 600
+    "keep_alive_method": "special_process",     // How to keep target machine alive, default is "special_process"
+                                                //   "special_process" - Fork a child process with specified name
+    "special_process_name": "wsp-keepalive",    // The display name of the forked child process, default is "wsp-keepalive"
+}
+```
+
+You need to periodically send an HTTP GET request to `/watchdog/feed` at the `listen_port` in `watchdog_feed_interval` time,
+or the special process will be killed.
+You can combine this mode with `circadian`'s `process_block` config to keep it from auto-suspending.
+
+If you enable `keep_alive_mode` in proxy mode's config, the proxy will send requests to `/watchdog/feed` of this machine whenever there is any traffic towards this machine through it.

{wolsocketproxy-0.2.0 → wolsocketproxy-0.3.1}/README.md

@@ -66,10 +66,13 @@ The `wolsocketproxy.conf` has the following structure:
                                                                         //   "http" - You must specify "online_check_http_url"
                                                                         //   "ping" - You must specify "ip_address"
             "online_check_http_url": "http://192.168.1.124/health",     // The URL used to check if machine is online, optional
-            "online_check_timeout": 300,                                // Timeout when checking machine is online, seconds, optional, default is 300
+            "online_check_timeout": 300,                                // Timeout when checking machine is online, seconds, optional, default is 60
             "online_check_http_expected_code": 200,                     // Expected HTTP status code when using "http" method, optional, default is 200
             "ipmi_force_reset_if_power_up_failed": true,                // Use IPMI power reset if this machine is not online after timeout, optional, default is false
-            "ipmi_max_reset_try_count": 3                               // Max IPMI power reset retry count before giving-up, optional, default is 3
+            "ipmi_max_reset_try_count": 3,                              // Max IPMI power reset retry count before giving-up, optional, default is 3
+            "keep_alive_mode": true,                                    // Indicates whether this machine has a keep-alive daemon, optional, default is false
+                                                                        // If you enable this, wolsocketproxy will send a request when there is any traffic
+            "keep_alive_mode_base_url": "http://192.168.1.124:8080"     // Keep-alive daemon provided URL, optional
         },
         // ... more machines ...
     },
@@ -99,3 +102,37 @@ The `wolsocketproxy.conf` has the following structure:
     ]
 }
 ```
+
+## Additional modes
+
+### Keep-alive daemon mode
+
+This mode is used for running on target machine with auto-suspend (e.g. running `circadian` or similar), to keep the target
+machine from auto suspending when running tasks.
+
+Use the following command on the target machine to enter this mode:
+
+```bash
+wolsocketproxy -k
+```
+
+The config file `wolsocketproxy.conf` should look like the following:
+
+
+```json5
+// Keep-alive daemon mode
+{
+    "listen_address": "0.0.0.0",                // The address to listen for HTTP server, default is 127.0.0.1
+    "listen_port": 18080,                       // The port to listen for HTTP server, default is 18080
+    "watchdog_feed_interval": 60,               // Watchdog feed interval, seconds, default is 600
+    "keep_alive_method": "special_process",     // How to keep target machine alive, default is "special_process"
+                                                //   "special_process" - Fork a child process with specified name
+    "special_process_name": "wsp-keepalive",    // The display name of the forked child process, default is "wsp-keepalive"
+}
+```
+
+You need to periodically send an HTTP GET request to `/watchdog/feed` at the `listen_port` in `watchdog_feed_interval` time,
+or the special process will be killed.
+You can combine this mode with `circadian`'s `process_block` config to keep it from auto-suspending.
+
+If you enable `keep_alive_mode` in proxy mode's config, the proxy will send requests to `/watchdog/feed` of this machine whenever there is any traffic towards this machine through it.

{wolsocketproxy-0.2.0 → wolsocketproxy-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wolsocketproxy"
-version = "0.2.0"
+version = "0.3.1"
 description = "A socket proxy with wake-on-lan feature."
 authors = [
     {name = "Song Fuchang", email = "song.fc@gmail.com"}
@@ -23,6 +23,7 @@ dependencies = [
     "dataclass-wizard==0.39.1",
     "icmplib==3.0.4",
     "redfish==3.3.5",
+    "setproctitle==1.3.7",
     "wakeonlan==3.1.0",
 ]
 
@@ -36,7 +37,7 @@ lint = [
     "ruff",
 ]
 build = [
-    "build[virtualenv]==1.4.2",
+    "build[virtualenv]==1.5.0",
 ]
 
 [project.urls]
@@ -52,6 +53,7 @@ src = ["src"]
 target-version = "py312"
 lint.select = ["ALL"]
 lint.ignore = [
+    "ASYNC110",
     "COM812",
     "D100",
     "D101",
@@ -62,6 +64,7 @@ lint.ignore = [
     "D203",
     "D211",
     "D213",
+    "DTZ005",
     "S101",
     "EM102",
     "FBT001",
@@ -69,4 +72,5 @@ lint.ignore = [
     "ISC001",
     "TRY003",
     "TRY201",
+    "PLR0913",
 ]

wolsocketproxy-0.3.1/src/wolsocketproxy/__init__.py

@@ -0,0 +1,75 @@
+import json
+import logging
+from argparse import ArgumentParser
+from pathlib import Path
+from sys import stdout
+
+import dataclass_wizard
+
+from wolsocketproxy.keepalive import KeepAliveConfig, KeepAliveDaemon
+from wolsocketproxy.proxy import Proxy, ProxyConfig
+
+
+def main() -> None:
+    logging.basicConfig(
+        format="%(asctime)s %(levelname)-8s %(name)s %(message)s",
+        level=logging.INFO,
+        datefmt="%Y-%m-%d %H:%M:%S",
+        handlers=[
+            logging.StreamHandler(
+                stream=stdout,
+            ),
+        ],
+        force=True,
+    )
+
+    log = logging.getLogger()
+
+    parser = ArgumentParser(prog="wolsocketproxy", description="A socket proxy with wake-on-lan feature.")
+
+    parser.add_argument(
+        "-k",
+        "--keep-alive",
+        dest="keep_alive_mode",
+        default=False,
+        action="store_true",
+        help="Start in keep-alive daemon mode",
+    )
+
+    parser.add_argument(
+        "-c",
+        "--config",
+        help="The config file to use, default lookup order: /etc/wolsocketproxy.conf, ./wolsocketproxy.conf",
+    )
+
+    args = parser.parse_args()
+    config_path: Path
+
+    if "config" in args and args.config is not None:
+        config_path = Path(args.config)
+    else:
+        config_path = Path("/etc/wolsocketproxy.conf")
+
+        if not config_path.exists():
+            config_path = Path("./wolsocketproxy.conf")
+
+    if not config_path.exists():
+        log.error("Config file path %s does not exist!", config_path)
+        return
+
+    config_data = json.loads(config_path.read_text())
+
+    if args.keep_alive_mode:
+        config = dataclass_wizard.fromdict(KeepAliveConfig, config_data)
+
+        log.info("Loaded keep-alive mode config from %s", config_path)
+
+        keep_alive_daemon = KeepAliveDaemon(config)
+        keep_alive_daemon.start()
+    else:
+        config = dataclass_wizard.fromdict(ProxyConfig, config_data)
+
+        log.info("Loaded proxy mode config from %s", config_path)
+
+        proxy = Proxy(config)
+        proxy.start()

wolsocketproxy-0.3.1/src/wolsocketproxy/common.py

@@ -0,0 +1 @@
+URL_WATCHDOG_FEED = "/watchdog/feed"

wolsocketproxy-0.3.1/src/wolsocketproxy/keepalive.py

@@ -0,0 +1,152 @@
+import asyncio
+import logging
+import os
+import signal
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from threading import Thread
+from typing import Literal
+
+from aiohttp import web
+from aiohttp.web import Request, Response
+from setproctitle import setproctitle
+
+from wolsocketproxy.common import URL_WATCHDOG_FEED
+
+
+@dataclass
+class KeepAliveConfig:
+    listen_address: str = "127.0.0.1"
+    listen_port: int = 18080
+
+    watchdog_feed_interval: int = 600
+
+    keep_alive_method: Literal["special_process"] = "special_process"
+
+    special_process_name: str | None = "wsp-keepalive"
+
+
+class KeepAliveDaemon:
+    _log: logging.Logger = logging.getLogger(__name__)
+
+    _config: KeepAliveConfig
+    _web_app: web.Application
+
+    _watchdog_last_feed_time: datetime
+    _watchdog_is_hungry: bool = False
+
+    _special_process_id: int = -1
+
+    def __init__(self, config: KeepAliveConfig) -> None:
+        self._config = config
+
+        self._web_app = web.Application()
+
+        self._web_app.add_routes([web.get(URL_WATCHDOG_FEED, self._handle_watchdog_feed)])
+
+    async def _watchdog_timer(self) -> None:
+        while True:
+            previous_is_hungry = self._watchdog_is_hungry
+            last_feed_interval = datetime.now() - self._watchdog_last_feed_time
+
+            if last_feed_interval.total_seconds() > self._config.watchdog_feed_interval:
+                self._watchdog_is_hungry = True
+            else:
+                self._watchdog_is_hungry = False
+
+            if not previous_is_hungry and self._watchdog_is_hungry:
+                Thread(target=self._on_watchdog_hungry, daemon=True).start()
+            elif previous_is_hungry and not self._watchdog_is_hungry:
+                Thread(target=self._on_watchdog_feed, daemon=True).start()
+
+            await asyncio.sleep(1)
+
+    def _on_watchdog_hungry(self) -> None:
+        self._log.warning("Watchdog is hungry!")
+
+        if self._special_process_id > 0:
+            os.kill(self._special_process_id, signal.SIGKILL)
+            os.waitpid(self._special_process_id, 0)
+            self._log.warning("Killed special process PID %d", self._special_process_id)
+            self._special_process_id = -1
+
+    def _on_watchdog_feed(self) -> None:
+        self._log.info("Watchdog is feed.")
+
+        if self._config.keep_alive_method == "special_process" and self._special_process_id < 0:
+            self._start_special_process()
+
+    def _special_process(self) -> None:
+        assert self._config.special_process_name is not None
+        setproctitle(self._config.special_process_name)
+
+        while True:
+            time.sleep(60)
+
+            if os.getppid() == 1:
+                os._exit(0)
+
+    def _start_special_process(self) -> bool:
+        self._special_process_id = os.fork()
+
+        if self._special_process_id == 0:
+            self._special_process()
+            return True
+
+        self._log.info(
+            "Started special process with name %s, PID %d", self._config.special_process_name, self._special_process_id
+        )
+
+        return False
+
+    def start(self) -> None:
+        self._watchdog_last_feed_time = datetime.now()
+        self._watchdog_is_hungry = False
+
+        if self._config.keep_alive_method == "special_process":  # noqa: SIM102
+            if self._start_special_process():
+                return
+
+        loop = asyncio.new_event_loop()
+
+        def _start_loop() -> None:
+            asyncio.set_event_loop(loop)
+            loop.run_forever()
+
+        Thread(target=_start_loop, daemon=True).start()
+
+        watchdog_task = asyncio.run_coroutine_threadsafe(self._watchdog_timer(), loop)
+
+        self._log.info(
+            "Keep-alive daemon started at %s:%d, watchdog feed interval %ds.",
+            self._config.listen_address,
+            self._config.listen_port,
+            self._config.watchdog_feed_interval,
+        )
+
+        web.run_app(self._web_app, host=self._config.listen_address, port=self._config.listen_port)
+
+        self._log.info("Stopping...")
+
+        watchdog_task.cancel()
+        loop.stop()
+
+        if self._special_process_id > 0:
+            os.kill(self._special_process_id, signal.SIGKILL)
+            os.waitpid(self._special_process_id, 0)
+
+        self._log.info("Stopped.")
+
+    async def _handle_watchdog_feed(self, _: Request) -> Response:
+        last_feed = self._watchdog_last_feed_time
+        self._watchdog_last_feed_time = datetime.now()
+        interval = (self._watchdog_last_feed_time - last_feed).total_seconds()
+
+        return web.json_response(
+            {
+                "status": "ok",
+                "last_feed": last_feed.strftime("%Y-%m-%d %H:%M:%S"),
+                "interval": interval,
+            }
+        )

{wolsocketproxy-0.2.0 → wolsocketproxy-0.3.1}/src/wolsocketproxy/proxy.py

@@ -3,11 +3,14 @@ import contextlib
 import logging
 from dataclasses import dataclass
 from logging import Logger
+from threading import Thread
 from typing import Any, Literal, override
 
+import aiohttp
 import wakeonlan
 from redfish.rest.v1 import HttpClient, redfish_client
 
+from wolsocketproxy.common import URL_WATCHDOG_FEED
 from wolsocketproxy.monitor import Monitor, MonitorConfig
 from wolsocketproxy.utils import perform_ipmi_action
 
@@ -29,6 +32,10 @@ class MachineConfig:
     online_check_http_expected_code: int = 200
     online_check_timeout: int = 60
 
+    keep_alive_mode: bool = False
+    keep_alive_mode_base_url: str | None = None
+    keep_alive_min_interval: int = 1
+
 
 @dataclass
 class ProxyRoute:
@@ -56,6 +63,42 @@ class ProxyConfig:
     ipmi_configs: list[IPMIConfig] | None = None
 
 
+class TargetKeepAliveSender:
+    _target_url: str
+    _keep_alive_min_interval: int
+    _loop: asyncio.AbstractEventLoop
+    _queue: asyncio.Queue
+
+    def __init__(self, target_base_url: str, keep_alive_min_interval: int) -> None:
+        self._target_url = target_base_url.removesuffix("/") + URL_WATCHDOG_FEED
+        self._keep_alive_min_interval = keep_alive_min_interval
+
+        self._loop = asyncio.new_event_loop()
+        self._queue = asyncio.Queue(1)
+
+        def _loop() -> None:
+            asyncio.set_event_loop(self._loop)
+            self._loop.run_until_complete(self._send_worker())
+
+        Thread(target=_loop, daemon=True).start()
+
+    async def _send_worker(self) -> None:
+        while True:
+            await self._queue.get()
+
+            async with aiohttp.request("GET", self._target_url) as resp:
+                await resp.json()
+
+            await asyncio.sleep(self._keep_alive_min_interval)
+
+    def schedule_send(self) -> None:
+        def _no_exception_put() -> None:
+            with contextlib.suppress(asyncio.QueueFull):
+                self._queue.put_nowait(1)
+
+        self._loop.call_soon_threadsafe(_no_exception_put)
+
+
 class ProxyUdpProtocol(asyncio.DatagramProtocol):
     _proxy: "Proxy"
     _monitor: Monitor
@@ -63,16 +106,24 @@ class ProxyUdpProtocol(asyncio.DatagramProtocol):
     _target_machine_name: str
     _target_address: str
     _target_port: int
+    _target_keep_alive_sender: TargetKeepAliveSender | None = None
     _target_pair: tuple[str, int]
 
     def __init__(
-        self, proxy: "Proxy", monitor: Monitor, target_machine_name: str, target_address: str, target_port: int
+        self,
+        proxy: "Proxy",
+        monitor: Monitor,
+        target_machine_name: str,
+        target_address: str,
+        target_port: int,
+        target_keep_alive_sender: TargetKeepAliveSender | None = None,
     ) -> None:
         self._proxy = proxy
         self._monitor = monitor
         self._target_machine_name = target_machine_name
         self._target_address = target_address
         self._target_port = target_port
+        self._target_keep_alive_sender = target_keep_alive_sender
         self._target_pair = (target_address, target_port)
 
     @override
@@ -92,6 +143,9 @@ class ProxyUdpProtocol(asyncio.DatagramProtocol):
 
         self._transport.sendto(data, self._target_pair)
 
+        if self._target_keep_alive_sender is not None:
+            self._target_keep_alive_sender.schedule_send()
+
 
 class Proxy:
     _log: Logger = logging.getLogger()
@@ -180,9 +234,23 @@ class Proxy:
 
     def __create_tcp_route(self, route: ProxyRoute) -> None:
         assert route.target_machine_name is not None
+        machine_config = self._machines[route.target_machine_name]
+        target_keep_alive_sender = None
+
+        if machine_config.keep_alive_mode:
+            assert machine_config.keep_alive_mode_base_url is not None
+
+            target_keep_alive_sender = TargetKeepAliveSender(
+                machine_config.keep_alive_mode_base_url, machine_config.keep_alive_min_interval
+            )
 
         cr = asyncio.start_server(
-            self.__make_tcp_route_handler(route.target_machine_name, route.target_address, route.target_port),
+            self.__make_tcp_route_handler(
+                route.target_machine_name,
+                route.target_address,
+                route.target_port,
+                target_keep_alive_sender,
+            ),
             route.local_address,
             route.local_port,
         )
@@ -190,16 +258,31 @@ class Proxy:
         loop = asyncio.get_event_loop()
         loop.run_until_complete(cr)
 
-    async def __pipe(self, target_address: str, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+    async def __pipe(
+        self,
+        target_address: str,
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter,
+        target_keep_alive_sender: TargetKeepAliveSender | None = None,
+    ) -> None:
         try:
             while not reader.at_eof():
                 writer.write(await reader.read(2048))
+
+                if target_keep_alive_sender is not None:
+                    target_keep_alive_sender.schedule_send()
         except ConnectionResetError:
             self._log.warning("Connection reset by target %s", target_address)
         finally:
             writer.close()
 
-    def __make_tcp_route_handler(self, target_machine_name: str, target_address: str, target_port: int) -> Any:  # noqa: ANN401
+    def __make_tcp_route_handler(
+        self,
+        target_machine_name: str,
+        target_address: str,
+        target_port: int,
+        target_keep_alive_sender: TargetKeepAliveSender | None = None,
+    ) -> Any:  # noqa: ANN401
         async def handler(local_reader: asyncio.StreamReader, local_writer: asyncio.StreamWriter) -> None:
             if not self._monitor.is_available(target_machine_name):
                 await self._wake_up_target(target_machine_name)
@@ -211,8 +294,8 @@ class Proxy:
                 self._log.error("Unable to open connection to %s:%d", target_address, target_port)
                 raise e
 
-            send_pipe = self.__pipe(target_address, local_reader, target_writer)
-            recv_pipe = self.__pipe(target_address, target_reader, local_writer)
+            send_pipe = self.__pipe(target_address, local_reader, target_writer, target_keep_alive_sender)
+            recv_pipe = self.__pipe(target_address, target_reader, local_writer, target_keep_alive_sender)
             await asyncio.gather(send_pipe, recv_pipe)
 
         return handler
@@ -221,10 +304,27 @@ class Proxy:
         target_machine_name = route.target_machine_name
         assert target_machine_name is not None
 
+        machine_config = self._machines[target_machine_name]
+        target_keep_alive_sender = None
+
+        if machine_config.keep_alive_mode:
+            assert machine_config.keep_alive_mode_base_url is not None
+
+            target_keep_alive_sender = TargetKeepAliveSender(
+                machine_config.keep_alive_mode_base_url, machine_config.keep_alive_min_interval
+            )
+
         loop = asyncio.get_event_loop()
 
         cr = loop.create_datagram_endpoint(
-            lambda: ProxyUdpProtocol(self, self._monitor, target_machine_name, route.target_address, route.target_port),
+            lambda: ProxyUdpProtocol(
+                self,
+                self._monitor,
+                target_machine_name,
+                route.target_address,
+                route.target_port,
+                target_keep_alive_sender,
+            ),
             local_addr=(route.local_address, route.local_port),
         )
 

{wolsocketproxy-0.2.0 → wolsocketproxy-0.3.1/src/wolsocketproxy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolsocketproxy
-Version: 0.2.0
+Version: 0.3.1
 Summary: A socket proxy with wake-on-lan feature.
 Author-email: Song Fuchang <song.fc@gmail.com>
 License-Expression: Apache-2.0
@@ -17,6 +17,7 @@ Requires-Dist: aiohttp==3.13.5
 Requires-Dist: dataclass-wizard==0.39.1
 Requires-Dist: icmplib==3.0.4
 Requires-Dist: redfish==3.3.5
+Requires-Dist: setproctitle==1.3.7
 Requires-Dist: wakeonlan==3.1.0
 Provides-Extra: dev
 Requires-Dist: wolsocketproxy[lint]; extra == "dev"
@@ -25,7 +26,7 @@ Provides-Extra: lint
 Requires-Dist: ty; extra == "lint"
 Requires-Dist: ruff; extra == "lint"
 Provides-Extra: build
-Requires-Dist: build[virtualenv]==1.4.2; extra == "build"
+Requires-Dist: build[virtualenv]==1.5.0; extra == "build"
 Dynamic: license-file
 
 # wol-socket-proxy
@@ -96,10 +97,13 @@ The `wolsocketproxy.conf` has the following structure:
                                                                         //   "http" - You must specify "online_check_http_url"
                                                                         //   "ping" - You must specify "ip_address"
             "online_check_http_url": "http://192.168.1.124/health",     // The URL used to check if machine is online, optional
-            "online_check_timeout": 300,                                // Timeout when checking machine is online, seconds, optional, default is 300
+            "online_check_timeout": 300,                                // Timeout when checking machine is online, seconds, optional, default is 60
             "online_check_http_expected_code": 200,                     // Expected HTTP status code when using "http" method, optional, default is 200
             "ipmi_force_reset_if_power_up_failed": true,                // Use IPMI power reset if this machine is not online after timeout, optional, default is false
-            "ipmi_max_reset_try_count": 3                               // Max IPMI power reset retry count before giving-up, optional, default is 3
+            "ipmi_max_reset_try_count": 3,                              // Max IPMI power reset retry count before giving-up, optional, default is 3
+            "keep_alive_mode": true,                                    // Indicates whether this machine has a keep-alive daemon, optional, default is false
+                                                                        // If you enable this, wolsocketproxy will send a request when there is any traffic
+            "keep_alive_mode_base_url": "http://192.168.1.124:8080"     // Keep-alive daemon provided URL, optional
         },
         // ... more machines ...
     },
@@ -129,3 +133,37 @@ The `wolsocketproxy.conf` has the following structure:
     ]
 }
 ```
+
+## Additional modes
+
+### Keep-alive daemon mode
+
+This mode is used for running on target machine with auto-suspend (e.g. running `circadian` or similar), to keep the target
+machine from auto suspending when running tasks.
+
+Use the following command on the target machine to enter this mode:
+
+```bash
+wolsocketproxy -k
+```
+
+The config file `wolsocketproxy.conf` should look like the following:
+
+
+```json5
+// Keep-alive daemon mode
+{
+    "listen_address": "0.0.0.0",                // The address to listen for HTTP server, default is 127.0.0.1
+    "listen_port": 18080,                       // The port to listen for HTTP server, default is 18080
+    "watchdog_feed_interval": 60,               // Watchdog feed interval, seconds, default is 600
+    "keep_alive_method": "special_process",     // How to keep target machine alive, default is "special_process"
+                                                //   "special_process" - Fork a child process with specified name
+    "special_process_name": "wsp-keepalive",    // The display name of the forked child process, default is "wsp-keepalive"
+}
+```
+
+You need to periodically send an HTTP GET request to `/watchdog/feed` at the `listen_port` in `watchdog_feed_interval` time,
+or the special process will be killed.
+You can combine this mode with `circadian`'s `process_block` config to keep it from auto-suspending.
+
+If you enable `keep_alive_mode` in proxy mode's config, the proxy will send requests to `/watchdog/feed` of this machine whenever there is any traffic towards this machine through it.

{wolsocketproxy-0.2.0 → wolsocketproxy-0.3.1}/src/wolsocketproxy.egg-info/SOURCES.txt

@@ -3,6 +3,8 @@ README.md
 pyproject.toml
 src/wolsocketproxy/__init__.py
 src/wolsocketproxy/__main__.py
+src/wolsocketproxy/common.py
+src/wolsocketproxy/keepalive.py
 src/wolsocketproxy/monitor.py
 src/wolsocketproxy/proxy.py
 src/wolsocketproxy/utils.py

{wolsocketproxy-0.2.0 → wolsocketproxy-0.3.1}/src/wolsocketproxy.egg-info/requires.txt

@@ -2,10 +2,11 @@ aiohttp==3.13.5
 dataclass-wizard==0.39.1
 icmplib==3.0.4
 redfish==3.3.5
+setproctitle==1.3.7
 wakeonlan==3.1.0
 
 [build]
-build[virtualenv]==1.4.2
+build[virtualenv]==1.5.0
 
 [dev]
 wolsocketproxy[lint]

wolsocketproxy-0.2.0/src/wolsocketproxy/__init__.py

@@ -1,44 +0,0 @@
-import json
-import logging
-from argparse import ArgumentParser
-from pathlib import Path
-
-import dataclass_wizard
-
-from wolsocketproxy.proxy import Proxy, ProxyConfig
-
-
-def main() -> None:
-    logging.basicConfig(level=logging.INFO)
-    log = logging.getLogger()
-
-    parser = ArgumentParser(prog="wolsocketproxy", description="A socket proxy with wake-on-lan feature.")
-
-    parser.add_argument(
-        "-c",
-        "--config",
-        help="The config file to use, default lookup order: /etc/wolsocketproxy.conf, ./wolsocketproxy.conf",
-    )
-
-    args = parser.parse_args()
-    config_path: Path
-
-    if "config" in args and args.config is not None:
-        config_path = Path(args.config)
-    else:
-        config_path = Path("/etc/wolsocketproxy.conf")
-
-        if not config_path.exists():
-            config_path = Path("./wolsocketproxy.conf")
-
-    if not config_path.exists():
-        log.error("Config file path %s does not exist!", config_path)
-        return
-
-    config_data = json.loads(config_path.read_text())
-    config = dataclass_wizard.fromdict(ProxyConfig, config_data)
-
-    log.info("Loaded config from %s", config_path)
-
-    proxy = Proxy(config)
-    proxy.start()