@le-space/rootfs 0.1.4 → 0.1.6

package/reference/uc-go-peer/rootfs/uc-go-peer-describe.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+import json
+import os
+import re
+import subprocess
+import time
+
+
+ENV_FILE = os.environ.get("ENV_FILE", "/etc/default/uc-go-peer")
+SERVICE_NAME = os.environ.get("SERVICE_NAME", "uc-go-peer.service")
+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"))
+
+PEER_ID_PATTERNS = [
+    re.compile(r"PeerID:\s+(\S+)"),
+    re.compile(r"Host created with PeerID:\s+(\S+)"),
+]
+LISTENING_PATTERN = re.compile(r"Listening on:\s+(\S+)/p2p/(\S+)")
+
+
+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 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 append_peer_id(addr: str, peer_id: str) -> str:
+    return addr if "/p2p/" in addr else f"{addr}/p2p/{peer_id}"
+
+
+def parse_logs() -> tuple[str | None, list[str]]:
+    result = subprocess.run(
+        ["journalctl", "-u", SERVICE_NAME, "-n", "500", "--no-pager"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    output = result.stdout or ""
+
+    peer_id = None
+    for pattern in PEER_ID_PATTERNS:
+        match = pattern.search(output)
+        if match:
+            peer_id = match.group(1)
+            break
+
+    listening_addrs = []
+    for addr, logged_peer_id in LISTENING_PATTERN.findall(output):
+        if peer_id is None:
+            peer_id = logged_peer_id
+        listening_addrs.append(addr)
+
+    return peer_id, dedupe(listening_addrs)
+
+
+def build_probe_multiaddrs(env_values: dict[str, str], peer_id: str, listening_addrs: list[str]) -> dict[str, list[str]]:
+    announce_addrs = [
+        entry.strip()
+        for entry in env_values.get("LIBP2P_ANNOUNCE_ADDRS", "").split(",")
+        if entry.strip()
+    ]
+    probe_multiaddrs: list[str] = []
+    direct_tcp_multiaddrs: list[str] = []
+    autotls_multiaddrs: list[str] = []
+    proxy_multiaddrs: list[str] = []
+    webtransport_multiaddrs: list[str] = []
+    webrtc_direct_multiaddrs: list[str] = []
+
+    for addr in announce_addrs:
+        if "/tcp/" in addr and "/tls/" not in addr and "/ws" not in addr:
+            direct_tcp_multiaddrs.append(append_peer_id(addr, peer_id))
+
+    ws_port = env_values.get("EXTERNAL_RELAY_WS_PORT", "").strip()
+    for addr in listening_addrs:
+        if "/tls/" not in addr or not addr.endswith("/ws"):
+            continue
+
+        dns_match = re.search(r"/dns[46]/([^/]+)/tcp/(\d+)/tls/ws$", addr)
+        if dns_match:
+            host = dns_match.group(1)
+            autotls_multiaddrs.append(f"/dns4/{host}/tcp/{ws_port or dns_match.group(2)}/tls/ws/p2p/{peer_id}")
+            autotls_multiaddrs.append(f"/dns6/{host}/tcp/{ws_port or dns_match.group(2)}/tls/ws/p2p/{peer_id}")
+            continue
+
+        sni_match = re.search(r"/tls/sni/([^/]+)/ws$", addr)
+        if sni_match:
+            host = sni_match.group(1)
+            if ws_port:
+                autotls_multiaddrs.append(f"/dns4/{host}/tcp/{ws_port}/tls/ws/p2p/{peer_id}")
+                autotls_multiaddrs.append(f"/dns6/{host}/tcp/{ws_port}/tls/ws/p2p/{peer_id}")
+
+    proxy_hostname = env_values.get("PROXY_HOSTNAME", "").strip()
+    if proxy_hostname:
+        proxy_multiaddrs.append(f"/dns4/{proxy_hostname}/tcp/443/tls/ws/p2p/{peer_id}")
+        proxy_multiaddrs.append(f"/dns6/{proxy_hostname}/tcp/443/tls/ws/p2p/{peer_id}")
+
+    public_ipv4 = env_values.get("PUBLIC_IPV4", "").strip()
+    public_ipv6 = env_values.get("PUBLIC_IPV6", "").strip()
+    udp_port = env_values.get("EXTERNAL_RELAY_UDP_PORT", "").strip()
+    if udp_port:
+        if public_ipv4:
+            webtransport_multiaddrs.append(f"/ip4/{public_ipv4}/udp/{udp_port}/quic-v1/webtransport/p2p/{peer_id}")
+            webrtc_direct_multiaddrs.append(f"/ip4/{public_ipv4}/udp/{udp_port}/webrtc-direct/p2p/{peer_id}")
+        if public_ipv6:
+            webtransport_multiaddrs.append(f"/ip6/{public_ipv6}/udp/{udp_port}/quic-v1/webtransport/p2p/{peer_id}")
+            webrtc_direct_multiaddrs.append(f"/ip6/{public_ipv6}/udp/{udp_port}/webrtc-direct/p2p/{peer_id}")
+
+    probe_multiaddrs.extend(direct_tcp_multiaddrs)
+    probe_multiaddrs.extend(autotls_multiaddrs)
+    probe_multiaddrs.extend(proxy_multiaddrs)
+
+    return {
+        "direct_tcp_multiaddrs": dedupe(direct_tcp_multiaddrs),
+        "autotls_wss_multiaddrs": dedupe(autotls_multiaddrs),
+        "proxy_wss_multiaddrs": dedupe(proxy_multiaddrs),
+        "webtransport_multiaddrs": dedupe(webtransport_multiaddrs),
+        "webrtc_direct_multiaddrs": dedupe(webrtc_direct_multiaddrs),
+        "browser_bootstrap_multiaddrs": dedupe(
+            autotls_multiaddrs + proxy_multiaddrs + webtransport_multiaddrs + webrtc_direct_multiaddrs
+        ),
+        "probe_multiaddrs": dedupe(probe_multiaddrs),
+    }
+
+
+def main() -> None:
+    started_at = time.monotonic()
+    deadline = time.monotonic() + WAIT_TIMEOUT_SECONDS
+    peer_id = None
+    listening_addrs: list[str] = []
+    grouped = {
+        "direct_tcp_multiaddrs": [],
+        "autotls_wss_multiaddrs": [],
+        "proxy_wss_multiaddrs": [],
+        "webtransport_multiaddrs": [],
+        "webrtc_direct_multiaddrs": [],
+        "browser_bootstrap_multiaddrs": [],
+        "probe_multiaddrs": [],
+    }
+
+    while time.monotonic() < deadline:
+        env_values = parse_env_file(ENV_FILE)
+        peer_id, listening_addrs = parse_logs()
+        if not peer_id:
+            time.sleep(WAIT_INTERVAL_SECONDS)
+            continue
+
+        grouped = build_probe_multiaddrs(env_values, peer_id, listening_addrs)
+        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
+        time.sleep(WAIT_INTERVAL_SECONDS)
+
+    if not peer_id:
+        raise SystemExit("unable to discover relay peer ID from service logs")
+
+    env_values = parse_env_file(ENV_FILE)
+    payload = {
+        "peer_id": peer_id,
+        "announce_addrs": [
+            entry.strip()
+            for entry in env_values.get("LIBP2P_ANNOUNCE_ADDRS", "").split(",")
+            if entry.strip()
+        ],
+        "listening_addrs": listening_addrs,
+        **grouped,
+    }
+    print(json.dumps(payload))
+
+
+if __name__ == "__main__":
+    main()

package/reference/uc-go-peer/rootfs/uc-go-peer-setup-server.py

@@ -0,0 +1,221 @@
+#!/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/uc-go-peer")
+READY_FILE = os.environ.get("READY_FILE", "/etc/default/uc-go-peer.ready")
+CONFIGURE_SCRIPT = "/usr/local/sbin/uc-go-peer-configure.sh"
+DESCRIBE_SCRIPT = "/usr/local/sbin/uc-go-peer-describe.py"
+BOOTSTRAP_SERVICE = os.environ.get("BOOTSTRAP_SERVICE", "uc-go-peer-bootstrap.service")
+METADATA_FILE = os.environ.get("METADATA_FILE", "/run/uc-go-peer-setup-metadata.json")
+METADATA_ERROR_FILE = os.environ.get("METADATA_ERROR_FILE", "/run/uc-go-peer-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 = "UcGoPeerSetup/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))
+            proxy_hostname = _validate_proxy_hostname(payload.get("proxy_url"))
+            tcp_port = payload.get("tcp_port")
+            ws_port = payload.get("ws_port")
+            udp_port = payload.get("udp_port")
+            quic_port = payload.get("quic_port")
+            webrtc_port = payload.get("webrtc_port")
+            args = [
+                CONFIGURE_SCRIPT,
+                "--public-ipv4",
+                public_ipv4,
+            ]
+            if tcp_port is not None:
+                args.extend(["--tcp-port", _validate_port(tcp_port, "tcp_port")])
+            if ws_port is not None:
+                args.extend(["--ws-port", _validate_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])
+            udp_candidate = udp_port if udp_port is not None else quic_port
+            if udp_candidate is None:
+                udp_candidate = webrtc_port
+            if udp_candidate is not None:
+                args.extend(["--udp-port", _validate_port(udp_candidate, "udp_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:
+    # Give the HTTP response a brief head start, then stop the temporary setup service.
+    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/uc-go-peer/rootfs/uc-go-peer.service

@@ -0,0 +1,19 @@
+[Unit]
+Description=universal-connectivity go-peer relay node
+Wants=network-online.target
+After=network-online.target
+ConditionPathExists=/etc/default/uc-go-peer.ready
+
+[Service]
+Type=simple
+User=uc-go-peer
+Group=uc-go-peer
+WorkingDirectory=/var/lib/uc-go-peer
+EnvironmentFile=-/etc/default/uc-go-peer
+ExecStart=/bin/sh -lc 'exec /usr/local/bin/universal-chat-go -headless -identity "${GO_PEER_IDENTITY_PATH:-/var/lib/uc-go-peer/identity.key}" -port "${GO_PEER_TCP_PORT:-9095}" -ws-port "${GO_PEER_WS_PORT:-9096}" -wss-port "${GO_PEER_WSS_PORT:-9097}"'
+Restart=always
+RestartSec=5
+NoNewPrivileges=true
+
+[Install]
+WantedBy=multi-user.target