wolsocketproxy 0.3.0__tar.gz → 0.4.0__tar.gz

{wolsocketproxy-0.3.0/src/wolsocketproxy.egg-info → wolsocketproxy-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolsocketproxy
-Version: 0.3.0
+Version: 0.4.0
 Summary: A socket proxy with wake-on-lan feature.
 Author-email: Song Fuchang <song.fc@gmail.com>
 License-Expression: Apache-2.0
@@ -14,6 +14,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp==3.13.5
+Requires-Dist: croniter==6.0.0
 Requires-Dist: dataclass-wizard==0.39.1
 Requires-Dist: icmplib==3.0.4
 Requires-Dist: redfish==3.3.5
@@ -100,7 +101,16 @@ The `wolsocketproxy.conf` has the following structure:
             "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
+            "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 ...
     },
@@ -162,3 +172,18 @@ The config file `wolsocketproxy.conf` should look like the following:
 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.
+
+### 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.

{wolsocketproxy-0.3.0 → wolsocketproxy-0.4.0}/README.md

@@ -69,7 +69,16 @@ The `wolsocketproxy.conf` has the following structure:
             "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
+            "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 ...
     },
@@ -131,3 +140,18 @@ The config file `wolsocketproxy.conf` should look like the following:
 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.
+
+### 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.

{wolsocketproxy-0.3.0 → wolsocketproxy-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wolsocketproxy"
-version = "0.3.0"
+version = "0.4.0"
 description = "A socket proxy with wake-on-lan feature."
 authors = [
     {name = "Song Fuchang", email = "song.fc@gmail.com"}
@@ -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",
@@ -72,4 +73,5 @@ lint.ignore = [
     "ISC001",
     "TRY003",
     "TRY201",
+    "PLR0913",
 ]

wolsocketproxy-0.4.0/src/wolsocketproxy/common.py

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

{wolsocketproxy-0.3.0 → wolsocketproxy-0.4.0}/src/wolsocketproxy/keepalive.py

@@ -12,6 +12,8 @@ from aiohttp import web
 from aiohttp.web import Request, Response
 from setproctitle import setproctitle
 
+from wolsocketproxy.common import URL_WATCHDOG_FEED
+
 
 @dataclass
 class KeepAliveConfig:
@@ -41,11 +43,7 @@ class KeepAliveDaemon:
 
         self._web_app = web.Application()
 
-        self._web_app.add_routes(
-            [
-                web.get("/watchdog/feed", self._handle_watchdog_feed)
-            ]
-        )
+        self._web_app.add_routes([web.get(URL_WATCHDOG_FEED, self._handle_watchdog_feed)])
 
     async def _watchdog_timer(self) -> None:
         while True:
@@ -97,8 +95,7 @@ class KeepAliveDaemon:
             return True
 
         self._log.info(
-            "Started special process with name %s, PID %d",
-            self._config.special_process_name, self._special_process_id
+            "Started special process with name %s, PID %d", self._config.special_process_name, self._special_process_id
         )
 
         return False
@@ -123,7 +120,9 @@ class KeepAliveDaemon:
 
         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
+            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)

{wolsocketproxy-0.3.0 → wolsocketproxy-0.4.0}/src/wolsocketproxy/proxy.py

@@ -1,17 +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 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"
@@ -29,6 +42,12 @@ 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
+
+    scheduled_power_up_times: list[ScheduledPowerUpTime] | None = None
+
 
 @dataclass
 class ProxyRoute:
@@ -56,6 +75,168 @@ class ProxyConfig:
     ipmi_configs: list[IPMIConfig] | None = None
 
 
+class TargetKeepAliveSender:
+    _log: logging.Logger = logging.getLogger(__name__)
+
+    _target_url: str
+    _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 _run_loop() -> None:
+            asyncio.set_event_loop(self._loop)
+            self._loop.run_until_complete(self._send_worker())
+
+        Thread(target=_run_loop, daemon=True).start()
+
+    async def _send_worker(self) -> None:
+        while not self._stop_event.is_set():
+            await self._queue.get()
+            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"
     _monitor: Monitor
@@ -63,16 +244,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 +281,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()
@@ -100,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
@@ -139,6 +332,11 @@ class Proxy:
             }
         )
 
+        self._scheduled_power_up_manager = ScheduledPowerUpManager(
+            machines=self._machines,
+            wake_up_callback=self._wake_up_target,
+        )
+
     def start(self) -> None:
         self._monitor.start()
 
@@ -147,6 +345,8 @@ class Proxy:
 
         loop = asyncio.get_event_loop()
 
+        self._scheduled_power_up_manager.start()
+
         self._log.info("Proxy server started.")
 
         with contextlib.suppress(KeyboardInterrupt):
@@ -180,9 +380,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 +404,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 +440,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 +450,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.3.0 → wolsocketproxy-0.4.0/src/wolsocketproxy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolsocketproxy
-Version: 0.3.0
+Version: 0.4.0
 Summary: A socket proxy with wake-on-lan feature.
 Author-email: Song Fuchang <song.fc@gmail.com>
 License-Expression: Apache-2.0
@@ -14,6 +14,7 @@ Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp==3.13.5
+Requires-Dist: croniter==6.0.0
 Requires-Dist: dataclass-wizard==0.39.1
 Requires-Dist: icmplib==3.0.4
 Requires-Dist: redfish==3.3.5
@@ -100,7 +101,16 @@ The `wolsocketproxy.conf` has the following structure:
             "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
+            "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 ...
     },
@@ -162,3 +172,18 @@ The config file `wolsocketproxy.conf` should look like the following:
 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.
+
+### 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.

{wolsocketproxy-0.3.0 → wolsocketproxy-0.4.0}/src/wolsocketproxy.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ 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

{wolsocketproxy-0.3.0 → wolsocketproxy-0.4.0}/src/wolsocketproxy.egg-info/requires.txt

@@ -1,4 +1,5 @@
 aiohttp==3.13.5
+croniter==6.0.0
 dataclass-wizard==0.39.1
 icmplib==3.0.4
 redfish==3.3.5