feat: add real POC cluster acceptance gate

This commit is contained in:
eust-w 2026-07-11 00:34:26 +08:00
parent 63c2d568d3
commit 0de6a61a47
5 changed files with 998 additions and 18 deletions

754
scripts/acceptance_poc_cluster.py Executable file
View File

@ -0,0 +1,754 @@
#!/usr/bin/env python3
from __future__ import annotations
import argparse
import hashlib
import http.cookiejar
import json
import os
import secrets
import shutil
import socket
import ssl
import subprocess
import sys
import tempfile
import time
import urllib.error
import urllib.request
import zipfile
from pathlib import Path
from typing import Any, Callable
ROOT = Path(__file__).resolve().parents[1]
DEFAULT_KUBECONFIG = Path("/Users/d-robotics/Downloads/poc.config")
DEFAULT_PLAYROOM = Path("/Users/d-robotics/Downloads/images")
NAMESPACE = "real2sim-poc"
TERMINAL = {"succeeded", "failed", "failed_recovered", "canceled"}
class AcceptanceError(RuntimeError):
pass
class ApiError(AcceptanceError):
def __init__(self, status: int, path: str, payload: Any) -> None:
super().__init__(f"HTTP {status} {path}: {payload}")
self.status = status
self.path = path
self.payload = payload
class ApiClient:
def __init__(self, base_url: str) -> None:
self.base_url = base_url.rstrip("/")
self.cookies = http.cookiejar.CookieJar()
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
self.opener = urllib.request.build_opener(
urllib.request.HTTPSHandler(context=context),
urllib.request.HTTPCookieProcessor(self.cookies),
)
def request(
self,
method: str,
path: str,
payload: Any | None = None,
*,
body: bytes | None = None,
content_type: str = "application/json",
timeout: int = 180,
) -> Any:
data = body
if payload is not None:
data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
headers = {"Accept": "application/json"}
if data is not None:
headers["Content-Type"] = content_type
request = urllib.request.Request(self.base_url + path, data=data, headers=headers, method=method)
try:
with self.opener.open(request, timeout=timeout) as response:
raw = response.read()
response_type = response.headers.get("content-type", "")
if "application/json" in response_type:
return json.loads(raw.decode("utf-8"))
return raw.decode("utf-8", errors="replace")
except urllib.error.HTTPError as exc:
raw = exc.read()
try:
payload = json.loads(raw.decode("utf-8"))
except Exception:
payload = raw.decode("utf-8", errors="replace")
raise ApiError(exc.code, path, payload) from exc
def get(self, path: str) -> Any:
return self.request("GET", path)
def post(self, path: str, payload: Any | None = None) -> Any:
return self.request("POST", path, payload)
def utc_now() -> str:
return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
def kubectl(kubeconfig: Path, *args: str, timeout: int = 3600, check: bool = True) -> subprocess.CompletedProcess[str]:
return subprocess.run(
["kubectl", "--kubeconfig", str(kubeconfig), *args],
text=True,
capture_output=True,
timeout=timeout,
check=check,
)
def free_port() -> int:
with socket.socket() as sock:
sock.bind(("127.0.0.1", 0))
return int(sock.getsockname()[1])
def start_port_forward(kubeconfig: Path, port: int, out_dir: Path) -> subprocess.Popen[str]:
log = (out_dir / "port-forward.log").open("w", encoding="utf-8")
process = subprocess.Popen(
[
"kubectl",
"--kubeconfig",
str(kubeconfig),
"-n",
NAMESPACE,
"port-forward",
"svc/real2sim-frontend",
f"{port}:443",
"--address",
"127.0.0.1",
],
text=True,
stdout=log,
stderr=subprocess.STDOUT,
)
deadline = time.time() + 90
while time.time() < deadline:
if process.poll() is not None:
log.close()
raise AcceptanceError((out_dir / "port-forward.log").read_text(encoding="utf-8", errors="replace"))
try:
with socket.create_connection(("127.0.0.1", port), timeout=1):
return process
except OSError:
time.sleep(1)
process.terminate()
log.close()
raise AcceptanceError("timed out waiting for the HTTPS port-forward")
class AcceptanceRun:
def __init__(self, *, client: ApiClient, out_dir: Path, kubeconfig: Path, build_id: str, timeout_seconds: int) -> None:
self.client = client
self.out_dir = out_dir
self.kubeconfig = kubeconfig
self.build_id = build_id
self.timeout_seconds = timeout_seconds
self.report: dict[str, Any] = {
"schema": "real2sim.poc_acceptance_report.v1",
"started_at": utc_now(),
"finished_at": "",
"build_id": build_id,
"namespace": NAMESPACE,
"version": {},
"doctor": {},
"capabilities": {},
"recipes": {},
"identities": {},
"tasks": [],
"datasets": [],
"scenes": [],
"models": [],
"storage": {},
"browser": {"status": "pending", "note": "Run browser acceptance after the API gate."},
"artifacts": [],
"checks": [],
"failures": [],
"warnings": [],
"pass": False,
}
def save(self) -> None:
self.out_dir.mkdir(parents=True, exist_ok=True)
(self.out_dir / "acceptance_report.json").write_text(
json.dumps(self.report, ensure_ascii=False, indent=2) + "\n",
encoding="utf-8",
)
lines = [
f"# Real2Sim POC Acceptance {self.build_id}",
"",
f"- Started: {self.report['started_at']}",
f"- Finished: {self.report['finished_at'] or 'running'}",
f"- Pass: **{self.report['pass']}**",
f"- Tasks: {len(self.report['tasks'])}",
f"- Failures: {len(self.report['failures'])}",
"",
"## Checks",
*[f"- {'PASS' if item['ok'] else 'FAIL'}: {item['name']}" for item in self.report["checks"]],
"",
"## Failures",
*([f"- {item['stage']}: {item['error']}" for item in self.report["failures"]] or ["- None"]),
"",
"## Warnings",
*([f"- {item}" for item in self.report["warnings"]] or ["- None"]),
]
(self.out_dir / "summary.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
def check(self, name: str, ok: bool, detail: Any = None) -> None:
self.report["checks"].append({"name": name, "ok": bool(ok), "detail": detail})
self.save()
if not ok:
raise AcceptanceError(f"{name}: {detail}")
def stage(self, name: str, action: Callable[[], Any]) -> Any | None:
print(f"\n== {name} ==", flush=True)
started = time.time()
try:
result = action()
self.report["checks"].append({"name": name, "ok": True, "elapsed_seconds": round(time.time() - started, 2)})
self.save()
return result
except Exception as exc:
failure = {
"stage": name,
"error": f"{type(exc).__name__}: {exc}",
"elapsed_seconds": round(time.time() - started, 2),
"next_action": "Inspect the task reports and logs recorded in this acceptance directory, fix the real runtime blocker, then rerun the gate.",
}
self.report["checks"].append({"name": name, "ok": False, "elapsed_seconds": failure["elapsed_seconds"]})
self.report["failures"].append(failure)
self.save()
print(f"FAILED: {failure['error']}", file=sys.stderr, flush=True)
return None
def create_task(self, task_type: str, params: dict[str, Any], *, required_artifacts: tuple[str, ...] = ()) -> dict[str, Any]:
created = self.client.post("/api/tasks", {"type": task_type, "params": params})
print(f"{task_type}: {created['id']}", flush=True)
return self.wait_task(created["id"], required_artifacts=required_artifacts)
def wait_task(
self,
task_id: str,
*,
required_artifacts: tuple[str, ...] = (),
expected_status: str = "succeeded",
timeout_seconds: int | None = None,
) -> dict[str, Any]:
deadline = time.time() + int(timeout_seconds or self.timeout_seconds)
previous = None
task: dict[str, Any] = {}
while time.time() < deadline:
task = self.client.get(f"/api/tasks/{task_id}")
marker = (task.get("status"), task.get("progress"), task.get("stage"), task.get("message"))
if marker != previous:
print(f" {task.get('status')} {task.get('progress')}% {task.get('stage')} {task.get('message')}", flush=True)
previous = marker
if task.get("status") in TERMINAL:
break
time.sleep(5)
else:
raise AcceptanceError(f"task {task_id} timed out after {timeout_seconds or self.timeout_seconds}s")
artifacts = self.client.get(f"/api/tasks/{task_id}/artifacts")
reports = self.client.get(f"/api/tasks/{task_id}/reports")
task_record = {
"id": task_id,
"type": task.get("type"),
"status": task.get("status"),
"progress": task.get("progress"),
"stage": task.get("stage"),
"message": task.get("message"),
"error": task.get("error"),
"result": task.get("result"),
"artifact_count": len(artifacts),
"artifact_names": sorted({str(item.get("name") or "") for item in artifacts}),
"reports": reports,
}
self.report["tasks"].append(task_record)
self.save()
if task.get("status") != expected_status:
log = self.client.get(f"/api/tasks/{task_id}/logs")
failure_dir = self.out_dir / "task_failures" / task_id
failure_dir.mkdir(parents=True, exist_ok=True)
(failure_dir / "task.json").write_text(json.dumps(task, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
(failure_dir / "reports.json").write_text(json.dumps(reports, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
(failure_dir / "artifacts.json").write_text(json.dumps(artifacts, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
(failure_dir / "task.log").write_text(str(log), encoding="utf-8")
raise AcceptanceError(f"task {task_id} ended as {task.get('status')}: {reports.get('readable_error') or task.get('error')}")
if expected_status == "succeeded" and not artifacts:
raise AcceptanceError(f"succeeded task {task_id} has no indexed artifacts")
names = {str(item.get("name") or "") for item in artifacts}
missing = sorted(set(required_artifacts) - names)
if missing:
raise AcceptanceError(f"task {task_id} is missing required artifacts: {missing}")
result = task.get("result") or {}
if expected_status == "succeeded" and not str(result.get("run_storage_uri") or "").startswith("bos://testxyz/real2sim-poc/runs/"):
raise AcceptanceError(f"task {task_id} has no owned BOS run URI")
return task
def credential_candidates(root: Path, out_dir: Path) -> list[str]:
candidates: list[str] = []
explicit = os.environ.get("REAL2SIM_POC_ADMIN_PASSWORD", "").strip()
if explicit:
candidates.append(explicit)
for path in [out_dir / "acceptance-admin-password.txt", out_dir / "bootstrap-admin-password.txt"]:
if path.is_file():
candidates.append(path.read_text(encoding="utf-8").strip())
prior = sorted((root / "acceptance_runs" / "poc").glob("*/acceptance-admin-password.txt"), key=lambda path: path.stat().st_mtime, reverse=True)
prior += sorted((root / "acceptance_runs" / "poc").glob("*/bootstrap-admin-password.txt"), key=lambda path: path.stat().st_mtime, reverse=True)
for path in prior:
candidates.append(path.read_text(encoding="utf-8").strip())
return list(dict.fromkeys(value for value in candidates if value))
def authenticate_admin(run: AcceptanceRun) -> str:
login = None
current_password = ""
errors: list[str] = []
for candidate in credential_candidates(ROOT, run.out_dir):
try:
login = run.client.post("/api/auth/login", {"username": "admin", "password": candidate})
current_password = candidate
break
except ApiError as exc:
errors.append(str(exc.status))
if login is None:
raise AcceptanceError(f"admin login failed for all credential candidates: {errors}")
if login["user"].get("must_change_password"):
next_password = "Real2Sim!" + secrets.token_urlsafe(18) + "Aa1"
run.client.post(
"/api/auth/change-password",
{"current_password": current_password, "new_password": next_password},
)
run.client.post("/api/auth/login", {"username": "admin", "password": next_password})
current_password = next_password
password_path = run.out_dir / "acceptance-admin-password.txt"
password_path.write_text(current_password + "\n", encoding="utf-8")
password_path.chmod(0o600)
me = run.client.get("/api/auth/me")["user"]
run.check("管理员登录且已完成首次改密", me.get("role") == "admin" and not me.get("must_change_password"), me)
return current_password
def verify_rbac(run: AcceptanceRun) -> None:
suffix = secrets.token_hex(4)
records: dict[str, Any] = {}
for role in ("engineer", "viewer"):
username = f"acceptance.{role}.{suffix}"
password = f"{role.title()}!Password123"
user = run.client.post("/api/users", {"username": username, "password": password, "role": role})
records[role] = {"id": user["id"], "username": username}
role_client = ApiClient(run.client.base_url)
login = role_client.post("/api/auth/login", {"username": username, "password": password})
if login["user"].get("must_change_password"):
changed = f"{role.title()}!Changed456"
role_client.post("/api/auth/change-password", {"current_password": password, "new_password": changed})
role_client.post("/api/auth/login", {"username": username, "password": changed})
role_client.get("/api/datasets")
try:
payload = {"type": "motrixsim_asset_import" if role == "engineer" else "renderer_benchmark", "params": {}}
role_client.post("/api/tasks", payload)
except ApiError as exc:
if exc.status != 403:
raise
else:
raise AcceptanceError(f"{role} unexpectedly created a forbidden task")
run.report["identities"] = records
for record in records.values():
run.client.request("DELETE", f"/api/users/{record['id']}")
def build_playroom_archive(source: Path, build_id: str) -> tuple[Path, int, str]:
images = sorted(path for path in source.rglob("*") if path.is_file() and path.suffix.lower() in {".jpg", ".jpeg", ".png", ".webp"})
if len(images) < 225:
raise AcceptanceError(f"Playroom source has {len(images)} images; at least 225 are required")
target = Path(tempfile.gettempdir()) / f"real2sim-playroom-{build_id}.zip"
with zipfile.ZipFile(target, "w", compression=zipfile.ZIP_STORED, allowZip64=True) as archive:
for image in images:
archive.write(image, Path("playroom") / image.relative_to(source))
digest = hashlib.sha256()
with target.open("rb") as handle:
while chunk := handle.read(8 * 1024 * 1024):
digest.update(chunk)
return target, len(images), digest.hexdigest()
def upload_with_resume(run: AcceptanceRun, archive: Path, checksum: str) -> dict[str, Any]:
chunk_size = 8 * 1024 * 1024
created = run.client.post(
"/api/uploads",
{
"filename": archive.name,
"content_type": "application/zip",
"total_size": archive.stat().st_size,
"chunk_size": chunk_size,
"checksum": checksum,
},
)
upload_id = created["id"]
total_parts = int(created["total_parts"])
pause_after = max(1, total_parts // 2)
with archive.open("rb") as handle:
for part in range(1, total_parts + 1):
body = handle.read(chunk_size)
run.client.request(
"PUT",
f"/api/uploads/{upload_id}/parts/{part}",
body=body,
content_type="application/octet-stream",
timeout=600,
)
print(f" uploaded part {part}/{total_parts}", flush=True)
if part == pause_after:
resumed = run.client.get(f"/api/uploads/{upload_id}")
expected = list(range(1, pause_after + 1))
run.check("BOS 上传分片状态可恢复", resumed.get("received_parts") == expected, resumed.get("received_parts"))
completed = run.client.post(f"/api/uploads/{upload_id}/complete")
dataset = completed["dataset"]
run.check("上传数据写入受控 BOS 前缀", str(dataset.get("storage_uri") or "").startswith("bos://testxyz/real2sim-poc/uploads/"), dataset.get("storage_uri"))
run.report["storage"] = {
"upload_id": upload_id,
"storage_uri": dataset.get("storage_uri"),
"checksum": checksum,
"size_bytes": archive.stat().st_size,
"total_parts": total_parts,
"resume_checkpoint_part": pause_after,
}
run.report["datasets"].append({"id": dataset["id"], "role": "playroom_upload", "storage_uri": dataset.get("storage_uri")})
return dataset
def validate_infrastructure(run: AcceptanceRun) -> None:
run.report["version"] = run.client.get("/api/version")
run.report["doctor"] = run.client.get("/api/doctor")
run.report["capabilities"] = run.client.get("/api/capabilities")
run.report["recipes"] = run.client.get("/api/recipes")
run.check("部署 build_id 与验收目标一致", run.report["version"].get("build_id") == run.build_id, run.report["version"].get("build_id"))
run.check("生产 API doctor 通过", bool(run.report["doctor"].get("ok")), run.report["doctor"])
run.check("A800 worker 心跳就绪", bool((run.report["doctor"].get("worker") or {}).get("ready")), run.report["doctor"].get("worker"))
runtimes = run.report["capabilities"].get("runtimes") or {}
for name in ("anysplat", "mujoco", "motrixsim", "discoverse_act", "rm65_controller"):
run.check(f"真实运行时就绪: {name}", bool((runtimes.get(name) or {}).get("ready")), runtimes.get(name))
run.check("BOS 前缀隔离", run.report["capabilities"].get("storage", {}).get("prefix") == "real2sim-poc", run.report["capabilities"].get("storage"))
def exercise_task_operations(run: AcceptanceRun, scene_id: str | None) -> None:
benchmark = run.create_task("renderer_benchmark", {})
retry = run.client.post(f"/api/tasks/{benchmark['id']}/retry")
retried = run.wait_task(retry["id"])
bulk = run.client.post("/api/tasks/bulk", {"action": "retry", "ids": [benchmark["id"], retried["id"]], "params": {}})
run.check("任务批量重试逐项返回", len(bulk.get("results") or []) == 2 and all(item.get("ok") for item in bulk["results"]), bulk)
for item in bulk["results"]:
run.wait_task(item["result"]["id"], timeout_seconds=300)
if not scene_id:
run.report["warnings"].append("RM65 scene unavailable; cancellation and restart-recovery probes were skipped")
return
cancel_probe = run.client.post(
"/api/tasks",
{
"type": "expert_collection",
"params": {
"scene_id": scene_id,
"policy_preset": "rm65_pick_place_6d_ik",
"episodes": 50,
"max_attempts": 150,
"steps": 240,
"name": "acceptance-cancel-probe",
},
},
)
wait_until_status(run.client, cancel_probe["id"], "running", 300)
run.client.post(f"/api/tasks/{cancel_probe['id']}/cancel")
run.wait_task(cancel_probe["id"], expected_status="canceled", timeout_seconds=300)
recovery_probe = run.client.post(
"/api/tasks",
{
"type": "expert_collection",
"params": {
"scene_id": scene_id,
"policy_preset": "rm65_pick_place_6d_ik",
"episodes": 50,
"max_attempts": 150,
"steps": 240,
"name": "acceptance-recovery-probe",
},
},
)
wait_until_status(run.client, recovery_probe["id"], "running", 300)
kubectl(run.kubeconfig, "-n", NAMESPACE, "rollout", "restart", "deployment/real2sim-worker")
kubectl(run.kubeconfig, "-n", NAMESPACE, "rollout", "status", "deployment/real2sim-worker", "--timeout=3600s", timeout=3700)
run.wait_task(recovery_probe["id"], expected_status="failed_recovered", timeout_seconds=600)
run.check("worker 重启后历史任务仍可查询", run.client.get(f"/api/tasks/{benchmark['id']}").get("id") == benchmark["id"])
def wait_until_status(client: ApiClient, task_id: str, status: str, timeout_seconds: int) -> dict[str, Any]:
deadline = time.time() + timeout_seconds
while time.time() < deadline:
task = client.get(f"/api/tasks/{task_id}")
if task.get("status") == status:
return task
if task.get("status") in TERMINAL:
raise AcceptanceError(f"task {task_id} reached {task.get('status')} before {status}")
time.sleep(2)
raise AcceptanceError(f"task {task_id} did not reach {status} within {timeout_seconds}s")
def run_acceptance(args: argparse.Namespace) -> int:
build_id = args.build_id or kubectl(
args.kubeconfig,
"-n",
NAMESPACE,
"get",
"deployment/real2sim-api",
"-o",
"jsonpath={.metadata.labels.app\\.kubernetes\\.io/version}",
).stdout.strip()
if not build_id:
raise AcceptanceError("unable to determine deployed build id")
out_dir = args.out or ROOT / "acceptance_runs" / "poc" / build_id
out_dir.mkdir(parents=True, exist_ok=True)
port = args.port or free_port()
forward = start_port_forward(args.kubeconfig, port, out_dir)
archive: Path | None = None
run = AcceptanceRun(
client=ApiClient(f"https://127.0.0.1:{port}"),
out_dir=out_dir,
kubeconfig=args.kubeconfig,
build_id=build_id,
timeout_seconds=args.timeout_seconds,
)
try:
if run.stage("管理员认证", lambda: authenticate_admin(run)) is None:
return finalize(run)
run.stage("运行时、存储与版本预检", lambda: validate_infrastructure(run))
run.stage("用户 CRUD 与角色隔离", lambda: verify_rbac(run))
uploaded_dataset: dict[str, Any] | None = None
prepared_dataset_id: str | None = None
playroom = run.stage("打包真实 Playroom 225 帧", lambda: build_playroom_archive(args.playroom, build_id))
if playroom:
archive, image_count, checksum = playroom
run.report["storage"]["source_image_count"] = image_count
uploaded_dataset = run.stage("BOS 分片上传与断点续传", lambda: upload_with_resume(run, archive, checksum))
if uploaded_dataset:
prepared = run.stage(
"媒体准备 225 帧",
lambda: run.create_task(
"media_prepare",
{
"dataset_id": uploaded_dataset["id"],
"camera_label": "playroom.rgb",
"target_frame_count": 225,
"min_total_frames": 80,
"max_frames_per_video": 225,
"max_videos": 1,
"sample_fps": 2,
"output_name": f"playroom-prepared-{build_id}",
},
required_artifacts=("prepared_manifest.json",),
),
)
if prepared:
prepared_dataset_id = str(prepared["result"]["dataset_id"])
run.report["datasets"].append({"id": prepared_dataset_id, "role": "playroom_prepared", "frame_count": prepared["result"].get("frame_count")})
run.stage(
"Playroom 重建质量预检",
lambda: run.create_task(
"reconstruction_preflight",
{"dataset_id": prepared_dataset_id, "min_frames": 80, "target_frame_count": 225, "allow_low_quality": False, "quality_preset": "capture-high"},
required_artifacts=("capture_preflight_report.json",),
),
)
reconstruction_scenes: list[str] = []
if prepared_dataset_id:
for index in range(1, 3):
reconstructed = run.stage(
f"Playroom AnySplat 真实重建 #{index}",
lambda index=index: run.create_task(
"scene_reconstruction",
{
"dataset_id": prepared_dataset_id,
"scene_name": f"Playroom A800 Reconstruction {index}",
"renderer": "spark",
"simulators": ["mujoco", "motrixsim"],
"dry_run": False,
"preflight_required": True,
"min_frames": 80,
"allow_low_quality": False,
"quality_preset": "capture-high",
"pose_init_train": True,
"sfm_matcher": "exhaustive",
"sfm_guided_matching": True,
"sfm_frames": "selected",
"anysplat_keyframe_strategy": "sfm-registered",
"auto_cover": True,
},
required_artifacts=(
"environment.json",
"reconstruction_command.json",
"capture_preflight_report.json",
"reconstruction_report.json",
"scene_manifest.json",
),
),
)
if reconstructed:
scene_id = str(reconstructed["result"]["scene_id"])
reconstruction_scenes.append(scene_id)
run.report["scenes"].append({"id": scene_id, "role": f"playroom_reconstruction_{index}"})
run.stage(
f"Playroom 重建仿真双运行时校验 #{index}",
lambda scene_id=scene_id: run.create_task(
"simulator_validation",
{"scene_id": scene_id, "simulators": ["mujoco", "motrixsim"], "level": "runtime_required"},
required_artifacts=("validation_report.json",),
),
)
if len(reconstruction_scenes) == 2:
run.stage(
"两次重建产生独立场景包",
lambda: run.check("重建 scene_id 独立", len(set(reconstruction_scenes)) == 2, reconstruction_scenes),
)
motrix_task = run.stage(
"MotrixSim 官方客厅与 RM65 资产导入",
lambda: run.create_task(
"motrixsim_asset_import",
{"source": "/opt/motrixsim-docs", "validation_steps": 120, "max_parlour_meshes": 240},
required_artifacts=("motrixsim_asset_import_report.json", "rm65_table_pick_place_validation.json", "motrixsim_parlour_rm65_preview.glb"),
),
)
rm65_scene_id = str(motrix_task["result"]["scene_id"]) if motrix_task else None
if rm65_scene_id:
run.report["scenes"].append({"id": rm65_scene_id, "role": "rm65_pick_place"})
run.stage(
"RM65 场景 runtime_required 校验",
lambda: run.create_task(
"simulator_validation",
{"scene_id": rm65_scene_id, "simulators": ["mujoco", "motrixsim"], "level": "runtime_required"},
required_artifacts=("validation_report.json",),
),
)
collection = None
if rm65_scene_id:
collection = run.stage(
"RM65 真实物理专家采集 50 条成功 episode",
lambda: run.create_task(
"expert_collection",
{
"scene_id": rm65_scene_id,
"policy_preset": "rm65_pick_place_6d_ik",
"episodes": 50,
"max_attempts": 150,
"steps": 240,
"workers": 1,
"seed": 7,
"image_width": 320,
"image_height": 240,
"name": f"RM65 Physical ACT Dataset {build_id}",
},
required_artifacts=("manifest.json", "episode_0.hdf5", "episode_0.mp4"),
),
)
collection_dataset_id = str(collection["result"]["dataset_id"]) if collection else None
if collection_dataset_id:
run.report["datasets"].append({"id": collection_dataset_id, "role": "rm65_physical_collection", "samples": collection["result"].get("samples")})
run.stage("采集成功数门槛", lambda: run.check("成功 episode 至少 50", int(collection["result"].get("samples") or 0) >= 50, collection["result"]))
trained = None
if collection_dataset_id:
trained = run.stage(
"DISCOVERSE ACT 真实训练",
lambda: run.create_task(
"training",
{
"dataset_id": collection_dataset_id,
"recipe": "discoverse_act",
"epochs": args.act_epochs,
"batch_size": 8,
"chunk_size": 32,
"seed": 1,
"name": f"RM65 ACT {build_id}",
},
required_artifacts=("policy_best.ckpt", "dataset_stats.pkl", "model_card.json", "task_config.py"),
),
)
model_id = str(trained["result"]["model_id"]) if trained else None
if model_id:
run.report["models"].append({"id": model_id, "role": "discoverse_act", "metrics": trained["result"].get("metrics")})
if model_id and rm65_scene_id:
inference = run.stage(
"DISCOVERSE ACT 在线推理 10 回合",
lambda: run.create_task(
"inference",
{
"model_id": model_id,
"scene_id": rm65_scene_id,
"recipe": "discoverse_act",
"episodes": 10,
"steps": 240,
"workers": 1,
"seed": 11,
"minimum_success_rate": 0.5,
},
required_artifacts=("inference_report.json", "episode_000.mp4", "episode_000_trajectory.json"),
),
)
if inference:
run.stage("ACT 推理成功率门槛", lambda: run.check("推理成功率至少 50%", float(inference["result"].get("success_rate") or 0) >= 0.5, inference["result"]))
run.stage("任务取消、重试、批量操作与重启恢复", lambda: exercise_task_operations(run, rm65_scene_id))
return finalize(run)
finally:
if archive and archive.exists():
archive.unlink()
forward.terminate()
try:
forward.wait(timeout=10)
except subprocess.TimeoutExpired:
forward.kill()
def finalize(run: AcceptanceRun) -> int:
run.report["finished_at"] = utc_now()
run.report["pass"] = not run.report["failures"] and all(item.get("ok") for item in run.report["checks"])
run.save()
print(f"\nacceptance_report={run.out_dir / 'acceptance_report.json'}", flush=True)
print(f"pass={run.report['pass']}", flush=True)
return 0 if run.report["pass"] else 1
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Run the real Real2Sim production acceptance against the isolated POC namespace.")
parser.add_argument("--kubeconfig", type=Path, default=Path(os.environ.get("REAL2SIM_POC_KUBECONFIG", DEFAULT_KUBECONFIG)))
parser.add_argument("--playroom", type=Path, default=Path(os.environ.get("REAL2SIM_POC_PLAYROOM", DEFAULT_PLAYROOM)))
parser.add_argument("--build-id", default=os.environ.get("REAL2SIM_POC_BUILD_ID", ""))
parser.add_argument("--out", type=Path, default=Path(os.environ["REAL2SIM_POC_ACCEPTANCE_OUT"]) if os.environ.get("REAL2SIM_POC_ACCEPTANCE_OUT") else None)
parser.add_argument("--port", type=int, default=0)
parser.add_argument("--timeout-seconds", type=int, default=int(os.environ.get("REAL2SIM_POC_ACCEPTANCE_TIMEOUT_SECONDS", "28800")))
parser.add_argument("--act-epochs", type=int, default=int(os.environ.get("REAL2SIM_POC_ACT_EPOCHS", "100")))
return parser.parse_args()
if __name__ == "__main__":
try:
raise SystemExit(run_acceptance(parse_args()))
except KeyboardInterrupt:
raise SystemExit(130)
except Exception as exc:
print(f"acceptance bootstrap failed: {type(exc).__name__}: {exc}", file=sys.stderr)
raise SystemExit(2)

View File

@ -171,6 +171,8 @@ def execute_task(config: PlatformConfig, store: PlatformStore, task: dict[str, A
return run_hf_import(config, store, task, emit)
if task_type == "bos_import":
return run_bos_import(config, store, task, emit)
if task_type == "motrixsim_asset_import":
return run_motrixsim_asset_import(config, store, task, emit)
if task_type == "simulator_validation":
return run_simulator_validation(config, store, task, emit)
if task_type == "expert_collection":
@ -623,6 +625,105 @@ def run_bos_import(config: PlatformConfig, store: PlatformStore, task: dict[str,
return {"dataset_id": dataset["id"], "dataset_path": str(out_dir), "storage_uri": source_uri, "object_count": len(objects), "checksum": digest}
def run_motrixsim_asset_import(config: PlatformConfig, store: PlatformStore, task: dict[str, Any], emit: Callable[[str], None]) -> dict[str, Any]:
"""Import the pinned MotrixSim package and prove both simulator runtimes load it."""
params = task["params"]
run_dir = Path(task["run_dir"])
report_path = run_dir / "motrixsim_asset_import_report.json"
source = Path(str(params.get("source") or "/opt/motrixsim-docs"))
scene_id = hashlib.sha1(b"motrixsim:parlour_rm65_pick_place").hexdigest()[:32]
scripts = config.app_root / "scripts"
import_script = scripts / "import_motrixsim_assets.py"
runtime_script = scripts / "generate_motrixsim_runtime_scene.py"
preview_script = scripts / "generate_motrixsim_preview.py"
missing = [str(path) for path in (import_script, runtime_script, preview_script) if not path.is_file()]
if missing:
raise FileNotFoundError("MotrixSim asset pipeline scripts are missing: " + ", ".join(missing))
if not source.is_dir():
raise FileNotFoundError(f"pinned MotrixSim source checkout not found: {source}")
env = _env_with_paths(config)
log_path = run_dir / "logs" / "task.log"
_task_progress(store, task, 15, "导入官方资产", "正在复制固定版本的 MotrixSim 客厅、RM65 与 pick-place 资产")
run_logged(
[
sys.executable,
str(import_script),
"--source",
str(source),
"--name",
str(params.get("name") or "MotrixSim 客厅 RM65 Pick-Place"),
"--replace-index",
],
cwd=config.app_root,
log_path=log_path,
env=env,
store=store,
task_id=task["id"],
)
_task_progress(store, task, 48, "验证仿真运行时", "正在使用 MuJoCo 与 MotrixSim 真实加载并执行场景 step")
run_logged(
[sys.executable, str(runtime_script), "--scene-id", scene_id, "--steps", str(int(params.get("validation_steps", 120)))],
cwd=config.app_root,
log_path=log_path,
env=env,
store=store,
task_id=task["id"],
)
_task_progress(store, task, 72, "生成浏览器预览", "正在从官方网格资产生成可交互 GLB")
run_logged(
[sys.executable, str(preview_script), "--scene-id", scene_id, "--max-parlour-meshes", str(int(params.get("max_parlour_meshes", 240)))],
cwd=config.app_root,
log_path=log_path,
env=env,
store=store,
task_id=task["id"],
)
scene = store.get_scene(scene_id)
package_dir = Path(str((scene.get("metadata") or {}).get("package") or ""))
manifest_path = Path(str(scene.get("manifest_path") or ""))
if not package_dir.is_dir() or not manifest_path.is_file():
raise RuntimeError("MotrixSim asset pipeline completed without a valid scene package")
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
runtime_validation = (scene.get("metadata") or {}).get("runtime_validation") or {}
if runtime_validation.get("mujoco") is not True or runtime_validation.get("motrixsim") is not True:
raise RuntimeError(f"MotrixSim scene did not pass both runtimes: {runtime_validation}")
primary = ((manifest.get("viewer_assets") or {}).get("primary") or {})
preview_path = Path(str(primary.get("path") or ""))
if not preview_path.is_file() or preview_path.stat().st_size == 0:
raise RuntimeError("MotrixSim GLB preview was not generated")
report = {
"schema": "real2sim.motrixsim_asset_import_report.v1",
"status": "succeeded",
"scene_id": scene_id,
"source": str(source),
"source_commit": _git_head(source),
"package_dir": str(package_dir),
"manifest_path": str(manifest_path),
"preview_path": str(preview_path),
"preview_size_bytes": preview_path.stat().st_size,
"runtime_validation": runtime_validation,
}
report_path.parent.mkdir(parents=True, exist_ok=True)
report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
store.add_artifact(task_id=task["id"], name=report_path.name, path=report_path, kind="json")
_index_artifacts(store, task["id"], package_dir)
_task_progress(store, task, 94, "登记场景资产", "官方资产、运行时报告和 GLB 预览已登记")
emit(f"MotrixSim asset package ready: scene_id={scene_id} preview={preview_path}")
return {
"scene_id": scene_id,
"scene_path": scene["path"],
"manifest_path": str(manifest_path),
"package_dir": str(package_dir),
"preview_path": str(preview_path),
"runtime_validation": runtime_validation,
}
def run_simulator_validation(config: PlatformConfig, store: PlatformStore, task: dict[str, Any], emit: Callable[[str], None]) -> dict[str, Any]:
params = task["params"]
run_dir = Path(task["run_dir"])
@ -645,6 +746,7 @@ def run_simulator_validation(config: PlatformConfig, store: PlatformStore, task:
if "mujoco" in simulators:
_task_progress(store, task, 45, "校验 MuJoCo", "正在检查 MJCF 并尝试运行时加载")
candidates = [
root / "simulator_assets" / "rm65_table_pick_place.xml",
root / "scene_mujoco.xml",
root / "mujoco.xml",
root / "scene.xml",
@ -654,6 +756,7 @@ def run_simulator_validation(config: PlatformConfig, store: PlatformStore, task:
*root.glob("*mujoco*.xml"),
*root.glob("mjcf/*.xml"),
*root.glob("mujoco/*.xml"),
*root.glob("simulator_assets/*.xml"),
]
report["simulators"]["mujoco"] = _validate_mujoco_asset(candidates, level=level)
if "motrixsim" in simulators:
@ -662,10 +765,12 @@ def run_simulator_validation(config: PlatformConfig, store: PlatformStore, task:
root / "motrix_scene.json",
root / "motrix_import.json",
root / "scene.json",
root / "simulator_assets" / "rm65_table_pick_place.xml",
root / "motrixsim" / "motrix_import.json",
root / "motrixsim" / "scene.json",
*root.glob("*motrix*.json"),
*root.glob("motrixsim/*.json"),
*root.glob("simulator_assets/*.xml"),
]
report["simulators"]["motrixsim"] = _validate_motrixsim_asset(candidates, level=level)
report["ok"] = all(item["ok"] for item in report["simulators"].values())
@ -2638,24 +2743,60 @@ def _validate_mujoco_asset(candidates: list[Path], *, level: str) -> dict[str, A
def _validate_motrixsim_asset(candidates: list[Path], *, level: str) -> dict[str, Any]:
result = _validate_sim_asset(candidates, required_suffix=".json")
if not result["ok"] or level == "smoke":
result["level_effective"] = "smoke"
return result
tooling = _motrixsim_tooling()
if not tooling["available"]:
result["runtime"] = {"status": "unavailable", "tooling": tooling}
result["level_effective"] = "smoke"
result["ok"] = result["ok"] and level != "runtime_required"
return result
result["runtime"] = {"status": "tooling_detected", "tooling": tooling}
result["level_effective"] = "runtime_if_available"
result["ok"] = True
return result
descriptor = _validate_sim_asset(candidates, required_suffix=".json")
if level == "smoke":
descriptor["level_effective"] = "smoke"
return descriptor
runtime_scene = next((path for path in candidates if path.is_file() and path.suffix.lower() == ".xml"), None)
if runtime_scene is None:
return {
"ok": False,
"path": descriptor.get("path"),
"descriptor": descriptor,
"level_effective": "runtime",
"runtime": {"status": "artifact_unavailable", "error": "no MJCF scene is available for MotrixSim runtime loading"},
}
try:
from motrixsim import SceneData, load_model, step # type: ignore
except Exception as exc:
return {
"ok": level != "runtime_required" and bool(descriptor.get("ok")),
"path": str(runtime_scene),
"descriptor": descriptor,
"level_effective": "runtime_if_available",
"runtime": {"status": "unavailable", "error": str(exc), "tooling": _motrixsim_tooling()},
}
try:
model = load_model(str(runtime_scene))
data = SceneData(model)
for _ in range(8):
step(model, data)
return {
"ok": True,
"path": str(runtime_scene),
"descriptor": descriptor,
"level_effective": "runtime",
"runtime": {
"status": "loaded_and_stepped",
"steps": 8,
"timestep": float(model.options.timestep),
"nq": len(data.low.dof_positions),
"nv": len(data.low.dof_velocities),
},
}
except Exception as exc:
return {
"ok": False,
"path": str(runtime_scene),
"descriptor": descriptor,
"level_effective": "runtime",
"runtime": {"status": "failed", "error": f"{type(exc).__name__}: {exc}"},
}
def _motrixsim_tooling() -> dict[str, Any]:
candidates = [
Path("/opt/motrixsim-docs"),
Path("/opt/Motphys/motrixsim-docs/examples/hello_motrixsim.py"),
Path("/opt/Motphys/MotrixLab"),
Path("/opt/Motphys/motrixsim_playground"),
@ -2696,6 +2837,7 @@ def collect_task_reports(store: PlatformStore, task_id: str) -> dict[str, Any]:
"reconstruction_command.json",
"reconstruction_report.json",
"validation_report.json",
"motrixsim_asset_import_report.json",
"splat_optimization_report.json",
"prepared_manifest.json",
"dataset_manifest.json",

View File

@ -707,7 +707,7 @@ def create_app(config: PlatformConfig | None = None) -> FastAPI:
payload = CreateTaskRequest(type=task_type, params=params)
_validate_task_payload(payload, cfg)
_validate_task_resources(store, payload)
if payload.type not in {"scene_reconstruction", "reconstruction_preflight", "media_prepare", "expert_collection", "training", "inference", "renderer_benchmark", "scene_cover_render", "scene_splat_optimize", "hf_import", "bos_import", "simulator_validation"}:
if payload.type not in {"scene_reconstruction", "reconstruction_preflight", "media_prepare", "expert_collection", "training", "inference", "renderer_benchmark", "scene_cover_render", "scene_splat_optimize", "hf_import", "bos_import", "motrixsim_asset_import", "simulator_validation"}:
raise ValueError(f"unknown task type: {payload.type}")
run_dir = cfg.runs_dir / payload.type / _next_run_name(cfg.runs_dir / payload.type, payload.type)
return store.create_task(task_type=payload.type, params=payload.params, run_dir=run_dir)
@ -821,7 +821,9 @@ def create_app(config: PlatformConfig | None = None) -> FastAPI:
return StreamingResponse(stream(), media_type="text/event-stream", headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})
@app.post("/api/tasks")
def create_task(payload: CreateTaskRequest) -> dict[str, Any]:
def create_task(payload: CreateTaskRequest, request: Request) -> dict[str, Any]:
if payload.type == "motrixsim_asset_import" and request.state.user.get("role") != "admin":
raise HTTPException(status_code=403, detail="仅管理员可以导入平台内置仿真资产")
try:
return _queue_task(payload.type, payload.params)
except ValueError as exc:
@ -1193,6 +1195,7 @@ def _task_type_label(task_type: str) -> str:
"media_prepare": "媒体准备",
"reconstruction_preflight": "重建预检",
"scene_reconstruction": "场景重建",
"motrixsim_asset_import": "MotrixSim 资产导入",
"simulator_validation": "仿真校验",
"expert_collection": "专家采集",
"training": "模型训练",
@ -1211,6 +1214,11 @@ def _validate_task_payload(payload: CreateTaskRequest, cfg: PlatformConfig) -> N
raise HTTPException(status_code=400, detail="bos_import requires prefix")
if not 1 <= int(params.get("max_objects", 1000)) <= 1000:
raise HTTPException(status_code=400, detail="max_objects must be between 1 and 1000")
if payload.type == "motrixsim_asset_import":
if not 1 <= int(params.get("validation_steps", 120)) <= 5000:
raise HTTPException(status_code=400, detail="validation_steps must be between 1 and 5000")
if not 1 <= int(params.get("max_parlour_meshes", 240)) <= 1000:
raise HTTPException(status_code=400, detail="max_parlour_meshes must be between 1 and 1000")
if payload.type == "hf_import":
repo_type = params.get("repo_type", "dataset")
if repo_type != "dataset":

View File

@ -24,7 +24,7 @@ const $ = (id) => document.getElementById(id);
const taskScopes = {
dataTaskList: ["hf_import", "media_prepare"],
sceneTaskList: ["scene_reconstruction", "reconstruction_preflight", "simulator_validation", "renderer_benchmark", "scene_cover_render", "scene_splat_optimize"],
sceneTaskList: ["scene_reconstruction", "reconstruction_preflight", "motrixsim_asset_import", "simulator_validation", "renderer_benchmark", "scene_cover_render", "scene_splat_optimize"],
collectTaskList: ["expert_collection"],
trainTaskList: ["training"],
inferTaskList: ["inference"],
@ -1172,6 +1172,7 @@ function taskTypeLabel(type) {
media_prepare: "输入准备",
reconstruction_preflight: "重建预检",
scene_reconstruction: "场景重建",
motrixsim_asset_import: "MotrixSim 资产导入",
simulator_validation: "仿真校验",
renderer_benchmark: "渲染器对比",
scene_cover_render: "场景封面",
@ -1361,7 +1362,7 @@ function exportSummary(payload = {}) {
function switchTaskPage(type) {
if (["hf_import", "media_prepare"].includes(type)) switchTab("data");
else if (["scene_reconstruction", "reconstruction_preflight", "simulator_validation", "renderer_benchmark", "scene_cover_render", "scene_splat_optimize"].includes(type)) switchTab("reconstruct");
else if (["scene_reconstruction", "reconstruction_preflight", "motrixsim_asset_import", "simulator_validation", "renderer_benchmark", "scene_cover_render", "scene_splat_optimize"].includes(type)) switchTab("reconstruct");
else if (type === "expert_collection") switchTab("collect");
else if (type === "training") switchTab("train");
else if (type === "inference") switchTab("infer");

View File

@ -166,6 +166,81 @@ def test_production_task_gates_reject_fake_routes(tmp_path: Path) -> None:
assert fake_expert.status_code == 400
def test_motrixsim_asset_import_is_admin_only_and_validated(tmp_path: Path) -> None:
config = PlatformConfig(
app_root=ROOT,
workspace_dir=tmp_path / "workspace",
worker_mode="api",
production_mode=True,
auth_enabled=True,
bootstrap_admin_password="Admin!Password123",
)
with TestClient(create_app(config)) as client:
assert client.post("/api/auth/login", json={"username": "admin", "password": "Admin!Password123"}).status_code == 200
assert client.post(
"/api/auth/change-password",
json={"current_password": "Admin!Password123", "new_password": "Changed!Password456"},
).status_code == 200
assert client.post("/api/auth/login", json={"username": "admin", "password": "Changed!Password456"}).status_code == 200
assert client.post(
"/api/users",
json={"username": "asset.engineer", "password": "Engineer!Password123", "role": "engineer"},
).status_code == 200
invalid = client.post(
"/api/tasks",
json={"type": "motrixsim_asset_import", "params": {"validation_steps": 0}},
)
assert invalid.status_code == 400
queued = client.post(
"/api/tasks",
json={"type": "motrixsim_asset_import", "params": {"validation_steps": 120, "max_parlour_meshes": 240}},
)
assert queued.status_code == 200
assert queued.json()["type"] == "motrixsim_asset_import"
assert client.post("/api/auth/logout").status_code == 200
assert client.post("/api/auth/login", json={"username": "asset.engineer", "password": "Engineer!Password123"}).status_code == 200
assert client.post(
"/api/auth/change-password",
json={"current_password": "Engineer!Password123", "new_password": "Engineer!Changed456"},
).status_code == 200
assert client.post("/api/auth/login", json={"username": "asset.engineer", "password": "Engineer!Changed456"}).status_code == 200
forbidden = client.post("/api/tasks", json={"type": "motrixsim_asset_import", "params": {}})
assert forbidden.status_code == 403
@pytest.mark.integration
def test_runtime_required_validation_steps_mujoco_and_motrixsim(tmp_path: Path) -> None:
pytest.importorskip("mujoco")
pytest.importorskip("motrixsim")
package = tmp_path / "runtime-scene"
simulator_assets = package / "simulator_assets"
simulator_assets.mkdir(parents=True)
(package / "scene.json").write_text('{"schema":"motrixsim.scene.v1"}\n', encoding="utf-8")
(simulator_assets / "scene.xml").write_text(
'<mujoco model="runtime-validation"><option timestep="0.002"/><worldbody><geom type="plane" size="1 1 .1"/><body pos="0 0 .2"><freejoint/><geom type="sphere" size=".03" mass=".1"/></body></worldbody></mujoco>\n',
encoding="utf-8",
)
config = PlatformConfig(app_root=ROOT, workspace_dir=tmp_path / "workspace", allowed_path_roots=(tmp_path,))
with TestClient(create_app(config)) as client:
created = client.post(
"/api/tasks",
json={
"type": "simulator_validation",
"params": {"scene_path": str(package), "simulators": ["mujoco", "motrixsim"], "level": "runtime_required"},
},
).json()
for _ in range(80):
task = client.get(f"/api/tasks/{created['id']}").json()
if task["status"] in {"succeeded", "failed"}:
break
__import__("time").sleep(0.1)
assert task["status"] == "succeeded", task.get("error")
simulators = task["result"]["report"]["simulators"]
assert simulators["mujoco"]["runtime"]["status"] == "loaded"
assert simulators["motrixsim"]["runtime"]["status"] == "loaded_and_stepped"
assert simulators["motrixsim"]["runtime"]["steps"] == 8
@pytest.mark.integration
def test_real_rm65_physical_collection_writes_act_hdf5(tmp_path: Path) -> None:
scene = ROOT / "workspace/motrixsim_assets/parlour_rm65_pick_place/simulator_assets/rm65_table_pick_place.xml"