Files
marqdo-cli/tools/release/smoke.py
T
cflmy 2c7c4f31e7
Linux strict security lane (G-C) / strict isolation escape matrix (push) Waiting to run
ci/woodpecker/push/main Pipeline was successful
ci/woodpecker/manual/performance Pipeline was successful
CI / fmt + clippy + test (Linux x86_64) (push) Waiting to run
CI / schema instance validation + consumers (push) Waiting to run
CI / runtime contract (macos-latest) (push) Waiting to run
CI / runtime contract (windows-latest) (push) Waiting to run
release(3.0.0-beta.1): product version migration, beta gates, archive tooling and developer docs
REL-01: workspace/CLI/Analysis product version 3.0.0-beta.1 with updated
Cargo.lock; project.marqdo is enforced against the running core with
package.marqdo_range_invalid/package.marqdo_incompatible fail-closed
diagnostics; Tool SemVer prerelease negotiation tests; init template and
examples use the beta range. Verify init derives the project name from the
target directory instead of falling back to 'example'.

REL-02: beta support matrix is Linux x86_64 only; macOS/Windows are explicitly
experimental/unclaimed; strict policy and G4 Beta-only WARN are documented for
the release evidence.

REL-03: deterministic release packaging (tools/release/package.py) ships the
CLI and provider worker together with SOURCE_SHA, RELEASE_INFO.json,
known-limitations, specs, developer docs, examples incl. built plugin/provider
artifacts and consumers; tools/release/smoke.py cold-install tests the archive.

REL-04: docs/developers entry pages; corrected and self-contained third-party
integration handbook; stale Proposed/native-only/informational spec claims
fixed; release/status/compatibility/changelog/releasing docs updated.

REL-05: release_evidence.py gains an explicit beta profile
(BETA_RELEASE_CANDIDATE) distinct from the stable profile; Woodpecker build
step now packages and smoke-tests the archive on every pipeline.

Adds a runnable Resource Provider v2 example and corrects check --emit to
Analysis v2.
2026-11-22 02:31:32 +08:00

340 lines
13 KiB
Python

