Implement scheduled power-up with cron-based auto power-on and time-bound keep-alive

Add scheduled_power_up_times to machine config with cron expressions for automatic power-up and keep_alive_time for post-wake keep-alive duration. Introduce ScheduledPowerUpManager with its own event loop; overlapping keep-alive windows are automatically merged. Extract _send() helper from TargetKeepAliveSender and add stop() for clean thread/loop teardown.

Author: notsyncing

.dockerignore

@@ -8,4 +8,5 @@ __pycache__/
 wolsocketproxy.conf
 wolsocketproxy-keepalive.conf
 *.egg-info/
-.vscode/
+.vscode/
+.kilo/

.gitignore

@@ -8,4 +8,5 @@ __pycache__/
 wolsocketproxy.conf
 wolsocketproxy-keepalive.conf
 *.egg-info/
-.vscode/
+.vscode/
+.kilo/

README.md

@@ -71,8 +71,14 @@ The `wolsocketproxy.conf` has the following structure:
             "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
             "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
+                                                                         // 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
+            "scheduled_power_up_times": [                               // Scheduled power-up times, optional
+                {
+                    "cron": "0 7 * * 1-5",                             // Cron expression for auto power-up
+                    "keep_alive_time": 7200                             // Send keep-alive requests for N seconds after power-up
+                }
+            ]
         },
         // ... more machines ...
     },
@@ -136,3 +142,16 @@ 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.
+
+### Scheduled power-up
+
+You can configure `scheduled_power_up_times` in each machine entry to automatically power up the machine at specified times using
+a cron expression. After the machine comes online, the proxy sends keep-alive requests to the machine's keep-alive daemon
+(for the duration specified by `keep_alive_time`) to prevent it from auto-suspending during the expected usage window.
+
+Each entry in `scheduled_power_up_times` contains:
+- `cron`: A standard 5-field cron expression (e.g. `"0 7 * * 1-5"` for weekdays at 7:00)
+- `keep_alive_time`: Duration in seconds to send keep-alive requests after power-up (e.g. `7200` for 2 hours)
+
+If multiple entries overlap in time, the keep-alive period is automatically extended to cover the longest window, and no
+duplicate keep-alive requests are sent.

pyproject.toml

@@ -20,6 +20,7 @@ classifiers = [
 requires-python = ">=3.12"
 dependencies = [
     "aiohttp==3.13.5",
+    "croniter==6.0.0",
     "dataclass-wizard==0.39.1",
     "icmplib==3.0.4",
     "redfish==3.3.5",

src/wolsocketproxy/proxy.py

@@ -1,20 +1,30 @@
 import asyncio
 import contextlib
 import logging
+import time
+from collections.abc import Callable, Coroutine
 from dataclasses import dataclass
+from datetime import datetime
 from logging import Logger
-from threading import Thread
+from threading import Event, Thread
 from typing import Any, Literal, override
 
 import aiohttp
 import wakeonlan
+from croniter import croniter
 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
 
 
+@dataclass
+class ScheduledPowerUpTime:
+    cron: str
+    keep_alive_time: int = 0
+
+
 @dataclass
 class MachineConfig:
     wake_up_method: Literal["ipmi", "wol"] = "wol"
@@ -36,6 +46,8 @@ class MachineConfig:
     keep_alive_mode_base_url: str | None = None
     keep_alive_min_interval: int = 1
 
+    scheduled_power_up_times: list[ScheduledPowerUpTime] | None = None
+
 
 @dataclass
 class ProxyRoute:
@@ -70,43 +82,160 @@ class TargetKeepAliveSender:
     _keep_alive_min_interval: int
     _loop: asyncio.AbstractEventLoop
     _queue: asyncio.Queue
+    _stop_event: Event
 
     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)
+        self._stop_event = Event()
 
-        def _loop() -> None:
+        def _run_loop() -> None:
             asyncio.set_event_loop(self._loop)
             self._loop.run_until_complete(self._send_worker())
 
-        Thread(target=_loop, daemon=True).start()
+        Thread(target=_run_loop, daemon=True).start()
 
     async def _send_worker(self) -> None:
-        while True:
+        while not self._stop_event.is_set():
             await self._queue.get()
-
-            try:
-                async with aiohttp.request(
-                    "GET",
-                    self._target_url,
-                    timeout=aiohttp.ClientTimeout(total=5),
-                ) as resp:
-                    await resp.json()
-            except (aiohttp.ClientError, aiohttp.ClientResponseError):
-                self._log.warning("Failed to send target keep alive request to %s", self._target_url, exc_info=True)
-
+            if self._stop_event.is_set():
+                break
+            await self._send()
             await asyncio.sleep(self._keep_alive_min_interval)
 
+    async def _send(self) -> None:
+        try:
+            async with aiohttp.request(
+                "GET",
+                self._target_url,
+                timeout=aiohttp.ClientTimeout(total=5),
+            ) as resp:
+                await resp.json()
+        except (aiohttp.ClientError, aiohttp.ClientResponseError):
+            self._log.warning("Failed to send target keep alive request to %s", self._target_url, exc_info=True)
+
     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)
 
