chore: commit local changes

backend/app/services/config_service.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import re
+from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import TYPE_CHECKING, TypeVar, cast
 
@@ -44,8 +45,12 @@ from app.models.config import (
     ServiceStatusResponse,
 )
 from app.exceptions import ConfigOperationError, ConfigValidationError, JailNotFoundError
-from app.services import log_service, setup_service
 from app.utils.fail2ban_client import Fail2BanClient
+from app.utils.log_utils import preview_log as util_preview_log, test_regex as util_test_regex
+from app.utils.setup_utils import (
+    get_map_color_thresholds as util_get_map_color_thresholds,
+    set_map_color_thresholds as util_set_map_color_thresholds,
+)
 
 log: structlog.stdlib.BoundLogger = structlog.get_logger()
 
@@ -493,8 +498,8 @@ async def update_global_config(socket_path: str, update: GlobalConfigUpdate) ->
 
 
 def test_regex(request: RegexTestRequest) -> RegexTestResponse:
-    """Proxy to :func:`app.services.log_service.test_regex`."""
-    return log_service.test_regex(request)
+    """Proxy to log utilities for regex test without service imports."""
+    return util_test_regex(request)
 
 
 # ---------------------------------------------------------------------------
@@ -572,9 +577,14 @@ async def delete_log_path(
         raise ConfigOperationError(f"Failed to delete log path {log_path!r}: {exc}") from exc
 
 
-async def preview_log(req: LogPreviewRequest) -> LogPreviewResponse:
-    """Proxy to :func:`app.services.log_service.preview_log`."""
-    return await log_service.preview_log(req)
+async def preview_log(
+    req: LogPreviewRequest,
+    preview_fn: Callable[[LogPreviewRequest], Awaitable[LogPreviewResponse]] | None = None,
+) -> LogPreviewResponse:
+    """Proxy to an injectable log preview function."""
+    if preview_fn is None:
+        preview_fn = util_preview_log
+    return await preview_fn(req)
 
 
 # ---------------------------------------------------------------------------
@@ -591,7 +601,7 @@ async def get_map_color_thresholds(db: aiosqlite.Connection) -> MapColorThreshol
     Returns:
         A :class:`MapColorThresholdsResponse` containing the three threshold values.
     """
-    high, medium, low = await setup_service.get_map_color_thresholds(db)
+    high, medium, low = await util_get_map_color_thresholds(db)
     return MapColorThresholdsResponse(
         threshold_high=high,
         threshold_medium=medium,
@@ -612,7 +622,7 @@ async def update_map_color_thresholds(
     Raises:
         ValueError: If validation fails (thresholds must satisfy high > medium > low).
     """
-    await setup_service.set_map_color_thresholds(
+    await util_set_map_color_thresholds(
         db,
         threshold_high=update.threshold_high,
         threshold_medium=update.threshold_medium,
@@ -634,16 +644,7 @@ _SAFE_LOG_PREFIXES: tuple[str, ...] = ("/var/log", "/config/log")
 
 
 def _count_file_lines(file_path: str) -> int:
-    """Count the total number of lines in *file_path* synchronously.
-
-    Uses a memory-efficient buffered read to avoid loading the whole file.
-
-    Args:
-        file_path: Absolute path to the file.
-
-    Returns:
-        Total number of lines in the file.
-    """
+    """Count the total number of lines in *file_path* synchronously."""
     count = 0
     with open(file_path, "rb") as fh:
         for chunk in iter(lambda: fh.read(65536), b""):
@@ -651,6 +652,32 @@ def _count_file_lines(file_path: str) -> int:
     return count
 
 
+def _read_tail_lines(file_path: str, num_lines: int) -> list[str]:
+    """Read the last *num_lines* from *file_path* in a memory-efficient way."""
+    chunk_size = 8192
+    raw_lines: list[bytes] = []
+    with open(file_path, "rb") as fh:
+        fh.seek(0, 2)
+        end_pos = fh.tell()
+        if end_pos == 0:
+            return []
+
+        buf = b""
+        pos = end_pos
+        while len(raw_lines) <= num_lines and pos > 0:
+            read_size = min(chunk_size, pos)
+            pos -= read_size
+            fh.seek(pos)
+            chunk = fh.read(read_size)
+            buf = chunk + buf
+            raw_lines = buf.split(b"\n")
+
+        if pos > 0 and len(raw_lines) > 1:
+            raw_lines = raw_lines[1:]
+
+    return [ln.decode("utf-8", errors="replace").rstrip() for ln in raw_lines[-num_lines:] if ln.strip()]
+
+
 async def read_fail2ban_log(
     socket_path: str,
     lines: int,
@@ -719,7 +746,7 @@ async def read_fail2ban_log(
 
     total_lines, raw_lines = await asyncio.gather(
         loop.run_in_executor(None, _count_file_lines, resolved_str),
-        loop.run_in_executor(None, log_service._read_tail_lines, resolved_str, lines),
+        loop.run_in_executor(None, _read_tail_lines, resolved_str, lines),
     )
 
     filtered = (
@@ -745,22 +772,27 @@ async def read_fail2ban_log(
     )
 
 
-async def get_service_status(socket_path: str) -> ServiceStatusResponse:
+async def get_service_status(
+    socket_path: str,
+    probe_fn: Callable[[str], Awaitable[ServiceStatusResponse]] | None = None,
+) -> ServiceStatusResponse:
     """Return fail2ban service health status with log configuration.
 
-    Delegates to :func:`~app.services.health_service.probe` for the core
-    health snapshot and augments it with the current log-level and log-target
-    values from the socket.
+    Delegates to an injectable *probe_fn* (defaults to
+    :func:`~app.services.health_service.probe`).  This avoids direct service-to-
+    service imports inside this module.
 
     Args:
         socket_path: Path to the fail2ban Unix domain socket.
+        probe_fn: Optional probe function.
 
     Returns:
         :class:`~app.models.config.ServiceStatusResponse`.
     """
-    from app.services.health_service import probe  # lazy import avoids circular dep
+    if probe_fn is None:
+        raise ValueError("probe_fn is required to avoid service-to-service coupling")
 
-    server_status = await probe(socket_path)
+    server_status = await probe_fn(socket_path)
 
     if server_status.online:
         client = Fail2BanClient(socket_path=socket_path, timeout=_SOCKET_TIMEOUT)