Files
tsumugu/backend/app/media/port.py
T
LarsandCursor 7e39fbb2bd
Deploy Development / deploy (push) Successful in 41s
Test Suite / pytest-backend (push) Failing after 2m55s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 23s
Mache große IMAP-Fächer, die Paperless-Suche und die interne Markdown-Notiz über die gemeinsamen Schnittstellen benutzbar.
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-10-20 07:34:14 +02:00

296 lines
9.1 KiB
Python

"""Opaque storage port. The adapter stores bytes and does not decide who may read them.
Cleartext for a reader goes through require_cleartext. Locked profiles stay
bytes on disk and are not decrypted here. No new cryptography is implemented.
"""
from __future__ import annotations
import hashlib
from pathlib import Path
from uuid import UUID
from app.core.errors import Problem, storage_unavailable, unprocessable
from app.media.storage import read_bytes, sha256, write_bytes
LEGACY_GENERATION = "legacy-local-1"
LEGACY_PROFILE = "legacy-plaintext"
LOCKED_PROFILES = frozenset({"managed-encrypted", "client-encrypted"})
PROFILES = frozenset({LEGACY_PROFILE, *LOCKED_PROFILES})
def require_cleartext(profile: str | None) -> None:
name = profile or LEGACY_PROFILE
if name == LEGACY_PROFILE:
return
if name in LOCKED_PROFILES:
raise Problem(
422,
"Geschützter Inhalt",
"Dieser Inhalt ist geschützt. Ein Klartextabruf ist in dieser Lieferung nicht möglich.",
"unsupported",
)
raise Problem(
422,
"Nicht unterstützt",
"Dieses Schutzprofil wird nicht unterstützt.",
"unsupported",
)
def check_object_key(object_key: str) -> str:
key = (object_key or "").replace("\\", "/").strip()
parts = key.split("/")
if not key or key.startswith("/") or any(part in {"", ".", ".."} for part in parts):
raise unprocessable("Ungültiger Speicherpfad.")
try:
if len(parts) == 1:
UUID(parts[0])
elif len(parts) == 2 and parts[0] == "dispatch":
UUID(parts[1])
else:
raise ValueError
except ValueError:
raise unprocessable("Ungültiger Speicherpfad.") from None
return key
def object_path(root: Path, object_key: str) -> Path:
key = check_object_key(object_key)
base = Path(root).resolve()
base.mkdir(parents=True, exist_ok=True)
target = (base / key).resolve()
if base != target and base not in target.parents:
raise unprocessable("Ungültiger Speicherpfad.")
return target
class LocalAdapter:
"""Files stay under one recorded root. A client path is not an address."""
def __init__(self, root: str | Path) -> None:
self.root = Path(root)
def put(self, object_key: str, data: bytes) -> None:
path = object_path(self.root, object_key)
path.parent.mkdir(parents=True, exist_ok=True)
write_bytes(path, data)
def open(self, object_key: str) -> bytes:
return read_bytes(object_path(self.root, object_key))
def delete(self, object_key: str) -> None:
path = object_path(self.root, object_key)
try:
path.unlink(missing_ok=True)
except OSError as exc:
raise storage_unavailable() from exc
def describe(self, object_key: str) -> dict:
path = object_path(self.root, object_key)
try:
if not path.is_file():
raise storage_unavailable()
return {"byte_size": path.stat().st_size, "object_key": object_key}
except OSError as exc:
raise storage_unavailable() from exc
class MemoryAdapter:
"""In-memory stand-in for the same port. It is not a second product store."""
def __init__(self) -> None:
self._items: dict[str, bytes] = {}
self.fail_put = False
def put(self, object_key: str, data: bytes) -> None:
if self.fail_put:
raise storage_unavailable()
key = check_object_key(object_key)
self._items[key] = bytes(data)
def open(self, object_key: str) -> bytes:
key = check_object_key(object_key)
try:
return self._items[key]
except KeyError as exc:
raise storage_unavailable() from exc
def delete(self, object_key: str) -> None:
key = check_object_key(object_key)
self._items.pop(key, None)
def describe(self, object_key: str) -> dict:
data = self.open(object_key)
return {"byte_size": len(data), "object_key": object_key}
def publish(adapter, object_key: str, data: bytes) -> None:
"""Make bytes readable only after a checked roundtrip. A failed put leaves nothing published."""
adapter.put(object_key, data)
try:
opened = adapter.open(object_key)
except Problem:
adapter.delete(object_key)
raise
if opened != data:
adapter.delete(object_key)
raise storage_unavailable()
def ensure_legacy_instance(conn, media_root: str) -> dict:
"""Bind the legacy generation to the current root once. Later roots do not retarget it."""
root = str(Path(media_root).resolve())
conn.execute(
"""
INSERT INTO storage_instances (kind, generation, root_path)
VALUES ('local', %s, %s)
ON CONFLICT (generation) DO NOTHING
""",
(LEGACY_GENERATION, root),
)
conn.execute(
"""
UPDATE storage_instances
SET root_path = %s
WHERE generation = %s AND root_path IS NULL
""",
(root, LEGACY_GENERATION),
)
row = conn.execute(
"""
SELECT id, kind, generation, root_path
FROM storage_instances
WHERE generation = %s
""",
(LEGACY_GENERATION,),
).fetchone()
conn.execute(
"""
UPDATE media_assets
SET storage_instance_id = %s
WHERE storage_generation = %s AND storage_instance_id IS NULL
""",
(row["id"], LEGACY_GENERATION),
)
conn.execute(
"""
UPDATE dispatch_snapshots
SET storage_instance_id = %s
WHERE storage_generation = %s AND storage_instance_id IS NULL
""",
(row["id"], LEGACY_GENERATION),
)
return row
def instance_for_write(conn, media_root: str) -> dict:
legacy = ensure_legacy_instance(conn, media_root)
root = str(Path(media_root).resolve())
if legacy["root_path"] == root:
return legacy
generation = "local-" + hashlib.sha256(root.encode("utf-8")).hexdigest()[:16]
conn.execute(
"""
INSERT INTO storage_instances (kind, generation, root_path)
VALUES ('local', %s, %s)
ON CONFLICT (generation) DO NOTHING
""",
(generation, root),
)
return conn.execute(
"""
SELECT id, kind, generation, root_path
FROM storage_instances
WHERE generation = %s
""",
(generation,),
).fetchone()
class StoredHandle:
"""Rollback and delete go through the adapter that owns the bytes."""
def __init__(self, adapter: StoragePort, object_key: str):
self._adapter = adapter
self._key = object_key
def discard(self) -> None:
self._adapter.delete(self._key)
_FACTORIES: dict[str, callable] = {}
def _local_factory(row: dict) -> StoragePort:
return LocalAdapter(row["root_path"])
_FACTORIES["local"] = _local_factory
def adapter_for(row: dict) -> StoragePort:
factory = _FACTORIES.get(row["kind"])
if factory is None or not row.get("root_path") and row["kind"] == "local":
raise storage_unavailable()
return factory(row)
def removal_for(conn, instance_id, generation: str | None, object_key: str, media_root: str) -> StoredHandle:
row = None
if instance_id is not None:
row = conn.execute(
"SELECT id, kind, generation, root_path FROM storage_instances WHERE id = %s",
(instance_id,),
).fetchone()
if row is None:
root = resolve_root(conn, instance_id, generation, media_root)
return StoredHandle(LocalAdapter(root), object_key)
return StoredHandle(adapter_for(row), object_key)
def resolve_root(conn, instance_id, generation: str | None, media_root: str) -> str:
if instance_id is not None:
row = conn.execute(
"SELECT root_path FROM storage_instances WHERE id = %s",
(instance_id,),
).fetchone()
if row is not None and row["root_path"]:
return row["root_path"]
if generation in {None, LEGACY_GENERATION}:
return ensure_legacy_instance(conn, media_root)["root_path"]
return str(Path(media_root).resolve())
def stored_path(conn, instance_id, generation: str | None, object_key: str, media_root: str) -> Path:
return object_path(Path(resolve_root(conn, instance_id, generation, media_root)), object_key)
def read_clear_bytes(
conn,
*,
instance_id,
generation: str | None,
object_key: str,
media_root: str,
protection_profile: str | None,
expected_sha256: str | None,
) -> bytes:
require_cleartext(protection_profile)
row = None
if instance_id is not None:
row = conn.execute(
"SELECT id, kind, generation, root_path FROM storage_instances WHERE id = %s",
(instance_id,),
).fetchone()
adapter = adapter_for(row) if row is not None else LocalAdapter(resolve_root(conn, instance_id, generation, media_root))
data = adapter.open(object_key)
if expected_sha256 and sha256(data) != expected_sha256:
raise Problem(
422,
"Inhalt nicht geprüft",
"Die gespeicherte Datei stimmt nicht mit dem erfassten Stand überein.",
"processing",
)
return data