aspyx-service 0.9.0__py3-none-any.whl

aspyx_service/__init__.py

@@ -0,0 +1,71 @@
+"""
+This module provides the core Aspyx service management framework allowing for service discovery and transparent remoting including multiple possible transport protocols.
+"""
+
+from aspyx.di import module
+
+from .service import ServiceException, Server, Channel, ComponentDescriptor, inject_service, ChannelAddress, ServiceAddress, ServiceManager, Component, Service, AbstractComponent, ComponentStatus, ComponentRegistry, implementation, health, component, service
+from .channels import HTTPXChannel, DispatchJSONChannel
+from .registries import ConsulComponentRegistry
+from .server import FastAPIServer
+from .healthcheck import health_checks, health_check, HealthCheckManager, HealthStatus
+from .restchannel import RestChannel, post, get, put, delete, QueryParam, Body, rest
+
+
+@module()
+class ServiceModule:
+    def __init__(self):
+        pass
+
+__all__ = [
+    # service
+
+    "ServiceManager",
+    "ServiceModule",
+    "ServiceException",
+    "Server",
+    "Component",
+    "Service",
+    "Channel",
+    "AbstractComponent",
+    "ComponentStatus",
+    "ComponentDescriptor",
+    "ComponentRegistry",
+    "ChannelAddress",
+    "ServiceAddress",
+    "health",
+    "component",
+    "service",
+    "implementation",
+    "inject_service",
+
+    # healthcheck
+
+    # serialization
+
+   # "deserialize",
+
+    # channel
+
+    "HTTPXChannel",
+    "DispatchJSONChannel",
+
+    # rest
+
+    "RestChannel",
+    "post",
+    "get",
+    "put",
+    "delete",
+    "rest",
+    "QueryParam",
+    "Body",
+
+    # registries
+
+    "ConsulComponentRegistry",
+
+    # server
+
+    "FastAPIServer"
+]

aspyx_service/channels.py