#!/usr/bin/env python3
"""Cold-install smoke test for a built Marqdo release archive.
Extracts the archive into a fresh temporary directory and exercises the shipped
binaries only (never the development source tree): version/help, check/run/call,
lock/sync for a path dependency, Analysis v2 + Trace v2 consumers, Tool
install/dispatch, native and worker plugin transports, foreign kernel, the
Provider v2 worker (positive, unauthorized and missing-helper fail-closed), and
strict mode when the host genuinely supports it.
Usage:
python3 tools/release/smoke.py --archive dist/marqdo-3.0.0-beta.1-x86_64-unknown-linux-gnu.tar.gz
"""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path
def fail(message: str) -> "NoReturn":
print(f"smoke: FAIL: {message}", file=sys.stderr)
raise SystemExit(1)
def sha256_file(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as handle:
for chunk in iter(lambda: handle.read(1024 * 1024), b""):
digest.update(chunk)
return digest.hexdigest()
class Runner:
def __init__(self, root: Path):
self.root = root
self.marqdo = root / "marqdo"
self.env = dict(os.environ)
self.env.pop("MARQDO_MODE", None)
self.env["MARQDO_TOOL_HOME"] = str(root / "tool-home")
def run(
self,
args: list[str],
*,
expect: int = 0,
contains: str | None = None,
cwd: Path | None = None,
env: dict | None = None,
) -> subprocess.CompletedProcess:
command = [str(self.marqdo), *args]
merged = dict(self.env)
if env:
merged.update(env)
result = subprocess.run(
command,
cwd=cwd or self.root,
env=merged,
capture_output=True,
text=True,
timeout=120,
)
shown = " ".join(command[1:])
if result.returncode != expect:
fail(
f"`marqdo {shown}` exited {result.returncode}, expected {expect}\n"
f"stdout:\n{result.stdout}\nstderr:\n{result.stderr}"
)
if contains is not None:
haystack = result.stdout + result.stderr
if contains not in haystack:
fail(f"`marqdo {shown}` output does not contain {contains!r}:\n{haystack}")
return result
def json(self, args: list[str]) -> dict:
result = self.run([*args, "--json"])
try:
return json.loads(result.stdout)
except json.JSONDecodeError as error:
fail(f"`marqdo {' '.join(args)} --json` is not JSON: {error}\n{result.stdout}")
def main(argv: list[str]) -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--archive", required=True)
parser.add_argument("--workdir", default=None, help="keep the extracted tree here")
parser.add_argument("--skip-strict", action="store_true")
args = parser.parse_args(argv)
archive = Path(args.archive).resolve()
if not archive.is_file():
fail(f"archive not found: {archive}")
checksum_file = archive.with_name(archive.name + ".sha256")
if checksum_file.is_file():
expected = checksum_file.read_text(encoding="utf-8").split()[0]
actual = sha256_file(archive)
if expected != actual:
fail(f"archive sha256 {actual} does not match {checksum_file}: {expected}")
if args.workdir:
root = Path(args.workdir).resolve()
shutil.rmtree(root, ignore_errors=True)
root.mkdir(parents=True)
else:
root = Path(tempfile.mkdtemp(prefix="marqdo-smoke-"))
try:
shutil.unpack_archive(str(archive), str(root))
entries = [path for path in root.iterdir() if path.is_dir()]
if len(entries) != 1:
fail(f"archive must contain exactly one top-level directory, found {entries}")
install = entries[0]
info = json.loads((install / "RELEASE_INFO.json").read_text(encoding="utf-8"))
version = info["product_version"]
source_sha = info["source_sha"]
if (install / "SOURCE_SHA").read_text(encoding="utf-8").strip() != source_sha:
fail("SOURCE_SHA does not match RELEASE_INFO.json")
for name in ("marqdo", "marqdo-provider-worker"):
binary = install / name
if not binary.is_file() or not os.access(binary, os.X_OK):
fail(f"{name} is missing or not executable in the archive")
recorded = info["binaries"][name]["sha256"]
if sha256_file(binary) != recorded:
fail(f"{name} sha256 does not match RELEASE_INFO.json")
runner = Runner(install)
print(f"smoke: archive version {version}, source {source_sha}")
version_out = runner.run(["--version"]).stdout.strip()
if version_out != f"marqdo {version}":
fail(f"--version printed {version_out!r}, expected 'marqdo {version}'")
runner.run(["--help"])
runner.run(["check", "examples/multi-module/index.mq.md"])
hello = runner.run(["run", "examples/hello.mq.md"]).stdout
if "你好" not in hello:
fail(f"hello example printed {hello!r}")
factor = runner.run(
["call", "examples/factorial.mq.md", "阶乘", "--arg", "n=5"]
).stdout.strip()
if factor != "120":
fail(f"factorial call printed {factor!r}, expected 120")
# Static Analysis v2 + Trace v2 through the public consumers.
analysis = install / "analysis.json"
trace = install / "trace.json"
runner.run(
[
"check",
"examples/multi-module/index.mq.md",
"--emit",
str(analysis),
]
)
runner.run(["check", "examples/multi-module/index.mq.md", "--refs"])
document = json.loads(analysis.read_text(encoding="utf-8"))
if document.get("schema") != "marqdo.analysis" or document.get("schema_version") != 2:
fail("--emit did not write Analysis v2")
if document.get("producer", {}).get("version") != version:
fail("Analysis producer.version does not match the released product version")
runner.run(
[
"run",
"examples/multi-module/index.mq.md",
"--trace-file",
str(trace),
]
)
run_trace = json.loads(trace.read_text(encoding="utf-8"))
if run_trace.get("schema") != "marqdo.trace" or run_trace.get("schema_version") != 2:
fail("--trace-file did not write Trace v2")
for consumer in ("analysis_consumer.py", "trace_consumer.py"):
command = [
sys.executable,
str(install / "tests" / "consumers" / consumer),
str(analysis),
]
if consumer == "trace_consumer.py":
command.append(str(trace))
result = subprocess.run(command, capture_output=True, text=True)
if result.returncode != 0:
fail(f"{consumer} failed:\n{result.stdout}\n{result.stderr}")
validate = subprocess.run(
[
sys.executable,
str(install / "tests" / "consumers" / "validate_protocols.py"),
str(analysis),
str(trace),
str(install / "examples" / "tool-unknown-name" / "tool.json"),
],
capture_output=True,
text=True,
)
if validate.returncode != 0:
if "jsonschema" in validate.stderr and "ModuleNotFoundError" in validate.stderr:
print("smoke: note: jsonschema is not installed; schema validation skipped")
else:
fail(f"validate_protocols.py failed:\n{validate.stdout}\n{validate.stderr}")
# Tool Protocol v1: install and dispatch an independent process.
runner.run(["tool", "install", "examples/tool-unknown-name/tool.json"])
listed = runner.run(["tool", "list"]).stdout
if "benchmark" not in listed:
fail(f"tool list does not contain benchmark:\n{listed}")
benchmark = runner.run(["benchmark", "run", "."]).stdout
if "benchmark tool:" not in benchmark:
fail(f"tool dispatch output unexpected:\n{benchmark}")
# Callable plugin ABI v1: native (explicit trust) and worker transports.
native = runner.run(
[
"run",
"examples/plugin-demo/plugin-call.mq.md",
"--plugin",
"examples/plugin-demo/build",
"--trust-native-plugin",
"--allow-plugin",
"demo.solver",
]
).stdout.strip()
if native != "42":
fail(f"native plugin example printed {native!r}, expected 42")
runner.run(
["plugin", "inspect", "examples/plugin-demo/build", "--json"]
)
worker_dir = install / "worker-plugin"
worker_dir.mkdir()
shutil.copy2(install / "examples/plugin-demo/build/solver.so", worker_dir / "solver.so")
worker_manifest = (
install / "examples/plugin-demo/build/plugin.yaml"
).read_text(encoding="utf-8").replace("kind: native", "kind: worker")
(worker_dir / "plugin.yaml").write_text(worker_manifest, encoding="utf-8")
worker = runner.run(
[
"run",
"examples/plugin-demo/plugin-call.mq.md",
"--plugin",
str(worker_dir),
"--allow-plugin",
"demo.solver",
]
).stdout.strip()
if worker != "42":
fail(f"worker plugin example printed {worker!r}, expected 42")
# Foreign kernel: no core change for a new language tag.
kernel = runner.run(
[
"run",
"examples/kernel-mock/demo.mq.md",
"--kernel",
"examples/kernel-mock/kernel.json",
"--allow-foreign",
]
).stdout.strip()
if kernel != "42":
fail(f"foreign kernel example printed {kernel!r}, expected 42")
# Resource Provider v2 through the shipped worker helper.
provider = "examples/provider-demo/build/provider.json"
provider_run = runner.json(
[
"run",
"examples/provider-demo/demo.mq.md",
"--provider",
provider,
"--allow-provider",
"demo.sensor",
]
)
if not provider_run.get("success"):
fail(f"provider run was not successful: {provider_run}")
reads = [
event
for event in provider_run.get("trace", [])
if event.get("op") == "resource.read"
]
if not reads or "count=5" not in str(reads[-1].get("result")):
fail(f"provider read did not report five bytes: {reads}")
runner.run(
[
"run",
"examples/provider-demo/unauthorized.mq.md",
"--provider",
provider,
],
expect=1,
contains="permission.denied",
)
worker_binary = install / "marqdo-provider-worker"
shutil.move(str(worker_binary), str(worker_binary.with_suffix(".hidden")))
try:
runner.run(
[
"run",
"examples/provider-demo/demo.mq.md",
"--provider",
provider,
"--allow-provider",
"demo.sensor",
],
expect=1,
contains="ext.worker_unavailable",
)
finally:
shutil.move(str(worker_binary.with_suffix(".hidden")), str(worker_binary))
# pure mode: language execution without project grants.
runner.run(["run", "examples/hello.mq.md", "--mode", "pure"])
if not args.skip_strict:
platform = runner.json(["inspect", "examples/hello.mq.md", "--platform"])
strict = platform.get("platform", {}).get("strict", {})
if strict.get("state") == "available":
runner.run(["run", "examples/hello.mq.md", "--mode", "strict"])
print(f"smoke: strict available ({strict.get('mechanism')}) and exercised")
else:
refused = runner.run(
["run", "examples/hello.mq.md", "--mode", "strict"],
expect=1,
)
if "strict" not in (refused.stdout + refused.stderr):
fail("unsupported strict mode did not fail closed with a strict diagnostic")
print(f"smoke: strict unsupported on this host; fail-closed refused: {strict}")
print("smoke: PASS")
return 0
finally:
if not args.workdir:
shutil.rmtree(root, ignore_errors=True)
if __name__ == "__main__":
raise SystemExit(main(sys.argv[1:]))