omserv 0.0.0.dev7__tar.gz

omserv-0.0.0.dev7/LICENSE

@@ -0,0 +1,21 @@
+Copyright 2023- wrmsr
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

omserv-0.0.0.dev7/MANIFEST.in

@@ -0,0 +1 @@
+global-exclude **/conftest.py

omserv-0.0.0.dev7/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: omserv
+Version: 0.0.0.dev7
+Summary: omserv
+Author: wrmsr
+License: BSD-3-Clause
+Project-URL: source, https://github.com/wrmsr/omlish
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: omlish==0.0.0.dev7
+Provides-Extra: server
+Requires-Dist: h11>=0.14; extra == "server"
+Requires-Dist: h2>=4.1; extra == "server"
+Requires-Dist: priority>=2; extra == "server"
+Requires-Dist: wsproto>=1.2; extra == "server"

omserv-0.0.0.dev7/README.rst

@@ -0,0 +1 @@
+*omlish*

omserv-0.0.0.dev7/omserv/__about__.py

@@ -0,0 +1,28 @@
+from omlish.__about__ import ProjectBase
+from omlish.__about__ import SetuptoolsBase
+from omlish.__about__ import __version__
+
+
+class Project(ProjectBase):
+    name = 'omserv'
+    description = 'omserv'
+
+    dependencies = [
+        f'omlish == {__version__}',
+    ]
+
+    optional_dependencies = {
+        'server': [
+            'h11 >= 0.14',
+            'h2 >= 4.1',
+            'priority >= 2',
+            'wsproto >= 1.2',
+        ],
+    }
+
+
+class Setuptools(SetuptoolsBase):
+    find_packages = {
+        'include': ['omserv', 'omserv.*'],
+        'exclude': [*SetuptoolsBase.find_packages['exclude']],
+    }

omserv-0.0.0.dev7/omserv/apps/base.py

@@ -0,0 +1,23 @@
+import contextvars
+import typing as ta
+
+from omlish.http.asgi import AsgiScope
+
+
+##
+
+
+SCOPE: contextvars.ContextVar[AsgiScope] = contextvars.ContextVar('scope')
+
+
+##
+
+
+BaseServerUrl = ta.NewType('BaseServerUrl', str)
+
+
+BASE_SERVER_URL: contextvars.ContextVar[BaseServerUrl] = contextvars.ContextVar('base_server_url')
+
+
+def url_for(s: str) -> str:
+    return BASE_SERVER_URL.get() + s

omserv-0.0.0.dev7/omserv/apps/inject.py

@@ -0,0 +1,89 @@
+import typing as ta
+
+from omlish import inject as inj
+from omlish.http import sessions
+from omlish.http.asgi import AsgiApp
+from omlish.http.asgi import AsgiScope
+
+from .base import SCOPE
+from .markers import AppMarker
+from .markers import AppMarkerProcessor
+from .markers import NopAppMarkerProcessor
+from .markers import get_app_markers
+from .routes import Handler_
+from .routes import Route
+from .routes import _HandlesAppMarker
+from .sessions import SESSION
+from .sessions import _WithSessionAppMarker
+from .sessions import _WithSessionAppMarkerProcessor
+from .templates import J2Namespace
+from .templates import J2Templates
+
+
+def bind_handler(hc: type[Handler_]) -> inj.Elemental:
+    return inj.as_elements(
+        inj.bind(hc, singleton=True),
+        inj.set_binder[Handler_]().bind(hc),
+    )
+
+
+def bind_app_marker_processor(mc: type[AppMarker], pc: type[AppMarkerProcessor]) -> inj.Elemental:
+    return inj.as_elements(
+        inj.bind(pc),
+        inj.map_binder[type[AppMarker], AppMarkerProcessor]().bind(mc, pc),
+    )
+
+
+def _build_route_handler_map(
+        handlers: ta.AbstractSet[Handler_],
+        processors: ta.Mapping[type[AppMarker], AppMarkerProcessor],
+) -> ta.Mapping[Route, AsgiApp]:
+    route_handlers: dict[Route, AsgiApp] = {}
+    for h in handlers:
+        for rh in h.get_route_handlers():
+            app = rh.handler
+            markers = get_app_markers(rh.handler)
+            for m in markers:
+                mp = processors[type(m)]
+                if mp is not None:
+                    app = mp(app)
+            route_handlers[rh.route] = app
+    return route_handlers
+
+
+def bind_route_handler_map() -> inj.Elemental:
+    return inj.as_elements(
+        inj.bind(_build_route_handler_map, singleton=True),
+        inj.map_binder[type[AppMarker], AppMarkerProcessor](),
+    )
+
+
+def bind() -> inj.Elemental:
+    return inj.as_elements(
+        inj.bind(ta.Callable[[], AsgiScope], to_const=SCOPE.get),
+        inj.bind(ta.Callable[[], sessions.Session], to_const=SESSION.get),
+
+        ##
+
+        inj.map_binder[type[AppMarker], AppMarkerProcessor](),
+
+        bind_app_marker_processor(_WithSessionAppMarker, _WithSessionAppMarkerProcessor),
+        bind_app_marker_processor(_HandlesAppMarker, NopAppMarkerProcessor),
+
+        ##
+
+        inj.set_binder[Handler_](),
+    )
+
+
+def _build_j2_namespaces(ns: ta.Annotated[ta.Mapping[str, ta.Any], inj.Tag(J2Namespace)]) -> J2Namespace:
+    return J2Namespace(ns)
+
+
+def bind_templates() -> inj.Elemental:
+    return inj.as_elements(
+        inj.bind(J2Templates, singleton=True),
+
+        inj.map_binder[str, ta.Any](tag=J2Namespace),
+        inj.bind(_build_j2_namespaces),
+    )

