aspyx-service 0.10.3__py3-none-any.whl → 0.10.4__py3-none-any.whl

aspyx_service/restchannel.py

@@ -3,18 +3,21 @@ rest channel implementation
 """
 import inspect
 import re
-from dataclasses import is_dataclass, asdict
+from dataclasses import is_dataclass
 
 from typing import get_type_hints, TypeVar, Annotated, Callable, get_origin, get_args, Type
 
+
 from pydantic import BaseModel
 
+from .channels import HTTPXChannel
+
 from aspyx.reflection import DynamicProxy, Decorators
 from .service import channel, ServiceCommunicationException
 
 T = TypeVar("T")
 
-from .channels import HTTPXChannel
+
 
 class BodyMarker:
     pass
@@ -169,7 +172,7 @@ class RestChannel(HTTPXChannel):
             for param_name, hint in hints.items():
                 if get_origin(hint) is Annotated:
                     metadata = get_args(hint)[1:]
-                    
+
                     if BodyMarker in metadata:
                         self.body_param_name = param_name
                         param_names.remove(param_name)
@@ -179,7 +182,7 @@ class RestChannel(HTTPXChannel):
 
             # check if something is missing
 
-            if len(param_names) > 0:
+            if param_names:
                 # check body params
                 if self.type in ("post", "put", "patch"):
                     if self.body_param_name is None:
@@ -248,14 +251,11 @@ class RestChannel(HTTPXChannel):
 
         try:
             result = None
-            if call.type == "get":
-                result = await self.get_async_client().get(self.get_url() + url, params=query_params, timeout=self.timeout)
-            elif call.type == "put":
-                result = await self.get_async_client().put(self.get_url() + url, params=query_params, timeout=self.timeout)
-            elif call.type == "delete":
-                result = await self.get_async_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout)
+            if call.type in ["get", "put", "delete"]:
+                result = await self.request_async(call.type, self.get_url() + url, params=query_params, timeout=self.timeout)
+
             elif call.type == "post":
-                result = await self.get_async_client().post(self.get_url() + url, params=query_params, json=body, timeout=self.timeout)
+                result = await self.request_async("post", self.get_url() + url, params=query_params, json=body, timeout=self.timeout)
 
             return self.get_deserializer(invocation.type, invocation.method)(result.json())
         except ServiceCommunicationException:
@@ -283,14 +283,11 @@ class RestChannel(HTTPXChannel):
 
         try:
             result = None
-            if call.type == "get":
-                result = self.get_client().get(self.get_url() + url, params=query_params, timeout=self.timeout)
-            elif call.type == "put":
-                result = self.get_client().put(self.get_url() + url, params=query_params, timeout=self.timeout)
-            elif call.type == "delete":
-                result = self.get_client().delete(self.get_url() + url, params=query_params, timeout=self.timeout)
+            if call.type in ["get", "put", "delete"]:
+                result = self.request("get", self.get_url() + url, params=query_params, timeout=self.timeout)
+
             elif call.type == "post":
-                result = self.get_client().post(self.get_url() + url, params=query_params, json=body, timeout=self.timeout)
+                result = self.request( "post", self.get_url() + url, params=query_params, json=body, timeout=self.timeout)
 
             return self.get_deserializer(invocation.type, invocation.method)(result.json())
         except ServiceCommunicationException:

aspyx_service/serialization.py

@@ -37,7 +37,7 @@ class TypeDeserializer:
             return deser_union
 
         if isinstance(typ, type) and issubclass(typ, BaseModel):
-            return typ.parse_obj
+            return typ.model_validate
 
         if is_dataclass(typ):
             field_deserializers = {f.name: TypeDeserializer(f.type) for f in fields(typ)}
@@ -61,7 +61,7 @@ class TypeDeserializer:
 
         # Fallback
         return lambda v: v
-    
+
 class TypeSerializer:
     def __init__(self, typ):
         self.typ = typ
@@ -88,7 +88,7 @@ class TypeSerializer:
             return ser_union
 
         if isinstance(typ, type) and issubclass(typ, BaseModel):
-            return lambda v: v.dict() if v is not None else None
+            return lambda v: v.model_dump() if v is not None else None
 
         if is_dataclass(typ):
             field_serializers = {f.name: TypeSerializer(f.type) for f in fields(typ)}

aspyx_service/server.py

@@ -4,15 +4,18 @@ FastAPI server implementation for the aspyx service framework.
 import atexit
 import inspect
 import threading
-from typing import Type, Optional, Callable
+from typing import Type, Optional, Callable, Any
 
 from fastapi.responses import JSONResponse
 import msgpack
 import uvicorn
 
-from fastapi import FastAPI, APIRouter, Request as HttpRequest, Response as HttpResponse
+from fastapi import FastAPI, APIRouter, Request as HttpRequest, Response as HttpResponse, HTTPException
+import contextvars
 
-from aspyx.di import Environment
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from aspyx.di import Environment, injectable, on_init, inject_environment
 from aspyx.reflection import TypeDescriptor, Decorators
 
 from .service import ComponentRegistry
@@ -21,28 +24,110 @@ from .healthcheck import HealthCheckManager
 from .serialization import get_deserializer
 
 from .service import Server, ServiceManager
-from .channels import Request, Response
+from .channels import Request, Response, TokenContext
 
 from .restchannel import get, post, put, delete, rest
 
+class RequestContext:
+    """
+    A request context is used to remember the current http request in the current thread
+    """
+    request_var = contextvars.ContextVar("request")
+
+    @classmethod
+    def get_request(cls) -> Request:
+        """
+        Return the current http request
+
+        Returns:
+            the current http request
+        """
+        return cls.request_var.get()
+
+    # constructor
+
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
 
+        request = HttpRequest(scope)
+        token = self.request_var.set(request)
+        try:
+            await self.app(scope, receive, send)
+        finally:
+            self.request_var.reset(token)
+
+class TokenMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        access_token = request.cookies.get("access_token") or request.headers.get("Authorization")
+        #refresh_token = request.cookies.get("refresh_token")
+
+        if access_token:
+            TokenContext.set(access_token)#, refresh_token)
+
+        try:
+            return await call_next(request)
+        finally:
+            TokenContext.clear()
+
+def create_server() -> FastAPI:
+    server = FastAPI()
+
+    server.add_middleware(RequestContext)
+    server.add_middleware(TokenMiddleware)
+
+    return server
+
+@injectable()
 class FastAPIServer(Server):
     """
     A server utilizing fastapi framework.
     """
+
+    fast_api = create_server()
+
+    # class methods
+
+    @classmethod
+    def boot(cls, module: Type, host="0.0.0.0", port=8000, start = True) -> 'FastAPIServer':
+        """
+        boot the DI infrastructure of the supplied module and optionally start a fastapi thread given the url
+        Args:
+            module: the module to initialize the environment
+            host: listen address
+            port: the port
+
+        Returns:
+            thr created server
+        """
+        cls.port = port
+
+        environment = Environment(module)
+
+        server = environment.get(FastAPIServer)
+
+        if start:
+            server.start_fastapi(host)
+
+        return server
+
     # constructor
 
-    def __init__(self, host="0.0.0.0", port=8000, **kwargs):
+    def __init__(self, service_manager: ServiceManager, component_registry: ComponentRegistry):
         super().__init__()
 
-        self.host = host
-        Server.port = port
+        self.environment : Optional[Environment] = None
+        self.service_manager = service_manager
+        self.component_registry = component_registry
+
+        self.host = "localhost"
         self.server_thread = None
-        self.service_manager : Optional[ServiceManager] = None
-        self.component_registry: Optional[ComponentRegistry] = None
 
         self.router = APIRouter()
-        self.fast_api = FastAPI()
 
         # cache
 
@@ -52,15 +137,37 @@ class FastAPIServer(Server):
 
         self.router.post("/invoke")(self.invoke)
 
+    # inject
+
+    @inject_environment()
+    def set_environment(self, environment: Environment):
+        self.environment = environment
+
+    @on_init()
+    def on_init(self):
+        self.service_manager.startup(self)
+
+        # add routes
+
+        self.add_routes()
+        self.fast_api.include_router(self.router)
+
+        #for route in self.fast_api.routes:
+        #    print(f"{route.name}: {route.path} [{route.methods}]")
+
+        # add cleanup hook
+
+        def cleanup():
+            self.service_manager.shutdown()
+
+        atexit.register(cleanup)
+
     # private
 
     def add_routes(self):
         """
