Refactored context creation to follow the contextvar switch

Author: eadwinCode

ellar/core/connection/http.py

@@ -8,16 +8,16 @@
 from ellar.constants import SCOPE_SERVICE_PROVIDER
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.di.injector import RequestServiceProvider
+    from ellar.di import EllarInjector
 
 
 class HTTPConnection(StarletteHTTPConnection):
     @property
-    def service_provider(self) -> "RequestServiceProvider":
+    def service_provider(self) -> "EllarInjector":
         assert (
             SCOPE_SERVICE_PROVIDER in self.scope
         ), "RequestServiceProviderMiddleware must be installed to access request.service_provider"
-        return t.cast("RequestServiceProvider", self.scope[SCOPE_SERVICE_PROVIDER])
+        return t.cast("EllarInjector", self.scope[SCOPE_SERVICE_PROVIDER])
 
 
 class Request(StarletteRequest, HTTPConnection):

ellar/core/context/__init__.py

@@ -1,9 +1,12 @@
 from .exceptions import HostContextException
 from .execution import ExecutionContext
+from .factory import ExecutionContextFactory, HostContextFactory
 from .host import HostContext
 from .interface import (
     IExecutionContext,
+    IExecutionContextFactory,
     IHostContext,
+    IHostContextFactory,
     IHTTPHostContext,
     IWebSocketHostContext,
 )
@@ -16,4 +19,8 @@
     "IWebSocketHostContext",
     "HostContext",
     "HostContextException",
+    "IExecutionContextFactory",
+    "IHostContextFactory",
+    "ExecutionContextFactory",
+    "HostContextFactory",
 ]

ellar/core/context/execution.py

@@ -1,20 +1,16 @@
 import typing as t
 
 from ellar.compatible import cached_property
-from ellar.constants import CONTROLLER_CLASS_KEY, SCOPE_SERVICE_PROVIDER
+from ellar.constants import CONTROLLER_CLASS_KEY
 from ellar.di import injectable
-from ellar.di.providers import ModuleProvider
 from ellar.services.reflector import Reflector
 from ellar.types import TReceive, TScope, TSend
 
-from .exceptions import ExecutionContextException
 from .host import HostContext
 from .interface import IExecutionContext
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.controller import ControllerBase
-    from ellar.core.routing import RouteOperationBase
-    from ellar.di.injector import RequestServiceProvider
 
 
 @injectable()
@@ -49,33 +45,3 @@ def _get_class(self) -> t.Optional[t.Type["ControllerBase"]]:
 
     def get_class(self) -> t.Optional[t.Type["ControllerBase"]]:
         return self._get_class  # type: ignore
-
-    @classmethod
-    def create_context(
-        cls,
-        *,
-        scope: TScope,
-        receive: TReceive,
-        send: TSend,
-        operation: "RouteOperationBase",
-    ) -> IExecutionContext:
-        provider = ModuleProvider(
-            cls,
-            scope=scope,
-            receive=receive,
-            send=send,
-            operation_handler=operation.endpoint,
-        )
-        request_provider: "RequestServiceProvider" = t.cast(
-            "RequestServiceProvider", scope.get(SCOPE_SERVICE_PROVIDER)
-        )
-        if not request_provider:
-            raise ExecutionContextException(
-                "RequestServiceProvider is not configured. "
-                "Please ensure `RequestServiceProviderMiddleware` is registered."
-            )
-
-        request_provider.update_context(IExecutionContext, provider)
-        execution_context = request_provider.get(IExecutionContext)  # type: ignore
-
-        return execution_context

ellar/core/context/factory.py

@@ -1,50 +1,59 @@
 import typing as t
 from abc import ABC, abstractmethod
 
+from ellar.constants import ASGI_CONTEXT_VAR
+from ellar.di import injectable
+from ellar.di.exceptions import ServiceUnavailable
+from ellar.services import Reflector
 from ellar.types import T
 
 from .exceptions import HostContextException
+from .execution import ExecutionContext
+from .host import HostContext
 from .http import HTTPHostContext
-from .interface import IHostContext
+from .interface import (
+    IExecutionContext,
+    IExecutionContextFactory,
+    IHostContext,
+    IHostContextFactory,
+)
 from .websocket import WebSocketHostContext
 
+if t.TYPE_CHECKING:  # pragma: no cover
+    from ellar.core.routing import RouteOperationBase
 