@@ -0,0 +1,210 @@
+"""
+Service management and dependency injection framework.
+"""
+from __future__ import annotations
+
+from typing import Type, Optional, Any, Callable
+
+import msgpack
+from httpx import Client, AsyncClient
+from pydantic import BaseModel
+
+from aspyx.reflection import DynamicProxy, TypeDescriptor
+from .service import ServiceManager
+
+from .service import ComponentDescriptor, ServiceAddress, ServiceException, channel, Channel, RemoteServiceException
+from .serialization import get_deserializer
+
+
+class HTTPXChannel(Channel):
+    __slots__ = [
+        "client",
+        "async_client",
+        "service_names",
+        "deserializers"
+    ]
+
+    # constructor
+
+    def __init__(self, name):
+        super().__init__(name)
+
+        self.client: Optional[Client] = None
+        self.async_client: Optional[AsyncClient] = None
+        self.service_names: dict[Type, str] = {}
+        self.deserializers: dict[Callable, Callable] = {}
+
+    # protected
+
+    def get_deserializer(self, type: Type, method: Callable) -> Type:
+        deserializer = self.deserializers.get(method, None)
+        if deserializer is None:
+            return_type = TypeDescriptor.for_type(type).get_method(method.__name__).return_type
+
+            deserializer = get_deserializer(return_type)
+
+            self.deserializers[method] = deserializer
+
+        return deserializer
+
+    # override
+
+    def setup(self, component_descriptor: ComponentDescriptor, address: ServiceAddress):
+        super().setup(component_descriptor, address)
+
+        # remember service names
+
+        for service in component_descriptor.services:
+            self.service_names[service.type] = service.name
+
+        # make client
+
+        self.client = self.make_client()
+        self.async_client = self.make_async_client()
+
+    # public
+
+    def get_client(self) -> Client:
+        if self.client is None:
+            self.client = self.make_client()
+
+        return self.client
+
+    def get_async_client(self) -> Client:
+        if self.async_client is None:
+            self.async_client = self.make_async_client()
+
+        return self.async_client
+
+    def make_client(self):
+        return Client()  # base_url=url
+
+    def make_async_client(self):
+        return AsyncClient()  # base_url=url
+
+class Request(BaseModel):
+    method: str  # component:service:method
+    args: tuple[Any, ...]
+
+class Response(BaseModel):
+    result: Optional[Any]
+    exception: Optional[Any]
+
+@channel("dispatch-json")
+class DispatchJSONChannel(HTTPXChannel):
+    # constructor
+
+    def __init__(self):
+        super().__init__("dispatch-json")
+
+    # internal
+
+    # implement Channel
+
+    def set_address(self, address: Optional[ServiceAddress]):
+        ServiceManager.logger.info("channel %s got an address %s", self.name, address)
+
+        super().set_address(address)
+
+    def setup(self, component_descriptor: ComponentDescriptor, address: ServiceAddress):
+        super().setup(component_descriptor, address)
+
+    def invoke(self, invocation: DynamicProxy.Invocation):
+        service_name = self.service_names[invocation.type]  # map type to registered service name
+        request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}", args=invocation.args)
+
+        try:
+            if self.client is not None:
+                result = Response(**self.get_client().post(f"{self.get_url()}/invoke", json=request.dict(), timeout=30000.0).json())
+                if result.exception is not None:
+                    raise RemoteServiceException(f"server side exception {result.exception}")
+
+                return self.get_deserializer(invocation.type, invocation.method)(result.result)
+            else:
+                raise ServiceException(f"no url for channel {self.name} for component {self.component_descriptor.name} registered")
+        except Exception as e:
+            raise ServiceException(f"communication exception {e}") from e
+
+    async def invoke_async(self, invocation: DynamicProxy.Invocation):
+        service_name = self.service_names[invocation.type]  # map type to registered service name
+        request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
+                          args=invocation.args)
+
+        try:
+            if self.async_client is not None:
+                data =  await self.async_client.post(f"{self.get_url()}/invoke", json=request.dict(), timeout=30000.0)
+                result = Response(**data.json())
+                if result.exception is not None:
+                    raise RemoteServiceException(f"server side exception {result.exception}")
+
+                return self.get_deserializer(invocation.type, invocation.method)(result.result)
+            else:
+                raise ServiceException(
+                    f"no url for channel {self.name} for component {self.component_descriptor.name} registered")
+        except Exception as e:
+            raise ServiceException(f"communication exception {e}") from e
+
+@channel("dispatch-msgpack")
+class DispatchMSPackChannel(HTTPXChannel):
+    # constructor
+
+    def __init__(self):
+        super().__init__("dispatch-msgpack")
+
+    # override
+
+    def set_address(self, address: Optional[ServiceAddress]):
+        ServiceManager.logger.info("channel %s got an address %s", self.name, address)
+
+        super().set_address(address)
+
+    def invoke(self, invocation: DynamicProxy.Invocation):
+        service_name = self.service_names[invocation.type]  # map type to registered service name
+        request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
+                          args=invocation.args)
+
+        try:
+            packed = msgpack.packb(request.dict(), use_bin_type=True)
+
+            response = self.get_client().post(
+                f"{self.get_url()}/invoke",
+                content=packed,
+                headers={"Content-Type": "application/msgpack"},
+                timeout=30.0
+            )
+
+            result = msgpack.unpackb(response.content, raw=False)
+
+            if result.get("exception", None):
+                raise RemoteServiceException(f"server-side: {result['exception']}")
+
+            return self.get_deserializer(invocation.type, invocation.method)(result["result"])
+
+        except Exception as e:
+            raise ServiceException(f"msgpack exception: {e}") from e
+
+    async def invoke_async(self, invocation: DynamicProxy.Invocation):
+        service_name = self.service_names[invocation.type]  # map type to registered service name
+        request = Request(method=f"{self.component_descriptor.name}:{service_name}:{invocation.method.__name__}",
+                          args=invocation.args)
+
+        try:
+            packed = msgpack.packb(request.dict(), use_bin_type=True)
+
+            response = await self.get_async_client().post(
+                f"{self.get_url()}/invoke",
+                content=packed,
+                headers={"Content-Type": "application/msgpack"},
+                timeout=30.0
+            )
+
+            result = msgpack.unpackb(response.content, raw=False)
+
+            if result.get("exception", None):
+                raise RemoteServiceException(f"server-side: {result['exception']}")
+
+            return self.get_deserializer(invocation.type, invocation.method)(result["result"])
+
+        except Exception as e:
+            raise ServiceException(f"msgpack exception: {e}") from e
+

