@le-space/rootfs 0.1.52 → 0.3.0

package/reference/orbitdb-relay-pinner/rootfs/orbitdb-relay-pinner-describe.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+
+
+ENV_FILE = os.environ.get("ENV_FILE", "/etc/default/orbitdb-relay-pinner")
+METRICS_PORT = int(os.environ.get("METRICS_PORT", "9090"))
+WAIT_TIMEOUT_SECONDS = int(os.environ.get("DESCRIBE_WAIT_TIMEOUT_SECONDS", "240"))
+WAIT_INTERVAL_SECONDS = float(os.environ.get("DESCRIBE_WAIT_INTERVAL_SECONDS", "2"))
+AUTOTLS_EXTRA_WAIT_SECONDS = int(os.environ.get("DESCRIBE_AUTOTLS_EXTRA_WAIT_SECONDS", "120"))
+
+
+def parse_env_file(path: str) -> dict[str, str]:
+    values: dict[str, str] = {}
+    if not os.path.exists(path):
+        return values
+
+    with open(path, encoding="utf-8") as handle:
+        for line in handle:
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#") or "=" not in stripped:
+                continue
+            key, value = stripped.split("=", 1)
+            values[key.strip()] = value.strip()
+    return values
+
+
+def fetch_json(path: str) -> dict:
+    url = f"http://127.0.0.1:{METRICS_PORT}{path}"
+    with urllib.request.urlopen(url, timeout=5) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def dedupe(values: list[str]) -> list[str]:
+    seen: set[str] = set()
+    result: list[str] = []
+    for value in values:
+        if value and value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result
+
+
+def normalize_multiaddrs(payload: dict) -> list[str]:
+    values = payload.get("all")
+    if not isinstance(values, list):
+        return []
+    return [entry for entry in values if isinstance(entry, str) and entry.strip()]
+
+
+def build_grouped_multiaddrs(env_values: dict[str, str], all_multiaddrs: list[str], peer_id: str) -> dict[str, list[str]]:
+    proxy_hostname = env_values.get("PROXY_HOSTNAME", "").strip().lower()
+    direct_tcp_multiaddrs = [addr for addr in all_multiaddrs if "/tcp/" in addr and "/ws" not in addr]
+    autotls_wss_multiaddrs = [
+        addr
+        for addr in all_multiaddrs
+        if addr.endswith("/ws/p2p/" + peer_id) and "/tls/ws" in addr and proxy_hostname not in addr.lower()
+    ]
+    plain_ws_multiaddrs = [
+        addr for addr in all_multiaddrs if addr.endswith("/ws/p2p/" + peer_id) and "/tls/ws" not in addr
+    ]
+    proxy_wss_multiaddrs: list[str] = []
+    if proxy_hostname:
+        proxy_wss_multiaddrs = [
+            f"/dns4/{proxy_hostname}/tcp/443/tls/ws/p2p/{peer_id}",
+            f"/dns6/{proxy_hostname}/tcp/443/tls/ws/p2p/{peer_id}",
+        ]
+    quic_multiaddrs = [addr for addr in all_multiaddrs if "/quic-v1" in addr and "/webtransport" not in addr]
+    webtransport_multiaddrs = [addr for addr in all_multiaddrs if "/webtransport" in addr]
+    webrtc_direct_multiaddrs = [addr for addr in all_multiaddrs if "/webrtc-direct" in addr]
+
+    browser_bootstrap_multiaddrs = dedupe(
+        proxy_wss_multiaddrs
+        + autotls_wss_multiaddrs
+        + plain_ws_multiaddrs
+        + webtransport_multiaddrs
+        + webrtc_direct_multiaddrs
+    )
+    probe_multiaddrs = dedupe(
+        direct_tcp_multiaddrs
+        + proxy_wss_multiaddrs
+        + autotls_wss_multiaddrs
+        + quic_multiaddrs
+        + webtransport_multiaddrs
+    )
+
+    return {
+        "direct_tcp_multiaddrs": dedupe(direct_tcp_multiaddrs),
+        "autotls_wss_multiaddrs": dedupe(autotls_wss_multiaddrs),
+        "proxy_wss_multiaddrs": dedupe(proxy_wss_multiaddrs),
+        "plain_ws_multiaddrs": dedupe(plain_ws_multiaddrs),
+        "quic_multiaddrs": dedupe(quic_multiaddrs),
+        "webtransport_multiaddrs": dedupe(webtransport_multiaddrs),
+        "webrtc_direct_multiaddrs": dedupe(webrtc_direct_multiaddrs),
+        "browser_bootstrap_multiaddrs": browser_bootstrap_multiaddrs,
+        "probe_multiaddrs": probe_multiaddrs,
+    }
+
+
+def main() -> None:
+    started_at = time.monotonic()
+    deadline = started_at + WAIT_TIMEOUT_SECONDS
+    health: dict = {}
+    multiaddrs_payload: dict = {}
+    grouped = {
+        "direct_tcp_multiaddrs": [],
+        "autotls_wss_multiaddrs": [],
+        "proxy_wss_multiaddrs": [],
+        "plain_ws_multiaddrs": [],
+        "quic_multiaddrs": [],
+        "webtransport_multiaddrs": [],
+        "webrtc_direct_multiaddrs": [],
+        "browser_bootstrap_multiaddrs": [],
+        "probe_multiaddrs": [],
+    }
+
+    while time.monotonic() < deadline:
+        try:
+            env_values = parse_env_file(ENV_FILE)
+            health = fetch_json("/health")
+            multiaddrs_payload = fetch_json("/multiaddrs")
+            peer_id = health.get("peerId") or multiaddrs_payload.get("peerId")
+            if not isinstance(peer_id, str) or not peer_id.strip():
+                time.sleep(WAIT_INTERVAL_SECONDS)
+                continue
+
+            all_multiaddrs = normalize_multiaddrs(multiaddrs_payload)
+            grouped = build_grouped_multiaddrs(env_values, all_multiaddrs, peer_id)
+            proxy_hostname = env_values.get("PROXY_HOSTNAME", "").strip()
+            if grouped["autotls_wss_multiaddrs"]:
+                break
+            if proxy_hostname and grouped["proxy_wss_multiaddrs"] and time.monotonic() - started_at >= AUTOTLS_EXTRA_WAIT_SECONDS:
+                break
+            if not proxy_hostname and time.monotonic() - started_at >= AUTOTLS_EXTRA_WAIT_SECONDS:
+                break
+        except (urllib.error.URLError, TimeoutError, json.JSONDecodeError):
+            pass
+
+        time.sleep(WAIT_INTERVAL_SECONDS)
+
+    peer_id = health.get("peerId") or multiaddrs_payload.get("peerId")
+    if not isinstance(peer_id, str) or not peer_id.strip():
+        raise SystemExit("unable to discover orbitdb relay peer ID from metrics endpoints")
+
+    env_values = parse_env_file(ENV_FILE)
+    payload = {
+        "peer_id": peer_id,
+        "announce_addrs": [
+            entry.strip()
+            for entry in env_values.get("VITE_APPEND_ANNOUNCE", "").split(",")
+            if entry.strip()
+        ],
+        "listening_addrs": normalize_multiaddrs(multiaddrs_payload),
+        "auto_tls_serving_zone": health.get("autoTlsServingZone"),
+        "metrics_https": health.get("metricsHttps"),
+        **grouped,
+    }
+    print(json.dumps(payload))
+
+
+if __name__ == "__main__":
+    main()

