| """Generated, site-bound backend integration seam.""" |
|
|
| from __future__ import annotations |
|
|
| import importlib |
| import json |
| import os |
| import sqlite3 |
| from contextlib import closing |
| from pathlib import Path |
| from typing import Any, Callable |
|
|
| from websitebench.local_clone_auth import LocalAuthStore |
| from websitebench.site_backend import SiteBackend, SiteBindingError, load_runtime |
| from websitebench.site_backend.copy_cutover import ( |
| CopyCutoverError, |
| publish_transformed_sqlite_copy, |
| ) |
| from websitebench.site_backend.database import BASE_SCHEMA, utc_now |
|
|
|
|
| DEFAULT_RUNTIME_PATH = Path(__file__).resolve().parents[2] / "backend" / "runtime.json" |
| LEGACY_DATABASE_FILENAME = "etsy.sqlite3" |
| CANONICAL_DATABASE_FILENAME = "websitebench-etsy.sqlite3" |
| LEGACY_BACKUP_SUFFIX = ".etsy-unbound-legacy" |
|
|
|
|
| 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 _legacy_etsy_prefix_connection(connection: sqlite3.Connection) -> None: |
| """Verify Etsy's own ordered business migrations before copy binding.""" |
|
|
| tables = { |
| str(row[0]) |
| for row in connection.execute( |
| "SELECT name FROM sqlite_master WHERE type='table'" |
| ) |
| } |
| if "websitebench_site_binding" in tables: |
| raise SiteBindingError("legacy Etsy source is already site-bound") |
| if "clawbench_site_binding" in tables: |
| raise SiteBindingError("Etsy database uses the other runtime namespace") |
| if not {"schema_migrations", "listings", "accounts"}.issubset(tables): |
| raise SiteBindingError( |
| "unbound database does not match the Etsy business schema" |
| ) |
| rows = connection.execute( |
| "SELECT version,name FROM schema_migrations ORDER BY version" |
| ).fetchall() |
| from backend.db import MIGRATIONS |
|
|
| expected = [(version, name) for version, name, _action in MIGRATIONS] |
| actual = [(str(row[0]), str(row[1])) for row in rows] |
| if not actual or actual != expected[: len(actual)]: |
| raise SiteBindingError("unbound database has an invalid Etsy migration prefix") |
|
|
|
|
| def _bind_legacy_etsy_copy( |
| source: Path, |
| canonical: Path, |
| *, |
| site_id: str, |
| ) -> bool: |
| if not source.exists(): |
| return False |
|
|
| def transform(database: Path) -> None: |
| with closing(sqlite3.connect(database, isolation_level=None)) as connection: |
| connection.execute("PRAGMA foreign_keys=ON") |
| connection.executescript(BASE_SCHEMA) |
| connection.execute("BEGIN IMMEDIATE") |
| try: |
| connection.execute( |
| "INSERT INTO websitebench_site_binding" |
| "(singleton,site_id,bound_at) VALUES (1,?,?)", |
| (site_id, utc_now()), |
| ) |
| connection.execute( |
| "INSERT OR IGNORE INTO websitebench_backend_migrations" |
| "(migration_id,applied_at) VALUES ('site-backend-v1',?)", |
| (utc_now(),), |
| ) |
| if connection.execute("PRAGMA foreign_key_check").fetchall(): |
| raise SiteBindingError("Etsy copy has foreign-key violations") |
| connection.execute("COMMIT") |
| except BaseException: |
| if connection.in_transaction: |
| connection.execute("ROLLBACK") |
| raise |
|
|
| def validate_canonical(database: Path) -> None: |
| with closing(sqlite3.connect(database)) as connection: |
| binding = connection.execute( |
| "SELECT singleton,site_id FROM websitebench_site_binding" |
| ).fetchall() |
| integrity = connection.execute("PRAGMA integrity_check").fetchall() |
| foreign_keys = connection.execute("PRAGMA foreign_key_check").fetchall() |
| if binding != [(1, site_id)] or integrity != [("ok",)] or foreign_keys: |
| raise SiteBindingError("Etsy copy failed integrity validation") |
|
|
| try: |
| publish_transformed_sqlite_copy( |
| source, |
| canonical, |
| expected_source_name=LEGACY_DATABASE_FILENAME, |
| expected_canonical_name=CANONICAL_DATABASE_FILENAME, |
| transform=transform, |
| validate_source=_legacy_etsy_prefix_connection, |
| validate_canonical=validate_canonical, |
| reserved_paths=(source.with_name(source.name + LEGACY_BACKUP_SUFFIX),), |
| ) |
| except CopyCutoverError as exc: |
| raise SiteBindingError(str(exc)) from exc |
| return True |
|
|
|
|
| def open_site_services( |
| database_path: Path | None = None, |
| ) -> tuple[SiteBackend, LocalAuthStore]: |
| """Open one bound database; never omit the site id for permanent auth. |
| |
| Etsy predates the shared runtime. Its business schema is initialized |
| before this seam is called; the one-time legacy path binds that same file |
| to Etsy and adds the WebsiteBench payment ledger. Every later open fails |
| closed if the database belongs to another site. |
| """ |
|
|
| runtime_path = Path( |
| os.environ.get( |
| "WEBSITEBENCH_SITE_BACKEND_RUNTIME", |
| str(DEFAULT_RUNTIME_PATH), |
| ) |
| ).resolve() |
| runtime = load_runtime(runtime_path) |
| migration_hook = _declared_hook(runtime.migration_hook) |
| seed_hook = _declared_hook(runtime.seed_hook) |
| deployed_database = ( |
| str(database_path.resolve()) |
| if database_path is not None |
| else os.environ.get("WEBSITEBENCH_SITE_BACKEND_DATABASE") |
| ) |
| if deployed_database is None: |
| backend = SiteBackend.open( |
| runtime_path, |
| migration_hook=migration_hook, |
| seed_hook=seed_hook, |
| ) |
| else: |
| database_path = Path(deployed_database).resolve() |
| if database_path.name != runtime.database_filename: |
| raise RuntimeError( |
| "deployed database filename does not match runtime contract" |
| ) |
| legacy_database = database_path.with_name(LEGACY_DATABASE_FILENAME) |
| if not database_path.exists() and legacy_database.exists(): |
| _bind_legacy_etsy_copy( |
| legacy_database, |
| database_path, |
| site_id=runtime.site_id, |
| ) |
| backend = SiteBackend.open( |
| json.loads(runtime_path.read_text(encoding="utf-8")), |
| data_root=database_path.parent, |
| migration_hook=migration_hook, |
| seed_hook=seed_hook, |
| ) |
| if backend.lifecycle.database_path != database_path: |
| raise RuntimeError( |
| "deployed database path does not match backend preflight" |
| ) |
| backend.lifecycle.initialize() |
| auth = LocalAuthStore( |
| backend.lifecycle.database_path, |
| site_id=backend.config.site_id, |
| ) |
| |
| |
| |
| |
| return backend, auth |
|
|
