Complete 26.3 parity acceptance and dual-version release workflow

scripts/regression_multiplayer_263.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Two real 26.3 clients, one sequential server, normal book travel and full restart."""
+from server_test_lock import server_test_lock
+import json
+import os
+from pathlib import Path
+import shutil
+import signal
+import socket
+import subprocess
+import tempfile
+import time
+
+ROOT = Path(__file__).resolve().parents[1]
+LOGS = ROOT / "build/verification/multiplayer263"
+
+
+class Handoff(RuntimeError):
+    pass
+
+
+def wait_for(processes, log, marker, timeout=60):
+    last_progress = time.monotonic()
+    last_stage = ""
+    while True:
+        text = log.read_text(errors="replace") if log.exists() else ""
+        if marker in text:
+            return
+        if "MC263_MATRIX FAIL" in text:
+            raise RuntimeError(f"Multiplayer assertion failed; inspect {log}")
+        stages = [line for line in text.splitlines() if "MC263_MATRIX PHASE" in line]
+        if stages and stages[-1] != last_stage:
+            last_stage = stages[-1]
+            last_progress = time.monotonic()
+            print(last_stage, flush=True)
+        if any(process.poll() is not None for process in processes):
+            raise RuntimeError(f"Process exited before {marker}; inspect {LOGS}")
+        if time.monotonic() - last_progress >= timeout:
+            raise Handoff(f"Stalled at {last_stage or marker}; stop and hand off, do not retry")
+        time.sleep(.25)
+
+
+def stop(process, server=False):
+    if process is None or process.poll() is not None:
+        return
+    if server:
+        try:
+            process.stdin.write("stop\n")
+            process.stdin.flush()
+            process.wait(timeout=25)
+            return
+        except (BrokenPipeError, subprocess.TimeoutExpired):
+            pass
+    os.killpg(process.pid, signal.SIGTERM)
+    try:
+        process.wait(timeout=10)
+    except subprocess.TimeoutExpired:
+        os.killpg(process.pid, signal.SIGKILL)
+        process.wait()
+
+
+def run():
+    if not os.environ.get("DISPLAY") and not os.environ.get("WAYLAND_DISPLAY"):
+        raise SystemExit("This real-client matrix needs a graphics session. Use the manual checklist.")
+    LOGS.mkdir(parents=True, exist_ok=True)
+    work = Path(tempfile.mkdtemp(prefix="rivencraft-multiplayer263-"))
+    server = work / "server"
+    server.mkdir()
+    with socket.socket() as reservation:
+        reservation.bind(("127.0.0.1", 0))
+        port = reservation.getsockname()[1]
+    settings = {"layers": [{"height": 1, "block": "minecraft:bedrock"},
+                           {"height": 2, "block": "minecraft:dirt"},
+                           {"height": 1, "block": "minecraft:grass_block"}],
+                "biome": "minecraft:plains"}
+    (server / "eula.txt").write_text("eula=true\n")
+    (server / "server.properties").write_text(
+        f"server-ip=127.0.0.1\nserver-port={port}\nonline-mode=false\nwhite-list=false\n"
+        "view-distance=2\nsimulation-distance=2\ngenerate-structures=false\n"
+        "level-type=minecraft:flat\nlevel-seed=263100\ngenerator-settings=" + json.dumps(settings) + "\n")
+    for name in ("One", "Two"):
+        client = work / f"client-{name}"
+        (client / "config").mkdir(parents=True)
+        (client / "config/neoforge-client.toml").write_text("showLoadWarnings=false\n")
+        (client / "options.txt").write_text("renderDistance:2\nsimulationDistance:5\nmaxFps:25\npauseOnLostFocus:false\n")
+    init = work / "fixture.gradle"
+    init.write_text("""
+gradle.beforeProject { p ->
+    p.layout.buildDirectory.set(p.file(System.getenv('RIVENCRAFT_MATRIX_WORK') + '/build'))
+    p.afterEvaluate {
+        p.sourceSets.main.java.srcDir(p.file('""" + str(ROOT / "scripts/fixtures/mc263_multiplayer") + """'))
+        p.neoForge.runs.client.gameDirectory = p.file(System.getenv('RIVENCRAFT_MATRIX_WORK') + '/client-' + p.findProperty('matrixClient'))
+        p.neoForge.runs.client.programArgument('--width')
+        p.neoForge.runs.client.programArgument('640')
+        p.neoForge.runs.client.programArgument('--height')
+        p.neoForge.runs.client.programArgument('480')
+    }
+}
+""")
+    env = dict(os.environ, RIVENCRAFT_MATRIX_WORK=str(work))
+    base = [str(ROOT / "gradlew"), "-p", str(ROOT / "ports/mc263"),
+            "-I", str(init), "--no-daemon", "--console=plain"]
+    server_process = None
+    clients = []
+    handles = []
+    try:
+        # Build fixture classes once in an isolated output tree. Shipping outputs
+        # are never overwritten or packaged with these extra test channels.
+        with (LOGS / "compile.log").open("w") as output:
+            subprocess.run(base + ["classes"], cwd=ROOT, env=env, stdout=output,
+                           stderr=subprocess.STDOUT, check=True, timeout=300)
+        for phase in ("first", "restart"):
+            log = LOGS / f"server-{phase}.log"
+            output = log.open("w")
+            handles.append(output)
+            server_process = subprocess.Popen(base + ["runServer", f"-PserverRunDir={server}"],
+                    cwd=ROOT, env=env, stdin=subprocess.PIPE, stdout=output,
+                    stderr=subprocess.STDOUT, text=True, start_new_session=True)
+            wait_for([server_process], log, "Done (")
+            clients = []
+            for name in ("One", "Two"):
+                output = (LOGS / f"client-{name}-{phase}.log").open("w")
+                handles.append(output)
+                clients.append(subprocess.Popen(base + ["runClient", f"-PmatrixClient={name}",
+                        f"-PclientName=Matrix{name}", f"-PconnectAddress=127.0.0.1:{port}"],
+                        cwd=ROOT, env=env, stdout=output, stderr=subprocess.STDOUT,
+                        text=True, start_new_session=True))
+            wait_for([server_process], log, "MC263_MATRIX " + ("FIRST_PASS" if phase == "first" else "RESTART_PASS"))
+            for process in clients:
+                process.wait(timeout=30)
+                if process.returncode:
+                    raise RuntimeError("Client exited unsuccessfully; inspect client log")
+            clients.clear()
+            stop(server_process, server=True)
+            if server_process.returncode:
+                raise RuntimeError("Server exited unsuccessfully")
+            server_process = None
+            print(f"PASS two-client {phase}", flush=True)
+    except Handoff as error:
+        directions = (
+            f"{error}\n\nManual test: two clients on one 26.3 server. Create a new Age while both "
+            "are online; both visit via Descriptive Books and return via Linking Books. "
+            "Create a second Age with different sky/lighting/weather. Restart and reconnect both, "
+            "confirm names, seeds and return links. Refuse occupied unload, then vacate and "
+            "unload/reload/reseed/retire an empty Age. A retired book must leave the player at source.\n"
+            "Temporary worlds were removed; do not rerun this stalled test automatically.\n")
+        (LOGS / "HANDOFF.md").write_text(directions)
+        print("HANDOFF: " + directions, flush=True)
+        raise SystemExit(2)
+    finally:
+        for process in clients:
+            stop(process)
+        stop(server_process, server=True)
+        for handle in handles:
+            handle.close()
+        shutil.rmtree(work)
+        print(f"Removed all temporary client/server worlds and fixture outputs; logs: {LOGS}", flush=True)
+
+
+def main():
+    with server_test_lock():
+        run()
+
+
+if __name__ == "__main__":
+    main()