omserv-0.0.0.dev7/omserv/apps/markers.py

@@ -0,0 +1,41 @@
+import abc
+import typing as ta
+
+from omlish import lang
+from omlish.http.asgi import AsgiApp
+
+
+T = ta.TypeVar('T')
+
+
+class AppMarker(lang.Abstract):
+    pass
+
+
+APP_MARKERS_ATTR = '__app_markers__'
+
+
+def append_app_marker(obj: T, *markers: AppMarker) -> T:
+    tgt = lang.unwrap_func(obj)  # type: ignore
+    tgt.__dict__.setdefault(APP_MARKERS_ATTR, []).extend(markers)
+    return obj
+
+
+def get_app_markers(obj: ta.Any) -> ta.Sequence[AppMarker]:
+    tgt = lang.unwrap_func(obj)
+    try:
+        dct = tgt.__dict__
+    except AttributeError:
+        return ()
+    return dct.get(APP_MARKERS_ATTR, ())
+
+
+class AppMarkerProcessor(lang.Abstract):
+    @abc.abstractmethod
+    def __call__(self, app: AsgiApp) -> AsgiApp:
+        return app
+
+
+class NopAppMarkerProcessor(AppMarkerProcessor, lang.Final):
+    def __call__(self, app: AsgiApp) -> AsgiApp:
+        return app

omserv-0.0.0.dev7/omserv/apps/routes.py