-class HostContextFactory(t.Generic[T], ABC):
+
+class SubHostContextFactory(t.Generic[T], ABC):
     """
     Factory for creating HostContext types and validating them.
     """
 
     context_type: t.Type[T]
 
-    __slots__ = ("context", "_context_type", "validate_func")
-
-    def __init__(
-        self,
-        context: IHostContext,
-    ) -> None:
-        self.context = context
+    __slots__ = ()
 
-    def __call__(self) -> T:
-        self.validate()
-        return self.create_context_type()
+    @injectable()
+    def __call__(self, context: IHostContext) -> T:
+        self.validate(context)
+        return self.create_context_type(context)
 
     @abstractmethod
-    def validate(self) -> None:
+    def validate(self, context: IHostContext) -> None:
         pass
 
-    def create_context_type(self) -> T:
-        scope, receive, send = self.context.get_args()
+    def create_context_type(self, context: IHostContext) -> T:
+        scope, receive, send = context.get_args()
         return self.context_type(  # type:ignore
             scope=scope,
             receive=receive,
             send=send,
         )
 
 
-class HTTPConnectionContextFactory(HostContextFactory[HTTPHostContext]):
+class HTTPConnectionContextFactory(SubHostContextFactory[HTTPHostContext]):
     context_type = HTTPHostContext
 