-        add everything that looks like a http endpoint
+        add everything that looks like an http endpoint
         """
-
-        # go
-
         for descriptor in self.service_manager.descriptors.values():
             if not descriptor.is_component() and descriptor.is_local():
                 prefix = ""
@@ -82,12 +189,13 @@ class FastAPIServer(Server):
                             response_model=method.return_type,
                         )
 
-    def start_fastapi_thread(self):
+    def start_fastapi(self, host: str):
         """
         start the fastapi server in a thread
         """
+        self.host = host
 
-        config = uvicorn.Config(self.fast_api, host=self.host, port=self.port, access_log=False) #log_level="debug"
+        config = uvicorn.Config(self.fast_api, host=self.host, port=self.port, access_log=False)
         server = uvicorn.Server(config)
 
         thread = threading.Thread(target=server.run, daemon=True)
@@ -95,7 +203,6 @@ class FastAPIServer(Server):
 
         return thread
 
-
     def get_deserializers(self, service: Type, method):
         deserializers = self.deserializers.get(method, None)
         if deserializers is None:
@@ -106,8 +213,8 @@ class FastAPIServer(Server):
 
         return deserializers
 
-    def deserialize_args(self, request: Request, type: Type, method: Callable) -> list:
-        args = list(request.args)
+    def deserialize_args(self, args: list[Any], type: Type, method: Callable) -> list:
+        #args = list(request.args)
 
         deserializers = self.get_deserializers(type, method)
 
@@ -133,22 +240,22 @@ class FastAPIServer(Server):
                 media_type="text/plain"
             )
 
-        request = Request(**data)
+        request = data
 
         if content == "json":
-            return await self.dispatch(request)
+            return await self.dispatch(http_request, request)
         else:
             return HttpResponse(
-                content=msgpack.packb(await self.dispatch(request), use_bin_type=True),
+                content=msgpack.packb(await self.dispatch(http_request, request), use_bin_type=True),
                 media_type="application/msgpack"
             )
 
-    async def dispatch(self, request: Request) :
-        ServiceManager.logger.debug("dispatch request %s", request.method)
+    async def dispatch(self, http_request: HttpRequest, request: dict) :
+        ServiceManager.logger.debug("dispatch request %s", request["method"])
 
         # <comp>:<service>:<method>
 
-        parts = request.method.split(":")
+        parts = request["method"].split(":")
 
         #component = parts[0]
         service_name = parts[1]
@@ -159,16 +266,20 @@ class FastAPIServer(Server):
 
         method = getattr(service, method_name)
 
-        args = self.deserialize_args(request, service_descriptor.type, method)
+        args = self.deserialize_args(request["args"], service_descriptor.type, method)
         try:
             if inspect.iscoroutinefunction(method):
                 result = await method(*args)
             else:
                 result = method(*args)
 
-            return Response(result=result, exception=None).dict()
+            return Response(result=result, exception=None).model_dump()
+
+        except HTTPException as e:
+            raise
+
         except Exception as e:
-            return Response(result=None, exception=str(e)).dict()
+            return Response(result=None, exception=str(e)).model_dump()
 
     # override
 
@@ -185,44 +296,3 @@ class FastAPIServer(Server):
             )
 
         self.router.get(url)(get_health_response)
-
-    def boot(self, module_type: Type) -> Environment:
-        """
-        startup the service manager, DI framework and the fastapi server based on the supplied module
-
-        Args:
-            module_type: the module
-
-        Returns:
-
-        """
-        # setup environment
-
-        self.environment = Environment(module_type)
-        self.service_manager = self.environment.get(ServiceManager)
-        self.component_registry = self.environment.get(ComponentRegistry)
-
-        self.service_manager.startup(self)
-
-        # add routes
-
-        self.add_routes()
-        self.fast_api.include_router(self.router)
-
-        #for route in self.fast_api.routes:
-        #    print(f"{route.name}: {route.path} [{route.methods}]")
-
-        # start server thread
-
-        self.start_fastapi_thread()
-
-        # shutdown
-
-        def cleanup():
-            self.service_manager.shutdown()
-
-        atexit.register(cleanup)
-
-        # done
-
-        return self.environment

aspyx_service/service.py

@@ -15,9 +15,10 @@ from typing import Type, TypeVar, Generic, Callable, Optional, cast
 
 from aspyx.di import injectable, Environment, Providers, ClassInstanceProvider, inject_environment, order, \
     Lifecycle, LifecycleCallable, InstanceProvider
+from aspyx.di.aop.aop import ClassAspectTarget
 from aspyx.reflection import Decorators, DynamicProxy, DecoratorDescriptor, TypeDescriptor
 from aspyx.util import StringBuilder
-from .healthcheck import HealthCheckManager
+from .healthcheck import HealthCheckManager, HealthStatus
 
 T = TypeVar("T")
 
@@ -55,10 +56,6 @@ class Server(ABC):
     def get(self, type: Type[T]) -> T:
         return self.environment.get(type)
 
-    @abstractmethod
-    def boot(self, module_type: Type):
-        pass
-
     @abstractmethod
     def route(self, url : str, callable: Callable):
         pass
@@ -121,7 +118,7 @@ class Component(Service):
     @abstractmethod
     def get_addresses(self, port: int) -> list[ChannelAddress]:
         """
