skeleton-framework 0.1.0__py3-none-any.whl

skeleton/infrastructure/gateway/src/client.py

@@ -0,0 +1,68 @@
+import httpx
+from fastapi import Request, Response
+
+from starlette.datastructures import Headers
+
+from skeleton.infrastructure.gateway.src.schemas import UpstreamRequest
+from skeleton.infrastructure.gateway.src.lifespan import HTTPAsyncClientManager
+from skeleton.infrastructure.gateway.src.headers import HOP_BY_HOP_HEADERS
+
+# talks directly to client &
+# sends AsyncioClient.request()
+class ProxyClient:
+    
+    def __init__(self, manager: HTTPAsyncClientManager):
+        self.manager = manager
+
+    @property
+    def client(self):
+        return self.manager.client
+
+    def filter_hop_by_hop_headers(self, h: Headers) -> dict:
+        
+        headers = dict(h)
+
+        # httpx auto regenerates host header from
+        headers.pop("host", None)
+
+        connection = headers.get("connection")
+
+        if connection:
+            for header in connection.split(","):
+                headers.pop(header.strip().lower(), None)
+
+        for header in HOP_BY_HOP_HEADERS:
+            headers.pop(header.lower(), None)
+
+        return headers
+
+    async def request(self, clientRequest: UpstreamRequest):
+
+        request: Request = clientRequest.request
+        
+        headers = self.filter_hop_by_hop_headers(
+            clientRequest.request.headers
+        )
+
+        # host regenerated by upstream target!
+        url = httpx.URL(clientRequest.target)
+        headers["host"] = (
+            f"{url.host}:{url.port}"
+            if url.port else url.host
+        )
+        # print(json.dumps(headers, indent=4))
+
+        # faster, once connected!
+        upstream_response = await self.client.request(
+            method=request.method,
+            url=clientRequest.target,
+            headers=headers,
+            # stream body in chunks!
+            content=await request.body()
+        )
+
+        return Response(
+            content=upstream_response.content,
+            status_code=upstream_response.status_code,
+            headers=dict(upstream_response.headers)
+        )

skeleton/infrastructure/gateway/src/config.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+from dataclasses import dataclass
+
+@dataclass(frozen=True, kw_only=True)
+class ProcessConfig:
+    module: str
+
+@dataclass(frozen=True, kw_only=True)
+class NetworkConfig:
+    host: str
+    port: int
+
+@dataclass(frozen=True, kw_only=True)
+class WatchConfig:
+    enabled: bool
+    extensions: tuple[str, ...]
+
+@dataclass(frozen=True, kw_only=True)
+class ServiceConfig:
+
+    id: str # backend (ALWAYS!) [FOR NOW!]
+    name: str # app => actual FastAPI app name
+    root: Path # resolving module paths, file paths, etc.
+
+    # service specs
+    network: NetworkConfig
+    process: ProcessConfig
+    watch: WatchConfig
+    

skeleton/infrastructure/gateway/src/context.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+from dataclasses import dataclass
+
+@dataclass(frozen=True, kw_only=True)
+class ProcessContext:
+    module: str
+    exe: Path
+    cwd: Path
+
+@dataclass(frozen=True, kw_only=True)
+class NetworkContext:
+    host: str
+    port: int
+
+@dataclass(frozen=True, kw_only=True)
+class WatchContext:
+    enabled: bool
+    directory: Path
+    extensions: tuple[str, ...]
+
+@dataclass(frozen=True, kw_only=True)
+class ServiceContext:
+
+    id: str # backend (ALWAYS!) [FOR NOW!]
+    name: str # app => actual FastAPI app name
+    root: Path # resolving module paths, file paths, etc.
+
+    network: NetworkContext
+    process: ProcessContext
+    watch: WatchContext
+    

skeleton/infrastructure/gateway/src/headers.py

