Add async read-only proxy client
This commit is contained in:
@@ -0,0 +1,288 @@
|
||||
"""Client TCP asynchrone, strictement en lecture seule, pour le proxy Arkteos."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import inspect
|
||||
from collections.abc import Awaitable, Callable, Sequence
|
||||
from contextlib import suppress
|
||||
from typing import Final, TypeAlias
|
||||
|
||||
from .frame_extractor import FrameExtractor
|
||||
from .parser import FilterResult, FrameError, ParsedFrame, filter_values, parse_frame
|
||||
|
||||
|
||||
DEFAULT_PROXY_PORT: Final = 9641
|
||||
DEFAULT_RECONNECT_DELAYS: Final[tuple[float, ...]] = (1.0, 2.0, 5.0, 10.0, 30.0)
|
||||
|
||||
DataCallback: TypeAlias = Callable[
|
||||
[str, dict[str, int | float | str], dict[str, int | float]], object
|
||||
]
|
||||
AvailabilityCallback: TypeAlias = Callable[[bool], object]
|
||||
SleepCallable: TypeAlias = Callable[[float], Awaitable[None]]
|
||||
|
||||
|
||||
class ArkteosClient:
|
||||
"""Lit le proxy Arkteos, extrait les trames et diffuse les données filtrées."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
host: str,
|
||||
port: int = DEFAULT_PROXY_PORT,
|
||||
*,
|
||||
read_size: int = 1024,
|
||||
frame_timeout: float = 30.0,
|
||||
reconnect_delays: Sequence[float] = DEFAULT_RECONNECT_DELAYS,
|
||||
max_buffer_size: int = 4096,
|
||||
sleep: SleepCallable = asyncio.sleep,
|
||||
) -> None:
|
||||
if not host:
|
||||
raise ValueError("host ne peut pas être vide")
|
||||
if not 1 <= port <= 65535:
|
||||
raise ValueError("port doit être compris entre 1 et 65535")
|
||||
if read_size < 1:
|
||||
raise ValueError("read_size doit être positif")
|
||||
if frame_timeout <= 0:
|
||||
raise ValueError("frame_timeout doit être positif")
|
||||
if not reconnect_delays or any(delay < 0 for delay in reconnect_delays):
|
||||
raise ValueError("reconnect_delays doit contenir des délais positifs ou nuls")
|
||||
|
||||
self.host = host
|
||||
self.port = port
|
||||
self.read_size = read_size
|
||||
self.frame_timeout = frame_timeout
|
||||
self.reconnect_delays = tuple(reconnect_delays)
|
||||
|
||||
self.running = False
|
||||
self.connected = False
|
||||
self.available = False
|
||||
self.last_valid_frame: ParsedFrame | None = None
|
||||
self.last_frame_type: str | None = None
|
||||
self.latest_frigo_data: dict[str, int | float | str] | None = None
|
||||
self.latest_regulation_data: dict[str, int | float | str] | None = None
|
||||
self.latest_metadata: dict[str, int | float | str] | None = None
|
||||
self.frames_received = 0
|
||||
self.frames_rejected = 0
|
||||
self.bytes_received = 0
|
||||
self.connection_attempts = 0
|
||||
self.reconnect_count = 0
|
||||
self.last_error: Exception | None = None
|
||||
|
||||
self._extractor = FrameExtractor(max_buffer_size=max_buffer_size)
|
||||
self._sleep = sleep
|
||||
self._task: asyncio.Task[None] | None = None
|
||||
self._writer: asyncio.StreamWriter | None = None
|
||||
self._connected_event = asyncio.Event()
|
||||
self._data_callbacks: list[DataCallback] = []
|
||||
self._availability_callbacks: list[AvailabilityCallback] = []
|
||||
|
||||
async def start(self) -> None:
|
||||
"""Démarre la tâche de connexion si le client n'est pas déjà actif."""
|
||||
|
||||
if self.running:
|
||||
return
|
||||
|
||||
self.running = True
|
||||
self._task = asyncio.create_task(self._run(), name="arkteos-client")
|
||||
|
||||
async def stop(self) -> None:
|
||||
"""Arrête le client, ferme le flux et attend toutes ses tâches."""
|
||||
|
||||
self.running = False
|
||||
self._set_connected(False)
|
||||
await self._set_available(False)
|
||||
await self._close_writer()
|
||||
|
||||
task = self._task
|
||||
self._task = None
|
||||
if task is not None and task is not asyncio.current_task() and not task.done():
|
||||
task.cancel()
|
||||
with suppress(asyncio.CancelledError):
|
||||
await task
|
||||
|
||||
async def wait_until_connected(self, timeout: float | None = None) -> bool:
|
||||
"""Attend une connexion établie, avec délai optionnel."""
|
||||
|
||||
if self.connected:
|
||||
return True
|
||||
try:
|
||||
if timeout is None:
|
||||
await self._connected_event.wait()
|
||||
else:
|
||||
await asyncio.wait_for(self._connected_event.wait(), timeout)
|
||||
except TimeoutError:
|
||||
return False
|
||||
return self.connected
|
||||
|
||||
def add_data_callback(self, callback: DataCallback) -> None:
|
||||
"""Ajoute un callback de données sans le dupliquer."""
|
||||
|
||||
if callback not in self._data_callbacks:
|
||||
self._data_callbacks.append(callback)
|
||||
|
||||
def remove_data_callback(self, callback: DataCallback) -> None:
|
||||
"""Retire un callback de données s'il est enregistré."""
|
||||
|
||||
with suppress(ValueError):
|
||||
self._data_callbacks.remove(callback)
|
||||
|
||||
def add_availability_callback(self, callback: AvailabilityCallback) -> None:
|
||||
"""Ajoute un callback de disponibilité sans le dupliquer."""
|
||||
|
||||
if callback not in self._availability_callbacks:
|
||||
self._availability_callbacks.append(callback)
|
||||
|
||||
def remove_availability_callback(self, callback: AvailabilityCallback) -> None:
|
||||
"""Retire un callback de disponibilité s'il est enregistré."""
|
||||
|
||||
with suppress(ValueError):
|
||||
self._availability_callbacks.remove(callback)
|
||||
|
||||
async def _run(self) -> None:
|
||||
delay_index = 0
|
||||
try:
|
||||
while self.running:
|
||||
self.connection_attempts += 1
|
||||
try:
|
||||
reader, writer = await asyncio.open_connection(self.host, self.port)
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
except Exception as error:
|
||||
self.last_error = error
|
||||
self._set_connected(False)
|
||||
await self._set_available(False)
|
||||
if not await self._wait_before_reconnect(delay_index):
|
||||
break
|
||||
delay_index = min(delay_index + 1, len(self.reconnect_delays) - 1)
|
||||
continue
|
||||
|
||||
self._writer = writer
|
||||
self._set_connected(True)
|
||||
received_valid_frame = await self._read_connection(reader)
|
||||
if received_valid_frame:
|
||||
delay_index = 0
|
||||
|
||||
self._set_connected(False)
|
||||
await self._set_available(False)
|
||||
await self._close_writer()
|
||||
if not self.running:
|
||||
break
|
||||
if not await self._wait_before_reconnect(delay_index):
|
||||
break
|
||||
delay_index = min(delay_index + 1, len(self.reconnect_delays) - 1)
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
finally:
|
||||
self._set_connected(False)
|
||||
await self._set_available(False)
|
||||
await self._close_writer()
|
||||
|
||||
async def _wait_before_reconnect(self, delay_index: int) -> bool:
|
||||
if not self.running:
|
||||
return False
|
||||
self.reconnect_count += 1
|
||||
await self._sleep(self.reconnect_delays[delay_index])
|
||||
return self.running
|
||||
|
||||
async def _read_connection(self, reader: asyncio.StreamReader) -> bool:
|
||||
received_valid_frame = False
|
||||
loop = asyncio.get_running_loop()
|
||||
deadline = loop.time() + self.frame_timeout
|
||||
|
||||
while self.running:
|
||||
remaining = deadline - loop.time()
|
||||
if remaining <= 0:
|
||||
await self._set_available(False)
|
||||
deadline = loop.time() + self.frame_timeout
|
||||
remaining = self.frame_timeout
|
||||
|
||||
try:
|
||||
data = await asyncio.wait_for(reader.read(self.read_size), remaining)
|
||||
except asyncio.CancelledError:
|
||||
raise
|
||||
except TimeoutError:
|
||||
await self._set_available(False)
|
||||
deadline = loop.time() + self.frame_timeout
|
||||
continue
|
||||
except Exception as error:
|
||||
self.last_error = error
|
||||
return received_valid_frame
|
||||
|
||||
if not data:
|
||||
return received_valid_frame
|
||||
|
||||
self.bytes_received += len(data)
|
||||
try:
|
||||
raw_frames = self._extractor.feed(data)
|
||||
except Exception as error:
|
||||
self.frames_rejected += 1
|
||||
self.last_error = error
|
||||
continue
|
||||
|
||||
for raw_frame in raw_frames:
|
||||
try:
|
||||
frame = parse_frame(raw_frame)
|
||||
filtered = filter_values(frame)
|
||||
except FrameError as error:
|
||||
self.frames_rejected += 1
|
||||
self.last_error = error
|
||||
continue
|
||||
|
||||
received_valid_frame = True
|
||||
deadline = loop.time() + self.frame_timeout
|
||||
await self._accept_frame(frame, filtered)
|
||||
|
||||
return received_valid_frame
|
||||
|
||||
async def _accept_frame(self, frame: ParsedFrame, filtered: FilterResult) -> None:
|
||||
accepted = dict(filtered.accepted)
|
||||
rejected = dict(filtered.rejected)
|
||||
frame_type = accepted["frame_type"]
|
||||
assert isinstance(frame_type, str)
|
||||
|
||||
self.frames_received += 1
|
||||
self.last_valid_frame = frame
|
||||
self.last_frame_type = frame_type
|
||||
if frame_type == "frigo":
|
||||
self.latest_frigo_data = accepted
|
||||
elif frame_type == "regulation":
|
||||
self.latest_regulation_data = accepted
|
||||
else:
|
||||
self.latest_metadata = accepted
|
||||
|
||||
await self._set_available(True)
|
||||
for callback in tuple(self._data_callbacks):
|
||||
await self._invoke_callback(callback, frame_type, dict(accepted), dict(rejected))
|
||||
|
||||
async def _set_available(self, value: bool) -> None:
|
||||
if self.available == value:
|
||||
return
|
||||
self.available = value
|
||||
for callback in tuple(self._availability_callbacks):
|
||||
await self._invoke_callback(callback, value)
|
||||
|
||||
async def _invoke_callback(self, callback: Callable[..., object], *args: object) -> None:
|
||||
try:
|
||||
result = callback(*args)
|
||||
if inspect.isawaitable(result):
|
||||
await result
|
||||
except Exception as error:
|
||||
self.last_error = error
|
||||
|
||||
def _set_connected(self, value: bool) -> None:
|
||||
self.connected = value
|
||||
if value:
|
||||
self._connected_event.set()
|
||||
else:
|
||||
self._connected_event.clear()
|
||||
|
||||
async def _close_writer(self) -> None:
|
||||
writer = self._writer
|
||||
self._writer = None
|
||||
if writer is None:
|
||||
return
|
||||
writer.close()
|
||||
try:
|
||||
await writer.wait_closed()
|
||||
except Exception as error:
|
||||
self.last_error = error
|
||||
Reference in New Issue
Block a user