bazaar-contrib-server-computer 0.3.0rc1__py3-none-any.whl

bazaar_contrib_server_computer/__init__.py

@@ -0,0 +1,187 @@
+"""The computers of the Bazaar Compute server: enrolling them, where their
+starlink connects, calling what they expose, and their pages; and the relay
+between the server's replicas, kept in memory for a server with one."""
+
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+lazy import asyncio
+lazy from collections.abc import AsyncIterator
+lazy from importlib.resources import files
+lazy from pathlib import Path
+
+from bazaar_contrib_http import HTTP
+from bazaar_contrib_server import SERVER, PermissionItem, SidebarItem, Topic
+from bazaar_contrib_server_access import ACCESS, Shared
+from bazaar_contrib_server_database import SERVER_DB, SERVER_SCHEMA
+from bazaar_contrib_server_migrations import SERVER_MIGRATIONS
+from bazaar_contrib_server_overview import OVERVIEW, OverviewItem
+from bazaar_contrib_timer import TIMER
+from bazaar_core import Context, Contrib
+
+from .contracts import (
+    ANSWER_MS,
+    CALLS_AT_MOST,
+    COMPUTERS,
+    HOLD_MS,
+    RELAY,
+    REPORTED,
+    Call,
+    Computers,
+    Relay,
+    Reported,
+)
+lazy from .calls import Calls
+lazy from .hosts import Hosts
+lazy from .memory import MemoryRelay
+lazy from .pages import CREATE, DELETE, SHARE, UPDATE, VIEW, Views
+lazy from .schema import MODULE
+lazy from .starlink import Starlink
+lazy from .store import Store
+
+__all__ = [
+    "ANSWER_MS",
+    "CALLS_AT_MOST",
+    "COMPUTERS",
+    "HOLD_MS",
+    "RELAY",
+    "REPORTED",
+    "Call",
+    "Computers",
+    "Relay",
+    "Reported",
+    "computer",
+    "relay",
+]
+
+
+@asynccontextmanager
+async def _computer(ctx: Context) -> AsyncIterator[None]:
+    server = ctx.accept(SERVER)
+    access = ctx.accept(ACCESS)
+    http = ctx.accept(HTTP)
+    relay = ctx.accept(RELAY)
+    resources = Path(str(files(__name__))) / "resources"
+    monitor = await asyncio.to_thread(
+        (resources / "templates" / "computers" / "icons" / "monitor.svg").read_text,
+        encoding="utf-8",
+    )
+    async with (
+        ctx.accept(SERVER_SCHEMA).register(MODULE),
+        asyncio.TaskGroup() as tasks,
+    ):
+        calls = Calls(relay)
+        hosts = Hosts(calls, tasks)
+        store = Store(ctx.accept(SERVER_DB), access)
+        starlink = Starlink(
+            store, relay, hosts, lambda reported: ctx.announce(REPORTED, reported)
+        )
+        pages = await server.pages("computers", __name__)
+        views = Views(server, pages, access, store, relay, hosts)
+        async with (
+            server.module(
+                "computers",
+                ui=pages.application(views.routes),
+                static=resources / "static",
+                locales=resources / "locales",
+            ),
+            server.permission(
+                PermissionItem(point=VIEW, description="computers.permission.view")
+            ),
+            server.permission(
+                PermissionItem(point=CREATE, description="computers.permission.create")
+            ),
+            server.permission(
+                PermissionItem(point=UPDATE, description="computers.permission.update")
+            ),
+            server.permission(
+                PermissionItem(point=DELETE, description="computers.permission.delete")
+            ),
+            server.permission(
+                PermissionItem(point=SHARE, description="computers.permission.share")
+            ),
+            server.sidebar(
+                SidebarItem(
+                    text="computers.title",
+                    icon=monitor,
+                    path="/computers",
+                    group="server.sidebar.workbench",
+                    permission=VIEW,
+                    order=30,
+                    badge="computers.count",
+                )
+            ),
+            server.topic(
+                Topic(name="computers.count", fetch=views.counted, permission=VIEW)
+            ),
+            server.topic(
+                Topic(name="computers.list", fetch=views.listed, permission=VIEW)
+            ),
+            server.topic(
+                Topic(
+                    name="computers.computer",
+                    fetch=views.computer,
+                    fields=("computer",),
+                    permission=VIEW,
+                )
+            ),
+            access.shared(
+                Shared(
+                    kind="computer",
+                    permission=SHARE,
+                    points=(VIEW, UPDATE, DELETE),
+                    name=views.name,
+                )
+            ),
+            ctx.accept(OVERVIEW).register(
+                OverviewItem(
+                    key="computers",
+                    title="computers.stalls",
+                    src="/ui/computers/stall",
+                    permission=VIEW,
+                    columns=2,
+                )
+            ),
+            http.route("/starlink/v1/listen", starlink.listen, methods=["GET"]),
+            http.route(
+                "/starlink/v1/announce/{number:int}",
+                starlink.announce,
+                methods=["PUT"],
+            ),
+            http.route("/starlink/v1/report", starlink.report, methods=["POST"]),
+        ):
+            ctx.offer(COMPUTERS, calls)
+            try:
+                yield
+            finally:
+                # held listens and questions out end before the routes wait
+                # for their requests
+                starlink.stop()
+                hosts.close()
+
+
+@asynccontextmanager
+async def _relay(ctx: Context) -> AsyncIterator[None]:
+    relay = MemoryRelay(ctx.accept(TIMER))
+    ctx.offer(RELAY, relay)
+    try:
+        yield
+    finally:
+        await relay.close()
+
+
+computer = Contrib(
+    accepts=[
+        SERVER,
+        ACCESS,
+        HTTP,
+        RELAY,
+        OVERVIEW,
+        SERVER_DB,
+        SERVER_SCHEMA,
+        SERVER_MIGRATIONS,
+    ],
+    offers=[COMPUTERS],
+    lifespan=_computer,
+)
+relay = Contrib(offers=[RELAY], accepts=[TIMER], lifespan=_relay)