@@ -0,0 +1,17 @@
+# HTTP protocol:
+# 
+#   https://en.wikipedia.org/wiki/HTTP
+# 
+# See RFC 7230:
+# 
+#   proxy servers should not forward the following header data:
+HOP_BY_HOP_HEADERS = {
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailers",
+    "transfer-encoding",
+    "upgrade"
+}

skeleton/infrastructure/gateway/src/lifespan.py

@@ -0,0 +1,17 @@
+import httpx
+
+class HTTPAsyncClientManager:
+
+    def __init__(self, config: dict) -> None:
+        self.config = config
+        self.client: httpx.AsyncClient | None = None
+
+    async def startup(self):
+        self.client = httpx.AsyncClient(
+            timeout=httpx.Timeout(self.config["defaultTimeout"]),
+            follow_redirects=self.config["followRedirects"]
+        )
+
+    async def shutdown(self):
+        if self.client:
+            await self.client.aclose()

skeleton/infrastructure/gateway/src/loader.py

@@ -0,0 +1,113 @@
+from pathlib import Path
+
+from skeleton.infrastructure.common.src.context import RuntimeContext
+
+from skeleton.infrastructure.gateway.src.utils import normalize_extensions
+
+from skeleton.infrastructure.common.src.utils import (
+    path_to_module, resolve_executable_path
+)
+
+from skeleton.infrastructure.gateway.src.context import (
+    NetworkContext, ProcessContext,
+    ServiceContext, WatchContext
+)
+
+from skeleton.infrastructure.gateway.src.config import (
+    NetworkConfig, ProcessConfig,
+    ServiceConfig, WatchConfig
+)
+
+def load_service_configs(
+    context: RuntimeContext
+) -> list[ServiceConfig]:
+    
+    configs: list[ServiceConfig] = []
+    
+    servers = context.config.servers["servers"]
+    services = context.config.services["services"]
+    
+    # use services to get the relevant server for that service:
+    for name, service in services.items():
+
+        networkConfig = NetworkConfig(
+            host=servers[name]["host"],
+            port=servers[name]["port"],
+        )
+
+        watchConfig = WatchConfig(
+            enabled=service["reload"],
+            extensions=service["ext"],
+        )
+
+        if name == "backend":
+
+            service_root = context.layout.backend
+
+            module_path = service_root / "src" / "main.py"
+
+            module = path_to_module(module_path.relative_to(service_root))
+
+        else:
+
+            service_root = context.root / service["root"]
+            module = service["module"]
+
+        processConfig = ProcessConfig(
+            module=module
+        )
+
+        configs.append(
+            ServiceConfig(
+                root=service_root,
+                id=name,
+                name=service["name"],
+                network=networkConfig,
+                watch=watchConfig,
+                process=processConfig,
+            )
+        )
+
+    return configs
+
+# build the immutable/frozen
+# service configuration objects
+def build_service_contexts(
+    configs: list[ServiceConfig]
+) -> list[ServiceContext]:
+    
+    contexts: list[ServiceContext] = []
+
+    for config in configs:
+
+        process = ProcessContext(
+            module=config.process.module,
+            exe=resolve_executable_path(config.root),
+            cwd=Path(config.root),
+        )
+
+        network = NetworkContext(
+            host=config.network.host,
+            port=config.network.port,
+        )
+        
+        watch = WatchContext(
+            enabled=config.watch.enabled,
+            directory=config.root,
+            extensions=normalize_extensions(
+                config.watch.extensions
+            ),
+        )
+
+        contexts.append(
+            ServiceContext(
+                id=config.id,
+                name=config.name,
+                root=config.root,
+                process=process,
+                network=network,
+                watch=watch,
+            )
+        )
+
+    return contexts

skeleton/infrastructure/gateway/src/logging.py

