π OpenHands: AI-Driven Development
Break verified_models β app_server.config import cycle (#14436)
Juan Michelinia88f5038c3d9
diff --git a/enterprise/server/verified_models/verified_model_router.py b/enterprise/server/verified_models/verified_model_router.pyindex 33a89b1e6d..e104c1bb73 100644--- a/enterprise/server/verified_models/verified_model_router.py+++ b/enterprise/server/verified_models/verified_model_router.py@@ -16,7 +16,6 @@ from server.verified_models.verified_model_service import (verified_model_store_dependency,)-from openhands.app_server.config import get_db_sessionfrom openhands.app_server.config_api.default_llm_model_service import (DefaultLLMModelService,)@@ -24,6 +23,7 @@ from openhands.app_server.config_api.llm_model_service import (LLMModelService,LLMModelServiceInjector,)+from openhands.app_server.services.db_session import get_db_sessionfrom openhands.app_server.services.injector import InjectorStatefrom openhands.app_server.utils.llm import ModelsResponse, get_supported_llm_modelsdiff --git a/enterprise/server/verified_models/verified_model_service.py b/enterprise/server/verified_models/verified_model_service.pyindex 52edec8269..d909fcd520 100644--- a/enterprise/server/verified_models/verified_model_service.py+++ b/enterprise/server/verified_models/verified_model_service.py@@ -21,7 +21,7 @@ from sqlalchemy.ext.asyncio import AsyncSessionfrom sqlalchemy.orm import Mapped, mapped_columnfrom storage.base import Base-from openhands.app_server.config import depends_db_session+from openhands.app_server.services.db_session import depends_db_sessionfrom openhands.app_server.utils.logger import openhands_logger as loggerdiff --git a/openhands/app_server/config.py b/openhands/app_server/config.pyindex e2e5ac1e2d..0625a38e90 100644--- a/openhands/app_server/config.py+++ b/openhands/app_server/config.py@@ -7,7 +7,6 @@ from typing import AsyncContextManagerimport httpxfrom fastapi import Depends, Requestfrom pydantic import Field, SecretStr-from sqlalchemy.ext.asyncio import AsyncSession# Import the event_callback module to ensure all processors are registeredimport openhands.app_server.event_callback # noqa: F401@@ -52,6 +51,10 @@ from openhands.app_server.sandbox.sandbox_spec_service import (SandboxSpecService,SandboxSpecServiceInjector,)+from openhands.app_server.services.db_session import ( # noqa: F401 (re-exported)+ depends_db_session,+ get_db_session,+)from openhands.app_server.services.db_session_injector import (DbSessionInjector,)@@ -518,12 +521,6 @@ def get_jwt_service(return injector.context(state, request)-def get_db_session(- state: InjectorState, request: Request | None = None-) -> AsyncContextManager[AsyncSession]:- return get_global_config().db_session.context(state, request)--def get_app_lifespan_service() -> AppLifespanService | None:config = get_global_config()return config.lifespan@@ -593,10 +590,6 @@ def depends_jwt_service():return Depends(injector.depends)-def depends_db_session():- return Depends(get_global_config().db_session.depends)--def get_llm_model_service(state: InjectorState, request: Request | None = None) -> AsyncContextManager[LLMModelService]:diff --git a/openhands/app_server/services/db_session.py b/openhands/app_server/services/db_session.pynew file mode 100644index 0000000000..61574820c6--- /dev/null+++ b/openhands/app_server/services/db_session.py@@ -0,0 +1,74 @@+"""FastAPI dependency-injection helpers for the global ``AsyncSession``.++These helpers live here (next to ``db_session_injector``) rather than in+``openhands.app_server.config`` so that feature-layer modules that need an+``AsyncSession`` do not have to import ``app_server.config``.++That separation is important because ``app_server.config`` imports+``openhands.agent_server.env_parser``, and ``env_parser`` is what+dynamically loads classes named by ``OH_LLM_MODEL_KIND`` (and similar+discriminated-union env vars) at runtime. Some of those classes live in+feature packages such as ``server.verified_models``. If a feature module+also imports from ``app_server.config`` at module top level, the import+graph closes into a cycle:++ feature module+ -> openhands.app_server.config+ -> openhands.agent_server.env_parser+ -> (dynamic) feature module++The cycle is latent today because the dynamic edge is only traversed+lazily, but it would surface as an ``ImportError`` the moment anything+caused the feature module to be imported before ``app_server.config``+finished initialising. Keeping these DI helpers in a dependency-free+module lets feature code obtain an ``AsyncSession`` without putting+``app_server.config`` on its static import path.++``get_global_config`` is imported lazily inside each function body for+the same reason: importing this module must not pull in+``app_server.config``.+"""++from typing import AsyncContextManager, AsyncGenerator++from fastapi import Depends, Request+from sqlalchemy.ext.asyncio import AsyncSession++from openhands.app_server.services.injector import InjectorState+++def get_db_session(+ state: InjectorState, request: Request | None = None+) -> AsyncContextManager[AsyncSession]:+ """Return an async context manager yielding the request-scoped ``AsyncSession``."""+ from openhands.app_server.config import get_global_config++ return get_global_config().db_session.context(state, request)+++async def _yield_db_session(request: Request) -> AsyncGenerator[AsyncSession, None]:+ """Per-request FastAPI dependency yielding the request-scoped ``AsyncSession``.++ ``get_global_config`` is looked up at request time -- not at module load --+ so that this module is safe to evaluate from inside ``config_from_env``.+ Concretely, when ``OH_LLM_MODEL_KIND`` (or a similar discriminated-union env+ var) names a feature class whose module body calls ``depends_db_session()``+ as a default argument, ``env_parser`` will dynamically import that module+ while we are still constructing the global config. Calling+ ``get_global_config()`` eagerly here would re-enter the unfinished+ initialiser and recurse until the stack blows.+ """+ from openhands.app_server.config import get_global_config++ async for db_session in get_global_config().db_session.depends(request):+ yield db_session+++def depends_db_session():+ """FastAPI ``Depends(...)`` factory for the request-scoped ``AsyncSession``.++ Returns a stable ``Depends`` object that defers the ``get_global_config()``+ lookup to request time. Safe to call from module top level (e.g. as a+ default argument), even while ``config_from_env`` is still running.+ """+ return Depends(_yield_db_session)diff --git a/tests/unit/app_server/test_db_session_dependency.py b/tests/unit/app_server/test_db_session_dependency.pynew file mode 100644index 0000000000..36a77f4001--- /dev/null+++ b/tests/unit/app_server/test_db_session_dependency.py@@ -0,0 +1,66 @@+"""Regression tests for ``openhands.app_server.services.db_session``.++These tests lock in a specific contract: calling ``depends_db_session()`` at+module load time must NOT trigger ``get_global_config()``. If it does, an+``OH_LLM_MODEL_KIND`` value that dynamically imports a feature module whose+body uses ``depends_db_session()`` as a default argument re-enters the+in-flight ``get_global_config()`` and recurses until the stack blows --+exactly the crashloop seen in OpenHands/deploy#4315.+"""++import sys+import types++from fastapi.params import Depends++from openhands.app_server.services.db_session import (+ _yield_db_session,+ depends_db_session,+)+++def test_depends_db_session_returns_depends():+ """``depends_db_session()`` returns a FastAPI ``Depends`` instance."""+ result = depends_db_session()+ assert isinstance(result, Depends)+ # Must wrap the stable module-level callable, not a freshly bound method+ # closed over a (possibly half-initialised) config singleton.+ assert result.dependency is _yield_db_session+++def test_depends_db_session_does_not_resolve_config_at_construction():+ """Constructing the ``Depends`` must NOT trigger the lazy ``config`` import.++ This is the bug that caused the enterprise-server pod to crashloop with+ ``OH_LLM_MODEL_KIND=server.verified_models.verified_model_router.SaaSLLMModelServiceInjector``:+ ``verified_model_service`` is dynamically imported by ``env_parser`` while+ ``config_from_env`` is still running, evaluates ``depends_db_session()``+ as a default argument, and -- in the buggy version -- called+ ``get_global_config()`` while ``_global_config`` was still ``None``,+ re-entering the same initialiser and recursing until ``RecursionError``.++ We install a sentinel ``openhands.app_server.config`` module whose+ attribute access blows up; ``depends_db_session()`` must succeed without+ ever touching it. (``_yield_db_session`` will only touch it per request.)+ """+ original = sys.modules.get('openhands.app_server.config')+ sentinel = types.ModuleType('openhands.app_server.config')++ def _explode():+ raise AssertionError(+ 'depends_db_session() must NOT call get_global_config() '+ 'at Depends-construction time'+ )++ sentinel.get_global_config = _explode # type: ignore[attr-defined]+ sys.modules['openhands.app_server.config'] = sentinel+ try:+ # Calling depends_db_session() repeatedly must not raise.+ for _ in range(3):+ result = depends_db_session()+ assert isinstance(result, Depends)+ finally:+ if original is None:+ sys.modules.pop('openhands.app_server.config', None)+ else:+ sys.modules['openhands.app_server.config'] = original