bazaar_contrib_server_computer/calls.py

@@ -0,0 +1,37 @@
+"""COMPUTERS: calling what a computer exposes, through the relay to wherever
+it listens."""
+
+from __future__ import annotations
+
+lazy from bazaar_contrib_sidecar import RemoteError
+lazy from bazaar_contrib_sidecar.wire import Failure, Request
+lazy from pydantic import JsonValue
+lazy from pydantic_core import to_jsonable_python
+
+lazy from .contracts import Relay
+
+
+class Calls:
+    def __init__(self, relay: Relay) -> None:
+        self._relay = relay
+
+    async def call(
+        self,
+        computer_id: str,
+        service: str,
+        method: str,
+        *args: object,
+        **kwargs: object,
+    ) -> JsonValue:
+        response = await self._relay.ask(
+            computer_id,
+            Request(
+                service=service,
+                method=method,
+                args=to_jsonable_python(args),
+                kwargs=to_jsonable_python(kwargs),
+            ),
+        )
+        if isinstance(response, Failure):
+            raise RemoteError(response.type, response.message)
+        return response.value

bazaar_contrib_server_computer/contracts.py

@@ -0,0 +1,98 @@
+"""What other modules hold server-computer to, and what a relay between the
+server's replicas holds to."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+lazy from collections.abc import Sequence
+
+from bazaar_core import EventKey, ServiceKey
+lazy from bazaar_contrib_audit import AuditEvent
+lazy from bazaar_contrib_sidecar.wire import Failure, Request, Result
+lazy from pydantic import JsonValue
+
+# how long a computer's listen is held when nothing is waiting for it
+HOLD_MS = 25_000
+# how many calls one listen hands over at most
+CALLS_AT_MOST = 20
+# how long a call waits for its answer before the computer counts as silent
+ANSWER_MS = 60_000
+
+
+@dataclass(frozen=True, slots=True)
+class Call:
+    """A call waiting for its computer: its number there, and what it asks."""
+
+    number: int
+    request: Request
+
+
+class Relay(Protocol):
+    """What the server's replicas share about computers: the calls waiting
+    for them, the answers coming back, and when each was last here. A
+    computer listens on any replica and a page calls it from any other; the
+    relay keeps only what lives while it does."""
+
+    async def ask(self, computer_id: str, request: Request) -> Result | Failure:
+        """Hand the call to the computer and wait for its answer, for
+        ANSWER_MS at most; the same call still waiting is joined rather than
+        handed over again. TimeoutError when no answer comes."""
+        ...
+
+    async def calls(self, computer_id: str, after: int) -> Sequence[Call]:
+        """The calls for the computer numbered after the given one, oldest
+        first and CALLS_AT_MOST of them at most; when there are none, the
+        first to come within HOLD_MS, or nothing."""
+        ...
+
+    async def answer(
+        self, computer_id: str, number: int, response: Result | Failure
+    ) -> None:
+        """The computer's answer to its call; one given again counts once."""
+        ...
+
+    async def seen(self, computer_id: str) -> int | None:
+        """Note that the computer is here now; when it was here before,
+        nothing when not since the relay started."""
+        ...
+
+    async def last_seen(self, computer_ids: Sequence[str]) -> dict[str, int]:
+        """When each of the computers was last here, those seen since the
+        relay started."""
+        ...
+
+
+RELAY = ServiceKey[Relay]("server.relay")
+
+
+class Computers(Protocol):
+    """What other modules do with the computers."""
+
+    async def call(
+        self,
+        computer_id: str,
+        service: str,
+        method: str,
+        *args: object,
+        **kwargs: object,
+    ) -> JsonValue:
+        """Call a member the computer exposes, as sidecar's Client does:
+        RemoteError when it fails there, TimeoutError when the computer does
+        not answer in time."""
+        ...
+
+
+COMPUTERS = ServiceKey[Computers]("server.computers")
+
+
+@dataclass(frozen=True, slots=True)
+class Reported:
+    """An audit event a computer reported, announced once however often the
+    computer sends it again."""
+
+    computer_id: str
+    event: AuditEvent
+
+
+REPORTED = EventKey[Reported]("server.computer.reported")