@@ -0,0 +1,37 @@
+import logging
+import uvicorn
+
+from copy import deepcopy
+
+class AccessLogFilter(logging.Filter):
+
+    def filter(
+        self,
+        record: logging.LogRecord
+    ) -> bool:
+
+        return (
+            "GET /.well-known/appspecific/com.chrome.devtools.json "
+            not in record.getMessage()
+        )
+
+def build_log_config() -> dict:
+
+    config = deepcopy(
+        uvicorn.config.LOGGING_CONFIG
+    )
+
+    config["filters"] = {
+        "skeleton_access": {
+            "()": (
+                "skeleton.infrastructure.gateway.src.logging."
+                "AccessLogFilter"
+            ),
+        },
+    }
+
+    config["handlers"]["access"]["filters"] = [
+        "skeleton_access",
+    ]
+
+    return config

skeleton/infrastructure/gateway/src/main.py

@@ -0,0 +1,139 @@
+import sys, asyncio, uvicorn
+
+from pathlib import Path
+
+from skeleton.infrastructure.common.src.constants import Bootstrap
+from skeleton.infrastructure.common.src.context import RuntimeContext
+from skeleton.infrastructure.common.src.config import load_runtime_config
+from skeleton.infrastructure.common.src.layout import build_layout
+from skeleton.infrastructure.common.src.env import build_env
+
+from skeleton.infrastructure.gateway.src.config import ServiceConfig
+from skeleton.infrastructure.gateway.src.context import ServiceContext
+from skeleton.infrastructure.gateway.src.service import Service
+from skeleton.infrastructure.gateway.src.registry import Registry
+
+from skeleton.infrastructure.gateway.src.logging import build_log_config
+
+from skeleton.infrastructure.gateway.src.app import create_app
+from skeleton.infrastructure.gateway.src.parser import parse
+
+from skeleton.infrastructure.gateway.src.validation import (
+    validate_service_configs,
+    validate_service_contexts
+)
+
+from skeleton.infrastructure.gateway.src.loader import (
+    build_service_contexts, load_service_configs
+)
+
+# service orchestration!
+async def start(context: RuntimeContext) -> None:
+
+    # pass in RuntimeContext
+    registry = Registry()
+
+    print("INFO:     Starting reverse proxy watchfile services ...")
+
+    # load & build the config objects
+    # configs = load_service_config(ROOT)
+    serviceConfigs: list[ServiceConfig] = load_service_configs(context)
+    validConfigs = validate_service_configs(serviceConfigs)
+
+    if not validConfigs:
+        exit(1)
+
+    serviceContexts: list[ServiceContext] = build_service_contexts(serviceConfigs)
+    validContexts = validate_service_contexts(serviceContexts)
+
+    if not validContexts:
+        exit(1)
+    
+    # log config data for visual output!
+    # for name, config in configs.items():
+    #     print(f"{name}:", config.to_json())
+    
+    # register config objects as services!
+    for service in serviceContexts:
+        registry.regsiter(Service(service))
+
+    try:
+
+        # start all services
+        await registry.start_all()
+        app = create_app(context)
+
+        servers = context.config.servers["servers"]
+        gateway = servers["gateway"]
+
+        # create the uvicorn server!
+        server = uvicorn.Server(
+            uvicorn.Config(
+                app,
+                host=gateway["host"],
+                port=gateway["port"],
+                log_config=build_log_config(),
+            )
+        )
+
+        # start the server, then ...
+        # await console interrupt!
+        await server.serve()
+
+    except asyncio.CancelledError:
+        print("INFO:     Stopping reverse proxy watchfile services ...")
+        
+    finally:
+        # shutdown all services!
+        await registry.stop_all()
+
+# receive subprocess command line flags passed like:
+# ['--root', 'C:\\Users\\Lambda\\Desktop\\skeleton', '--watch', '--open']
+if __name__ == "__main__":
+
+    args = sys.argv[1:]
+    raw = parse(args)
+
+    PROJECT_ROOT = Path(raw["root"]).resolve()
+    FRAMEWORK_ROOT = Path(__file__).resolve().parents[4]
+    MODE = raw["mode"]
+
+    options: dict[str, str | bool] = {
+        "root": str(PROJECT_ROOT),
+        "mode": MODE,
+        "watch": raw["watch"],
+        "open": raw["open"],
+    }
+
+    layout = build_layout(
+        PROJECT_ROOT / Bootstrap.LAYOUT,
+        project_root=PROJECT_ROOT,
+        framework_root=FRAMEWORK_ROOT,
+    )
+
+    # config = load_runtime_config(
+    #     layout.common / Bootstrap.CONFIG_FILE_EXT,
+    #     FRAMEWORK_ROOT,
+    #     layout,
+    # )
+
+    config = load_runtime_config(
+        layout.common / Bootstrap.CONFIG_FILE_EXT,
+        PROJECT_ROOT,
+        FRAMEWORK_ROOT,
+        layout,
+    )
+
+    env = build_env(PROJECT_ROOT, MODE)
+
+    context = RuntimeContext(
+        root=PROJECT_ROOT,
+        mode=MODE,
+        args=args,
+        env=env,
+        layout=layout,
+        options=options,
+        config=config,
+    )
+
+    asyncio.run(start(context))