-    def validate(self) -> None:
+    def validate(self, context: IHostContext) -> None:
         """
         Validation is skipped here because HTTPConnection is compatible with websocket and http
         During websocket connection, we can still get HTTPConnection available,
@@ -53,11 +62,57 @@ def validate(self) -> None:
         pass
 
 
-class WebSocketContextFactory(HostContextFactory[WebSocketHostContext]):
+class WebSocketContextFactory(SubHostContextFactory[WebSocketHostContext]):
     context_type = WebSocketHostContext
 
-    def validate(self) -> None:
-        if self.context.get_type() != "websocket":
+    def validate(self, context: IHostContext) -> None:
+        if context.get_type() != "websocket":
             raise HostContextException(
-                f"WebsocketConnection Context creation is not allow for scope[type]={self.context.get_type()}"
+                f"WebsocketConnection Context creation is not allow for scope[type]={context.get_type()}"
             )
+
+
+@injectable()
+class HostContextFactory(IHostContextFactory):
+    __slots__ = ()
+
+    def create_context(self) -> IHostContext:
+        scoped_request_args = ASGI_CONTEXT_VAR.get()
+
+        if not scoped_request_args:
+            raise ServiceUnavailable()
+
+        scope, receive, send = scoped_request_args.get_args()
+        host_context = HostContext(scope=scope, receive=receive, send=send)
+        host_context.get_service_provider().update_scoped_context(
+            IHostContext, host_context  # type: ignore
+        )
+        return host_context
+
+
+@injectable()
+class ExecutionContextFactory(IExecutionContextFactory):
+    __slots__ = ("reflector",)
+
+    def __init__(self, reflector: Reflector) -> None:
+        self.reflector = reflector
+
+    def create_context(self, operation: "RouteOperationBase") -> IExecutionContext:
+        scoped_request_args = ASGI_CONTEXT_VAR.get()
+
+        if not scoped_request_args:
+            raise ServiceUnavailable()
+
+        scope, receive, send = scoped_request_args.get_args()
+        i_execution_context = ExecutionContext(
+            scope=scope,
+            receive=receive,
+            send=send,
+            operation_handler=operation.endpoint,
+            reflector=self.reflector,
+        )
+        i_execution_context.get_service_provider().update_scoped_context(
+            IExecutionContext, i_execution_context  # type: ignore
+        )
+
+        return i_execution_context

ellar/core/context/host.py

@@ -8,7 +8,7 @@
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.main import App
-    from ellar.di.injector import RequestServiceProvider
+    from ellar.di import EllarInjector
 
 
 class HostContext(IHostContext):
@@ -29,11 +29,11 @@ def __init__(
         self.receive = receive
         self.send = send
 
-    def get_service_provider(self) -> "RequestServiceProvider":
+    def get_service_provider(self) -> "EllarInjector":
         return self._service_provider  # type:ignore
 
     @cached_property
-    def _service_provider(self) -> "RequestServiceProvider":
+    def _service_provider(self) -> "EllarInjector":
         return self.scope[SCOPE_SERVICE_PROVIDER]  # type:ignore
 
     def switch_to_http_connection(self) -> IHTTPHostContext:

ellar/core/context/interface.py

@@ -8,7 +8,8 @@
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core import ControllerBase
     from ellar.core.main import App
-    from ellar.di.injector import RequestServiceProvider
+    from ellar.core.routing import RouteOperationBase
+    from ellar.di.injector import EllarInjector
 
 
 class IHTTPHostContext(ABC):
@@ -38,7 +39,7 @@ def get_client(self) -> WebSocket:
 
 class IHostContext(ABC, metaclass=ABCMeta):
     @abstractmethod
-    def get_service_provider(self) -> "RequestServiceProvider":
+    def get_service_provider(self) -> "EllarInjector":
         """Gets  RequestServiceProvider instance"""
 
     @abstractmethod
@@ -70,3 +71,15 @@ def get_handler(self) -> t.Callable:
     @abstractmethod
     def get_class(self) -> t.Optional[t.Type["ControllerBase"]]:
         """Gets operation handler class"""
+
+
+class IHostContextFactory(ABC):
+    @abstractmethod
+    def create_context(self) -> IHostContext:
+        pass
+
+
+class IExecutionContextFactory(ABC):
+    @abstractmethod
+    def create_context(self, operation: "RouteOperationBase") -> IExecutionContext:
+        pass

ellar/core/factory.py

@@ -7,14 +7,14 @@
 
 from ellar.constants import MODULE_METADATA, MODULE_WATERMARK
 from ellar.core import Config
-from ellar.core.exceptions.interfaces import IExceptionMiddlewareService
-from ellar.core.exceptions.service import ExceptionMiddlewareService
 from ellar.core.main import App
 from ellar.core.modules import ModuleBase
 from ellar.core.modules.ref import create_module_ref_factor
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.reflect import reflect
 
+from .services import CoreServiceRegistration
+
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.commands import EllarTyper
     from ellar.core import GuardCanActivate
@@ -97,9 +97,8 @@ def _create_app(
 
         config = Config(app_configured=True, config_module=config_module)
         injector = EllarInjector(auto_bind=config.INJECTOR_AUTO_BIND)
-        injector.container.register(
-            IExceptionMiddlewareService, ExceptionMiddlewareService
-        )
+
+        CoreServiceRegistration(injector).register_all()
         injector.container.register_instance(config, concrete_type=Config)
         cls._build_modules(app_module=module, injector=injector, config=config)
 

ellar/core/main.py

@@ -5,7 +5,6 @@
 
 from ellar.constants import LOG_LEVELS
 from ellar.core.conf import Config
-from ellar.core.context import IExecutionContext, IHostContext
 from ellar.core.datastructures import State, URLPath
 from ellar.core.events import EventHandler, RouterEventManager
 from ellar.core.exceptions.interfaces import (
@@ -27,9 +26,7 @@
 from ellar.core.templating import AppTemplating, Environment
 from ellar.core.versioning import VERSIONING, BaseAPIVersioning
 from ellar.di.injector import EllarInjector
-from ellar.di.providers import ServiceUnavailableProvider
 from ellar.logger import logger
-from ellar.services.reflector import Reflector
 from ellar.types import ASGIApp, T, TReceive, TScope, TSend
 
 
@@ -181,9 +178,7 @@ def config(self) -> Config:  # type: ignore
         return self._config
 
     def build_middleware_stack(self) -> ASGIApp:
-        service_middleware = self.injector.get(
-            IExceptionMiddlewareService  # type:ignore
-        )
+        service_middleware = self.injector.get(IExceptionMiddlewareService)
         service_middleware.build_exception_handlers(*self._exception_handlers)
         error_handler = service_middleware.get_500_error_handler()
         allowed_hosts = self.config.ALLOWED_HOSTS
@@ -264,19 +259,9 @@ def _run_module_application_ready(
             module_ref.run_application_ready(self)
 
     def _finalize_app_initialization(self) -> None:
-
         self.injector.container.register_instance(self)
-        self.injector.container.register_instance(Reflector())
         self.injector.container.register_instance(self.config, Config)
         self.injector.container.register_instance(self.jinja_environment, Environment)
-        self.injector.container.register_scoped(
-            IHostContext,
-            ServiceUnavailableProvider("Service Unavailable at the current context."),
-        )
-        self.injector.container.register_scoped(
-            IExecutionContext,
-            ServiceUnavailableProvider("Service Unavailable at the current context."),
-        )
         self._run_module_application_ready()
 
     def add_exception_handler(