@@ -0,0 +1,139 @@
+import contextlib
+import dataclasses as dc
+import logging
+import typing as ta
+
+from omlish import check
+from omlish import lang
+from omlish.http.asgi import AsgiApp
+from omlish.http.asgi import AsgiApp_
+from omlish.http.asgi import AsgiRecv
+from omlish.http.asgi import AsgiScope
+from omlish.http.asgi import AsgiSend
+from omlish.http.asgi import send_response
+from omlish.http.asgi import stub_lifespan
+
+from .base import BASE_SERVER_URL
+from .base import SCOPE
+from .base import BaseServerUrl
+from .markers import AppMarker
+from .markers import append_app_marker
+from .markers import get_app_markers
+
+
+log = logging.getLogger(__name__)
+
+
+##
+
+
+class Route(ta.NamedTuple):
+    method: str
+    path: str
+
+    @classmethod
+    def get(cls, path: str) -> 'Route':
+        return cls('GET', path)
+
+    @classmethod
+    def post(cls, path: str) -> 'Route':
+        return cls('POST', path)
+
+    @classmethod
+    def put(cls, path: str) -> 'Route':
+        return cls('PUT', path)
+
+    @classmethod
+    def delete(cls, path: str) -> 'Route':
+        return cls('DELETE', path)
+
+
+class RouteHandler(ta.NamedTuple):
+    route: Route
+    handler: AsgiApp
+
+
+@dc.dataclass(frozen=True)
+class _HandlesAppMarker(AppMarker, lang.Final):
+    routes: ta.Sequence[Route]
+
+
+def handles(*routes: Route):
+    def inner(fn):
+        append_app_marker(fn, _HandlesAppMarker(routes))
+        return fn
+
+    routes = tuple(map(check.of_isinstance(Route), routes))
+    return inner
+
+
+##
+
+
+class Handler_(lang.Abstract):  # noqa
+    def get_route_handlers(self) -> ta.Iterable[RouteHandler]:
+        return get_marked_route_handlers(self)
+
+
+def get_marked_route_handlers(h: Handler_) -> ta.Sequence[RouteHandler]:
+    ret: list[RouteHandler] = []
+
+    cdct: dict[str, ta.Any] = {}
+    for mcls in reversed(type(h).__mro__):
+        cdct.update(**mcls.__dict__)
+
+    for att, obj in cdct.items():
+        if not (mks := get_app_markers(obj)):
+            continue
+        if not (hms := [m for m in mks if isinstance(m, _HandlesAppMarker)]):
+            continue
+        if not (rs := [r for hm in hms for r in hm.routes]):
+            continue
+
+        app = getattr(h, att)
+        ret.extend(RouteHandler(r, app) for r in rs)
+
+    return ret
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class RouteHandlerApp(AsgiApp_):
+    route_handlers: ta.Mapping[Route, AsgiApp]
+    base_server_url: BaseServerUrl | None = None
+
+    async def __call__(self, scope: AsgiScope, recv: AsgiRecv, send: AsgiSend) -> None:
+        with contextlib.ExitStack() as es:
+            es.enter_context(lang.context_var_setting(SCOPE, scope))
+
+            match scope_ty := scope['type']:
+                case 'lifespan':
+                    await stub_lifespan(scope, recv, send)
+                    return
+
+                case 'http':
+                    if self.base_server_url is not None:
+                        bsu = self.base_server_url
+                    else:
+                        sch = scope['scheme']
+                        h, p = scope['server']
+                        if (sch, p) not in (('http', 80), ('https', 443)):
+                            ps = f':{p}'
+                        else:
+                            ps = ''
+                        bsu = BaseServerUrl(f'{sch}://{h}{ps}/')
+                    es.enter_context(lang.context_var_setting(BASE_SERVER_URL, bsu))
+
+                    route = Route(scope['method'], scope['raw_path'].decode())
+                    handler = self.route_handlers.get(route)
+
+                    if handler is not None:
+                        await handler(scope, recv, send)
+
+                    else:
+                        await send_response(send, 404)
+
+                case _:
+                    raise ValueError(f'Unhandled scope type: {scope_ty!r}')

omserv-0.0.0.dev7/omserv/apps/sessions.py

@@ -0,0 +1,57 @@
+import contextvars
+import dataclasses as dc
+import logging
+
+from omlish import lang
+from omlish.http import sessions
+from omlish.http.asgi import AsgiApp
+from omlish.http.asgi import AsgiRecv
+from omlish.http.asgi import AsgiScope
+from omlish.http.asgi import AsgiSend
+
+from .markers import AppMarker
+from .markers import AppMarkerProcessor
+from .markers import append_app_marker
+
+
+log = logging.getLogger(__name__)
+
+
+##
+
+
+SESSION: contextvars.ContextVar[sessions.Session] = contextvars.ContextVar('session')
+
+
+class _WithSessionAppMarker(AppMarker, lang.Singleton, lang.Final):
+    pass
+
+
+def with_session(fn):
+    return append_app_marker(fn, _WithSessionAppMarker())
+
+
+@dc.dataclass(frozen=True)
+class _WithSessionAppMarkerProcessor(AppMarkerProcessor):
+    _ss: sessions.CookieSessionStore
+
+    async def _wrap(self, fn: AsgiApp, scope: AsgiScope, recv: AsgiRecv, send: AsgiSend) -> None:
+        async def _send(obj):
+            if obj['type'] == 'http.response.start':
+                out_session = SESSION.get()
+                obj = {
+                    **obj,
+                    'headers': [
+                        *obj.get('headers', []),
+                        *self._ss.build_headers(out_session),
+                    ],
+                }
+
+            await send(obj)
+
+        in_session = self._ss.extract(scope)
+        with lang.context_var_setting(SESSION, in_session):
+            await fn(scope, recv, _send)
+
+    def __call__(self, app: AsgiApp) -> AsgiApp:
+        return lang.decorator(self._wrap)(app)  # noqa

omserv-0.0.0.dev7/omserv/apps/templates.py

