@le-space/rootfs 0.3.15 → 0.3.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/rootfs",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "description": "Shared rootfs contract parsing, reference profile assets, and build helpers.",
   "license": "MIT",
   "type": "module",

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

@@ -58,17 +58,20 @@ def parse_logs() -> tuple[str | None, list[str]]:
     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
+    for line in output.splitlines():
+        for pattern in PEER_ID_PATTERNS:
+            match = pattern.search(line)
+            if match:
+                peer_id = match.group(1)
+
+    logged_addrs = LISTENING_PATTERN.findall(output)
+    if peer_id is None and logged_addrs:
+        peer_id = logged_addrs[-1][1]
 
     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)
+    for addr, logged_peer_id in logged_addrs:
+        if peer_id is None or logged_peer_id == peer_id:
+            listening_addrs.append(addr)
 
     return peer_id, dedupe(listening_addrs)
 

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

@@ -6,6 +6,7 @@ import subprocess
 import threading
 import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
 from urllib.error import HTTPError, URLError
 from urllib.parse import urlencode, urlsplit
 from urllib.request import urlopen
@@ -22,6 +23,8 @@ AUTHORIZED_KEYS_FILE = os.environ.get("AUTHORIZED_KEYS_FILE", "/root/.ssh/author
 ALEPH_API_HOST = os.environ.get("ALEPH_API_HOST", "https://api2.aleph.im")
 BOOTSTRAP_CONFIG_KEY = os.environ.get("BOOTSTRAP_CONFIG_KEY", "vm-bootstrap-config")
 BOOTSTRAP_CONFIG_POLL_SECONDS = float(os.environ.get("BOOTSTRAP_CONFIG_POLL_SECONDS", "5"))
+DESCRIBE_TIMEOUT_SECONDS = int(os.environ.get("DESCRIBE_TIMEOUT_SECONDS", "15"))
+DESCRIBE_INTERVAL_SECONDS = float(os.environ.get("DESCRIBE_INTERVAL_SECONDS", "1"))
 
 CONFIGURE_LOCK = threading.Lock()
 
@@ -64,7 +67,7 @@ def _extract_guest_bootstrap_locator() -> tuple[str | None, str | None]:
                 for part in line.split():
                     if part.startswith("aleph-bootstrap-config:"):
                         _, owner_address, deployment_token = part.split(":", 2)
-                        owner_address = owner_address.strip().lower()
+                        owner_address = owner_address.strip()
                         deployment_token = deployment_token.strip()
                         if owner_address and deployment_token:
                             return owner_address, deployment_token
@@ -87,6 +90,16 @@ def _start_metadata_generation() -> None:
     threading.Thread(target=_generate_metadata_files, daemon=True).start()
 
 
+def _service_active(service_name: str) -> bool:
+    result = subprocess.run(
+        ["systemctl", "is-active", service_name],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0 and result.stdout.strip() == "active"
+
+
 def _build_configure_args(record: dict) -> list[str]:
     runtime = record.get("runtime") if isinstance(record.get("runtime"), dict) else {}
     bootstrap = record.get("bootstrap") if isinstance(record.get("bootstrap"), dict) else {}
@@ -222,34 +235,11 @@ class Handler(BaseHTTPRequestHandler):
             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),
-            },
-        )
+        self._send_json(200, _health_payload())
 
     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"})
+        status, payload = _metadata_status_payload()
+        self._send_json(status, payload)
 
     def do_POST(self) -> None:  # noqa: N802
         if self._request_path() != "/configure":
@@ -349,26 +339,111 @@ class Handler(BaseHTTPRequestHandler):
         )
 
 
-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 _generate_metadata_files() -> None:
+def _describe_metadata() -> dict:
     try:
         describe = subprocess.run(
             [DESCRIBE_SCRIPT],
             check=True,
             capture_output=True,
             text=True,
+            env={
+                **os.environ,
+                "DESCRIBE_WAIT_TIMEOUT_SECONDS": str(DESCRIBE_TIMEOUT_SECONDS),
+                "DESCRIBE_WAIT_INTERVAL_SECONDS": str(DESCRIBE_INTERVAL_SECONDS),
+            },
         )
-        payload = json.loads(describe.stdout.strip() or "{}")
-        with open(METADATA_FILE, "w", encoding="utf-8") as handle:
-            json.dump(payload, handle)
+        return json.loads(describe.stdout.strip() or "{}")
     except (subprocess.CalledProcessError, json.JSONDecodeError) as error:
-        with open(METADATA_ERROR_FILE, "w", encoding="utf-8") as handle:
-            handle.write(str(error))
+        raise RuntimeError(str(error)) from error
+
+
+def _write_metadata_files(payload: dict) -> None:
+    Path(METADATA_FILE).write_text(json.dumps(payload), encoding="utf-8")
+    try:
+        os.remove(METADATA_ERROR_FILE)
+    except FileNotFoundError:
+        pass
+
+
+def _write_metadata_error(error_message: str) -> None:
+    try:
+        os.remove(METADATA_FILE)
+    except FileNotFoundError:
+        pass
+    Path(METADATA_ERROR_FILE).write_text(error_message, encoding="utf-8")
+
+
+def _generate_metadata_files() -> None:
+    try:
+        payload = _describe_metadata()
+        _write_metadata_files(payload)
+    except RuntimeError as error:
+        _write_metadata_error(str(error))
+
+
+def _fresh_metadata_payload() -> tuple[dict | None, str | None]:
+    try:
+        payload = _describe_metadata()
+        _write_metadata_files(payload)
+        return payload, None
+    except RuntimeError as error:
+        return None, str(error)
+
+
+def _read_cached_metadata() -> dict | None:
+    try:
+        with open(METADATA_FILE, encoding="utf-8") as handle:
+            payload = json.load(handle)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def _read_cached_metadata_error() -> str | None:
+    try:
+        message = Path(METADATA_ERROR_FILE).read_text(encoding="utf-8").strip()
+    except FileNotFoundError:
+        return None
+    return message or "metadata generation failed"
+
+
+def _metadata_status_payload() -> tuple[int, dict]:
+    if not os.path.exists(READY_FILE):
+        return 202, {"status": "pending"}
+
+    payload, error_message = _fresh_metadata_payload()
+    if payload is not None:
+        return 200, {"status": "ready", "metadata": payload}
+
+    cached_payload = _read_cached_metadata()
+    if cached_payload is not None:
+        return 200, {"status": "ready", "metadata": cached_payload, "stale": True}
+
+    cached_error = error_message or _read_cached_metadata_error()
+    if _service_active("uc-go-peer.service"):
+        return 202, {
+            "status": "pending",
+            "ready": True,
+            "relay_active": True,
+            "error": cached_error,
+        }
+
+    return 500, {"status": "error", "error": cached_error or "metadata generation failed"}
+
+
+def _health_payload() -> dict:
+    relay_ready = os.path.exists(READY_FILE)
+    metadata_status, metadata_payload = _metadata_status_payload()
+    return {
+        "status": "ready" if relay_ready and metadata_status == 200 else "waiting-for-port-mapping",
+        "ready": relay_ready,
+        "env_file": ENV_FILE,
+        "metadata_ready": metadata_status == 200,
+        "relay_active": _service_active("uc-go-peer.service"),
+        "caddy_active": _service_active("caddy.service"),
+        "bootstrap_active": _service_active(BOOTSTRAP_SERVICE),
+        "metadata_status": metadata_payload.get("status"),
+    }
 
 
 def main() -> None: