hosted_room_links.py 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151
  1. """Private SQLite storage for negotiated hosted-room links.
  2. Route metadata and its scoped grant share the gateway's private root ``state.db``. SQLite WAL plus
  3. ``BEGIN IMMEDIATE`` owns concurrency; grants are never included in reprs, status payloads, or exception messages.
  4. """
  5. from __future__ import annotations
  6. import contextlib
  7. import json
  8. import os
  9. import time
  10. from dataclasses import dataclass, field
  11. from functools import partial
  12. from pathlib import Path
  13. from typing import Any, Mapping
  14. from gateway import hosted_rooms
  15. from gateway.hosted_room_peer import (
  16. GatewayRoomCatalog, HostedRoomPeerError, TransportSecurity, validate_room_link_url)
  17. from gateway.hosted_rooms_common import DbPath, compact_json, exact_fields, identifier
  18. MAX_LINKS = 512
  19. MAX_GRANT_CHARS = 16 * 1024
  20. _LEGACY_FIELDS = {
  21. "room_id", "member_id", "target_url", "target_profile", "grant", "catalog", "cancellation_scope_id", "trace_id",
  22. "updated_at"}
  23. _OPTIONAL_FIELDS = {"transport_security", "status"}
  24. # SQLite record columns that map 1:1 onto mapping fields, in record order
  25. # (``catalog_json`` is the serialized ``catalog``).
  26. _RECORD_FIELDS = (
  27. "room_id", "member_id", "target_url", "target_profile", "grant", "cancellation_scope_id", "trace_id",
  28. "transport_security", "status", "updated_at")
  29. _STATUSES = {"ready", "unavailable", "needs_reauthorization"}
  30. @dataclass(frozen=True)
  31. class StoredRoomLink:
  32. room_id: str
  33. member_id: str
  34. target_url: str
  35. target_profile: str
  36. grant: str = field(repr=False)
  37. catalog: GatewayRoomCatalog
  38. cancellation_scope_id: str
  39. trace_id: str
  40. transport_security: TransportSecurity
  41. status: str
  42. updated_at: float
  43. @classmethod
  44. def from_mapping(cls, value: Mapping[str, Any]) -> StoredRoomLink:
  45. _link_fields(value)
  46. room_id = _short_string(value["room_id"], "room_id")
  47. member_id = _short_string(value["member_id"], "member_id")
  48. target_profile = _short_string(value["target_profile"], "target_profile")
  49. target_url, detected_security = validate_room_link_url(value["target_url"])
  50. transport_security = str(value.get("transport_security") or detected_security)
  51. if transport_security != detected_security:
  52. raise HostedRoomPeerError("transport_security does not match target_url")
  53. grant = str(value["grant"] or "")
  54. if not grant or len(grant) > MAX_GRANT_CHARS:
  55. raise HostedRoomPeerError("room grant is missing or too large")
  56. status = str(value.get("status") or "ready")
  57. if status not in _STATUSES:
  58. raise HostedRoomPeerError("stored room link status is invalid")
  59. updated_at = float(value["updated_at"])
  60. if not updated_at > 0:
  61. raise HostedRoomPeerError("updated_at must be positive")
  62. return cls(
  63. room_id=room_id, member_id=member_id, target_url=target_url, target_profile=target_profile,
  64. grant=grant, catalog=GatewayRoomCatalog.from_mapping(value["catalog"]),
  65. cancellation_scope_id=_short_string(value["cancellation_scope_id"], "cancellation_scope_id"),
  66. trace_id=_short_string(value["trace_id"], "trace_id"), transport_security=transport_security,
  67. status=status, updated_at=updated_at)
  68. @classmethod
  69. def from_record(cls, value: Mapping[str, Any]) -> StoredRoomLink:
  70. try:
  71. catalog = json.loads(str(value["catalog_json"]))
  72. except Exception as exc:
  73. raise HostedRoomPeerError("stored room link catalog is unreadable") from exc
  74. return cls.from_mapping({**{name: value[name] for name in _RECORD_FIELDS}, "catalog": catalog})
  75. def catalog_mapping(self) -> dict[str, Any]:
  76. return self.catalog.as_mapping()
  77. def as_record(self) -> dict[str, Any]:
  78. record = {name: getattr(self, name) for name in _RECORD_FIELDS}
  79. record["catalog_json"] = compact_json(self.catalog_mapping(), ensure_ascii=False)
  80. return record
  81. _link_fields = partial(
  82. exact_fields, label="stored room link", required=_LEGACY_FIELDS, optional=_OPTIONAL_FIELDS,
  83. error=HostedRoomPeerError, not_object="stored room link fields are invalid",
  84. missing_fmt="stored room link fields are invalid", unknown_fmt="stored room link fields are invalid")
  85. def _short_string(value: Any, field: str) -> str:
  86. return identifier(
  87. str(value or ""), label=field, error=HostedRoomPeerError, max_chars=256, pattern=None,
  88. invalid=f"{field} is invalid")
  89. def _link_rows(db_path: DbPath) -> list[dict[str, Any]]:
  90. rows = hosted_rooms.list_room_link_records(db_path)
  91. if len(rows) > MAX_LINKS:
  92. raise HostedRoomPeerError("stored room link list is invalid")
  93. return rows
  94. def load_room_links(db_path: DbPath) -> tuple[StoredRoomLink, ...]:
  95. return tuple(StoredRoomLink.from_record(row) for row in _link_rows(db_path))
  96. def load_room_links_tolerant(db_path: DbPath) -> tuple[tuple[StoredRoomLink, ...], tuple[str, ...]]:
  97. """Load healthy routes while quarantining malformed rows by identity."""
  98. links, errors = [], []
  99. for row in _link_rows(db_path):
  100. try:
  101. links.append(StoredRoomLink.from_record(row))
  102. except Exception:
  103. errors.append(f"{row.get('room_id') or 'unknown'}:{row.get('member_id') or 'unknown'}:invalid")
  104. return tuple(links), tuple(errors)
  105. def save_room_link(db_path: DbPath, link: StoredRoomLink) -> None:
  106. hosted_rooms.upsert_room_link_record(db_path, record=link.as_record(), max_links=MAX_LINKS)
  107. if os.name == "posix":
  108. with contextlib.suppress(OSError):
  109. Path(db_path).chmod(0o600)
  110. def mark_room_link_status(db_path: DbPath, *, room_id: str, member_id: str, status: str) -> bool:
  111. if status not in _STATUSES:
  112. raise HostedRoomPeerError("stored room link status is invalid")
  113. return hosted_rooms.update_room_link_status(
  114. db_path, room_id=_short_string(room_id, "room_id"), member_id=_short_string(member_id, "member_id"),
  115. status=status)
  116. def make_stored_link(
  117. *, room_id: str, member_id: str, target_url: str, target_profile: str, grant: str, catalog: GatewayRoomCatalog,
  118. cancellation_scope_id: str, trace_id: str) -> StoredRoomLink:
  119. target_url, transport_security = validate_room_link_url(target_url)
  120. return StoredRoomLink.from_mapping({
  121. "room_id": room_id, "member_id": member_id, "target_url": target_url, "target_profile": target_profile,
  122. "grant": grant, "catalog": catalog.as_mapping(), "cancellation_scope_id": cancellation_scope_id,
  123. "trace_id": trace_id, "transport_security": transport_security, "status": "ready", "updated_at": time.time()})