aspyx_service/healthcheck.py

@@ -0,0 +1,178 @@
+"""
+health checks
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from enum import Enum
+from typing import Any, Callable, Type, Optional
+
+from aspyx.di import Providers, ClassInstanceProvider, injectable, Environment, inject_environment, on_init
+from aspyx.reflection import Decorators, TypeDescriptor
+
+
+def health_checks():
+    """
+    Instances of classes that are annotated with @injectable can be created by an Environment.
+    """
+    def decorator(cls):
+        Decorators.add(cls, health_checks)
+
+        #if not Providers.is_registered(cls):
+        #    Providers.register(ClassInstanceProvider(cls, True, "singleton"))
+
+        HealthCheckManager.types.append(cls)
+
+        return cls
+
+    return decorator
+
+def health_check(name="", cache = 0, fail_if_slower_than = 0):
+    """
+    Methods annotated with `@on_init` will be called when the instance is created."""
+    def decorator(func):
+        Decorators.add(func, health_check, name, cache, fail_if_slower_than)
+        return func
+
+    return decorator
+
+class HealthStatus(Enum):
+    OK = 1
+    WARNING = 2
+    ERROR = 3
+
+    def __str__(self):
+        return self.name
+
+
+@injectable()
+class HealthCheckManager:
+    logger = logging.getLogger("aspyx.service.health")
+
+    # local classes
+
+    class Check:
+        def __init__(self, name: str, cache: int, fail_if_slower_than: int, instance: Any, callable: Callable):
+            self.name = name
+            self.cache = cache
+            self.callable = callable
+            self.instance = instance
+            self.fail_if_slower_than = fail_if_slower_than
+            self.last_check = 0
+
+            self.last_value : Optional[HealthCheckManager.Result] = None
+
+        async def run(self, result: HealthCheckManager.Result):
+            now = time.time()
+
+            if self.cache > 0 and self.last_check is not None and now - self.last_check < self.cache:
+                result.copy_from(self.last_value)
+                return
+
+            self.last_check = now
+            self.last_value = result
+
+            if asyncio.iscoroutinefunction(self.callable):
+                await self.callable(self.instance, result)
+            else:
+                await asyncio.to_thread(self.callable, self.instance, result)
+
+            spent = time.time() - now
+
+            if result.status == HealthStatus.OK and 0 < self.fail_if_slower_than < spent:
+                result.status = HealthStatus.ERROR
+                result.details = f"spent {spent:.3f}s"
+
+
+    class Result:
+        def __init__(self, name: str):
+            self.status = HealthStatus.OK
+            self.name = name
+            self.details = ""
+
+        def copy_from(self, value: HealthCheckManager.Result):
+            self.status  = value.status
+            self.details = value.details
+
+        def set_status(self, status: HealthStatus, details =""):
+            self.status = status
+            self.details = details
+
+        def to_dict(self):
+            result = {
+                "name": self.name,
+                "status": str(self.status),
+            }
+
+            if len(self.details) > 0:
+                result["details"] = self.details
+
+            return result
+
+    class Health:
+        def __init__(self):
+            self.status = HealthStatus.OK
+            self.results : list[HealthCheckManager.Result] = []
+
+        def to_dict(self):
+            return {
+                "status": str(self.status),
+                "checks": [result.to_dict() for result in self.results]
+            }
+
+    # class data
+
+    types : list[Type] = []
+
+    # constructor
+
+    def __init__(self):
+        self.environment : Optional[Environment] = None
+        self.checks: list[HealthCheckManager.Check] = []
+
+    # check
+
+    async def check(self) -> HealthCheckManager.Health:
+        self.logger.info("Checking health...")
+
+        health = HealthCheckManager.Health()
+
+        tasks = []
+        for check in self.checks:
+            result = HealthCheckManager.Result(check.name)
+            health.results.append(result)
+            tasks.append(check.run(result))
+
+        await asyncio.gather(*tasks)
+
+        for result in health.results:
+            if result.status.value > health.status.value:
+                health.status = result.status
+
+        return health
+
+    # public
+
+    @inject_environment()
+    def set_environment(self, environment: Environment):
+        self.environment = environment
+
+    @on_init()
+    def setup(self):
+        for type in self.types:
+            descriptor = TypeDescriptor(type).for_type(type)
+            instance = self.environment.get(type)
+
+            for method in descriptor.get_methods():
+                if method.has_decorator(health_check):
+                    decorator = method.get_decorator(health_check)
+
+                    name = decorator.args[0]
+                    cache = decorator.args[1]
+                    fail_if_slower_than = decorator.args[2]
+                    if len(name) == 0:
+                        name = method.get_name()
+
+                    self.checks.append(HealthCheckManager.Check(name, cache, fail_if_slower_than, instance, method.method))

aspyx_service/registries.py

@@ -0,0 +1,227 @@
+"""
+registries for components in aspyx service
+"""
+import re
+import threading
+from abc import abstractmethod
+import time
+from typing import Optional
+from urllib.parse import urlparse
+
+import consul
+
+from aspyx.util import StringBuilder
+from aspyx.di import on_init
+from .healthcheck import HealthCheckManager, HealthStatus
+
+from .server import Server
+from .service import ComponentRegistry, Channel, ServiceAddress, ServiceManager, ComponentDescriptor, Component, ChannelAddress
+
+class ConsulComponentRegistry(ComponentRegistry):
+    # constructor
+
+    def __init__(self, port: int, consul_url: str):
+        self.port = port
+        self.ip = Server.get_local_ip()
+        self.running = False
+        self.consul = None
+        self.watchdog = None
+        self.interval = 5
+        self.last_index = {}
+        self.component_addresses : dict[str, dict[str, ServiceAddress]] = {} # comp -> channel -> address
+        self.watch_channels : list[Channel] = []
+
+        parsed = urlparse(consul_url)
+
+        self.consul_host = parsed.hostname
+        self.consul_port = parsed.port
+
+    def make_consul(self, host: str, port: int) -> consul.Consul:
+        return consul.Consul(host=host, port=port)
+
+    # lifecycle hooks
+
+    @on_init()
+    def setup(self):
+        # create consul client
+
+        self.consul = self.make_consul(host=self.consul_host, port=self.consul_port)
+        self.running = True
+
+        # start thread
+
+        self.watchdog = threading.Thread(target=self.watch_consul, daemon=True)
+        self.watchdog.start()
+
+    def inform_channels(self, old_address: ServiceAddress, new_address: Optional[ServiceAddress]):
+        for channel in self.watch_channels:
+            if channel.address is old_address:
+                channel.set_address(new_address)
+
+
+    def watch_consul(self):
+        while self.running:
+            # check services
+
+            for component, old_addresses in self.component_addresses.items():
+                old_addresses = dict(old_addresses) # we will modify it...
+                new_addresses = self.fetch_addresses(component, wait="1s")
+
+                # compare
+
+                changed = False
+                for channel_name, address in new_addresses.items():
+                    service_address = old_addresses.get(channel_name, None)
+                    if service_address is None:
+                        ServiceManager.logger.info("new %s address for %s", channel_name, component)
+                        changed = True
+                    else:
+                        if service_address != address:
+                            changed = True
+
+                            ServiceManager.logger.info("%s address for %s changed", channel_name, component)
+
+                            # inform channels
+
+                            self.inform_channels(service_address, address)
+
+                        # delete
+
+                        del old_addresses[channel_name]
+
+                # watchout for deleted addresses
+
+                for channel_name, address in old_addresses.items():
+                    ServiceManager.logger.info("deleted %s address for %s", channel_name, component)
+
+                    changed = True
+
+                    # inform channel
+
+                    self.inform_channels(address, None)
+
+                # replace ( does that work while iterating )
+
+                if changed:
+                    self.component_addresses[component] = new_addresses
+
+            # time to sleep
+
+            time.sleep(5)
+
+    @abstractmethod
+    def watch(self, channel: Channel):
+        self.watch_channels.append(channel)
+
+        #self.component_addresses[channel.component_descriptor.name] = {}
+
+   # public
+
+    def register_service(self, name, service_id, health: str, tags=None, meta=None):
+        ip = "host.docker.internal" # TODO
+
+        self.consul.agent.service.register(
+            name=name,
+            service_id=service_id,
+            address=self.ip,
+            port=self.port,
+            tags=tags or [],
+            meta=meta or {},
+            check=consul.Check().http(
+                url=f"http://{ip}:{self.port}{health}",
+                interval="10s",
+                timeout="3s",
+                deregister="5m")
+            )
+
+    def deregister(self, descriptor: ComponentDescriptor[Component]):
+        name = descriptor.name
+
+        service_id = f"{self.ip}:{self.port}:{name}"
+
+        self.consul.agent.service.deregister(service_id)
+
+    def stop(self):
+        self.running = False
+        if self.watchdog is not None:
+            self.watchdog.join()
+            self.watchdog = None
+
+    # private
+
+    def fetch_addresses(self, component: str, wait=None) -> dict[str, ServiceAddress]:
+        addresses : dict[str, ServiceAddress] = {} # channel name -> ServiceAddress
+
+        index, nodes = self.consul.health.service(component, passing=True, index=self.last_index.get(component, None), wait=wait)
+        self.last_index[component] = index
+
+        for node in nodes:
+            service = node["Service"]
+
+            meta = service.get('Meta')
+
+            channels = meta.get("channels").split(",")
+
+            for channel in channels:
+                match = re.search(r"([\w-]+)\((.*)\)", channel)
+
+                channel_name = match.group(1)
+                url = match.group(2)
+
+                address = addresses.get(channel, None)
+                if address is None:
+                    address = ServiceAddress(component=component, channel=channel_name)
+                    addresses[channel] = address
+
+                address.urls.append(url)
+
+        # done
+
+        return addresses
+
+    # implement ComponentRegistry
+
+    def register(self, descriptor: ComponentDescriptor[Component], addresses: list[ChannelAddress]):
+        name = descriptor.name
+
+        id = f"{self.ip}:{self.port}:{name}"
+
+        builder = StringBuilder()
+        first = True
+        for address in addresses:
+            if not first:
+                builder.append(",")
+
+            builder.append(address.channel).append("(").append(address.uri).append(")")
+
+            first = False
+
+        addresses = str(builder)
+
+        self.register_service(name, id, descriptor.health, tags =["component"], meta={"channels": addresses})
+
+    def get_addresses(self, descriptor: ComponentDescriptor) -> list[ServiceAddress]:
+        component_addresses = self.component_addresses.get(descriptor.name, None)
+        if component_addresses is None:
+            component_addresses = self.fetch_addresses(descriptor.name)
+
+            # only cache if non-empty
+
+            if len(component_addresses) > 0:
+                self.component_addresses[descriptor.name] = component_addresses
+
+        return list(component_addresses.values())
+
+    #200–299	passing	Service is healthy (OK, Created, No Content…)
+    #429	warning	Rate limited or degraded
+    #300–399	warning	Redirects interpreted as potential issues
+    #400–499	critical	Client errors (Bad Request, Unauthorized…)
+    #500–599	critical	Server errors (Internal Error, Timeout…)
+    #Other / No response	critical	Timeout, connection refused, etc.
+    def map_health(self, health: HealthCheckManager.Health) -> int:
+        if health.status is HealthStatus.OK:
+            return 200
+        elif health.status is HealthStatus.WARNING:
+            return 429
+        else:
+            return 500