Cameras on devices (openpanel C1): frames in memory, a binary uplink, demand

- Volatile frames are held in memory with a byte-bounded queue instead of
  the /dev/shm ring scanned on every put; workers keep writing to the
  directory, which is trimmed on a timer. A volatile upload no longer spools
  to disk. ARTIFACT_VOLATILE_BYTES=0 turns the ring off.
- A device sends camera frames as binary messages on its socket, held and
  published in one step and credited to its device node; refused frames are
  logged and dropped. Its snapshot carries demand and the uplink (binary, or
  http through the portal).
- One demand registry for every socket's wanted media, the tunnel's
  included, plus what running flows read, mapped onto on-demand ports and
  published as device_demand; at most 8 media names per socket.
- Per-message deflate off in serve and dev; a device may fetch the last 8
  digests of a message; published dashboards cached per store revision; a
  revoked device socket is closed with 1008.
- Media tiles want bytes only while on screen; the Devices tab previews a
  wired camera; the device node warns when a flow reads an on-demand port.
This commit is contained in:
Melvin Strobl
2026-10-16 20:43:14 +02:00
parent d79203a5f7
commit ecc4bee4bb
29 changed files with 1425 additions and 220 deletions
+1 -1
View File
@@ -162,7 +162,7 @@ install: ## Install all dependencies (backend + frontend)
cd frontend && bun install cd frontend && bun install
dev-backend: ## Start the FastAPI backend with hot-reload (local) dev-backend: ## Start the FastAPI backend with hot-reload (local)
cd backend && uv run --all-extras fastapi dev fluksio/main.py cd backend && uv run --all-extras uvicorn fluksio.main:app --reload --ws-per-message-deflate false
dev-frontend: ## Start the Vite dev server (local) dev-frontend: ## Start the Vite dev server (local)
cd frontend && bun dev cd frontend && bun dev
+10 -5
View File
@@ -20,6 +20,7 @@ from fluksio.flow.artifacts import is_reference
from fluksio.flow.controller import FlowController from fluksio.flow.controller import FlowController
from fluksio.flow.dashboards import DashboardDef, DashboardStore from fluksio.flow.dashboards import DashboardDef, DashboardStore
from fluksio.flow.devices import DeviceDef, DeviceStore, DeviceUnavailable, presence from fluksio.flow.devices import DeviceDef, DeviceStore, DeviceUnavailable, presence
from fluksio.flow.events import event_bus
from fluksio.flow.workers import PythonWorkerPool from fluksio.flow.workers import PythonWorkerPool
from fluksio.models import OAuthClient, TokenPayload, User, WorkerToken from fluksio.models import OAuthClient, TokenPayload, User, WorkerToken
@@ -165,11 +166,13 @@ def _device_writable(device: DeviceDef, request: Request) -> set[str]:
def _device_digests(device: DeviceDef, request: Request) -> set[str]: def _device_digests(device: DeviceDef, request: Request) -> set[str]:
"""The artifacts this panel's messages are pointing at right now. """The artifacts this panel's messages are pointing at, now or just before.
A media tile fetches the bytes its message names, so the messages already A media tile fetches the bytes its message names, so the messages already
bounding the panel bound this too — one step further along, through bounding the panel bound this too — one step further along, through
whatever those messages currently hold. whatever those messages currently hold. And through the last few they
held: a screen through the portal fetches a camera frame by frame, and by
the time its fetch arrives the camera may have published the next one.
""" """
controller: FlowController | None = getattr( controller: FlowController | None = getattr(
request.app.state, "flow_controller", None request.app.state, "flow_controller", None
@@ -183,6 +186,8 @@ def _device_digests(device: DeviceDef, request: Request) -> set[str]:
for value in controller.state.get_present(sorted(names)).values(): for value in controller.state.get_present(sorted(names)).values():
if is_reference(value): if is_reference(value):
found.add(str(value["digest"])) found.add(str(value["digest"]))
for name in names:
found.update(event_bus.digests.get(name, ()))
return found return found
@@ -215,9 +220,9 @@ def _device_may(payload: dict[str, Any], request: Request) -> None:
The device is left on ``request.state`` for the route, which credits a The device is left on ``request.state`` for the route, which credits a
value published on one of its ports to the node holding that port. value published on one of its ports to the node holding that port.
# ponytail: the device file and the published dashboards are re-read per The device file is read per request, which is what makes deleting a
# request (the nonces are cached by the file's stat). Cache them behind device revoke it at once. The nonces are cached by the file's stat and
# the store's revision if this shows up in a profile. the published dashboards until the flow store's next commit.
""" """
device = _device_for(payload, request.app) device = _device_for(payload, request.app)
request.state.device = device request.state.device = device
+19 -2
View File
@@ -101,7 +101,9 @@ async def put_artifact(
``volatile`` puts it in the ring instead of the store — a frame a screen is ``volatile`` puts it in the ring instead of the store — a frame a screen is
watching now, which the oldest of falls out of memory rather than being watching now, which the oldest of falls out of memory rather than being
kept. A worker on another host publishing a camera sends this. kept. A worker on another host or a device publishing a camera sends this.
It is read into memory, where the ring holds it, and never touches the
disk.
""" """
store = _store(request) store = _store(request)
cap = settings.MAX_ARTIFACT_BYTES cap = settings.MAX_ARTIFACT_BYTES
@@ -110,6 +112,17 @@ async def put_artifact(
raise HTTPException( raise HTTPException(
status_code=413, detail=f"An artifact may be at most {cap} bytes" status_code=413, detail=f"An artifact may be at most {cap} bytes"
) )
ring = store.volatile if volatile else None
if ring is not None:
body = bytearray()
async for chunk in request.stream():
body += chunk
if cap and len(body) > cap:
raise HTTPException(
status_code=413,
detail=f"An artifact may be at most {cap} bytes",
)
return await run_in_threadpool(ring.put, [bytes(body)], name, media_type)
handle = tempfile.NamedTemporaryFile(dir=store.root, delete=False) handle = tempfile.NamedTemporaryFile(dir=store.root, delete=False)
written = 0 written = 0
try: try:
@@ -146,7 +159,9 @@ def get_artifact(
""" """
store = _store(request) store = _store(request)
path = store.path(digest) path = store.path(digest)
if path is None: # A live frame is held in memory, not on disk.
frame = store.volatile.get(digest) if path is None and store.volatile else None
if path is None and frame is None:
raise HTTPException(status_code=404, detail="No such artifact") raise HTTPException(status_code=404, detail="No such artifact")
if not _MEDIA_TYPE.match(media_type): if not _MEDIA_TYPE.match(media_type):
media_type = "application/octet-stream" media_type = "application/octet-stream"
@@ -158,6 +173,8 @@ def get_artifact(
# beside the session, for whoever follows a link to it. # beside the session, for whoever follows a link to it.
headers["Content-Security-Policy"] = "sandbox" headers["Content-Security-Policy"] = "sandbox"
headers["X-Content-Type-Options"] = "nosniff" headers["X-Content-Type-Options"] = "nosniff"
if path is None:
return Response(frame, media_type=media_type, headers=headers)
return FileResponse(path, media_type=media_type, headers=headers) return FileResponse(path, media_type=media_type, headers=headers)
+247 -33
View File
@@ -3,6 +3,7 @@
import asyncio import asyncio
import logging import logging
import os import os
import re
import time import time
from pathlib import Path from pathlib import Path
from typing import Any from typing import Any
@@ -32,12 +33,23 @@ from fluksio.api.deps import (
get_current_user, get_current_user,
user_from_token, user_from_token,
) )
from fluksio.api.routes.messages import port_source
from fluksio.api.socket_auth import TICKET_TTL_S, issue_ticket, socket_token from fluksio.api.socket_auth import TICKET_TTL_S, issue_ticket, socket_token
from fluksio.core.config import settings
from fluksio.core.db import engine from fluksio.core.db import engine
from fluksio.flow.artifacts import is_reference from fluksio.flow.artifacts import is_reference
from fluksio.flow.controller import NODE_TYPES, FlowController, follow_header from fluksio.flow.controller import NODE_TYPES, FlowController, follow_header
from fluksio.flow.dashboards import DashboardStore from fluksio.flow.dashboards import DashboardStore
from fluksio.flow.devices import DeviceStore, messages_for, presence from fluksio.flow.demand import demand
from fluksio.flow.devices import (
DeviceDef,
DeviceStore,
DeviceUnavailable,
dashboards_for,
messages_for,
messages_of,
presence,
)
from fluksio.flow.events import event_bus from fluksio.flow.events import event_bus
from fluksio.flow.messages import flow_of, qualify from fluksio.flow.messages import flow_of, qualify
from fluksio.flow.pipeline import ValidationIssue from fluksio.flow.pipeline import ValidationIssue
@@ -1017,7 +1029,10 @@ def read_message_history(
def snapshot_payload( def snapshot_payload(
controller: FlowController, only: set[str] | None = None controller: FlowController,
only: set[str] | None = None,
device: str = "",
uplink: str = "",
) -> dict[str, Any]: ) -> dict[str, Any]:
"""Everything a client needs to catch up, sent the moment it connects. """Everything a client needs to catch up, sent the moment it connects.
@@ -1032,12 +1047,16 @@ def snapshot_payload(
gets: the values its own dashboards draw, and none of the rest — no node gets: the values its own dashboards draw, and none of the rest — no node
status, no logs, no shape of the graph. A panel renders none of that, and status, no logs, no shape of the graph. A panel renders none of that, and
a screen may be hanging somewhere nobody here can see. a screen may be hanging somewhere nobody here can see.
A device's socket also says which of its ports have ``demand`` now, and
which ``uplink`` its frames take: ``binary`` on its own socket, ``http``
through the portal, whose tunnel carries text only.
""" """
if only is not None: if only is not None:
# The same keys, emptied rather than dropped: a screen already hanging # The same keys, emptied rather than dropped: a screen already hanging
# runs whatever bundle it was paired with, and the shape of this # runs whatever bundle it was paired with, and the shape of this
# message is what that bundle reads. # message is what that bundle reads.
return { payload: dict[str, Any] = {
"type": "snapshot", "type": "snapshot",
"values": {k: v for k, v in controller.values().items() if k in only}, "values": {k: v for k, v in controller.values().items() if k in only},
"nodes": [], "nodes": [],
@@ -1047,6 +1066,10 @@ def snapshot_payload(
"emits": {}, "emits": {},
"queued": [], "queued": [],
} }
if device:
payload["demand"] = demand.ports(device)
payload["uplink"] = uplink
return payload
return { return {
"type": "snapshot", "type": "snapshot",
"values": controller.values(), "values": controller.values(),
@@ -1059,6 +1082,11 @@ def snapshot_payload(
} }
def demand_frame(ports: list[str]) -> str:
"""What a device is told when its ports with demand change."""
return orjson.dumps({"type": "demand", "ports": ports}).decode()
def device_of(token: str, app: Any) -> str: def device_of(token: str, app: Any) -> str:
"""The device this credential stands for, or "" for a person or none.""" """The device this credential stands for, or "" for a person or none."""
try: try:
@@ -1067,12 +1095,30 @@ def device_of(token: str, app: Any) -> str:
return "" return ""
def revoked(token: str, app: Any) -> bool:
"""Whether a device's credential has stopped standing since its handshake.
Unpaired or deleted. One that cannot be checked right now has not: a
device closed with 1008 checks whether it is still paired.
"""
try:
decode_token(token, app=app)
except InvalidTokenError:
return True
except DeviceUnavailable:
return False
return False
def panel_scope(token: str, app: Any) -> set[str] | None: def panel_scope(token: str, app: Any) -> set[str] | None:
"""The messages this credential is bounded to, or None if it is a person's. """The messages this credential is bounded to, or None if it is a person's.
The socket is the one authenticated surface the route check cannot reach, The socket is the one authenticated surface the route check cannot reach,
a handshake has no route to judge, so a device is bounded by what it is a handshake has no route to judge, so a device is bounded by what it is
sent instead of by what it asks for. sent instead of by what it asks for.
Its own camera's frames are left out unless a dashboard it shows draws
them: it sent them, and a camera's values come several a second.
""" """
device_id = device_of(token, app) device_id = device_of(token, app)
if not device_id: if not device_id:
@@ -1081,7 +1127,18 @@ def panel_scope(token: str, app: Any) -> set[str] | None:
devices: DeviceStore | None = getattr(app.state, "device_store", None) devices: DeviceStore | None = getattr(app.state, "device_store", None)
if store is None or devices is None: if store is None or devices is None:
return set() return set()
return messages_for(devices.find(device_id), store, devices) device = devices.find(device_id)
found = messages_for(device, store, devices)
if device is not None:
shown = {
name for defn in dashboards_for(device, store) for name in messages_of(defn)
}
found -= {
b.message
for b in devices.bound(device.id)
if b.direction == "in" and b.dtype == "image"
} - shown
return found
def event_for_panel(event: dict[str, Any], only: set[str]) -> bool: def event_for_panel(event: dict[str, Any], only: set[str]) -> bool:
@@ -1103,9 +1160,9 @@ def event_for_panel(event: dict[str, Any], only: set[str]) -> bool:
MAX_FRAME_EVENTS = 64 MAX_FRAME_EVENTS = 64
#: How many message names one socket may ask for bytes on. A screen draws a #: How many message names one socket may ask for bytes on. A screen draws a
#: handful of tiles; this is only here so a client cannot ask for the whole #: handful of tiles, and every live one keeps a camera sending, so a phone
#: namespace and be served every frame of it. #: scrolled past several cameras does not pull them all. The rest are refused.
MAX_MEDIA_NAMES = 32 MAX_MEDIA_NAMES = 8
def wanted_names(frame: str, only: set[str] | None) -> set[str] | None: def wanted_names(frame: str, only: set[str] | None) -> set[str] | None:
@@ -1126,7 +1183,17 @@ def wanted_names(frame: str, only: set[str] | None) -> set[str] | None:
names = payload.get("names") names = payload.get("names")
if not isinstance(names, list): if not isinstance(names, list):
return set() return set()
asked = {str(name) for name in names[:MAX_MEDIA_NAMES]} asked = {str(name) for name in names}
if len(asked) > MAX_MEDIA_NAMES:
kept = list(dict.fromkeys(str(name) for name in names))[:MAX_MEDIA_NAMES]
logger.warning(
"A socket asked for live media on %d messages; only %d are served, "
"the first it named: %s",
len(asked),
MAX_MEDIA_NAMES,
", ".join(kept),
)
asked = set(kept)
return asked if only is None else asked & only return asked if only is None else asked & only
@@ -1140,10 +1207,10 @@ def media_frames(
the socket that already carries the event closes that, and only for the the socket that already carries the event closes that, and only for the
frames a client said it was drawing. frames a client said it was drawing.
Only what the ring holds: the durable store is what a fetch is for, and a Only what the ring holds, out of memory: the durable store is what a fetch
checkpoint has no business being pushed at anyone. The newest value per is for, and a checkpoint has no business being pushed at anyone. The
name wins, so a client that fell behind is not handed a backlog of frames newest value per name wins, so a client that fell behind is not handed a
it would only draw over. backlog of frames it would only draw over.
""" """
if not wanted or store is None or getattr(store, "volatile", None) is None: if not wanted or store is None or getattr(store, "volatile", None) is None:
return [] return []
@@ -1161,12 +1228,8 @@ def media_frames(
for name, event in newest.items(): for name, event in newest.items():
value = event["value"] value = event["value"]
digest = str(value.get("digest") or "") digest = str(value.get("digest") or "")
path = store.volatile.path(digest) payload = store.volatile.get(digest)
if path is None: if payload is None:
continue
try:
payload = path.read_bytes()
except OSError:
continue continue
header = orjson.dumps( header = orjson.dumps(
{ {
@@ -1183,6 +1246,91 @@ def media_frames(
return frames return frames
#: What a device may say a frame is.
_IMAGE_TYPE = re.compile(r"^image/[\w.+-]+$")
def parse_frame(data: bytes) -> tuple[dict[str, Any], bytes] | None:
"""Split a binary frame into its JSON header and the bytes after it.
The layout media frames go out in: four bytes of header length, big
endian, the header, then the bytes. None for anything else.
"""
if len(data) < 4:
return None
length = int.from_bytes(data[:4], "big")
if length == 0 or 4 + length > len(data):
return None
try:
header = orjson.loads(data[4 : 4 + length])
except orjson.JSONDecodeError:
return None
if not isinstance(header, dict):
return None
return header, data[4 + length :]
def ingest_frame(app: Any, device: DeviceDef, data: bytes) -> str:
"""Store a frame a device sent on its socket and publish it.
Returns why it was refused, or "" once it is published.
The same frame over HTTP is two requests, each authenticated: the upload,
then the publish. Here the socket was authenticated once, at its
handshake, and the frame is held and published in one step. Only a
message one of the device's own ``in`` ports is wired to, as an ``image``,
and the value is credited to the device node holding that port, as an
HTTP publish is.
"""
parsed = parse_frame(data)
if parsed is None or parsed[0].get("type") != "frame":
return "not a frame"
header, payload = parsed
name = str(header.get("name") or "")
devices: DeviceStore | None = getattr(app.state, "device_store", None)
store: Any = getattr(app.state, "artifact_store", None)
controller: FlowController | None = getattr(app.state, "flow_controller", None)
if devices is None or store is None or controller is None:
return "the engine is not running"
binding = next(
(
b
for b in devices.bound(device.id)
if b.direction == "in" and b.message == name
),
None,
)
if binding is None:
return f"{name!r} is not a message one of its ports publishes"
if binding.dtype != "image":
return f"its port {binding.port!r} is wired as {binding.dtype}, not image"
media_type = str(header.get("media_type") or "")
if not _IMAGE_TYPE.match(media_type):
return f"{media_type!r} is not an image type"
cap = settings.MAX_ARTIFACT_BYTES
if cap and len(payload) > cap:
return f"a frame may be at most {cap} bytes"
reference = store.put(
[payload], name=binding.port, media_type=media_type, volatile=True
)
try:
controller.publish_message(name, reference, port_source(devices, device, name))
except KeyError:
return f"no flow declares {name!r}"
except TypeError as exc:
return str(exc)
return ""
async def _receive(websocket: WebSocket) -> str | bytes:
"""The client's next frame, text or binary."""
message = await websocket.receive()
if message["type"] == "websocket.disconnect":
raise WebSocketDisconnect(message.get("code", 1000), message.get("reason"))
data = message.get("bytes")
return data if data is not None else str(message.get("text") or "")
async def _send(websocket: WebSocket, events: list[dict[str, Any]]) -> None: async def _send(websocket: WebSocket, events: list[dict[str, Any]]) -> None:
"""One event, or a batch of them under `events`. """One event, or a batch of them under `events`.
@@ -1216,6 +1364,11 @@ async def flow_events(websocket: WebSocket, ticket: str = "", token: str = "") -
A browser brings a ticket from `POST /flows/ws-ticket`; anything that can A browser brings a ticket from `POST /flows/ws-ticket`; anything that can
set headers sends `Authorization: Bearer`. `?token=` is still read for one set headers sends `Authorization: Bearer`. `?token=` is still read for one
release, for clients from before either. release, for clients from before either.
A client says which media it is drawing (``{"type": "media", "names":
[...]}``) and is pushed those frames. A device also sends its camera's
frames here, as binary frames in the layout it is pushed them in, and is
told when its on-demand ports have demand.
""" """
token = socket_token(websocket.headers, ticket, token) token = socket_token(websocket.headers, ticket, token)
@@ -1228,10 +1381,10 @@ async def flow_events(websocket: WebSocket, ticket: str = "", token: str = "") -
only = panel_scope(token, websocket.app) if user is not None else None only = panel_scope(token, websocket.app) if user is not None else None
# A device is online for as long as this socket is open. # A device is online for as long as this socket is open.
device = device_of(token, websocket.app) if only is not None else "" device = device_of(token, websocket.app) if only is not None else ""
return user, only, device return user, only, device, _device_def(websocket.app, device)
try: try:
user, only, device = await run_in_threadpool(_authenticate) user, only, device, device_def = await run_in_threadpool(_authenticate)
except Exception as exc: except Exception as exc:
# Not a refusal: the database or the device store could not say. A # Not a refusal: the database or the device store could not say. A
# device takes 1008, or a 403 before accepting, as its credential # device takes 1008, or a 403 before accepting, as its credential
@@ -1246,6 +1399,10 @@ async def flow_events(websocket: WebSocket, ticket: str = "", token: str = "") -
# Nothing until a client says it is drawing something: bytes are what this # Nothing until a client says it is drawing something: bytes are what this
# socket cannot afford to send speculatively. # socket cannot afford to send speculatively.
wanted: set[str] = set() wanted: set[str] = set()
# This socket's entry in the registry every socket's wants are kept in.
viewer = object()
# Each reason a frame was refused for, logged once per socket.
refused: set[str] = set()
await websocket.accept() await websocket.accept()
@@ -1254,17 +1411,27 @@ async def flow_events(websocket: WebSocket, ticket: str = "", token: str = "") -
) )
store = getattr(websocket.app.state, "artifact_store", None) store = getattr(websocket.app.state, "artifact_store", None)
async def send_snapshot() -> None: async def send_snapshot() -> list[str]:
if controller is not None: """Send the snapshot, and return the demand it told a device of."""
payload = await run_in_threadpool(snapshot_payload, controller, only) if controller is None:
await websocket.send_text(orjson.dumps(payload).decode()) return []
payload = await run_in_threadpool(
snapshot_payload, controller, only, device, "binary"
)
await websocket.send_text(orjson.dumps(payload).decode())
return list(payload.get("demand", []))
await send_snapshot() told = await send_snapshot()
async with event_bus.subscribe() as queue: async with event_bus.subscribe() as queue:
receiver = asyncio.create_task(websocket.receive_text()) receiver = asyncio.create_task(_receive(websocket))
if device: if device:
presence.opened(device) presence.opened(device)
# Demand that moved between the snapshot and the subscription
# would otherwise wait for the next change.
ports = demand.ports(device)
if ports != told:
await websocket.send_text(demand_frame(ports))
try: try:
while True: while True:
sender = asyncio.create_task(queue.get()) sender = asyncio.create_task(queue.get())
@@ -1284,14 +1451,35 @@ async def flow_events(websocket: WebSocket, ticket: str = "", token: str = "") -
# it every live update from then on. # it every live update from then on.
failure = receiver.exception() failure = receiver.exception()
if failure is not None: if failure is not None:
# The client is gone, and `receive_text` raises for # The client is gone, and `receive` raises for good
# good from here on. Reading it again would spin this # from here on. Reading it again would spin this loop
# loop at full tilt against a dead socket. # at full tilt against a dead socket.
raise failure raise failure
asked = wanted_names(receiver.result(), only) frame = receiver.result()
if asked is not None: if isinstance(frame, bytes):
wanted = asked # A camera's frame. Refused ones are dropped and the
receiver = asyncio.create_task(websocket.receive_text()) # socket stays open: one bad frame is not a reason to
# take the device's live values away.
reason = (
await run_in_threadpool(
ingest_frame, websocket.app, device_def, frame
)
if device_def is not None
else "only a device sends frames"
)
if reason and reason not in refused:
refused.add(reason)
logger.warning(
"Dropped a frame from %s: %s",
device or "a person's socket",
reason,
)
else:
asked = wanted_names(frame, only)
if asked is not None:
wanted = asked
demand.want(viewer, wanted)
receiver = asyncio.create_task(_receive(websocket))
if sender not in done: if sender not in done:
continue continue
# `sender` is done from here: `FIRST_COMPLETED` returns with at # `sender` is done from here: `FIRST_COMPLETED` returns with at
@@ -1309,7 +1497,22 @@ async def flow_events(websocket: WebSocket, ticket: str = "", token: str = "") -
out: list[dict[str, Any]] = [] out: list[dict[str, Any]] = []
for event in batch: for event in batch:
if event.get("type") == "device_demand":
# For the device it names, and for nobody else.
if device and event.get("device") == device:
await websocket.send_text(
demand_frame(list(event.get("ports") or []))
)
continue
if only is not None and event.get("type") == "dashboard_changed": if only is not None and event.get("type") == "dashboard_changed":
# An unpaired or deleted device is closed with 1008,
# which sends it to check its credential: otherwise
# its frames would still be taken here.
if device and await run_in_threadpool(
revoked, token, websocket.app
):
await websocket.close(code=1008)
return
# The scope was resolved once, at the handshake. A # The scope was resolved once, at the handshake. A
# panel pointed at another dashboard would otherwise # panel pointed at another dashboard would otherwise
# fetch the new document and then draw tiles nothing # fetch the new document and then draw tiles nothing
@@ -1318,7 +1521,9 @@ async def flow_events(websocket: WebSocket, ticket: str = "", token: str = "") -
# token — and that would widen this socket to # token — and that would widen this socket to
# everything on the bus. # everything on the bus.
only = panel_scope(token, websocket.app) or set() only = panel_scope(token, websocket.app) or set()
device_def = _device_def(websocket.app, device)
wanted &= only wanted &= only
demand.want(viewer, wanted)
if out: if out:
await _send(websocket, out) await _send(websocket, out)
out = [] out = []
@@ -1339,5 +1544,14 @@ async def flow_events(websocket: WebSocket, ticket: str = "", token: str = "") -
pass pass
finally: finally:
receiver.cancel() receiver.cancel()
demand.drop(viewer)
if device: if device:
presence.closed(device) presence.closed(device)
def _device_def(app: Any, device_id: str) -> DeviceDef | None:
"""The device a socket stands for, as its frames are credited to it."""
devices: DeviceStore | None = getattr(app.state, "device_store", None)
if not device_id or devices is None:
return None
return devices.find(device_id)
+13 -6
View File
@@ -72,17 +72,16 @@ async def read_messages(controller: FlowControllerDep) -> Any:
return MessagesPublic(data=infos, count=len(infos)) return MessagesPublic(data=infos, count=len(infos))
def _port_source(request: Request, name: str) -> ValueSource | None: def port_source(
devices: DeviceStore, device: DeviceDef, name: str
) -> ValueSource | None:
"""The device node a device's own publish on a bound ``in`` port is from. """The device node a device's own publish on a bound ``in`` port is from.
Said by the server rather than by the device: the node is what the canvas Said by the server rather than by the device: the node is what the canvas
draws the value leaving from, and the device does not know which node in draws the value leaving from, and the device does not know which node in
which flow holds its port. which flow holds its port. Also what a frame on the device's socket is
credited to.
""" """
device: DeviceDef | None = getattr(request.state, "device", None)
devices: DeviceStore | None = getattr(request.app.state, "device_store", None)
if device is None or devices is None:
return None
for bound in devices.bound(device.id): for bound in devices.bound(device.id):
if bound.direction == "in" and bound.message == name: if bound.direction == "in" and bound.message == name:
return ValueSource( return ValueSource(
@@ -94,6 +93,14 @@ def _port_source(request: Request, name: str) -> ValueSource | None:
return None return None
def _port_source(request: Request, name: str) -> ValueSource | None:
device: DeviceDef | None = getattr(request.state, "device", None)
devices: DeviceStore | None = getattr(request.app.state, "device_store", None)
if device is None or devices is None:
return None
return port_source(devices, device, name)
@router.post("/{name}", response_model=MessageValue) @router.post("/{name}", response_model=MessageValue)
async def publish_message( async def publish_message(
name: str, body: PublishRequest, controller: FlowControllerDep, request: Request name: str, body: PublishRequest, controller: FlowControllerDep, request: Request
+4
View File
@@ -577,6 +577,10 @@ def cmd_serve(args: argparse.Namespace) -> int:
port=port, port=port,
log_level=args.log_level, log_level=args.log_level,
log_config=_log_config(args.log_level), log_config=_log_config(args.log_level),
# Media frames are JPEGs, which deflate cannot shrink, and
# compressing each one again per open socket was a quarter of the
# engine's time with four cameras.
ws_per_message_deflate=False,
) )
) )
try: try:
+78 -14
View File
@@ -22,7 +22,7 @@ import logging
import random import random
import time import time
import uuid import uuid
from collections.abc import MutableMapping from collections.abc import Callable, MutableMapping
from dataclasses import replace from dataclasses import replace
from datetime import timedelta from datetime import timedelta
from typing import Any from typing import Any
@@ -72,6 +72,8 @@ ALLOWED_PATHS = frozenset(
#: Neither dict was bounded, and an id the hub reused silently dropped the #: Neither dict was bounded, and an id the hub reused silently dropped the
#: reference to a task that was still running. #: reference to a task that was still running.
MAX_IN_FLIGHT = 256 MAX_IN_FLIGHT = 256
#: How many of a client's frames are kept for a stream not listening yet.
MAX_EARLY = 8
#: How often to look for a config that appeared while the engine was up. #: How often to look for a config that appeared while the engine was up.
#: Enrolment is something a person does and then waits on, so this is the #: Enrolment is something a person does and then waits on, so this is the
#: delay they sit through — short enough not to be worth a restart. #: delay they sit through — short enough not to be worth a restart.
@@ -160,6 +162,10 @@ class CloudConnector:
self.app_url: str | None = None self.app_url: str | None = None
#: What the hub sent each bridged hook socket, waiting to be received. #: What the hub sent each bridged hook socket, waiting to be received.
self._inboxes: dict[str, asyncio.Queue[dict[str, Any]]] = {} self._inboxes: dict[str, asyncio.Queue[dict[str, Any]]] = {}
#: What reads a client's frames on each bridged live stream, and what
#: a client said before its stream was listening.
self._listeners: dict[str, Callable[[str], None]] = {}
self._early: dict[str, list[str]] = {}
@property @property
def revoked(self) -> bool: def revoked(self) -> bool:
@@ -279,14 +285,21 @@ class CloudConnector:
elif op == "ws_open": elif op == "ws_open":
self._start_stream(socket, frame) self._start_stream(socket, frame)
elif op == "ws_msg": elif op == "ws_msg":
inbox = self._inboxes.get(str(frame.get("id") or "")) stream = str(frame.get("id") or "")
text = str(frame.get("text") or "")
inbox = self._inboxes.get(stream)
listener = self._listeners.get(stream)
if inbox is not None: if inbox is not None:
inbox.put_nowait( inbox.put_nowait(
{ {"type": "websocket.receive", "text": text}
"type": "websocket.receive",
"text": str(frame.get("text") or ""),
}
) )
elif listener is not None:
listener(text)
elif stream in self._streams:
# A browser speaks as soon as the hub accepts it,
# before this end has checked its credential.
early = self._early.setdefault(stream, [])
early[:] = [*early[-(MAX_EARLY - 1) :], text]
elif op == "ws_close": elif op == "ws_close":
self._cancel_stream(str(frame.get("id") or "")) self._cancel_stream(str(frame.get("id") or ""))
elif op == "member_removed": elif op == "member_removed":
@@ -638,13 +651,17 @@ class CloudConnector:
from fluksio.api.deps import user_from_token from fluksio.api.deps import user_from_token
from fluksio.api.routes.flows import ( from fluksio.api.routes.flows import (
demand_frame,
device_of, device_of,
event_for_panel, event_for_panel,
panel_scope, panel_scope,
revoked,
snapshot_payload, snapshot_payload,
wanted_names,
) )
from fluksio.api.socket_auth import redeem_ticket from fluksio.api.socket_auth import redeem_ticket
from fluksio.core.db import engine from fluksio.core.db import engine
from fluksio.flow.demand import demand
from fluksio.flow.devices import presence from fluksio.flow.devices import presence
from fluksio.flow.events import event_bus from fluksio.flow.events import event_bus
@@ -682,24 +699,64 @@ class CloudConnector:
await socket.send(_dump({"op": "ws_open_ok", "id": stream_id})) await socket.send(_dump({"op": "ws_open_ok", "id": stream_id}))
controller = getattr(self._app.state, "flow_controller", None) controller = getattr(self._app.state, "flow_controller", None)
told: list[str] = []
if controller is not None: if controller is not None:
# A device here sends its frames over HTTP: the tunnel carries
# text only.
snapshot = snapshot_payload(controller, only, device, "http")
told = list(snapshot.get("demand", []))
await socket.send( await socket.send(
_dump( _dump({"op": "ws_msg", "id": stream_id, "text": _dump(snapshot)})
{
"op": "ws_msg",
"id": stream_id,
"text": _dump(snapshot_payload(controller, only)),
}
)
) )
# The media this client's tiles are drawing count as demand on the
# devices sending them, as a direct socket's do. The bytes themselves
# are fetched one by one through the portal.
viewer = ("tunnel", stream_id)
wanted: set[str] = set()
def heard(text: str) -> None:
nonlocal wanted
asked = wanted_names(text, only)
if asked is not None:
wanted = asked
demand.want(viewer, asked)
self._listeners[stream_id] = heard
for text in self._early.pop(stream_id, []):
heard(text)
if device: if device:
presence.opened(device) presence.opened(device)
try: try:
async with event_bus.subscribe() as queue: async with event_bus.subscribe() as queue:
if device and (ports := demand.ports(device)) != told:
await socket.send(
_dump(
{
"op": "ws_msg",
"id": stream_id,
"text": demand_frame(ports),
}
)
)
while True: while True:
event = await queue.get() event = await queue.get()
if event.get("type") == "device_demand":
# For the device it names, and for nobody else.
if device and event.get("device") == device:
text = demand_frame(list(event.get("ports") or []))
await socket.send(
_dump({"op": "ws_msg", "id": stream_id, "text": text})
)
continue
if only is not None and event.get("type") == "dashboard_changed": if only is not None and event.get("type") == "dashboard_changed":
if device and revoked(token, self._app):
# Unpaired or deleted: 1008 sends it to check.
await socket.send(
_dump({"op": "ws_close", "id": stream_id, "code": 1008})
)
return
# What this screen shows may have just changed under # What this screen shows may have just changed under
# it. Rescope, then resend the snapshot so a dashboard # it. Rescope, then resend the snapshot so a dashboard
# it has only now been assigned draws values instead of # it has only now been assigned draws values instead of
@@ -707,8 +764,12 @@ class CloudConnector:
# deleted scopes to nothing, and None would widen this # deleted scopes to nothing, and None would widen this
# socket to everything on the bus. # socket to everything on the bus.
only = panel_scope(token, self._app) or set() only = panel_scope(token, self._app) or set()
wanted &= only
demand.want(viewer, wanted)
if controller is not None: if controller is not None:
catch_up = snapshot_payload(controller, only) catch_up = snapshot_payload(
controller, only, device, "http"
)
await socket.send( await socket.send(
_dump( _dump(
{ {
@@ -732,6 +793,9 @@ class CloudConnector:
_dump({"op": "ws_close", "id": stream_id, "code": 1011}) _dump({"op": "ws_close", "id": stream_id, "code": 1011})
) )
finally: finally:
self._listeners.pop(stream_id, None)
self._early.pop(stream_id, None)
demand.drop(viewer)
if device: if device:
presence.closed(device) presence.closed(device)
+12 -9
View File
@@ -207,16 +207,19 @@ class Settings(BaseSettings):
# Storing bytes and recording the reference are two steps; this is the # Storing bytes and recording the reference are two steps; this is the
# window between them. # window between them.
ARTIFACT_GC_GRACE_S: int = 3600 ARTIFACT_GC_GRACE_S: int = 3600
#: Where frames a flow only shows live are held: memory rather than the #: Where a worker in this container writes the frames a flow only shows
#: data volume, so a camera at ten frames a second is not writing to an SD #: live: memory rather than the data volume, so a camera at ten frames a
#: card. Empty works it out — a directory under `/dev/shm` named for this #: second is not writing to an SD card. The engine holds its own frames in
#: data directory, so two instances on one host do not trim each other — #: its memory. Empty works it out — a directory under `/dev/shm` named for
#: and falls back to the temporary directory where there is no `/dev/shm`. #: this data directory, so two instances on one host do not trim each
#: other — and falls back to the temporary directory where there is no
#: `/dev/shm`.
ARTIFACT_VOLATILE_DIR: Path | None = None ARTIFACT_VOLATILE_DIR: Path | None = None
#: How much the volatile ring holds before the oldest frames fall out of #: How many bytes of live frames the engine holds before the oldest fall
#: it; 0 turns it off, and a volatile save then lands in the durable store #: out, and the workers' directory too; 0 turns the ring off, and a
#: like any other. Under Docker's default 64 MB `/dev/shm`: raise #: volatile save then lands in the durable store like any other. Under
#: `shm_size` with it. #: Docker's default 64 MB `/dev/shm`: raise `shm_size` with it when
#: workers publish frames.
ARTIFACT_VOLATILE_BYTES: int = 48 * 1024 * 1024 ARTIFACT_VOLATILE_BYTES: int = 48 * 1024 * 1024
# Without a Redis host the engine keeps its state in memory. # Without a Redis host the engine keeps its state in memory.
REDIS_HOST: str | None = None REDIS_HOST: str | None = None
+107 -39
View File
@@ -19,7 +19,9 @@ import hashlib
import logging import logging
import os import os
import tempfile import tempfile
import threading
import time import time
from collections import OrderedDict
from collections.abc import Iterable, Iterator from collections.abc import Iterable, Iterator
from pathlib import Path from pathlib import Path
from typing import Any from typing import Any
@@ -52,9 +54,10 @@ class ArtifactStore:
def __init__(self, root: Path) -> None: def __init__(self, root: Path) -> None:
self.root = root self.root = root
self.root.mkdir(parents=True, exist_ok=True) self.root.mkdir(parents=True, exist_ok=True)
#: A ring of frames held in memory, for media a flow only shows live. #: Frames held in memory, for media a flow only shows live. Set by the
#: Set by the engine at startup; every lookup below falls through to #: engine at startup unless the ring is turned off; every lookup below
#: it, which is what lets a volatile reference be an ordinary one. #: falls through to it, which is what lets a volatile reference be an
#: ordinary one.
self.volatile: VolatileStore | None = None self.volatile: VolatileStore | None = None
def _path(self, digest: str) -> Path: def _path(self, digest: str) -> Path:
@@ -79,7 +82,8 @@ class ArtifactStore:
``volatile`` puts it in the ring instead, where it is held in memory ``volatile`` puts it in the ring instead, where it is held in memory
and falls out once newer frames need the room. The reference is the and falls out once newer frames need the room. The reference is the
same shape either way — what differs is how long the bytes last, and a same shape either way — what differs is how long the bytes last, and a
caller that wants one kept returns it from a run. caller that wants one kept returns it from a run. Without a ring it
lands here like anything else.
""" """
if volatile and self.volatile is not None: if volatile and self.volatile is not None:
return self.volatile.put(chunks, name=name, media_type=media_type) return self.volatile.put(chunks, name=name, media_type=media_type)
@@ -128,20 +132,26 @@ class ArtifactStore:
) )
def path(self, digest: str) -> Path | None: def path(self, digest: str) -> Path | None:
"""Where the bytes are, or None if this store does not have them. """Where the stored bytes are, or None if this store does not have them.
The ring is looked in second, so everything that resolves a digest — Only the durable store: a live frame has no file. ``has`` and ``read``
serving one over HTTP, checking a run input still exists, a panel's are what reach both.
scope — reaches a live frame without knowing there are two stores.
""" """
if not valid_digest(digest): if not valid_digest(digest):
return None return None
target = self._path(digest) target = self._path(digest)
if target.exists(): return target if target.exists() else None
return target
if self.volatile is not None: def has(self, digest: str) -> bool:
return self.volatile.path(digest) """Whether the bytes are here, stored or held in the ring.
return None
Everything that only asks whether a digest resolves — a run input
that has to still exist, a cached result — reaches a live frame
without knowing there are two stores.
"""
if self.path(digest) is not None:
return True
return self.volatile is not None and self.volatile.has(digest)
def adopt(self, digest: str) -> bool: def adopt(self, digest: str) -> bool:
"""Copy a volatile artifact into this store, so it outlives the ring. """Copy a volatile artifact into this store, so it outlives the ring.
@@ -154,10 +164,10 @@ class ArtifactStore:
return False return False
if self._path(digest).exists(): if self._path(digest).exists():
return True return True
source = self.volatile.path(digest) data = self.volatile.get(digest)
if source is None: if data is None:
return False return False
self.put_file(source) self.put([data])
return True return True
def delete(self, digest: str) -> bool: def delete(self, digest: str) -> bool:
@@ -176,7 +186,11 @@ class ArtifactStore:
def read(self, digest: str) -> Iterator[bytes]: def read(self, digest: str) -> Iterator[bytes]:
target = self.path(digest) target = self.path(digest)
if target is None: if target is None:
raise FileNotFoundError(digest) data = self.volatile.get(digest) if self.volatile is not None else None
if data is None:
raise FileNotFoundError(digest)
yield data
return
with target.open("rb") as handle: with target.open("rb") as handle:
while chunk := handle.read(CHUNK): while chunk := handle.read(CHUNK):
yield chunk yield chunk
@@ -211,44 +225,98 @@ class ArtifactStore:
return removed return removed
class VolatileStore(ArtifactStore): class VolatileStore:
"""A bounded ring of artifacts, held wherever memory is cheaper than disk. """Live frames, held in memory and bounded by size.
A camera publishing ten frames a second is ten files a second, and on the A camera publishing five frames a second is five artifacts a second that
wall panel this is built for that disk is an SD card. So the frames go to a nobody keeps, so they never reach a disk: each one is held here in the
memory-backed directory instead and the oldest fall out once the ring is order it came and the oldest fall out once the bound is reached. Nothing
full: nothing sweeps it, because a frame nobody kept is not worth a pass sweeps it, and a ``put`` costs the same however full it is.
over the store to find.
It is an ``ArtifactStore``, digest layout and all, which is what lets a ``root`` is a memory-backed directory beside it for the frames a worker in
frame be an ordinary reference — the dtype check, the panel's scope, a this container writes itself (``FLUKSIO_ARTIFACT_VOLATILE_DIR``), since a
node opening one with ``load_artifact`` and the widget fetching one all worker is another process. Read from there once and held here after, so
work on it unchanged. a frame pushed to every open screen is read from the file once. The
engine trims that directory on a timer.
A frame is an ordinary reference all the same: the dtype check, the
device's scope, a node opening one with ``load_artifact`` and the widget
fetching one all work on it unchanged, through ``ArtifactStore``.
""" """
def __init__(self, root: Path, limit_bytes: int) -> None: def __init__(self, root: Path, limit_bytes: int) -> None:
super().__init__(root) self.root = root
self.root.mkdir(parents=True, exist_ok=True)
self.limit_bytes = limit_bytes self.limit_bytes = limit_bytes
self._frames: OrderedDict[str, bytes] = OrderedDict()
self._size = 0
self._lock = threading.Lock()
def put( def put(
self, self,
chunks: Iterable[bytes], chunks: Iterable[bytes],
name: str = "", name: str = "",
media_type: str = "", media_type: str = "",
volatile: bool = False,
) -> dict[str, Any]: ) -> dict[str, Any]:
reference = super().put(chunks, name=name, media_type=media_type) """Hold a frame and return the reference to it."""
self.trim() data = b"".join(chunks)
return reference digest = DIGEST_PREFIX + hashlib.sha256(data).hexdigest()
self._hold(digest, data)
return {
"digest": digest,
"size": len(data),
"media_type": media_type or "application/octet-stream",
"name": name,
}
def _hold(self, digest: str, data: bytes) -> None:
with self._lock:
if digest in self._frames:
# The same bytes again are the newest frame again.
self._frames.move_to_end(digest)
return
self._frames[digest] = data
self._size += len(data)
# The one just held stays, even past the bound: its reference is
# about to be published.
while self._size > self.limit_bytes and len(self._frames) > 1:
_, dropped = self._frames.popitem(last=False)
self._size -= len(dropped)
def _file(self, digest: str) -> Path:
body = digest[len(DIGEST_PREFIX) :]
return self.root / body[:2] / body
def get(self, digest: str) -> bytes | None:
"""The frame's bytes, or None once it has fallen out."""
with self._lock:
data = self._frames.get(digest)
if data is not None or not valid_digest(digest):
return data
try:
data = self._file(digest).read_bytes()
except OSError:
return None
self._hold(digest, data)
return data
def has(self, digest: str) -> bool:
with self._lock:
if digest in self._frames:
return True
return valid_digest(digest) and self._file(digest).is_file()
@property
def size(self) -> int:
"""Bytes held in memory."""
return self._size
def trim(self) -> int: def trim(self) -> int:
"""Drop the oldest until the ring is inside its bound. """Drop the oldest of the workers' frames until the directory is
inside the bound. Returns how many went.
Also called on a timer, because a worker in this container writes here A scan of the directory, so it runs on a timer and never per frame:
itself and the engine never sees that ``put``. only frames a worker in this container wrote are there.
# ponytail: a scandir per trim. An in-memory index if a ring of
# thousands of frames ever shows up in a profile.
""" """
if self.limit_bytes <= 0: if self.limit_bytes <= 0:
return 0 return 0
+25
View File
@@ -35,6 +35,7 @@ from fluksio_worker.worker_main import load_function
from fluksio.core.config import settings from fluksio.core.config import settings
from fluksio.flow.alerts import AlertManager from fluksio.flow.alerts import AlertManager
from fluksio.flow.demand import demand
from fluksio.flow.events import EventBus from fluksio.flow.events import EventBus
from fluksio.flow.executor import ExecutionService from fluksio.flow.executor import ExecutionService
from fluksio.flow.messages import MessageSpec, flow_of, qualify from fluksio.flow.messages import MessageSpec, flow_of, qualify
@@ -853,6 +854,9 @@ class FlowController:
) )
finally: finally:
self._lock.release() self._lock.release()
# A device created, deleted or reporting changes whose ports send on
# demand.
demand.refresh()
self._publish( self._publish(
{ {
"type": "pipeline_rebuilt", "type": "pipeline_rebuilt",
@@ -868,9 +872,13 @@ class FlowController:
An empty dashboard name is what a device refetches its own document An empty dashboard name is what a device refetches its own document
on, and what its socket rescopes on. The first build only takes note: on, and what its socket rescopes on. The first build only takes note:
a device connecting later reads the document as it is. a device connecting later reads the document as it is.
What a running flow reads may have moved with it, so demand on the
devices' ports is worked out again too.
""" """
if self.devices is None: if self.devices is None:
return return
demand.refresh()
wiring = self.devices.wiring() wiring = self.devices.wiring()
known, self._device_wiring = self._device_wiring, wiring known, self._device_wiring = self._device_wiring, wiring
if known is not None and known != wiring: if known is not None and known != wiring:
@@ -1488,6 +1496,23 @@ class FlowController:
def values(self, flow: str | None = None) -> dict[str, dict[str, Any]]: def values(self, flow: str | None = None) -> dict[str, dict[str, Any]]:
return self.pipeline.values(flow) if self.pipeline else {} return self.pipeline.values(flow) if self.pipeline else {}
def consumed_messages(self) -> set[str]:
"""The messages a node of a running flow reads.
What keeps a device's on-demand port sending whether or not anyone is
watching: a node that reads a camera wants every frame. A stopped or
batch flow reads nothing until it runs, and a device node is passive.
"""
pipeline = self.pipeline
if pipeline is None:
return set()
idle = self.disabled | self.batch
return {
name
for name, nodes in pipeline.consumes.items()
if any(node.flow not in idle for node in nodes)
}
def get_node(self, node_id: str) -> Node | None: def get_node(self, node_id: str) -> Node | None:
entry = self.loaded.get(node_id) entry = self.loaded.get(node_id)
return entry.node if entry else None return entry.node if entry else None
+22
View File
@@ -655,6 +655,10 @@ class DashboardStore:
self.root = flows.root / DASHBOARD_DIR self.root = flows.root / DASHBOARD_DIR
# Read-modify-write of the version counter, same as the flow store. # Read-modify-write of the version counter, same as the flow store.
self._lock = threading.Lock() self._lock = threading.Lock()
#: Published documents as last read, until the flow store commits.
self._published: dict[str, DashboardDef | None] = {}
self._published_at = -1
self._published_lock = threading.Lock()
def _file(self, name: str) -> Path: def _file(self, name: str) -> Path:
return self.root / checked(name) / "dashboard.json" return self.root / checked(name) / "dashboard.json"
@@ -719,6 +723,24 @@ class DashboardStore:
update={"has_draft": self.has_draft(name)} update={"has_draft": self.has_draft(name)}
) )
def published(self, name: str) -> DashboardDef | None:
"""The published document, or None, as of the store's last commit.
What a device's credential is held against on every request, a camera
fetching frame by frame included, so it is read once per commit rather
than from disk each time. Every write commits. The document is shared:
read it, never change it.
"""
with self._published_lock:
if self._published_at != self.flows.revision:
self._published, self._published_at = {}, self.flows.revision
if name not in self._published:
try:
self._published[name] = self.read(name)
except DashboardNotFound:
self._published[name] = None
return self._published[name]
def write( def write(
self, defn: DashboardDef, base_version: int | None = None self, defn: DashboardDef, base_version: int | None = None
) -> DashboardDef: ) -> DashboardDef:
+114
View File
@@ -0,0 +1,114 @@
"""Which of a device's ports someone wants right now.
A camera is sent nothing while nobody watches it. A port the device reports as
``on_demand`` has demand while a viewer socket wants bytes for the message it
is wired to — a dashboard tile, the Devices tab's preview, a screen through the
portal — or a node of a running flow reads that message.
Every socket says what it wants here, in one registry, and the result is
published on the bus as a ``device_demand`` event whenever a device's set
changes. Each device socket picks out its own and tells the device, so nothing
here has to know which sockets belong to which device.
"""
from __future__ import annotations
import threading
import time
from collections.abc import Hashable
from typing import Any
from fluksio.flow.events import event_bus
class Demand:
"""The media names every live socket wants, and what that asks of devices.
One per process, as the sockets are. ``bind`` hands it the controller,
whose device store says what is wired and whose graph says what a flow
reads.
"""
def __init__(self) -> None:
self._lock = threading.Lock()
self._wanted: dict[Hashable, frozenset[str]] = {}
#: The last set published per device, so only a change is.
self._sent: dict[str, tuple[str, ...]] = {}
self._refresh_lock = threading.Lock()
self._controller: Any = None
def bind(self, controller: Any) -> None:
self._controller = controller
self.refresh()
def want(self, viewer: Hashable, names: set[str]) -> None:
"""What one socket wants bytes for now, replacing what it said before."""
with self._lock:
if names:
self._wanted[viewer] = frozenset(names)
else:
self._wanted.pop(viewer, None)
self.refresh()
def drop(self, viewer: Hashable) -> None:
"""A socket closed, and wants nothing any more."""
self.want(viewer, set())
def viewed(self) -> set[str]:
with self._lock:
return set().union(*self._wanted.values())
def ports(self, device_id: str) -> list[str]:
"""The device's ports that have demand, sorted."""
return list(self._compute().get(device_id, ()))
def refresh(self) -> None:
"""Work demand out again and publish what changed.
Called whenever its inputs move: a socket's wanted set, and a rebuild,
a started or stopped flow or a new report, which change what is wired
and what reads it.
"""
with self._refresh_lock:
found = self._compute()
for device_id in sorted(set(found) | set(self._sent)):
ports = found.get(device_id, ())
if ports == self._sent.get(device_id, ()):
continue
if ports:
self._sent[device_id] = ports
else:
self._sent.pop(device_id, None)
event_bus.publish(
{
"type": "device_demand",
"device": device_id,
"ports": list(ports),
"ts": time.time(),
}
)
def _compute(self) -> dict[str, tuple[str, ...]]:
controller = self._controller
devices = getattr(controller, "devices", None)
if devices is None:
return {}
wanted = self.viewed() | controller.consumed_messages()
found: dict[str, tuple[str, ...]] = {}
for device_id in devices.wiring():
reported = devices.reported_ports(device_id) or {}
ports = tuple(
sorted(
binding.port
for binding in devices.bound(device_id)
if binding.direction == "in"
and binding.message in wanted
and reported.get(binding.port, {}).get("on_demand") is True
)
)
if ports:
found[device_id] = ports
return found
demand = Demand()
+2 -8
View File
@@ -45,7 +45,7 @@ from pydantic import (
model_validator, model_validator,
) )
from fluksio.flow.dashboards import DashboardDef, DashboardNotFound, DashboardStore from fluksio.flow.dashboards import DashboardDef, DashboardStore
from fluksio.flow.events import event_bus from fluksio.flow.events import event_bus
from fluksio.flow.messages import ( from fluksio.flow.messages import (
DType, DType,
@@ -985,13 +985,7 @@ def dashboards_for(
""" """
if device is None: if device is None:
return [] return []
found: list[DashboardDef] = [] return [defn for name in device.dashboards if (defn := store.published(name))]
for name in device.dashboards:
try:
found.append(store.read(name))
except DashboardNotFound:
continue
return found
def messages_of(defn: DashboardDef) -> set[str]: def messages_of(defn: DashboardDef) -> set[str]:
+15
View File
@@ -19,6 +19,8 @@ logger = logging.getLogger(__name__)
QUEUE_SIZE = 256 QUEUE_SIZE = 256
LOG_HISTORY = 400 LOG_HISTORY = 400
#: How many of a message's last artifact digests are remembered.
RECENT_DIGESTS = 8
class EventBus: class EventBus:
@@ -42,6 +44,11 @@ class EventBus:
# zero and draw a busy graph as idle. A session count, not a metric — # zero and draw a busy graph as idle. A session count, not a metric —
# the rollups in `metrics.py` are what survives a restart. # the rollups in `metrics.py` are what survives a restart.
self.emits: dict[str, int] = {} self.emits: dict[str, int] = {}
#: The last few artifacts each message pointed at, newest last. A
#: screen fetching a camera frame by frame asks for one the message
#: may already have moved past, and a device's credential reaches
#: these as well as the current one.
self.digests: dict[str, deque[str]] = {}
def bind(self, loop: asyncio.AbstractEventLoop) -> None: def bind(self, loop: asyncio.AbstractEventLoop) -> None:
"""Attach the bus to the running event loop (called once at startup).""" """Attach the bus to the running event loop (called once at startup)."""
@@ -59,6 +66,14 @@ class EventBus:
# increment, which is a count nobody is going to miss. # increment, which is a count nobody is going to miss.
node = str(event.get("node") or "") node = str(event.get("node") or "")
self.emits[node] = self.emits.get(node, 0) + 1 self.emits[node] = self.emits.get(node, 0) + 1
elif kind == "message_value":
value = event.get("value")
if isinstance(value, dict) and isinstance(value.get("digest"), str):
name = str(event.get("name") or "")
recent = self.digests.get(name)
if recent is None:
recent = self.digests[name] = deque(maxlen=RECENT_DIGESTS)
recent.append(value["digest"])
loop = self._loop loop = self._loop
if loop is None or not self._subscribers: if loop is None or not self._subscribers:
return return
+3 -6
View File
@@ -306,7 +306,7 @@ def _from_run(
).all() ).all()
for row in rows: for row in rows:
if output in (row.name, row.name.rsplit(".", 1)[-1]): if output in (row.name, row.name.rsplit(".", 1)[-1]):
if artifacts is not None and artifacts.path(row.digest) is None: if artifacts is not None and not artifacts.has(row.digest):
raise RunRejected( raise RunRejected(
f"Parameter '{key}': run '{run_id}' made '{output}', but its " f"Parameter '{key}': run '{run_id}' made '{output}', but its "
"bytes are gone from this instance's store" "bytes are gone from this instance's store"
@@ -337,7 +337,7 @@ def _from_digest(
f"Parameter '{key}': no run has produced '{digest}', so there is " f"Parameter '{key}': no run has produced '{digest}', so there is "
"nothing here under that digest" "nothing here under that digest"
) )
if artifacts is not None and artifacts.path(digest) is None: if artifacts is not None and not artifacts.has(digest):
raise RunRejected( raise RunRejected(
f"Parameter '{key}': '{digest}' is known but its bytes are gone " f"Parameter '{key}': '{digest}' is known but its bytes are gone "
"from this instance's store" "from this instance's store"
@@ -829,10 +829,7 @@ class RunCache:
def _unrestorable(self, outputs: dict[str, Any]) -> bool: def _unrestorable(self, outputs: dict[str, Any]) -> bool:
return any( return any(
is_reference(value) is_reference(value)
and ( and (self.artifacts is None or not self.artifacts.has(str(value["digest"])))
self.artifacts is None
or self.artifacts.path(str(value["digest"])) is None
)
for value in outputs.values() for value in outputs.values()
) )
+24 -9
View File
@@ -34,6 +34,7 @@ from fluksio.flow.alerts import AlertManager
from fluksio.flow.artifacts import ArtifactStore, VolatileStore from fluksio.flow.artifacts import ArtifactStore, VolatileStore
from fluksio.flow.controller import FlowController, RebuildBusy from fluksio.flow.controller import FlowController, RebuildBusy
from fluksio.flow.dashboards import DashboardStore from fluksio.flow.dashboards import DashboardStore
from fluksio.flow.demand import demand
from fluksio.flow.devices import DeviceStore, DeviceUnavailable from fluksio.flow.devices import DeviceStore, DeviceUnavailable
from fluksio.flow.events import event_bus from fluksio.flow.events import event_bus
from fluksio.flow.executor import ExecutionService from fluksio.flow.executor import ExecutionService
@@ -159,14 +160,13 @@ VOLATILE_TRIM_S = 5.0
async def _trim_volatile(ring: VolatileStore) -> None: async def _trim_volatile(ring: VolatileStore) -> None:
"""Hold the volatile ring inside its bound. """Hold the workers' frame directory inside its bound.
``put`` trims what it wrote, but a worker in this container writes to the The engine's own frames are held in memory and bounded as they arrive, but
ring itself and the engine never sees that one — so the bound needs a worker in this container writes its frames to a directory and the
something of its own watching it. engine never sees that ``put`` — so the bound needs something of its own
watching it.
""" """
if ring.limit_bytes <= 0:
return
while True: while True:
await asyncio.sleep(VOLATILE_TRIM_S) await asyncio.sleep(VOLATILE_TRIM_S)
try: try:
@@ -190,6 +190,17 @@ def _volatile_root() -> Path:
return parent / f"fluksio-volatile-{tag}" return parent / f"fluksio-volatile-{tag}"
def _volatile_ring() -> VolatileStore | None:
"""The ring of live frames, or None when its bound is zero.
Without one a volatile save is an ordinary one, and a worker writes its
frames to the durable store too.
"""
if settings.ARTIFACT_VOLATILE_BYTES <= 0:
return None
return VolatileStore(_volatile_root(), settings.ARTIFACT_VOLATILE_BYTES)
def _mcp_sessions() -> AbstractAsyncContextManager[None]: def _mcp_sessions() -> AbstractAsyncContextManager[None]:
"""The MCP session manager's run scope, or nothing when MCP is off.""" """The MCP session manager's run scope, or nothing when MCP is off."""
if not settings.MCP_ENABLED: if not settings.MCP_ENABLED:
@@ -285,7 +296,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
# Frames a flow only shows live, held in memory and bounded by size. # Frames a flow only shows live, held in memory and bounded by size.
# The store falls through to it, so a volatile reference is an # The store falls through to it, so a volatile reference is an
# ordinary one everywhere but in how long its bytes last. # ordinary one everywhere but in how long its bytes last.
volatile = VolatileStore(_volatile_root(), settings.ARTIFACT_VOLATILE_BYTES) volatile = _volatile_ring()
artifacts.volatile = volatile artifacts.volatile = volatile
app.state.artifact_store = artifacts app.state.artifact_store = artifacts
# Zero means "work it out" for cards and memory, as it always has for cores. # Zero means "work it out" for cards and memory, as it always has for cores.
@@ -309,7 +320,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
# is given a URL instead. Node code calls the same two functions. # is given a URL instead. Node code calls the same two functions.
env={ env={
ARTIFACT_DIR_ENV: str(artifacts.root), ARTIFACT_DIR_ENV: str(artifacts.root),
ARTIFACT_VOLATILE_DIR_ENV: str(volatile.root), **({ARTIFACT_VOLATILE_DIR_ENV: str(volatile.root)} if volatile else {}),
# Every slot can be busy at once, so a worker left to size its own # Every slot can be busy at once, so a worker left to size its own
# thread pool to the machine means as many processes as there are # thread pool to the machine means as many processes as there are
# slots, each believing it has the whole of it. A node that says # slots, each believing it has the whole of it. A node that says
@@ -359,6 +370,9 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
await run_in_threadpool(devices.move_io) await run_in_threadpool(devices.move_io)
app.state.device_store = devices app.state.device_store = devices
controller.devices = devices controller.devices = devices
# What the sockets want and the flows read, mapped onto the devices'
# on-demand ports.
demand.bind(controller)
# Charts need a deeper series than the default; tell the engine # Charts need a deeper series than the default; tell the engine
# before it starts recording. # before it starts recording.
controller.set_history_limits(dashboards.history_requirements()) controller.set_history_limits(dashboards.history_requirements())
@@ -398,7 +412,8 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
app.state.metrics_collector = MetricsCollector(event_bus) app.state.metrics_collector = MetricsCollector(event_bus)
_background(app.state.metrics_collector.run(), "metrics-collector") _background(app.state.metrics_collector.run(), "metrics-collector")
_background(_sweep_artifacts(artifacts, controller), "artifact-gc") _background(_sweep_artifacts(artifacts, controller), "artifact-gc")
_background(_trim_volatile(volatile), "artifact-ring") if volatile is not None:
_background(_trim_volatile(volatile), "artifact-ring")
await controller.start() await controller.start()
started.append(controller.stop) started.append(controller.stop)
run_service.start() run_service.start()
+363
View File
@@ -0,0 +1,363 @@
"""Cameras on a device: frames over its socket, demand, and what a screen fetches.
openpanel ROADMAP C1. A device reports a ``camera`` port that sends only while
somebody wants it. Demand is what the viewer sockets want plus what running
flows read, mapped onto the device's on-demand ports and sent to its socket.
"""
import json
import time
from collections.abc import Callable
from typing import Any
import orjson
import pytest
from fastapi.testclient import TestClient
from fluksio.api.routes import oauth
from fluksio.core.config import settings
from fluksio.flow.demand import demand
from fluksio.flow.events import RECENT_DIGESTS, event_bus
from tests.api.routes.test_devices import (
FLOWS,
_device_node,
_pair,
_panels,
_publish_flow,
)
PREFIX = f"{settings.API_V1_STR}/devices"
SOCKET = f"{settings.API_V1_STR}/flows/ws"
ARTIFACTS = f"{settings.API_V1_STR}/artifacts"
#: What the NANO reports, as C1 fixes it.
REPORT = {
"schema": 1,
"platform": "esp32p4",
"board": "nano",
"firmware": "0.2.0",
"ports": [
{"port": "camera", "direction": "in", "dtype": "image", "on_demand": True},
{"port": "person", "direction": "in", "dtype": "bool"},
{"port": "detections", "direction": "in", "dtype": "json"},
{"port": "snapshot", "direction": "in", "dtype": "image"},
],
}
CAMERA_NODE = _device_node(
"cam1",
node="hall",
provides=[
{"name": "camera", "port": "camera", "dtype": "image"},
{"name": "person", "port": "person", "dtype": "bool"},
{"name": "snapshot", "port": "snapshot", "dtype": "image"},
],
)
#: A node reading the camera's every frame, which keeps it on for good.
READER = {
"id": "watch",
"type": "debounce",
"params": {"wait": 5},
"requires": [{"name": "camera", "dtype": "image"}],
"provides": [{"name": "moving", "dtype": "bool"}],
}
@pytest.fixture(autouse=True)
def _pairing_unlimited() -> None:
"""Every test pairs from the test client's one address."""
for bucket in [b for b in oauth._hits if b.startswith("pair:")]:
del oauth._hits[bucket]
def frame(name: str, data: bytes, media_type: str = "image/jpeg") -> bytes:
"""A binary frame as a device sends it."""
header = orjson.dumps(
{"type": "frame", "name": name, "media_type": media_type, "ts": 1234}
)
return len(header).to_bytes(4, "big") + header + data
def wait_for(check: Callable[[], Any], timeout: float = 5.0) -> Any:
deadline = time.time() + timeout
while time.time() < deadline:
found = check()
if found:
return found
time.sleep(0.02)
raise AssertionError("timed out")
@pytest.fixture
def camera(client: TestClient, superuser_token_headers: dict[str, str]):
"""A paired device with a camera, wired in flow ``cams``. Yields its header."""
_panels(client, superuser_token_headers, {"panels": [{"id": "cam1"}]})
device = _pair(client, superuser_token_headers, "cam1")
reported = client.put(f"{PREFIX}/cam1/report", headers=device, json=REPORT)
assert reported.status_code == 200, reported.text
_publish_flow(client, superuser_token_headers, "cams", [CAMERA_NODE])
yield device
client.delete(f"{FLOWS}/cams", headers=superuser_token_headers)
client.delete(f"{PREFIX}/cam1", headers=superuser_token_headers)
def _ticket(client: TestClient, headers: dict[str, str]) -> str:
answer = client.post(f"{settings.API_V1_STR}/flows/ws-ticket", headers=headers)
return f"{SOCKET}?ticket={answer.json()['ticket']}"
def _next_demand(ws: Any) -> list[str]:
"""The next demand message on a device's socket, skipping values."""
while True:
message = ws.receive_json()
if message.get("type") == "demand":
return message["ports"]
def test_a_tile_asking_for_the_camera_turns_it_on_and_off(
client: TestClient, superuser_token_headers: dict[str, str], camera
) -> None:
"""Demand follows what viewers draw, and only on a port sent on demand."""
with client.websocket_connect(SOCKET, headers=camera) as device:
snapshot = device.receive_json()
assert snapshot["demand"] == []
assert snapshot["uplink"] == "binary"
with client.websocket_connect(
_ticket(client, superuser_token_headers)
) as viewer:
viewer.receive_json()
# `person` is drawn too, but it sends all the time anyway.
viewer.send_json({"type": "media", "names": ["cams.camera", "cams.person"]})
assert _next_demand(device) == ["camera"]
# The tile scrolled away: the page asks for nothing.
viewer.send_json({"type": "media", "names": []})
assert _next_demand(device) == []
viewer.send_json({"type": "media", "names": ["cams.camera"]})
assert _next_demand(device) == ["camera"]
# The viewer closed its socket.
assert _next_demand(device) == []
# A snapshot taken while someone watches says so.
demand.want("someone", {"cams.camera"})
try:
assert _next_demand(device) == ["camera"]
with client.websocket_connect(SOCKET, headers=camera) as again:
assert again.receive_json()["demand"] == ["camera"]
finally:
demand.drop("someone")
@pytest.mark.usefixtures("camera")
def test_a_flow_reading_the_camera_keeps_it_on(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
"""A running flow that reads frames wants every one, watched or not."""
assert demand.ports("cam1") == []
_publish_flow(client, superuser_token_headers, "cams", [CAMERA_NODE, READER])
assert demand.ports("cam1") == ["camera"]
stopped = client.post(f"{FLOWS}/cams/stop", headers=superuser_token_headers)
assert stopped.status_code == 200, stopped.text
assert demand.ports("cam1") == []
client.post(f"{FLOWS}/cams/start", headers=superuser_token_headers)
assert demand.ports("cam1") == ["camera"]
# A port the device does not send on demand never has any.
_publish_flow(client, superuser_token_headers, "cams", [CAMERA_NODE])
demand.want("someone", {"cams.snapshot", "cams.person"})
try:
assert demand.ports("cam1") == []
finally:
demand.drop("someone")
def test_a_device_sends_frames_on_its_socket(
client: TestClient, superuser_token_headers: dict[str, str], camera
) -> None:
"""Held and published in one step, credited to its node, pushed to tiles."""
with (
client.websocket_connect(SOCKET, headers=camera) as device,
client.websocket_connect(_ticket(client, superuser_token_headers)) as viewer,
):
device.receive_json()
viewer.receive_json()
viewer.send_json({"type": "media", "names": ["cams.camera"]})
_next_demand(device)
device.send_bytes(frame("cams.camera", b"\xff\xd8 a jpeg"))
pushed = viewer.receive_bytes()
length = int.from_bytes(pushed[:4], "big")
header = orjson.loads(pushed[4 : 4 + length])
assert header["name"] == "cams.camera"
assert header["media_type"] == "image/jpeg"
assert pushed[4 + length :] == b"\xff\xd8 a jpeg"
value = viewer.receive_json()
assert value["type"] == "message_value"
assert value["value"]["digest"] == header["digest"]
assert value["source"]["kind"] == "node"
assert value["source"]["id"] == "cams.hall"
store = client.app.state.artifact_store
assert store.volatile.get(header["digest"]) == b"\xff\xd8 a jpeg"
# In memory, and not on the volume.
assert store.path(header["digest"]) is None
# The device is not sent its own camera's values back, only the rest.
from fluksio.api.routes.flows import panel_scope
scope = panel_scope(camera["Authorization"][7:], client.app)
assert scope == {"cams.person"}
def test_a_frame_the_device_may_not_send_is_dropped(
client: TestClient,
superuser_token_headers: dict[str, str],
camera,
caplog: pytest.LogCaptureFixture,
) -> None:
"""Refused, logged and dropped, and the socket carries on."""
controller = client.app.state.flow_controller
before = controller.values().get("cams.person")
with client.websocket_connect(SOCKET, headers=camera) as device:
device.receive_json()
for refused in (
frame("cams.person", b"\xff\xd8"), # a bool port
frame("cams.elsewhere", b"\xff\xd8"), # not one of its ports
frame("cams.camera", b"<svg/>", "text/html"), # not an image
b"\x00\x00\x00\x09not json!",
b"\x01",
):
device.send_bytes(refused)
# Still open: a frame it may send goes through after them.
device.send_bytes(frame("cams.camera", b"\xff\xd8 after"))
wait_for(lambda: (controller.values().get("cams.camera") or {}).get("value"))
assert controller.values().get("cams.person") == before
# A person's socket is no camera.
with client.websocket_connect(_ticket(client, superuser_token_headers)) as ws:
ws.receive_json()
ws.send_bytes(frame("cams.camera", b"\xff\xd8 forged"))
ws.send_json({"type": "media", "names": []})
current = controller.values()["cams.camera"]["value"]
data = client.app.state.artifact_store.volatile.get(current["digest"])
assert data == b"\xff\xd8 after"
said = [r.getMessage() for r in caplog.records if "Dropped a frame" in r.message]
assert any("'person' is wired as bool" in line for line in said)
assert any("not a message one of its ports publishes" in line for line in said)
assert any("only a device sends frames" in line for line in said)
def test_an_unpaired_device_is_closed_and_its_frames_stop(
client: TestClient, superuser_token_headers: dict[str, str], camera
) -> None:
from starlette.websockets import WebSocketDisconnect
with client.websocket_connect(SOCKET, headers=camera) as device:
device.receive_json()
client.post(f"{PREFIX}/cam1/unpair", headers=superuser_token_headers)
with pytest.raises(WebSocketDisconnect) as closed:
while True:
device.receive_json()
assert closed.value.code == 1008
def test_a_screen_may_fetch_the_last_few_frames(client: TestClient, camera) -> None:
"""A remote screen fetching frame by frame is often one behind."""
controller = client.app.state.flow_controller
store = client.app.state.artifact_store
refs = []
for index in range(RECENT_DIGESTS + 2):
ref = store.put([b"frame %d" % index], media_type="image/jpeg", volatile=True)
controller.publish_message("cams.camera", ref)
refs.append(ref)
def fetch(ref: dict[str, Any]) -> int:
return client.get(f"{ARTIFACTS}/{ref['digest']}", headers=camera).status_code
assert [fetch(ref) for ref in refs[-RECENT_DIGESTS:]] == [200] * RECENT_DIGESTS
# Older than that, it is not what the screen is drawing.
assert fetch(refs[0]) == 403
assert list(event_bus.digests["cams.camera"]) == [
ref["digest"] for ref in refs[-RECENT_DIGESTS:]
]
def test_a_viewer_asks_for_a_few_cameras_at_most() -> None:
from fluksio.api.routes.flows import MAX_MEDIA_NAMES, wanted_names
names = [f"cams.c{i}" for i in range(MAX_MEDIA_NAMES + 3)]
asked = wanted_names(json.dumps({"type": "media", "names": names}), None)
assert asked == set(names[:MAX_MEDIA_NAMES])
def test_viewers_through_the_portal_count_too(
client: TestClient, superuser_token_headers: dict[str, str], camera
) -> None:
"""The tunnel carries text only, so a device there uploads over HTTP, and a
browser there asks for media like any other."""
from fluksio.cloud.connector import CloudConnector
connector = CloudConnector(client.app)
sent: dict[str, list[dict[str, Any]]] = {"dev": [], "view": []}
class Socket:
def __init__(self, stream: str) -> None:
self.stream = stream
async def send(self, text: str) -> None:
sent[self.stream].append(json.loads(text))
def texts(stream: str) -> list[dict[str, Any]]:
return [
json.loads(frame["text"])
for frame in sent[stream]
if frame["op"] == "ws_msg"
]
def demands() -> list[list[str]]:
return [t["ports"] for t in texts("dev") if t.get("type") == "demand"]
token = camera["Authorization"][7:]
device = client.portal.start_task_soon(
connector._stream,
Socket("dev"),
{"id": "dev", "path": "/api/v1/flows/ws", "query": f"token={token}"},
)
try:
snapshot = wait_for(lambda: texts("dev"))[0]
assert snapshot["uplink"] == "http"
assert snapshot["demand"] == []
ticket = _ticket(client, superuser_token_headers).split("?", 1)[1]
viewer = client.portal.start_task_soon(
connector._stream,
Socket("view"),
{"id": "view", "path": "/api/v1/flows/ws", "query": ticket},
)
wait_for(lambda: texts("view"))
asking = json.dumps({"type": "media", "names": ["cams.camera"]})
client.portal.call(_say, connector, "view", asking)
assert wait_for(demands)[-1] == ["camera"]
viewer.cancel()
wait_for(lambda: len(demands()) == 2)
assert demands()[-1] == []
finally:
device.cancel()
async def _say(connector: Any, stream: str, text: str) -> None:
"""What the hub delivers when the browser behind a stream speaks."""
connector._listeners[stream](text)
def test_a_zero_bound_turns_the_ring_off(monkeypatch: pytest.MonkeyPatch) -> None:
from fluksio.main import _volatile_ring
monkeypatch.setattr(settings, "ARTIFACT_VOLATILE_BYTES", 0)
assert _volatile_ring() is None
monkeypatch.setattr(settings, "ARTIFACT_VOLATILE_BYTES", 1000)
assert _volatile_ring() is not None
+3 -4
View File
@@ -2,7 +2,6 @@ import asyncio
from datetime import UTC, datetime from datetime import UTC, datetime
import pytest import pytest
from fastapi import WebSocketDisconnect
from fastapi.testclient import TestClient from fastapi.testclient import TestClient
from sqlalchemy import func from sqlalchemy import func
from sqlmodel import Session, select from sqlmodel import Session, select
@@ -538,10 +537,10 @@ async def test_the_live_socket_ends_when_its_client_goes(
async def send_text(self, text: str) -> None: async def send_text(self, text: str) -> None:
self.sent.append(text) self.sent.append(text)
async def receive_text(self) -> str: async def receive(self) -> dict[str, object]:
if self.frames: if self.frames:
return self.frames.pop(0) return {"type": "websocket.receive", "text": self.frames.pop(0)}
raise WebSocketDisconnect(1006) return {"type": "websocket.disconnect", "code": 1006}
peer = Peer() peer = Peer()
subscribed = len(event_bus._subscribers) subscribed = len(event_bus._subscribers)
+1 -1
View File
@@ -790,7 +790,7 @@ def test_a_node_saves_a_frame_to_the_ring(tmp_path):
assert MessageSpec(name="frame", dtype=DType.IMAGE).check(ref) is None assert MessageSpec(name="frame", dtype=DType.IMAGE).check(ref) is None
# In the ring, and nowhere near the data volume. # In the ring, and nowhere near the data volume.
assert store.volatile.path(ref["digest"]) is not None assert store.volatile.has(ref["digest"])
assert not (store.root / ref["digest"][7:9]).exists() assert not (store.root / ref["digest"][7:9]).exists()
read = pool.run( read = pool.run(
+40 -6
View File
@@ -141,25 +141,59 @@ def test_a_ring_drops_the_oldest_once_it_is_full(tmp_path):
ring = VolatileStore(tmp_path / "ring", limit_bytes=3000) ring = VolatileStore(tmp_path / "ring", limit_bytes=3000)
refs = [ring.put([bytes([i]) * 1000], name=f"{i}.bin") for i in range(5)] refs = [ring.put([bytes([i]) * 1000], name=f"{i}.bin") for i in range(5)]
held = [ref for ref in refs if ring.path(ref["digest"]) is not None] held = [ref for ref in refs if ring.has(ref["digest"])]
assert len(held) == 3 assert len(held) == 3
# The newest three, in order: eviction is by age, not by chance. # The newest three, in order: eviction is by age, not by chance.
assert held == refs[2:] assert held == refs[2:]
assert ring.size == 3000
# Held in memory: nothing reached the directory.
assert not any(ring.root.iterdir())
def test_the_newest_frame_stays_whatever_its_size(tmp_path):
"""A frame larger than the bound is still there for its own publish."""
ring = VolatileStore(tmp_path / "ring", limit_bytes=100)
small = ring.put([b"s" * 50])
big = ring.put([b"b" * 500])
assert ring.get(big["digest"]) == b"b" * 500
assert not ring.has(small["digest"])
def test_a_workers_frame_is_read_from_its_directory_once(tmp_path):
"""A worker in the container writes its frames to the ring's directory."""
import hashlib
ring = VolatileStore(tmp_path / "ring", limit_bytes=1_000_000)
data = b"a worker's frame"
body = hashlib.sha256(data).hexdigest()
path = ring.root / body[:2] / body
path.parent.mkdir(parents=True)
path.write_bytes(data)
assert ring.has("sha256:" + body)
assert ring.get("sha256:" + body) == data
# Held after the first read, so every screen is served from memory.
path.unlink()
assert ring.get("sha256:" + body) == data
def test_a_volatile_reference_resolves_like_any_other(tmp_path): def test_a_volatile_reference_resolves_like_any_other(tmp_path):
"""A frame is an ordinary reference, which is what keeps the rest honest. """A frame is an ordinary reference, which is what keeps the rest honest.
Everything that resolves a digest — serving one, checking a run's input, Everything that asks whether a digest resolves — checking a run's input,
a panel's scope — goes through ``path``, so the ring has to answer there. a cached result — goes through ``has``, and reading one through ``read``,
so the ring has to answer there.
""" """
store = ArtifactStore(tmp_path / "artifacts") store = ArtifactStore(tmp_path / "artifacts")
store.volatile = VolatileStore(tmp_path / "ring", limit_bytes=1_000_000) store.volatile = VolatileStore(tmp_path / "ring", limit_bytes=1_000_000)
ref = store.put([b"frame"], name="f.png", media_type="image/png", volatile=True) ref = store.put([b"frame"], name="f.png", media_type="image/png", volatile=True)
assert store.path(ref["digest"]) is not None assert store.has(ref["digest"])
assert b"".join(store.read(ref["digest"])) == b"frame"
# In the ring, and not on the volume the sweep is about. # In the ring, and not on the volume the sweep is about.
assert store.path(ref["digest"]) is None
assert not (store.root / ref["digest"][7:9]).exists() assert not (store.root / ref["digest"][7:9]).exists()
@@ -171,7 +205,7 @@ def test_a_recorded_frame_is_copied_out_of_the_ring(tmp_path):
assert store.adopt(ref["digest"]) is True assert store.adopt(ref["digest"]) is True
store.volatile.collect(set()) store.volatile = VolatileStore(tmp_path / "ring2", limit_bytes=1_000_000)
assert store.path(ref["digest"]) is not None assert store.path(ref["digest"]) is not None
assert store.adopt("sha256:" + "0" * 64) is False assert store.adopt("sha256:" + "0" * 64) is False
@@ -195,7 +229,7 @@ def test_an_upload_may_ask_for_the_ring(
assert answer.status_code == 200, answer.text assert answer.status_code == 200, answer.text
digest = answer.json()["digest"] digest = answer.json()["digest"]
assert store.volatile.path(digest) is not None assert store.volatile.has(digest)
assert not (store.root / digest[7:9]).exists() assert not (store.root / digest[7:9]).exists()
# And it is served back like anything else, which is what the widget # And it is served back like anything else, which is what the widget
# falls back on when the socket did not push it. # falls back on when the socket did not push it.
+9 -4
View File
@@ -94,19 +94,24 @@ services:
build: build:
context: .. context: ..
dockerfile: backend/Dockerfile dockerfile: backend/Dockerfile
# `fastapi dev`, because `run` takes no `--reload-dir`. Watching the worker # uvicorn itself, because `fastapi dev` cannot turn per-message deflate
# off, which `fluksio serve` does for the media frames. Watching the worker
# too makes a worker edit restart the engine, which respawns the local # too makes a worker edit restart the engine, which respawns the local
# worker pool with the new code. # worker pool with the new code.
command: command:
- fastapi - uvicorn
- dev - fluksio.main:app
- --reload
- --host - --host
- 0.0.0.0 - 0.0.0.0
- --port
- "8000"
- --ws-per-message-deflate
- "false"
- --reload-dir - --reload-dir
- /app/backend - /app/backend
- --reload-dir - --reload-dir
- /app/worker - /app/worker
- "fluksio/main.py"
develop: develop:
watch: watch:
- path: ../backend - path: ../backend
+26
View File
@@ -173,6 +173,8 @@ curl "$FLUKSIO/artifacts/<digest>" \
The upload returns a reference with the content digest. Identical bytes are The upload returns a reference with the content digest. Identical bytes are
stored once. Node code uses `save_artifact` and `load_artifact` instead. stored once. Node code uses `save_artifact` and `load_artifact` instead.
`?volatile=true` holds the bytes in the engine's memory for a live frame, where
newer frames push them out, instead of storing them.
A superuser can remove stored bytes with `DELETE /artifacts/<digest>`. While A superuser can remove stored bytes with `DELETE /artifacts/<digest>`. While
a run, a current message or a flow input's initial value still references the a run, a current message or a flow input's initial value still references the
@@ -249,6 +251,30 @@ Browsers first call `POST /flows/ws-ticket`, then connect with
`?ticket=<ticket>`. Tickets are single-use and expire after 30 seconds. `?ticket=<ticket>`. Tickets are single-use and expire after 30 seconds.
The socket sends a snapshot followed by node, value, health, and run events. The socket sends a snapshot followed by node, value, health, and run events.
A client asks for the bytes of the media it shows with
`{"type": "media", "names": [...]}`, which replaces what it asked for before,
for at most 8 messages. Each frame held in memory then arrives as a binary
message before the value naming it: four bytes of header length (big endian),
a JSON header `{"type": "media", "name", "digest", "media_type", "ts"}`, then
the bytes. Messages are sent without per-message compression.
A device's socket is bounded to its own messages. Its snapshot carries
`"demand"`, the ports it reported as `on_demand` that someone wants now, and
`"uplink"`, `"binary"` on its own socket and `"http"` through the portal. When
that set changes it is sent `{"type": "demand", "ports": [...]}`. A port has
demand while a socket asks for the media of the message it is wired to, or a
node of a running flow reads that message.
With a `binary` uplink the device sends a camera frame as a binary message in
the same layout, with the header `{"type": "frame", "name": "<message>",
"media_type": "image/jpeg", "ts": <device ms>}`. The message has to be one of
its `in` ports wired as `image`. The frame is held in memory and published
in one step, credited to its device node. A frame that does not qualify is
logged and dropped and the socket stays open. With `http` it uploads with
`PUT /artifacts?volatile=true&name=<message>` and publishes with
`POST /messages/<message>`. A device that is unpaired or deleted while
connected is closed with 1008.
## Errors and client generation ## Errors and client generation
| Code | Meaning | | Code | Meaning |
+35
View File
@@ -203,6 +203,13 @@ For local streams, `volatile=True` artifacts can be pushed over the websocket
with their message. Stored artifacts are fetched individually, as are frames with their message. Stored artifacts are fetched individually, as are frames
viewed through a portal. Use occasional snapshots for remote screens. viewed through a portal. Use occasional snapshots for remote screens.
A tile asks for frames only while it is on screen in a tab that is being looked
at, and stops when it scrolls away, the tab is hidden or the tile closes. A
clip keeps playing either way. One page is pushed frames for at most 8
messages at once. A ninth tile fetches its frames one by one and does not turn
a camera on. A [device's camera](#a-devices-camera) sends only while a tile like
this wants it.
For continuous video, set **Live stream** to a browser-compatible camera URL. For continuous video, set **Live stream** to a browser-compatible camera URL.
The browser must be able to reach that URL; enrollment does not expose the The browser must be able to reach that URL; enrollment does not expose the
camera itself. See [Media payloads](../reference/payload-types.md#image-audio-video). camera itself. See [Media payloads](../reference/payload-types.md#image-audio-video).
@@ -591,6 +598,34 @@ the dashboard settings, named after the device, and the first report of a
touch screen turns **Touch friendly** on. A device paired before this version touch screen turns **Touch friendly** on. A device paired before this version
keeps the switch as it was set. keeps the switch as it was set.
### A device's camera
A camera device (openpanel on a NANO) reports four ports:
| Port | Type | Settings | What it sends |
|---|---|---|---|
| `camera` | `image`, on demand | `width` (640), `fps` (5), `idle_fps` (0, off), `quality` (65) | JPEG frames, held in memory and never stored |
| `person` | `bool` | `hold_s` (10) | whether someone is in view, held for `hold_s` after they leave |
| `detections` | `json` | | `{count, boxes: [{score, x0, y0, x1, y1}]}`, boxes scaled 0 to 1, on change and at most once a second |
| `snapshot` | `image` | | one stored frame each time `person` turns true |
`camera` sends only while it has demand: while a page wants its frames (a
dashboard tile, the preview on the device's page, a screen through the
portal), or a node of a running flow reads its message. Once its flow wires
`camera`, the device's page shows a **Camera** preview. A flow that reads
`camera` keeps it sending all the time, about 300 GB a month through a cloud
instance, so the Device node warns when a node in its flow reads a port that
sends on demand. Have flows read `snapshot` or `person` instead.
The device is told which of its ports have demand on its live socket, and sends
its frames there too, as described under [Live events](../code/api.md#live-events).
Through the portal the socket carries text only, so a device paired there
uploads each frame over HTTP instead.
A device may fetch the last 8 artifacts each of its messages pointed at, not
only the current one, so a screen fetching a camera frame by frame through the
portal is not refused a frame the camera has just replaced.
### Before device nodes ### Before device nodes
Before device nodes a device carried its ports itself. On its first start an Before device nodes a device carried its ports itself. On its first start an
+8 -6
View File
@@ -167,14 +167,16 @@ MIG entries are passed on as written.
| `MAX_ARTIFACT_BYTES` | `2147483648` (2 GiB) | upload limit; `0` removes it | | `MAX_ARTIFACT_BYTES` | `2147483648` (2 GiB) | upload limit; `0` removes it |
| `ARTIFACT_GC_INTERVAL_S` | `3600` | cleanup interval; `0` disables | | `ARTIFACT_GC_INTERVAL_S` | `3600` | cleanup interval; `0` disables |
| `ARTIFACT_GC_GRACE_S` | `3600` | minimum age before cleanup | | `ARTIFACT_GC_GRACE_S` | `3600` | minimum age before cleanup |
| `ARTIFACT_VOLATILE_DIR` | auto-detected | live-media directory under `/dev/shm`, or the temporary directory | | `ARTIFACT_VOLATILE_DIR` | auto-detected | where local workers write live frames, under `/dev/shm` or the temporary directory |
| `ARTIFACT_VOLATILE_BYTES` | `50331648` (48 MiB) | live-media ring size; `0` stores volatile saves durably | | `ARTIFACT_VOLATILE_BYTES` | `50331648` (48 MiB) | live-media ring size, in the engine's memory and again in that directory; `0` stores volatile saves durably |
Cleanup removes durable artifacts no longer referenced by recorded runs or Cleanup removes durable artifacts no longer referenced by recorded runs or
current messages, and pauses while a run is active. Volatile artifacts use a current messages, and pauses while a run is active. Volatile artifacts live in
bounded ring; the oldest disappear as it fills. Recorded run outputs are a bounded ring in the engine's memory, and the oldest disappear as it fills.
copied into durable storage. If you increase the ring size in Docker, increase Recorded run outputs are copied into durable storage. A worker in the engine's
`shm_size` too. container writes its frames to `ARTIFACT_VOLATILE_DIR` instead, which the
engine trims to the same size every few seconds. If workers publish frames
under Docker, raise `shm_size` with the ring size.
## Agents ## Agents
+122 -67
View File
@@ -1,3 +1,6 @@
import { useRef } from "react"
import { useOnScreen } from "@/hooks/useOnScreen"
import { isRef, useArtifactUrl } from "@/lib/media" import { isRef, useArtifactUrl } from "@/lib/media"
import { cn } from "@/lib/utils" import { cn } from "@/lib/utils"
import { useBoundValue } from "./dataContext" import { useBoundValue } from "./dataContext"
@@ -15,74 +18,126 @@ import type { WidgetProps } from "./widgets"
*/ */
export function MediaWidget({ widget }: WidgetProps) { export function MediaWidget({ widget }: WidgetProps) {
const cfg = config(widget) const cfg = config(widget)
const message = text(cfg.message)
const stream = text(cfg.stream_url)
const live = useBoundValue(message || undefined)
const value = live?.value
const ref = isRef(value) ? value : null
const url = useArtifactUrl(ref, message || undefined)
const kind = (ref?.media_type ?? text(cfg.dtype)).split("/")[0]
const fit = text(cfg.fit) === "contain" ? "object-contain" : "object-cover"
const label = widget.title || ref?.name || message
// A camera serving its own stream is played from source: the engine carries
// references at whatever rate the flow publishes them, which is not video.
if (stream && kind !== "audio") {
return (
<img
src={stream}
alt={label}
className={cn("h-full w-full rounded-md", fit)}
/>
)
}
if (!message && !stream) {
return <p className="text-muted-foreground">Pick a message.</p>
}
if (!ref) {
return <p className="text-muted-foreground">Nothing published yet.</p>
}
if (!url) {
return <p className="text-muted-foreground">Loading…</p>
}
if (kind === "audio") {
return (
<audio
// Keyed on the digest so a new clip replaces the element rather than
// leaving the last one's playhead on it.
key={ref.digest}
src={url}
controls
autoPlay={Boolean(cfg.autoplay)}
className="w-full"
>
<track kind="captions" />
</audio>
)
}
if (kind === "video") {
return (
<video
key={ref.digest}
src={url}
controls
autoPlay={Boolean(cfg.autoplay)}
className={cn("h-full w-full rounded-md", fit)}
>
<track kind="captions" />
</video>
)
}
return ( return (
<img <MediaView
src={url} message={text(cfg.message)}
alt={label} stream={text(cfg.stream_url)}
className={cn("h-full w-full rounded-md", fit)} dtype={text(cfg.dtype)}
fit={text(cfg.fit) === "contain" ? "contain" : "cover"}
autoplay={Boolean(cfg.autoplay)}
label={widget.title}
/> />
) )
} }
/**
* The tile's body, for anywhere a message's media is shown.
*
* Frames are asked for only while the tile is on screen, in a tab being
* looked at: a camera is only sent while somebody watches it, and a tile
* scrolled away or behind another tab is nobody. A clip keeps playing either
* way.
*/
export function MediaView({
message,
stream = "",
dtype = "",
fit = "cover",
autoplay = false,
label,
}: {
message: string
stream?: string
dtype?: string
fit?: "cover" | "contain"
autoplay?: boolean
label?: string
}) {
const box = useRef<HTMLDivElement>(null)
const shown = useOnScreen(box)
const live = useBoundValue(message || undefined)
const value = live?.value
const ref = isRef(value) ? value : null
const kind = (ref?.media_type ?? dtype).split("/")[0]
const playing = kind === "audio" || kind === "video"
const active = shown || playing
const url = useArtifactUrl(
active ? ref : null,
active ? message || undefined : undefined,
)
const objectFit = fit === "contain" ? "object-contain" : "object-cover"
const alt = label || ref?.name || message
return (
<div
ref={box}
className="flex min-h-0 w-full flex-1 flex-col justify-center"
>
{body()}
</div>
)
function body() {
// A camera serving its own stream is played from source: the engine
// carries references at whatever rate the flow publishes them, which is
// not video.
if (stream && kind !== "audio") {
return (
<img
src={stream}
alt={alt}
className={cn("h-full w-full rounded-md", objectFit)}
/>
)
}
if (!message && !stream) {
return <p className="text-muted-foreground">Pick a message.</p>
}
if (!ref) {
return <p className="text-muted-foreground">Nothing published yet.</p>
}
if (!url) {
return <p className="text-muted-foreground">Loading…</p>
}
if (kind === "audio") {
return (
<audio
// Keyed on the digest so a new clip replaces the element rather than
// leaving the last one's playhead on it.
key={ref.digest}
src={url}
controls
autoPlay={autoplay}
className="w-full"
>
<track kind="captions" />
</audio>
)
}
if (kind === "video") {
return (
<video
key={ref.digest}
src={url}
controls
autoPlay={autoplay}
className={cn("h-full w-full rounded-md", objectFit)}
>
<track kind="captions" />
</video>
)
}
return (
<img
src={url}
alt={alt}
className={cn("h-full w-full rounded-md", objectFit)}
/>
)
}
}
@@ -19,6 +19,7 @@ import {
FlowsService, FlowsService,
} from "@/client" } from "@/client"
import { initials, resolveIcon } from "@/components/Dashboard/icons" import { initials, resolveIcon } from "@/components/Dashboard/icons"
import { MediaView } from "@/components/Dashboard/MediaWidget"
import { dashboardsQueryOptions } from "@/components/Dashboard/queries" import { dashboardsQueryOptions } from "@/components/Dashboard/queries"
import { flowsQueryOptions } from "@/components/Flow/queries" import { flowsQueryOptions } from "@/components/Flow/queries"
import { InfoTip, PanelSection } from "@/components/Flow/SidePanel" import { InfoTip, PanelSection } from "@/components/Flow/SidePanel"
@@ -139,6 +140,7 @@ export function DeviceDetail({ id }: { id: string }) {
<section className={cn(CARD, "grid gap-4")}> <section className={cn(CARD, "grid gap-4")}>
<Basics device={device} canEdit={canEdit} onChange={write} /> <Basics device={device} canEdit={canEdit} onChange={write} />
</section> </section>
<Camera device={device} />
<section className={CARD}> <section className={CARD}>
<Dashboards device={device} canEdit={canEdit} onChange={write} /> <Dashboards device={device} canEdit={canEdit} onChange={write} />
</section> </section>
@@ -216,6 +218,38 @@ function Basics({
) )
} }
/**
* What the device's camera sees, once a flow wires its `camera` port.
*
* Watching is what turns the camera on: it sends frames only while this
* preview, a tile or a flow reading them wants them.
*/
function Camera({ device }: { device: DevicePublic }) {
const bound = (device.bindings ?? []).find(
(binding) => binding.port === "camera" && binding.direction === "in",
)
if (!bound) return null
return (
<section className={CARD}>
<PanelSection
title="Camera"
help="Live while this preview is on screen. The camera sends frames only while someone watches them here or on a dashboard, or a running flow reads them."
>
<div
className="flex aspect-video w-full overflow-hidden rounded-md bg-muted text-center text-sm"
data-testid="device-camera"
>
<MediaView
message={bound.message}
fit="contain"
label={`${device.title || device.id} camera`}
/>
</div>
</PanelSection>
</section>
)
}
/** Which dashboards the device shows, in the order its rail carries them. */ /** Which dashboards the device shows, in the order its rail carries them. */
function Dashboards({ function Dashboards({
device, device,
@@ -511,6 +511,19 @@ function FlowEditorInner({
} }
}, [key]) }, [key])
// What the flow's nodes read, for a device node to say that a camera read
// here sends all the time.
const readers = useMemo(() => {
const found = new Set<string>()
for (const node of definitions) {
if (node.type === DEVICE_TYPE) continue
for (const spec of node.requires ?? []) {
if (spec.name) found.add(qualify(flowName, spec.name))
}
}
return found
}, [definitions, flowName])
/** /**
* Where clicking an endpoint takes you: the thing it stands for. * Where clicking an endpoint takes you: the thing it stands for.
* *
@@ -1508,6 +1521,7 @@ function FlowEditorInner({
nodeTypes={nodeTypeInfo ?? []} nodeTypes={nodeTypeInfo ?? []}
origin={flowDoc.origin} origin={flowDoc.origin}
suggestions={suggestions} suggestions={suggestions}
readers={readers}
expanded={editorExpanded} expanded={editorExpanded}
onToggleExpand={() => setEditorExpanded((wide) => !wide)} onToggleExpand={() => setEditorExpanded((wide) => !wide)}
onChange={updateNode} onChange={updateNode}
@@ -56,6 +56,7 @@ import useAuth from "@/hooks/useAuth"
import useCustomToast from "@/hooks/useCustomToast" import useCustomToast from "@/hooks/useCustomToast"
import { inCodeEditor, useShortcuts } from "@/lib/shortcuts" import { inCodeEditor, useShortcuts } from "@/lib/shortcuts"
import { cn } from "@/lib/utils" import { cn } from "@/lib/utils"
import { qualify } from "./deriveEdges"
import { DtypeValue } from "./FlowBoundary" import { DtypeValue } from "./FlowBoundary"
import { import {
IDENTIFIER, IDENTIFIER,
@@ -508,11 +509,14 @@ function DeviceSettings({
node, node,
flow, flow,
suggestions, suggestions,
readers,
onChange, onChange,
}: { }: {
node: NodeDef_Input node: NodeDef_Input
flow: string flow: string
suggestions: PortSuggestions suggestions: PortSuggestions
/** Qualified messages another node of this flow reads. */
readers: ReadonlySet<string>
onChange: (next: NodeDef_Input) => void onChange: (next: NodeDef_Input) => void
}) { }) {
const { data } = useQuery(devicesQueryOptions()) const { data } = useQuery(devicesQueryOptions())
@@ -591,6 +595,7 @@ function DeviceSettings({
flow={flow} flow={flow}
config={config} config={config}
reported={reported} reported={reported}
readers={readers}
suggestions={suggestions.provides} suggestions={suggestions.provides}
onChange={ports("provides")} onChange={ports("provides")}
onConfig={setConfig} onConfig={setConfig}
@@ -619,6 +624,7 @@ function DevicePortList({
flow, flow,
config, config,
reported, reported,
readers,
suggestions, suggestions,
onChange, onChange,
onConfig, onConfig,
@@ -632,6 +638,8 @@ function DevicePortList({
config: Record<string, unknown> config: Record<string, unknown>
/** What the device says it has, or null when it has not said. */ /** What the device says it has, or null when it has not said. */
reported: ReportedPort[] | null reported: ReportedPort[] | null
/** Qualified messages another node of this flow reads. */
readers?: ReadonlySet<string>
suggestions: string[] suggestions: string[]
/** `renamed` is a port taking another name, or dropped (`to` of null). */ /** `renamed` is a port taking another name, or dropped (`to` of null). */
onChange: (next: MessageSpec[], renamed?: [string, string | null]) => void onChange: (next: MessageSpec[], renamed?: [string, string | null]) => void
@@ -809,6 +817,18 @@ function DevicePortList({
The device does not report this port. The device does not report this port.
</p> </p>
) : null} ) : null}
{said?.on_demand &&
spec.name &&
readers?.has(qualify(flow, spec.name)) ? (
<p
className="pl-5.5 text-xs text-status-warning"
data-testid="device-port-always-on"
>
A node in this flow reads every frame, so {port} sends all the
time, also while nobody watches. Read snapshot or person
instead.
</p>
) : null}
{schema ? ( {schema ? (
<div className="pl-5.5"> <div className="pl-5.5">
<ParamsForm <ParamsForm
@@ -1771,6 +1791,7 @@ function PanelBody({
nodeType, nodeType,
origin, origin,
suggestions, suggestions,
readers,
expanded, expanded,
onChange, onChange,
onRenameMessage, onRenameMessage,
@@ -1783,6 +1804,7 @@ function PanelBody({
nodeType: NodeTypeInfo | undefined nodeType: NodeTypeInfo | undefined
origin: FlowOrigin | null | undefined origin: FlowOrigin | null | undefined
suggestions: PortSuggestions suggestions: PortSuggestions
readers: ReadonlySet<string>
expanded: boolean expanded: boolean
onChange: (next: NodeDef_Input) => void onChange: (next: NodeDef_Input) => void
onRenameMessage: (previous: string, next: string) => void onRenameMessage: (previous: string, next: string) => void
@@ -1954,6 +1976,7 @@ function PanelBody({
node={node} node={node}
flow={flow} flow={flow}
suggestions={suggestions} suggestions={suggestions}
readers={readers}
onChange={editNode} onChange={editNode}
/> />
) : ( ) : (
@@ -2133,6 +2156,7 @@ export function NodePanel({
nodeTypes, nodeTypes,
origin, origin,
suggestions, suggestions,
readers,
expanded, expanded,
onChange, onChange,
onRenameMessage, onRenameMessage,
@@ -2148,6 +2172,8 @@ export function NodePanel({
/** Set when the flow was declared in code elsewhere; its bodies are generated. */ /** Set when the flow was declared in code elsewhere; its bodies are generated. */
origin: FlowOrigin | null | undefined origin: FlowOrigin | null | undefined
suggestions: PortSuggestions suggestions: PortSuggestions
/** Qualified messages the flow's nodes read, a device node's aside. */
readers: ReadonlySet<string>
expanded: boolean expanded: boolean
onChange: (next: NodeDef_Input) => void onChange: (next: NodeDef_Input) => void
onRenameMessage: (previous: string, next: string) => void onRenameMessage: (previous: string, next: string) => void
@@ -2201,6 +2227,7 @@ export function NodePanel({
nodeType={nodeType} nodeType={nodeType}
origin={origin} origin={origin}
suggestions={suggestions} suggestions={suggestions}
readers={readers}
expanded={expanded} expanded={expanded}
onChange={onChange} onChange={onChange}
onRenameMessage={onRenameMessage} onRenameMessage={onRenameMessage}
+47
View File
@@ -0,0 +1,47 @@
import {
type RefObject,
useEffect,
useState,
useSyncExternalStore,
} from "react"
function subscribeVisibility(listener: () => void) {
document.addEventListener("visibilitychange", listener)
return () => document.removeEventListener("visibilitychange", listener)
}
/** Whether the tab is the one being looked at. */
export function usePageVisible(): boolean {
return useSyncExternalStore(
subscribeVisibility,
() => document.visibilityState === "visible",
() => true,
)
}
/**
* Whether an element is on screen: inside the viewport, in a tab that is
* being looked at.
*
* Off until the observer first says otherwise, so a tile below the fold never
* asks for anything on its way to being found out of view.
*/
export function useOnScreen(ref: RefObject<Element | null>): boolean {
const page = usePageVisible()
const [inView, setInView] = useState(
() => typeof IntersectionObserver === "undefined",
)
useEffect(() => {
const element = ref.current
if (!element || typeof IntersectionObserver === "undefined") return
const observer = new IntersectionObserver((entries) => {
const last = entries[entries.length - 1]
if (last) setInView(last.isIntersecting)
})
observer.observe(element)
return () => observer.disconnect()
}, [ref])
return page && inView
}