@@ -0,0 +1,90 @@
+import dataclasses as dc
+import importlib.resources
+import logging
+import typing as ta
+
+import jinja2
+
+from .base import url_for
+
+
+log = logging.getLogger(__name__)
+
+
+##
+
+
+J2_DEFAULT_NAMESPACE = {}
+
+
+def j2_helper(fn):
+    J2_DEFAULT_NAMESPACE[fn.__name__] = fn
+    return fn
+
+
+j2_helper(url_for)
+
+
+##
+
+
+J2Namespace = ta.NewType('J2Namespace', ta.Mapping[str, ta.Any])
+
+
+class J2Templates:
+    @dc.dataclass(frozen=True)
+    class Config:
+        resource_root: str
+        reload: bool = False
+
+    def __init__(self, config: Config, ns: J2Namespace) -> None:
+        super().__init__()
+
+        self._config = config
+        self._ns = ns
+
+        self._env = jinja2.Environment(
+            loader=self._Loader(self),
+            autoescape=True,
+        )
+
+        self._all: ta.Mapping[str, jinja2.Template] | None = None
+
+    class _Loader(jinja2.BaseLoader):
+        def __init__(self, owner: 'J2Templates') -> None:
+            super().__init__()
+            self._owner = owner
+
+        def get_source(self, environment, template):
+            raise TypeError
+
+        def list_templates(self):
+            raise TypeError
+
+        def load(self, environment, name, globals=None):  # noqa
+            return self._owner.load(name)
+
+    def _load_all(self) -> ta.Mapping[str, jinja2.Template]:
+        ret: dict[str, jinja2.Template] = {}
+        for fn in importlib.resources.files(self._config.resource_root).iterdir():
+            if fn.name.endswith('.j2'):
+                ret[fn.name] = self._env.from_string(fn.read_text())
+        return ret
+
+    def load_all(self) -> ta.Mapping[str, jinja2.Template]:
+        if self._config.reload:
+            return self._load_all()
+
+        if self._all is None:
+            self._all = self._load_all()
+        return self._all
+
+    def load(self, name: str) -> jinja2.Template:
+        return self.load_all()[name]
+
+    def render(self, template_name: str, **kwargs: ta.Any) -> bytes:
+        return self.load(template_name).render(**{
+            **J2_DEFAULT_NAMESPACE,
+            **self._ns,
+            **kwargs,
+        }).encode()

omserv-0.0.0.dev7/omserv/dbs.py

@@ -0,0 +1,24 @@
+import os
+
+from .secrets import load_secrets  # noqa
+
+
+def get_secret_db_url() -> str:
+    cfg = load_secrets()
+    return f'postgresql+asyncpg://{cfg["postgres_user"]}:{cfg["postgres_pass"]}@{cfg["postgres_host"]}:5432'
+
+
+def get_docker_db_url() -> str:
+    from omlish import docker
+    cc = docker.ComposeConfig('omlish-', file_path='docker/compose.yml')
+    svc = cc.get_services()['postgres']
+    port = docker.get_compose_port(svc, 5432)
+    env = svc['environment']
+    return f'postgresql+asyncpg://{env["POSTGRES_USER"]}:{env["POSTGRES_PASSWORD"]}@127.0.0.1:{port}'
+
+
+def get_db_url() -> str:
+    if os.environ.get('PROD', '').lower() in ('1', 'true'):  # FIXME: lol
+        return get_secret_db_url()
+    else:
+        return get_docker_db_url()

omserv-0.0.0.dev7/omserv/node/models.py

@@ -0,0 +1,53 @@
+import typing as ta
+
+import sqlalchemy as sa
+import sqlalchemy.dialects.postgresql as sapg
+import sqlalchemy.orm
+
+from omlish import sql
+
+from .sql import CREATE_UPDATED_AT_FUNCTION_STATEMENT
+from .sql import IdMixin
+from .sql import TimestampsMixin
+from .sql import install_updated_at_trigger
+
+
+##
+
+
+Metadata = sa.MetaData()
+Base: ta.Any = sa.orm.declarative_base(metadata=Metadata)
+
+
+class Node(
+    IdMixin,
+    TimestampsMixin,
+    Base,
+):
+    __tablename__ = 'nodes'
+    __table_args__ = (
+        sa.Index('nodes_by_uuid', 'uuid', unique=True),
+    )
+
+    uuid = sa.Column(sa.String(50), nullable=False, unique=True)
+    hostname = sa.Column(sa.String(100), nullable=False)
+
+    heartbeat_at = sa.Column(sa.TIMESTAMP(timezone=True))
+
+    extra = sa.Column(sapg.JSONB)
+
+
+Nodes = Node.__table__
+
+
+install_updated_at_trigger(Metadata, 'nodes')
+
+
+async def setup_db(engine: sql.AsyncEngineLike, *, drop: bool = False) -> None:
+    conn: sql.AsyncConnection
+    async with sql.async_adapt(engine).connect() as conn:
+        async with conn.begin():
+            if drop:
+                await conn.run_sync(Metadata.drop_all)
+            await conn.execute(sa.text(CREATE_UPDATED_AT_FUNCTION_STATEMENT))
+            await conn.run_sync(Metadata.create_all)