-        returns a list of channel addresses that expose this components services.
+        returns a list of channel addresses that expose this component's services.
 
         Args:
             port: the port of a server hosting this component
@@ -164,6 +161,9 @@ class AbstractComponent(Component, ABC):
     def get_status(self) -> ComponentStatus:
         return self.status
 
+    async def get_health(self) -> HealthCheckManager.Health:
+        return HealthCheckManager.Health(HealthStatus.OK)
+
 def to_snake_case(name: str) -> str:
     return re.sub(r'(?<!^)(?=[A-Z])', '-', name).lower()
 
@@ -401,6 +401,22 @@ class RemoteServiceException(ServiceException):
     base class for service exceptions occurring on the server side
     """
 
+
+class AuthorizationException(ServiceException):
+    pass
+
+class TokenException(AuthorizationException):
+    pass
+
+class InvalidTokenException(TokenException):
+    pass
+
+class MissingTokenException(TokenException):
+    pass
+
+class TokenExpiredException(TokenException):
+    pass
+
 class Channel(DynamicProxy.InvocationHandler, ABC):
     """
     A channel is a dynamic proxy invocation handler and transparently takes care of remoting.
@@ -432,7 +448,7 @@ class Channel(DynamicProxy.InvocationHandler, ABC):
         a url selector always retrieving the first URL given a list of possible URLS
         """
         def get(self, urls: list[str]) -> str:
-            if len(urls) == 0:
+            if not urls:
                 raise ServiceCommunicationException("no known url")
 
             return urls[0]
@@ -445,7 +461,7 @@ class Channel(DynamicProxy.InvocationHandler, ABC):
             self.index = 0
 
         def get(self, urls: list[str]) -> str:
-            if len(urls) > 0:
+            if urls:
                 try:
                     return urls[self.index]
                 finally:
@@ -462,6 +478,8 @@ class Channel(DynamicProxy.InvocationHandler, ABC):
         self.address: Optional[ChannelInstances] = None
         self.url_selector : Channel.URLSelector = Channel.FirstURLSelector()
 
+        self.select_round_robin()
+
     # public
 
     def customize(self):
@@ -692,11 +710,17 @@ class ServiceManager:
 
                     # fetch health
 
-                    descriptor.health = Decorators.get_decorator(descriptor.implementation, health).args[0]
+                    health_name = None
+                    health_descriptor = Decorators.get_decorator(descriptor.implementation, health)
+
+                    if health_descriptor is not None:
+                        health_name = health_descriptor.args[0]
+
+                    descriptor.health = health_name
 
                     self.component_registry.register(descriptor.get_component_descriptor(), [ChannelAddress("local", "")])
 
-                    health_name = next((decorator.args[0] for decorator in Decorators.get(descriptor.type) if decorator.decorator is health), None)
+                    #health_name = next((decorator.args[0] for decorator in Decorators.get(descriptor.type) if decorator.decorator is health), None)
 
                     # startup
 
@@ -704,7 +728,8 @@ class ServiceManager:
 
                     # add health route
 
-                    server.route_health(health_name, instance.get_health)
+                    if health_name is not None:
+                        server.route_health(health_name, instance.get_health)
 
                     # register addresses
 
@@ -733,7 +758,7 @@ class ServiceManager:
         addresses = self.component_registry.get_addresses(component_descriptor)  # component, channel + urls
         address = next((address for address in addresses if address.channel == preferred_channel), None)
         if address is None:
-            if len(addresses) > 0:
+            if addresses:
                 # return the first match
                 address = addresses[0]
             else:
@@ -908,3 +933,13 @@ class ServiceLifecycleCallable(LifecycleCallable):
 
     def args(self, decorator: DecoratorDescriptor, method: TypeDescriptor.MethodDescriptor, environment: Environment):
         return [self.manager.get_service(method.param_types[0], preferred_channel=decorator.args[0])]
+
+def component_services(component_type: Type) -> ClassAspectTarget:
+    target = ClassAspectTarget()
+
+    descriptor = TypeDescriptor.for_type(component_type)
+
+    for service_type in descriptor.get_decorator(component).args[2]:
+        target.of_type(service_type)
+
+    return target

aspyx_service/session.py

@@ -0,0 +1,97 @@
+"""
+session related module
+"""
+import contextvars
+from typing import Type, Optional, Callable, Any, TypeVar
+from datetime import datetime, timezone
+from cachetools import TTLCache
+
+from aspyx.di import injectable
+from aspyx.threading import ThreadLocal
+
+
+class Session:
+    """
+    Base class for objects covers data related to a server side session.
+    """
+    def __init__(self):
+        pass
+
+T = TypeVar("T")
+
+@injectable()
+class SessionManager:
+    """
+    A SessionManager controls the lifecycle of sessions and is responsible to establish a session thread local.
+    """
+    #current_session = ThreadLocal[Session]()
+    current_session  = contextvars.ContextVar("session")
+
+    @classmethod
+    def current(cls, type: Type[T]) -> T:
+        """
+        return the current session associated with the thread
+        Args:
+            type:  the session type
+
+        Returns:
+            the current session
+        """
+        return cls.current_session.get()
+
+    @classmethod
+    def set_session(cls, session: Session) -> None:
+        """
+        set the current session in the thread context
+        Args:
+            session: the session
+        """
+        cls.current_session.set(session)
+
+    @classmethod
+    def delete_session(cls) -> None:
+        """
+        delete the current session
+        """
+        cls.current_session.set(None)#clear()
+
+    # constructor
+
+    def __init__(self):
+        self.sessions = TTLCache(maxsize=1000, ttl=3600)
+        self.session_creator : Optional[Callable[[Any], Session]] = None
+
+    # public
+
+    def set_session_factory(self, callable: Callable[..., Session]) -> None:
+        """
+        set a factory function that will be used to create a concrete session
+        Args:
+            callable: the function
+        """
+        self.session_creator = callable
+
+    def create_session(self, *args, **kwargs) -> Session:
+        """
+        create a session given the argument s(usually a token, etc.)
+        Args:
+            args: rest args
+            kwargs: keyword args
+
+        Returns:
+            the new session
+        """
+        return self.session_creator(*args, **kwargs)
+
+    def store_session(self, token: str, session: Session, expiry: datetime):
+        now = datetime.now(timezone.utc)
+        ttl_seconds = max(int((expiry - now).total_seconds()), 0)
+        self.sessions[token] = (session, ttl_seconds)
+
+    def get_session(self, token: str) -> Optional[Session]:
+        value = self.sessions.get(token)
+        if value is None:
+            return None
+
+        session, ttl = value
+        return session