+    def stop(self) -> None:
+        self._stop_event.set()
+        with contextlib.suppress(asyncio.QueueFull):
+            self._loop.call_soon_threadsafe(lambda: self._queue.put_nowait(None))
+
+
+class ScheduledPowerUpManager:
+    _log: Logger = logging.getLogger(__name__)
+
+    _machines: dict[str, MachineConfig]
+    _wake_up_callback: Callable[[str], Coroutine[Any, Any, None]]
+    _loop: asyncio.AbstractEventLoop
+    _keep_alive_end_times: dict[str, float]
+
+    def __init__(
+        self,
+        machines: dict[str, MachineConfig],
+        wake_up_callback: Callable[[str], Coroutine[Any, Any, None]],
+    ) -> None:
+        self._machines = machines
+        self._wake_up_callback = wake_up_callback
+        self._keep_alive_end_times = {}
+
+    def start(self) -> None:
+        self._loop = asyncio.new_event_loop()
+
+        def _run_loop() -> None:
+            asyncio.set_event_loop(self._loop)
+            self._loop.run_forever()
+
+        Thread(target=_run_loop, daemon=True).start()
+
+        for machine_name, machine in self._machines.items():
+            schedules = machine.scheduled_power_up_times
+            if not schedules:
+                continue
+
+            if machine.keep_alive_mode_base_url is None:
+                self._log.warning(
+                    "Machine %s has scheduled_power_up_times but no keep_alive_mode_base_url configured, "
+                    "keep-alive after power-up will be skipped",
+                    machine_name,
+                )
+
+            for schedule in schedules:
+                asyncio.run_coroutine_threadsafe(
+                    self._process_schedule(machine_name, machine, schedule),
+                    self._loop,
+                )
+
+    async def _process_schedule(
+        self,
+        machine_name: str,
+        machine: MachineConfig,
+        schedule: ScheduledPowerUpTime,
+    ) -> None:
+        while True:
+            now = datetime.now()
+            cron = croniter(schedule.cron, now)
+            next_time = cron.get_next(datetime)
+
+            delay = (next_time - datetime.now()).total_seconds()
+            if delay > 0:
+                await asyncio.sleep(delay)
+
+            self._log.info(
+                "Scheduled power-up triggered for %s (cron: %s)",
+                machine_name,
+                schedule.cron,
+            )
+
+            try:
+                await self._wake_up_callback(machine_name)
+            except ConnectionAbortedError:
+                self._log.error(
+                    "Scheduled power-up failed for %s, will retry at next schedule time",
+                    machine_name,
+                )
+                continue
+
+            if schedule.keep_alive_time > 0 and machine.keep_alive_mode_base_url is not None:
+                await self._run_keep_alive(machine_name, machine, schedule.keep_alive_time)
+
+
+    async def _run_keep_alive(
+        self,
+        machine_name: str,
+        machine: MachineConfig,
+        keep_alive_time: int,
+    ) -> None:
+        assert machine.keep_alive_mode_base_url is not None
+        new_end = time.monotonic() + keep_alive_time
+        current_end = self._keep_alive_end_times.get(machine_name, 0.0)
+
+        if new_end > current_end:
+            self._keep_alive_end_times[machine_name] = new_end
+
+        if current_end > time.monotonic():
+            return
+
+        sender = TargetKeepAliveSender(
+            machine.keep_alive_mode_base_url,
+            machine.keep_alive_min_interval,
+        )
+
+        try:
+            while time.monotonic() < self._keep_alive_end_times.get(machine_name, 0.0):
+                sender.schedule_send()
+                await asyncio.sleep(machine.keep_alive_min_interval)
+        finally:
+            sender.stop()
+
 
 class ProxyUdpProtocol(asyncio.DatagramProtocol):
     _proxy: "Proxy"
@@ -163,6 +292,7 @@ class Proxy:
     _machines: dict[str, MachineConfig]
     _routes: list[ProxyRoute]
     _ipmi_configs: dict[str, IPMIConfig]
+    _scheduled_power_up_manager: ScheduledPowerUpManager
 
     def __init__(self, config: ProxyConfig) -> None:
         self._config = config
@@ -202,6 +332,11 @@ def __init__(self, config: ProxyConfig) -> None:
             }
         )
 
+        self._scheduled_power_up_manager = ScheduledPowerUpManager(
+            machines=self._machines,
+            wake_up_callback=self._wake_up_target,
+        )
+
     def start(self) -> None:
         self._monitor.start()
 
@@ -210,6 +345,8 @@ def start(self) -> None:
 
         loop = asyncio.get_event_loop()
 
+        self._scheduled_power_up_manager.start()
+
         self._log.info("Proxy server started.")
 
         with contextlib.suppress(KeyboardInterrupt):