skeleton/infrastructure/gateway/src/parser.py

@@ -0,0 +1,59 @@
+# command line input received from
+# subprocess call may look like:
+# --mode prod --watch --open
+
+# arguments are thus:
+# ["--mode", "prod", "--watch", "--open"]
+def parse(argv: list[str]) -> dict:
+
+    options: dict[str, str | bool] = {
+        "mode": "dev",
+        "watch": False,
+        "open": False,
+    } # dev/prod
+
+    i = 0
+
+    while i < len(argv):
+
+        arg = argv[i]
+
+        if arg == "--mode":
+
+            if i + 1 >= len(argv):
+                raise ValueError("--mode requires a values to be specified")
+            
+            mode = argv[i + 1]
+
+            if mode not in ["dev", "prod"]:
+                raise ValueError(f"invalid mode: {mode}")
+            
+            options["mode"] = mode
+
+            i += 2
+            continue
+
+        if arg == "--root":
+    
+            if i + 1 >= len(argv):
+                raise ValueError("--root requires a values to be specified")
+            
+            root = argv[i + 1]
+            options["root"] = root
+
+            i += 2
+            continue
+
+        if arg == "--watch":
+            options["watch"] = True
+            i += 1
+            continue
+
+        if arg == "--open":
+            options["open"] = True
+            i += 1
+            continue
+
+        raise ValueError(f"Unknown option: {arg}")
+
+    return options

skeleton/infrastructure/gateway/src/registry.py

@@ -0,0 +1,30 @@
+import asyncio
+
+from skeleton.infrastructure.gateway.src.service import Service
+
+# service config manager!
+class Registry:
+
+    def __init__(self) -> None:
+        self.services: dict[str, Service] = {}
+
+    def regsiter(self, service: Service) -> None:
+        self.services[service.config.id] = service
+
+    async def start_all(self) -> None:
+        await asyncio.gather(
+            *[
+                service.run()
+                for service
+                in self.services.values()
+            ]
+        )
+
+    async def stop_all(self) -> None:
+
+        print("INFO:     Gracefully shutting down all services ...")
+        for service in self.services.values():
+            await service.shutdown()
+
+    def get(self, name) -> Service:
+        return self.services[name]

skeleton/infrastructure/gateway/src/reverseproxy.py

