| """Generated, site-bound backend integration seam.""" |
|
|
| from __future__ import annotations |
|
|
| import importlib |
| import json |
| import os |
| import secrets |
| import sqlite3 |
| from pathlib import Path |
| from typing import Any, Callable |
|
|
| from websitebench.local_clone_auth import ( |
| MAIL_LOCAL_ONLY, |
| MAIL_SMTP_PENDING, |
| LocalAuthStore, |
| ) |
| from websitebench.site_backend import SiteBackend, load_runtime |
|
|
|
|
| DEFAULT_RUNTIME_PATH = ( |
| Path(__file__).resolve().parents[2] / "backend" / "runtime.json" |
| ) |
| DEFAULT_DEPLOYMENT_PROFILE = "offline-harbor" |
| _AUTH_MAIL_WORKER_TOKEN = secrets.token_urlsafe(32) |
|
|
|
|
| def auth_mail_worker_token() -> str: |
| """Return process-local mail-worker authority without persisting it.""" |
|
|
| return _AUTH_MAIL_WORKER_TOKEN |
|
|
|
|
| def _declared_hook( |
| declaration: str | None, |
| ) -> Callable[[sqlite3.Connection], None] | None: |
| if declaration is None: |
| return None |
| module_name, function_name = declaration.split(":", 1) |
| module = importlib.import_module(module_name) |
| hook: Any = getattr(module, function_name, None) |
| if not callable(hook): |
| raise RuntimeError(f"declared backend hook is not callable: {declaration}") |
| actual = f"{hook.__module__}:{hook.__name__}" |
| if actual != declaration: |
| raise RuntimeError( |
| f"declared backend hook resolved as {actual!r}, expected {declaration!r}" |
| ) |
| return hook |
|
|
|
|
| def resolve_runtime_path() -> Path: |
| return Path( |
| os.environ.get( |
| "WEBSITEBENCH_SITE_BACKEND_RUNTIME", |
| str(DEFAULT_RUNTIME_PATH), |
| ) |
| ).absolute() |
|
|
|
|
| def open_site_services( |
| *, |
| database_path: Path | None = None, |
| auth_now: Callable[[], int] | None = None, |
| mail_worker_token: str | None = None, |
| ) -> tuple[SiteBackend, LocalAuthStore]: |
| """Open one bound database; never omit the site id for permanent auth.""" |
|
|
| runtime_path = resolve_runtime_path() |
| runtime = load_runtime(runtime_path) |
| profile_name = os.environ.get( |
| "WEBSITEBENCH_BACKEND_PROFILE", DEFAULT_DEPLOYMENT_PROFILE |
| ).strip() or DEFAULT_DEPLOYMENT_PROFILE |
| profile = runtime.deployment["profiles"].get(profile_name) |
| if profile is None: |
| raise RuntimeError("IMDb backend profile is not declared") |
| if profile["payment_adapter"] != "local-sandbox": |
| raise RuntimeError("IMDb has no enabled payment capability") |
| benchmark_mailbox = bool( |
| os.environ.get("WEBSITEBENCH_MAILBOX_BOOTSTRAP_URL", "").strip() |
| ) |
| mail_mode = ( |
| MAIL_SMTP_PENDING |
| if benchmark_mailbox or profile["mail_adapter"] != "local-outbox" |
| else MAIL_LOCAL_ONLY |
| ) |
| selected_mail_worker_token = ( |
| (mail_worker_token or _AUTH_MAIL_WORKER_TOKEN) |
| if mail_mode == MAIL_SMTP_PENDING |
| else None |
| ) |
| migration_hook = _declared_hook(runtime.migration_hook) |
| seed_hook = _declared_hook(runtime.seed_hook) |
| deployed_database = os.environ.get( |
| "WEBSITEBENCH_SITE_BACKEND_DATABASE", |
| ) |
| selected_database = ( |
| Path(deployed_database).resolve() |
| if deployed_database is not None |
| else database_path.resolve() |
| if database_path is not None |
| else None |
| ) |
| if selected_database is None: |
| backend = SiteBackend.open( |
| runtime_path, |
| migration_hook=migration_hook, |
| seed_hook=seed_hook, |
| ) |
| else: |
| if selected_database.name != runtime.database_filename: |
| raise RuntimeError( |
| "deployed database filename does not match runtime contract" |
| ) |
| backend = SiteBackend.open( |
| json.loads(runtime_path.read_text(encoding="utf-8")), |
| data_root=selected_database.parent, |
| migration_hook=migration_hook, |
| seed_hook=seed_hook, |
| ) |
| if backend.lifecycle.database_path != selected_database: |
| raise RuntimeError( |
| "deployed database path does not match backend preflight" |
| ) |
| backend.lifecycle.initialize() |
| |
| |
| |
| |
| if migration_hook is not None: |
| with sqlite3.connect(backend.lifecycle.database_path, timeout=30) as connection: |
| connection.row_factory = sqlite3.Row |
| connection.execute("PRAGMA foreign_keys=ON") |
| connection.execute("PRAGMA busy_timeout=30000") |
| migration_hook(connection) |
| auth_options: dict[str, Any] = { |
| "site_id": backend.config.site_id, |
| "mail_mode": mail_mode, |
| "mail_worker_token": selected_mail_worker_token, |
| } |
| if auth_now is not None: |
| auth_options["now"] = auth_now |
| auth = LocalAuthStore( |
| backend.lifecycle.database_path, |
| **auth_options, |
| ) |
| auth.ensure_schema() |
| backend.deployment_profile_name = profile_name |
| backend.deployment_profile = dict(profile) |
| return backend, auth |
|
|