bazaar_contrib_server_computer/hosts.py

@@ -0,0 +1,96 @@
+"""What each computer's node says about the machine it runs on: asked when
+the computer comes online, and again once a minute old while a page shows
+it."""
+
+from __future__ import annotations
+
+lazy import asyncio
+lazy import logging
+lazy from time import time_ns
+
+from pydantic import BaseModel, ValidationError
+lazy from bazaar_contrib_sidecar import RemoteError
+
+from .contracts import Computers
+
+# what was said is shown for a minute before the node is asked again
+FRESH_MS = 60_000
+
+
+class Usage(BaseModel):
+    total: int
+    used: int
+
+    @property
+    def percent(self) -> int:
+        return round(self.used * 100 / self.total) if self.total else 0
+
+
+class Disk(Usage):
+    mount: str
+
+
+class Processor(BaseModel):
+    cores: int | None
+    percent: float
+
+
+class Host(BaseModel):
+    """node.info as a node answers it."""
+
+    version: str
+    system: str
+    name: str
+    release: str
+    machine: str
+    started_ms: int
+    cpu: Processor
+    memory: Usage
+    disks: list[Disk]
+
+    @property
+    def fullest(self) -> Disk | None:
+        return max(self.disks, key=lambda disk: disk.percent, default=None)
+
+
+class Hosts:
+    def __init__(self, computers: Computers, tasks: asyncio.TaskGroup) -> None:
+        self._computers = computers
+        self._tasks = tasks
+        self._known: dict[str, tuple[int, Host]] = {}
+        self._asking: dict[str, asyncio.Task[None]] = {}
+
+    def ask(self, computer_id: str) -> None:
+        """Ask the computer about its machine again, unless that is under way."""
+        if computer_id not in self._asking:
+            self._asking[computer_id] = self._tasks.create_task(self._ask(computer_id))
+
+    async def _ask(self, computer_id: str) -> None:
+        try:
+            value = await self._computers.call(computer_id, "node", "info")
+            self._known[computer_id] = (
+                time_ns() // 1_000_000,
+                Host.model_validate(value),
+            )
+        except RemoteError, TimeoutError, ValidationError:
+            # a node that does not answer, or answers otherwise, keeps what
+            # was said before
+            logging.getLogger(__name__).info("computer.info.unanswered", exc_info=True)
+        finally:
+            del self._asking[computer_id]
+
+    def of(self, computer_id: str, online: bool) -> tuple[int, Host] | None:
+        """When the computer last said what about its machine; one online
+        is asked again once that is a minute old."""
+        known = self._known.get(computer_id)
+        if online and (known is None or time_ns() // 1_000_000 - known[0] >= FRESH_MS):
+            self.ask(computer_id)
+        return known
+
+    def forget(self, computer_id: str) -> None:
+        self._known.pop(computer_id, None)
+
+    def close(self) -> None:
+        """Stop asking: the server is going down."""
+        for task in self._asking.values():
+            task.cancel()

bazaar_contrib_server_computer/memory.py

@@ -0,0 +1,122 @@
+"""server-relay-memory: the relay of a server with one replica, kept in its
+own memory, as 0.2's controls were."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+lazy import asyncio
+lazy import json
+lazy from collections.abc import Sequence
+lazy from time import time_ns
+
+lazy from bazaar_contrib_sidecar.wire import Failure, Request, Result
+lazy from bazaar_contrib_timer import Timer, timeout
+
+from .contracts import ANSWER_MS, CALLS_AT_MOST, HOLD_MS, Call
+
+
+@dataclass(slots=True)
+class _Asked:
+    computer_id: str
+    call: Call
+    answer: asyncio.Future[Result | Failure]
+    # how many askers wait on the answer; none, and the call is forgotten
+    waiters: int = 0
+
+
+class MemoryRelay:
+    def __init__(self, timer: Timer) -> None:
+        self._timer = timer
+        # what each computer has been asked and not yet answered, by number
+        self._asked: defaultdict[str, dict[int, _Asked]] = defaultdict(dict)
+        # the same call to the same computer, while one is out, is asked once
+        self._out: dict[tuple[str, str], _Asked] = {}
+        # a listen waits here until its computer has something
+        self._arrivals: defaultdict[str, asyncio.Condition] = defaultdict(
+            asyncio.Condition
+        )
+        self._seen: dict[str, int] = {}
+        # numbers climb with the clock, so where a computer got to before the
+        # server restarted is behind what comes after
+        self._last = 0
+        self._closing = False
+
+    async def ask(self, computer_id: str, request: Request) -> Result | Failure:
+        key = (
+            computer_id,
+            json.dumps(request.model_dump(mode="json"), sort_keys=True),
+        )
+        asked = self._out.get(key)
+        fresh = asked is None
+        if asked is None:
+            number = self._last = max(self._last + 1, time_ns() // 1_000_000)
+            asked = _Asked(
+                computer_id,
+                Call(number, request),
+                asyncio.get_running_loop().create_future(),
+            )
+            self._out[key] = asked
+            self._asked[computer_id][number] = asked
+            asked.answer.add_done_callback(lambda _: self._forget(key, asked))
+        asked.waiters += 1
+        try:
+            if fresh:
+                arrivals = self._arrivals[computer_id]
+                async with arrivals:
+                    arrivals.notify_all()
+            async with timeout(self._timer, ANSWER_MS):
+                # one asker giving up does not take the answer from the others
+                return await asyncio.shield(asked.answer)
+        finally:
+            asked.waiters -= 1
+            if asked.waiters == 0 and not asked.answer.done():
+                self._forget(key, asked)
+
+    def _forget(self, key: tuple[str, str], asked: _Asked) -> None:
+        if self._out.get(key) is asked:
+            del self._out[key]
+        self._asked[asked.computer_id].pop(asked.call.number, None)
+
+    async def calls(self, computer_id: str, after: int) -> Sequence[Call]:
+        arrivals = self._arrivals[computer_id]
+        async with arrivals:
+            if not self._closing and not self._pending(computer_id, after):
+                try:
+                    async with timeout(self._timer, HOLD_MS):
+                        await arrivals.wait()
+                except TimeoutError:
+                    return []
+            return [] if self._closing else self._pending(computer_id, after)
+
+    def _pending(self, computer_id: str, after: int) -> list[Call]:
+        asked = self._asked[computer_id]
+        return [asked[number].call for number in sorted(asked) if number > after][
+            :CALLS_AT_MOST
+        ]
+
+    async def answer(
+        self, computer_id: str, number: int, response: Result | Failure
+    ) -> None:
+        asked = self._asked[computer_id].get(number)
+        if asked is not None and not asked.answer.done():
+            asked.answer.set_result(response)
+
+    async def seen(self, computer_id: str) -> int | None:
+        before = self._seen.get(computer_id)
+        self._seen[computer_id] = time_ns() // 1_000_000
+        return before
+
+    async def last_seen(self, computer_ids: Sequence[str]) -> dict[str, int]:
+        return {
+            computer_id: self._seen[computer_id]
+            for computer_id in computer_ids
+            if computer_id in self._seen
+        }
+
+    async def close(self) -> None:
+        """Let every held listen go: the relay is going away."""
+        self._closing = True
+        for arrivals in list(self._arrivals.values()):
+            async with arrivals:
+                arrivals.notify_all()