@@ -0,0 +1,54 @@
+from fastapi import Request
+from urllib.parse import urljoin
+
+from skeleton.infrastructure.gateway.src.client import ProxyClient
+from skeleton.infrastructure.gateway.src.router import ProxyRouter
+from skeleton.infrastructure.gateway.src.schemas import UpstreamRequest
+
+from pathlib import PurePosixPath
+
+# coming from:
+# http://127.0.0.1:8000/api/some/path
+# resolves to:
+# http://127.0.0.1:8080/some/path
+# send request to Backend!
+
+# coming from:
+# http://127.0.0.1:8000/some/path
+# resolves to:
+# http://127.0.0.1:3000/some/path
+# send request to Frontend!
+
+def is_asset(path: str) -> bool:
+    return "." in PurePosixPath(path).name
+
+class ReverseProxy:
+    
+    def __init__(self, router: ProxyRouter, client: ProxyClient):
+        self.router = router
+        self.client = client
+
+    async def handle_http_request(self, request: Request):
+
+        path = request.url.path
+        upstream = self.router.resolve(path)
+
+        # SPA Fallback logic!
+        if upstream.target == self.router.frontend.target:
+            if not is_asset(path):
+                path = f"/{self.router.index}"
+
+        # build the target url
+        target = urljoin(upstream.target, upstream.path)
+
+        # if request has query params
+        # include them for client.request!
+        if request.url.query:
+            target += f"?{request.url.query}"
+
+        return await self.client.request(
+            UpstreamRequest(
+                request=request,
+                target=target
+            )
+        )

skeleton/infrastructure/gateway/src/router.py

@@ -0,0 +1,74 @@
+from skeleton.infrastructure.common.src.context import RuntimeContext
+from skeleton.infrastructure.gateway.src.schemas import RouteContext, UpstreamContext
+
+class ProxyRouter:
+
+    def __init__(self, context: RuntimeContext):
+
+        schemas = context.config.schemas["schemas"]
+        http = schemas["http"]
+        ws = schemas["ws"]
+
+        # print(http)
+        # print(ws)
+
+        # index.html file name configurable by:
+        # skeleton/app/frontend/webpack/config.json
+        self.index = context.config.frontend["entry"]["index"]
+
+        backend = context.config.servers["servers"]["backend"]
+        frontend = context.config.servers["servers"]["frontend"]
+
+        self.backend = RouteContext(
+            prefix=http["backend"]["prefix"],
+            target=f"http://{backend['host']}:{backend['port']}",
+            strip=http["backend"]["strip"],
+            protocol="http",
+        )
+
+        self.frontend = RouteContext(
+            prefix=http["frontend"]["prefix"],
+            target=f"http://{frontend['host']}:{frontend['port']}",
+            strip=http["frontend"]["strip"],
+            protocol="http",
+        )
+
+        self.websock = RouteContext(
+            prefix=ws["backend"]["prefix"],
+            target=f"http://{backend['host']}:{backend['port']}",
+            strip=http["backend"]["strip"],
+            protocol="ws",
+        )
+
+    # decide where to forward/redirect
+    def resolve(self, path: str) -> UpstreamContext:
+
+        if path.startswith(self.backend.prefix):
+
+            if self.backend.strip:
+                path = path.removeprefix(self.backend.prefix)
+
+            return UpstreamContext(
+                target=self.backend.target,
+                path=path,
+                protocol=self.backend.protocol,
+            )
+        
+        if path.startswith(self.websock.prefix):
+
+            if self.websock.strip:
+                path = path.removeprefix(self.websock.prefix)
+
+            return UpstreamContext(
+                target=self.websock.target,
+                path=path,
+                protocol=self.websock.protocol,
+            )
+        
+        # Every other shape routes to frontend SPA!
+        return UpstreamContext(
+            target=self.frontend.target,
+            path=path,
+            protocol=self.frontend.protocol,
+        )
+    

skeleton/infrastructure/gateway/src/schemas.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+
+from fastapi import Request
+
+@dataclass(frozen=True, kw_only=True)
+class RouteContext:
+    prefix: str # /api or /ws or /
+    target: str # frontend/backend
+    strip: bool # weather to strip prefixes
+    protocol: str # http or ws
+
+@dataclass(frozen=True, kw_only=True)
+class UpstreamContext:
+    path: str # composed path/...
+    target: str # resolved
+    protocol: str # http or ws
+
+@dataclass(frozen=True, kw_only=True)
+class UpstreamRequest:
+    target: str
+    request: Request