refactor: move hc-required filter into check_route_health

``HealthCheckRouteHandler`` shrinks to a passthrough and drops its
``DeploymentRepository`` dependency. The (``hc is not None``) filter
that keeps the probe loop from misclassifying opt-out routes as stale
now lives at the head of ``RouteExecutor.check_route_health``, alongside
the Valkey record lookup it gates.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: fregataa

src/ai/backend/manager/sokovan/deployment/route/coordinator.py

@@ -158,7 +158,6 @@ def _init_handlers(self, executor: RouteExecutor) -> Mapping[RouteLifecycleType,
             RouteLifecycleType.HEALTH_CHECK: HealthCheckRouteHandler(
                 route_executor=executor,
                 event_producer=self._event_producer,
-                deployment_repository=self._deployment_repository,
             ),
             RouteLifecycleType.ROUTE_EVICTION: RouteEvictionHandler(
                 route_executor=executor,

src/ai/backend/manager/sokovan/deployment/route/executor.py

@@ -388,6 +388,19 @@ async def check_route_health(self, routes: Sequence[RouteData]) -> RouteExecutio
         Returns:
             Result with successes (healthy), errors (unhealthy), stale (degraded)
         """
+        if not routes:
+            return RouteExecutionResult(successes=[], errors=[], stale=[])
+
+        # Revisions that opted out of ``service.health_check`` have no
+        # RouteHealthRecord in Valkey; including them would classify
+        # them as stale. Drop them before the probe loop.
+        hc_configs = await self._deployment_repo.fetch_health_check_configs({
+            r.revision_id for r in routes
+        })
+        routes = [r for r in routes if hc_configs.get(r.revision_id) is not None]
+        if not routes:
+            return RouteExecutionResult(successes=[], errors=[], stale=[])
+
         # Phase 1: Load RouteHealthRecords
         with RouteRecorderContext.shared_phase("load_health_status"):
             with RouteRecorderContext.shared_step("query_health_check_results"):

src/ai/backend/manager/sokovan/deployment/route/handlers/health_check.py

@@ -14,7 +14,6 @@
     RouteTransitionTarget,
 )
 from ai.backend.manager.defs import LockID
-from ai.backend.manager.repositories.deployment import DeploymentRepository
 from ai.backend.manager.repositories.deployment.types import RouteData
 from ai.backend.manager.sokovan.deployment.route.executor import RouteExecutor
 from ai.backend.manager.sokovan.deployment.route.types import RouteExecutionResult
@@ -31,11 +30,9 @@ def __init__(
         self,
         route_executor: RouteExecutor,
         event_producer: EventProducer,
-        deployment_repository: DeploymentRepository,
     ) -> None:
         self._route_executor = route_executor
         self._event_producer = event_producer
-        self._deployment_repository = deployment_repository
 
     @classmethod
     def name(cls) -> str:
@@ -73,23 +70,9 @@ def status_transitions(cls) -> RouteStatusTransitions:
         )
 
     async def execute(self, routes: Sequence[RouteData]) -> RouteExecutionResult:
-        """Execute health check for routes.
-
-        Revisions that opted out of ``service.health_check`` have no
-        ``RouteHealthRecord`` in Valkey — including them would let the
-        executor classify them as stale. Filter on the per-revision
-        config fetched on entry so the probe loop only sees routes that
-        should be probed.
-        """
+        """Execute health check for routes."""
         log.debug("Checking health for {} routes", len(routes))
-        if not routes:
-            return RouteExecutionResult(successes=[], errors=[])
-        revision_ids = {r.revision_id for r in routes}
-        hc_configs = await self._deployment_repository.fetch_health_check_configs(revision_ids)
-        eligible = [r for r in routes if hc_configs.get(r.revision_id) is not None]
-        if not eligible:
-            return RouteExecutionResult(successes=[], errors=[])
-        return await self._route_executor.check_route_health(eligible)
+        return await self._route_executor.check_route_health(routes)
 
     async def post_process(self, result: RouteExecutionResult) -> None:
         """Log health-check results.

tests/unit/manager/sokovan/deployment/route/executor/conftest.py

@@ -9,6 +9,7 @@
 import pytest
 from dateutil.tz import tzutc
 
+from ai.backend.common.config import ModelHealthCheck
 from ai.backend.common.data.endpoint.types import EndpointLifecycle, ScalingState
 from ai.backend.common.identifier.deployment import DeploymentID
 from ai.backend.common.identifier.deployment_revision import DeploymentRevisionID
@@ -38,7 +39,16 @@ def mock_deployment_repo() -> AsyncMock:
     repo.get_deployments_by_ids = AsyncMock(return_value=[])
     repo.update_route_sessions = AsyncMock(return_value=None)
     repo.fetch_session_statuses_by_route_ids = AsyncMock(return_value={})
-    repo.fetch_health_check_configs = AsyncMock(return_value={})
+
+    # Default to "every revision declared a probe" so tests for paths
+    # that filter on hc_configs (``check_route_health``, ``sync_appproxy``)
+    # see the input route set unchanged unless they override this.
+    async def _default_health_check_configs(
+        revision_ids: set[DeploymentRevisionID],
+    ) -> dict[DeploymentRevisionID, ModelHealthCheck]:
+        return {rid: ModelHealthCheck(path="/health", initial_delay=720.0) for rid in revision_ids}
+
+    repo.fetch_health_check_configs = AsyncMock(side_effect=_default_health_check_configs)
     repo.fetch_route_service_discovery_info = AsyncMock(return_value=[])
     repo.get_scaling_group_cleanup_configs = AsyncMock(return_value={})
     repo.fetch_deployment_context = AsyncMock(return_value=MagicMock())

tests/unit/manager/sokovan/deployment/route/handlers/test_health_check_handler.py

@@ -1,11 +1,8 @@
 """Unit tests for HealthCheckRouteHandler.
 
-The handler resolves the per-revision ``ModelHealthCheck`` itself and
-drops routes whose revision opted out of ``service.health_check`` before
-forwarding the remainder to ``RouteExecutor.check_route_health``. The
-register push for first-time HEALTHY transitions is exercised in the
-executor tests; here we only verify the handler stays a thin shim plus
-the hc-null skip.
+The handler is a thin pass-through to ``RouteExecutor.check_route_health``;
+the per-revision hc filtering and the register push for first-time
+HEALTHY transitions are exercised in the executor tests.
 """
 
 from __future__ import annotations
@@ -16,7 +13,6 @@
 
 from dateutil.tz import tzutc
 
-from ai.backend.common.config import ModelHealthCheck
 from ai.backend.common.identifier.deployment import DeploymentID
 from ai.backend.common.identifier.deployment_revision import DeploymentRevisionID
 from ai.backend.common.types import SessionId
@@ -28,78 +24,41 @@
 from ai.backend.manager.sokovan.deployment.route.types import RouteExecutionResult
 
 
-def _route(
-    health_status: RouteHealthStatus,
-    revision_id: DeploymentRevisionID | None = None,
-) -> RouteData:
+def _route(health_status: RouteHealthStatus) -> RouteData:
     return RouteData(
         route_id=uuid4(),
         deployment_id=DeploymentID(uuid4()),
         session_id=SessionId(uuid4()),
         status=RouteStatus.RUNNING,
         health_status=health_status,
         traffic_ratio=1.0,
-        revision_id=revision_id or DeploymentRevisionID(uuid4()),
+        revision_id=DeploymentRevisionID(uuid4()),
         replica_host="10.0.0.1",
         replica_port=8000,
         created_at=datetime.now(tzutc()),
     )
 
 
 class TestHealthCheckHandler:
-    """Tests for HealthCheckRouteHandler delegation and hc gating."""
+    """Tests for HealthCheckRouteHandler delegation."""
 
-    async def test_execute_forwards_routes_with_health_check(self) -> None:
-        """Routes whose revision declares a probe reach the executor."""
+    async def test_execute_forwards_routes_to_executor(self) -> None:
         executor = AsyncMock()
         check_result = RouteExecutionResult(successes=[], errors=[], stale=[])
         executor.check_route_health = AsyncMock(return_value=check_result)
-        repo = AsyncMock()
-        route = _route(RouteHealthStatus.NOT_CHECKED)
-        repo.fetch_health_check_configs = AsyncMock(
-            return_value={route.revision_id: ModelHealthCheck(path="/health", initial_delay=720.0)}
-        )
-        handler = HealthCheckRouteHandler(executor, MagicMock(), repo)
+        handler = HealthCheckRouteHandler(executor, MagicMock())
 
-        result = await handler.execute([route])
+        routes = [_route(RouteHealthStatus.NOT_CHECKED)]
+        result = await handler.execute(routes)
 
-        executor.check_route_health.assert_awaited_once_with([route])
-        repo.fetch_health_check_configs.assert_awaited_once_with({route.revision_id})
+        executor.check_route_health.assert_awaited_once_with(routes)
         assert result is check_result
 
-    async def test_execute_skips_routes_without_health_check(self) -> None:
-        """Routes whose revision opted out of probing never reach the executor."""
-        executor = AsyncMock()
-        executor.check_route_health = AsyncMock(
-            return_value=RouteExecutionResult(successes=[], errors=[], stale=[])
-        )
-        repo = AsyncMock()
-        route = _route(RouteHealthStatus.NOT_CHECKED)
-        repo.fetch_health_check_configs = AsyncMock(return_value={route.revision_id: None})
-        handler = HealthCheckRouteHandler(executor, MagicMock(), repo)
-
-        result = await handler.execute([route])
-
-        executor.check_route_health.assert_not_awaited()
-        assert result.successes == []
-
-    async def test_execute_empty_routes_is_noop(self) -> None:
-        executor = AsyncMock()
-        repo = AsyncMock()
-        handler = HealthCheckRouteHandler(executor, MagicMock(), repo)
-
-        result = await handler.execute([])
-
-        repo.fetch_health_check_configs.assert_not_awaited()
-        executor.check_route_health.assert_not_awaited()
-        assert result.successes == []
-
     async def test_post_process_logs_only(self) -> None:
         """post_process is a logging shim — no executor call here."""
         executor = AsyncMock()
-        repo = AsyncMock()
         event_producer = MagicMock()
-        handler = HealthCheckRouteHandler(executor, event_producer, repo)
+        handler = HealthCheckRouteHandler(executor, event_producer)
         success_route = _route(RouteHealthStatus.NOT_CHECKED)
 
         await handler.post_process(