package/reference/orbitdb-relay-pinner/rootfs/orbitdb-relay-pinner-setup-server.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+import ipaddress
+import json
+import os
+import subprocess
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlsplit
+
+
+ENV_FILE = os.environ.get("ENV_FILE", "/etc/default/orbitdb-relay-pinner")
+READY_FILE = os.environ.get("READY_FILE", "/etc/default/orbitdb-relay-pinner.ready")
+SERVICE_NAME = os.environ.get("SERVICE_NAME", "orbitdb-relay-pinner.service")
+BOOTSTRAP_SERVICE = os.environ.get("BOOTSTRAP_SERVICE", "orbitdb-relay-pinner-bootstrap.service")
+CONFIGURE_SCRIPT = "/usr/local/sbin/orbitdb-relay-pinner-configure.sh"
+DESCRIBE_SCRIPT = "/usr/local/sbin/orbitdb-relay-pinner-describe.py"
+METADATA_FILE = os.environ.get("METADATA_FILE", "/run/orbitdb-relay-pinner-setup-metadata.json")
+METADATA_ERROR_FILE = os.environ.get("METADATA_ERROR_FILE", "/run/orbitdb-relay-pinner-setup-metadata.error")
+
+
+def _cors_headers(handler: BaseHTTPRequestHandler) -> None:
+    handler.send_header("Access-Control-Allow-Origin", "*")
+    handler.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+    handler.send_header("Access-Control-Allow-Headers", "content-type")
+
+
+def _validate_port(value: object, field_name: str) -> str:
+    if not isinstance(value, int) or value < 1 or value > 65535:
+        raise ValueError(f"{field_name} must be an integer TCP/UDP port between 1 and 65535")
+    return str(value)
+
+
+def _validate_proxy_hostname(value: object) -> str | None:
+    if value is None:
+        return None
+
+    if not isinstance(value, str):
+        raise ValueError("proxy_url must be a string when provided")
+
+    candidate = value.strip()
+    if not candidate:
+        return None
+
+    parsed = urlsplit(candidate if "://" in candidate else f"https://{candidate}")
+    if not parsed.hostname:
+        raise ValueError("proxy_url must include a valid hostname")
+
+    return parsed.hostname
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "OrbitdbRelaySetup/1.0"
+
+    def _request_path(self) -> str:
+        return urlsplit(self.path).path
+
+    def _send_json(self, status: int, payload: dict) -> None:
+        body = json.dumps(payload).encode("utf-8")
+        self.send_response(status)
+        _cors_headers(self)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, format: str, *args) -> None:  # noqa: A003
+        return
+
+    def do_OPTIONS(self) -> None:  # noqa: N802
+        self.send_response(204)
+        _cors_headers(self)
+        self.end_headers()
+
+    def do_GET(self) -> None:  # noqa: N802
+        if self._request_path() == "/metadata":
+            self._handle_metadata()
+            return
+
+        if self._request_path() not in ("/", "/health"):
+            self._send_json(404, {"status": "not-found"})
+            return
+
+        self._send_json(
+            200,
+            {
+                "status": "waiting-for-port-mapping",
+                "ready": os.path.exists(READY_FILE),
+                "env_file": ENV_FILE,
+                "metadata_ready": os.path.exists(METADATA_FILE),
+            },
+        )
+
+    def _handle_metadata(self) -> None:
+        if os.path.exists(METADATA_FILE):
+            with open(METADATA_FILE, encoding="utf-8") as handle:
+                metadata = json.load(handle)
+            self._send_json(200, {"status": "ready", "metadata": metadata})
+            threading.Thread(target=self.server.shutdown, daemon=True).start()  # type: ignore[arg-type]
+            threading.Thread(target=_stop_bootstrap_service, daemon=True).start()
+            return
+
+        if os.path.exists(METADATA_ERROR_FILE):
+            with open(METADATA_ERROR_FILE, encoding="utf-8") as handle:
+                error_message = handle.read().strip() or "metadata generation failed"
+            self._send_json(500, {"status": "error", "error": error_message})
+            threading.Thread(target=self.server.shutdown, daemon=True).start()  # type: ignore[arg-type]
+            threading.Thread(target=_stop_bootstrap_service, daemon=True).start()
+            return
+
+        self._send_json(202, {"status": "pending"})
+
+    def do_POST(self) -> None:  # noqa: N802
+        if self._request_path() != "/configure":
+            self._send_json(404, {"status": "not-found"})
+            return
+
+        try:
+            content_length = int(self.headers.get("Content-Length", "0"))
+        except ValueError:
+            self._send_json(400, {"status": "bad-request", "error": "Invalid Content-Length"})
+            return
+
+        try:
+            payload = json.loads(self.rfile.read(content_length).decode("utf-8") or "{}")
+        except json.JSONDecodeError as error:
+            self._send_json(400, {"status": "bad-request", "error": f"Invalid JSON body: {error}"})
+            return
+
+        try:
+            public_ipv4 = str(ipaddress.ip_address(payload.get("public_ipv4")))
+            public_ipv6 = payload.get("public_ipv6")
+            if public_ipv6 is not None:
+                public_ipv6 = str(ipaddress.ip_address(public_ipv6))
+            tcp_port = _validate_port(payload.get("tcp_port"), "tcp_port")
+            ws_port = _validate_port(payload.get("ws_port"), "ws_port")
+            proxy_hostname = _validate_proxy_hostname(payload.get("proxy_url"))
+            metrics_port = payload.get("metrics_port")
+            metrics_https_port = payload.get("metrics_https_port")
+            webrtc_port = payload.get("webrtc_port")
+            quic_port = payload.get("quic_port")
+            args = [
+                CONFIGURE_SCRIPT,
+                "--public-ipv4",
+                public_ipv4,
+                "--tcp-port",
+                tcp_port,
+                "--ws-port",
+                ws_port,
+            ]
+            if proxy_hostname is not None:
+                args.extend(["--proxy-hostname", proxy_hostname])
+            if public_ipv6 is not None:
+                args.extend(["--public-ipv6", public_ipv6])
+            if metrics_port is not None:
+                args.extend(["--metrics-port", _validate_port(metrics_port, "metrics_port")])
+            if metrics_https_port is not None:
+                args.extend(
+                    [
+                        "--metrics-https-port",
+                        _validate_port(metrics_https_port, "metrics_https_port"),
+                    ]
+                )
+            if webrtc_port is not None:
+                args.extend(["--webrtc-port", _validate_port(webrtc_port, "webrtc_port")])
+            if quic_port is not None:
+                args.extend(["--quic-port", _validate_port(quic_port, "quic_port")])
+        except ValueError as error:
+            self._send_json(400, {"status": "bad-request", "error": str(error)})
+            return
+
+        try:
+            result = subprocess.run(
+                args,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except subprocess.CalledProcessError as error:
+            self._send_json(
+                500,
+                {
+                    "status": "error",
+                    "error": error.stderr.strip() or error.stdout.strip() or str(error),
+                },
+            )
+            return
+
+        _clear_metadata_state()
+        threading.Thread(target=_generate_metadata_files, daemon=True).start()
+
+        self._send_json(
+            200,
+            {
+                "status": "configured",
+                "stdout": result.stdout.strip(),
+                "metadata_pending": True,
+            },
+        )
+
+
+def _stop_bootstrap_service() -> None:
+    time.sleep(1)
+    subprocess.run(["systemctl", "stop", BOOTSTRAP_SERVICE], check=False)
+
+
+def _clear_metadata_state() -> None:
+    for path in (METADATA_FILE, METADATA_ERROR_FILE):
+        try:
+            os.remove(path)
+        except FileNotFoundError:
+            pass
+
+
+def _generate_metadata_files() -> None:
+    try:
+        describe = subprocess.run(
+            [DESCRIBE_SCRIPT],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        payload = json.loads(describe.stdout.strip() or "{}")
+        with open(METADATA_FILE, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle)
+    except (subprocess.CalledProcessError, json.JSONDecodeError) as error:
+        with open(METADATA_ERROR_FILE, "w", encoding="utf-8") as handle:
+            handle.write(str(error))
+
+
+def main() -> None:
+    server = ThreadingHTTPServer(("0.0.0.0", 80), Handler)
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

package/reference/orbitdb-relay-pinner/rootfs/read-rootfs-contract.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import json
+import shlex
+import sys
+from pathlib import Path
+
+
+def shell_assign(name: str, value: str) -> str:
+    return f"{name}={shlex.quote(value)}"
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Read a relay rootfs contract and emit shell exports.")
+    parser.add_argument("contract", type=Path, help="Path to the rootfs contract JSON file")
+    args = parser.parse_args()
+
+    try:
+        payload = json.loads(args.contract.read_text())
+    except FileNotFoundError:
+        print(f"Missing rootfs contract: {args.contract}", file=sys.stderr)
+        return 1
+    except json.JSONDecodeError as exc:
+        print(f"Invalid rootfs contract JSON in {args.contract}: {exc}", file=sys.stderr)
+        return 1
+
+    rootfs = payload.get("rootfs") or {}
+    services = payload.get("services") or {}
+    source = payload.get("source") or {}
+    manifest = payload.get("manifest") or {}
+    ports = payload.get("ports") or []
+
+    profile = rootfs.get("profile")
+    install_mode = rootfs.get("installMode")
+
+    if not isinstance(profile, str) or not profile.strip():
+        print("Rootfs contract is missing rootfs.profile", file=sys.stderr)
+        return 1
+    if not isinstance(install_mode, str) or not install_mode.strip():
+        print("Rootfs contract is missing rootfs.installMode", file=sys.stderr)
+        return 1
+    if not isinstance(ports, list):
+        print("Rootfs contract field ports must be a list", file=sys.stderr)
+        return 1
+
+    lines = [
+        shell_assign("ROOTFS_CONTRACT_PATH", str(args.contract.resolve())),
+        shell_assign("ROOTFS_CONTRACT_ID", str(payload.get("id", ""))),
+        shell_assign("ROOTFS_CONTRACT_PROFILE", profile.strip()),
+        shell_assign("ROOTFS_CONTRACT_INSTALL_MODE", install_mode.strip()),
+        shell_assign("ROOTFS_CONTRACT_SOURCE_SUBDIRECTORY", str(source.get("subdirectory", ""))),
+        shell_assign("ROOTFS_CONTRACT_INSTALL_DIR", str(rootfs.get("installDir", ""))),
+        shell_assign("ROOTFS_CONTRACT_BINARY_PATH", str(rootfs.get("binaryPath", "/usr/local/bin/universal-chat-go"))),
+        shell_assign("ROOTFS_CONTRACT_DATA_DIR", str(rootfs.get("dataDir", ""))),
+        shell_assign("ROOTFS_CONTRACT_ENV_FILE", str(rootfs.get("envFile", ""))),
+        shell_assign("ROOTFS_CONTRACT_MAIN_SERVICE", str(services.get("main", ""))),
+        shell_assign("ROOTFS_CONTRACT_BOOTSTRAP_SERVICE", str(services.get("bootstrap", ""))),
+        shell_assign("ROOTFS_CONTRACT_AUTOTLS_SERVICE", str(services.get("autotlsRefresh", ""))),
+        shell_assign("ROOTFS_CONTRACT_MANIFEST_COPY_TARGET", str(manifest.get("copyTarget", ""))),
+        shell_assign("ROOTFS_CONTRACT_MANIFEST_NOTES", str(manifest.get("notes", ""))),
+        shell_assign("ROOTFS_CONTRACT_PORT_FORWARDS_JSON", json.dumps(ports, separators=(",", ":"))),
+    ]
+
+    print("\n".join(lines))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())