update
This commit is contained in:
Executable
+592
@@ -0,0 +1,592 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
umask 022
|
||||
|
||||
gate_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd -P)
|
||||
root=$(CDPATH= cd -- "$gate_dir/../../../.." && pwd -P)
|
||||
input=$gate_dir/P15-030-input.json
|
||||
base=
|
||||
output=
|
||||
deadline=60
|
||||
|
||||
while test "$#" -gt 0; do
|
||||
case "$1" in
|
||||
--base)
|
||||
test "$#" -ge 2 || { printf '%s\n' '--base requires a commit' >&2; exit 20; }
|
||||
base=$2
|
||||
shift 2
|
||||
;;
|
||||
--output)
|
||||
test "$#" -ge 2 || { printf '%s\n' '--output requires a directory' >&2; exit 20; }
|
||||
output=$2
|
||||
shift 2
|
||||
;;
|
||||
*)
|
||||
printf 'unknown argument: %s\n' "$1" >&2
|
||||
exit 20
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
test -n "$base" || { printf '%s\n' '--base is required' >&2; exit 20; }
|
||||
test -n "$output" || { printf '%s\n' '--output is required' >&2; exit 20; }
|
||||
test -f "$input" || { printf 'missing input: %s\n' "$input" >&2; exit 20; }
|
||||
for tool in git mktemp python3 sha256sum timeout; do
|
||||
command -v "$tool" >/dev/null 2>&1 || {
|
||||
printf 'missing required host tool: %s\n' "$tool" >&2
|
||||
exit 21
|
||||
}
|
||||
done
|
||||
case "$output" in
|
||||
/*) ;;
|
||||
*) output=$PWD/$output ;;
|
||||
esac
|
||||
test ! -e "$output" || { printf 'refusing existing output: %s\n' "$output" >&2; exit 20; }
|
||||
mkdir -p "$output"
|
||||
work=$(mktemp -d "${TMPDIR:-/tmp}/P15-030.XXXXXX")
|
||||
|
||||
cleanup_trap()
|
||||
{
|
||||
rm -rf -- "$work"
|
||||
}
|
||||
trap cleanup_trap EXIT HUP INT TERM
|
||||
|
||||
python3 -B - "$output/command-argv.json" "$0" --base "$base" --output "$output" <<'PY'
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
|
||||
Path(sys.argv[1]).write_text(
|
||||
json.dumps(sys.argv[2:], ensure_ascii=True, separators=(",", ":")) + "\n",
|
||||
encoding="ascii",
|
||||
)
|
||||
PY
|
||||
python3 -B - "$output/ownership.json" "$work" "$output" <<'PY'
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
|
||||
Path(sys.argv[1]).write_text(
|
||||
json.dumps(
|
||||
{
|
||||
"owned_temporary_paths": [sys.argv[2]],
|
||||
"persistent_output": sys.argv[3],
|
||||
"owned_processes": [],
|
||||
"owned_ports": [],
|
||||
"owned_overlays": [],
|
||||
"qemu": "NOT_RUN",
|
||||
},
|
||||
ensure_ascii=True,
|
||||
indent=2,
|
||||
sort_keys=True,
|
||||
) + "\n",
|
||||
encoding="ascii",
|
||||
)
|
||||
PY
|
||||
|
||||
set +e
|
||||
timeout -k 5 "$deadline" python3 -B - \
|
||||
"$root" "$input" "$base" "$output" "$deadline" <<'PY' \
|
||||
>"$output/stdout.log" 2>"$output/stderr.log"
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
from typing import Any
|
||||
|
||||
|
||||
ROOT = Path(sys.argv[1])
|
||||
INPUT = Path(sys.argv[2])
|
||||
REQUESTED_BASE = sys.argv[3]
|
||||
OUTPUT = Path(sys.argv[4])
|
||||
DEADLINE = int(sys.argv[5])
|
||||
SPEC = json.loads(INPUT.read_text(encoding="utf-8"))
|
||||
|
||||
|
||||
class GateFailure(RuntimeError):
|
||||
def __init__(self, status: str, reason: str):
|
||||
super().__init__(reason)
|
||||
self.status = status
|
||||
self.reason = reason
|
||||
|
||||
|
||||
def sha256_bytes(data: bytes) -> str:
|
||||
return hashlib.sha256(data).hexdigest()
|
||||
|
||||
|
||||
def write_json(path: Path, value: Any) -> None:
|
||||
path.write_text(
|
||||
json.dumps(value, ensure_ascii=True, indent=2, sort_keys=True) + "\n",
|
||||
encoding="ascii",
|
||||
)
|
||||
|
||||
|
||||
def run_bytes(argv: list[str], allowed: set[int] | None = None) -> bytes:
|
||||
try:
|
||||
completed = subprocess.run(
|
||||
argv,
|
||||
cwd=ROOT,
|
||||
check=False,
|
||||
stdin=subprocess.DEVNULL,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE,
|
||||
timeout=20,
|
||||
)
|
||||
except subprocess.TimeoutExpired as error:
|
||||
raise GateFailure(
|
||||
"INFRA_BLOCKED", f"command timed out: {' '.join(argv)}"
|
||||
) from error
|
||||
accepted = {0} if allowed is None else allowed
|
||||
if completed.returncode not in accepted:
|
||||
detail = completed.stderr.decode("utf-8", errors="replace").strip()
|
||||
raise GateFailure(
|
||||
"RUNNER_FAIL",
|
||||
f"command failed ({completed.returncode}): {' '.join(argv)}: {detail}",
|
||||
)
|
||||
return completed.stdout
|
||||
|
||||
|
||||
def git_text(*args: str) -> str:
|
||||
return run_bytes(["git", "-C", str(ROOT), *args]).decode(
|
||||
"utf-8", errors="strict"
|
||||
).strip()
|
||||
|
||||
|
||||
def source_at(commit: str, relative: str) -> bytes:
|
||||
return run_bytes(["git", "-C", str(ROOT), "show", f"{commit}:{relative}"])
|
||||
|
||||
|
||||
def parse_ls_tree(raw: bytes) -> dict[str, dict[str, Any]]:
|
||||
entries: dict[str, dict[str, Any]] = {}
|
||||
for record in raw.split(b"\0"):
|
||||
if not record:
|
||||
continue
|
||||
metadata, path_bytes = record.split(b"\t", 1)
|
||||
mode, kind, oid, size = metadata.decode("ascii").split()
|
||||
path = path_bytes.decode("utf-8", errors="strict")
|
||||
entries[path] = {
|
||||
"mode": mode,
|
||||
"kind": kind,
|
||||
"oid": oid,
|
||||
"size": int(size),
|
||||
}
|
||||
return entries
|
||||
|
||||
|
||||
def grep_paths(commit: str, expressions: list[str], fixed: bool = False) -> list[str]:
|
||||
argv = ["git", "-C", str(ROOT), "grep", "-I", "-l"]
|
||||
if fixed:
|
||||
argv.append("-F")
|
||||
else:
|
||||
argv.append("-i")
|
||||
for expression in expressions:
|
||||
argv.extend(["-e", expression])
|
||||
argv.extend(
|
||||
[
|
||||
commit,
|
||||
"--",
|
||||
"repo-pre-15",
|
||||
"planning/pre15",
|
||||
":(exclude)planning/pre15/introduction.md",
|
||||
":(exclude)repo-pre-15/tests/pre15/gates/P15-030.sh",
|
||||
":(exclude)repo-pre-15/tests/pre15/gates/P15-030-input.json",
|
||||
":(exclude)repo-pre-15/docs/pre15-stage0/P15-030.md",
|
||||
]
|
||||
)
|
||||
raw = run_bytes(argv, {0, 1})
|
||||
prefix = f"{commit}:"
|
||||
paths = []
|
||||
for line in raw.decode("utf-8", errors="strict").splitlines():
|
||||
if not line.startswith(prefix):
|
||||
raise GateFailure("RUNNER_FAIL", f"unexpected git grep path: {line}")
|
||||
paths.append(line[len(prefix):])
|
||||
return sorted(paths)
|
||||
|
||||
|
||||
def classify_reference(path: str) -> str:
|
||||
if path.startswith("planning/pre15/evidence/"):
|
||||
return "historical-evidence"
|
||||
if path.startswith("planning/pre15/"):
|
||||
return "planning-proposal"
|
||||
if path.startswith("repo-pre-15/tests/"):
|
||||
return "test-only"
|
||||
if path.startswith("repo-pre-15/docs/") or path.startswith("repo-pre-15/current/"):
|
||||
return "project-report-or-documentation"
|
||||
return "possible-operational-consumer"
|
||||
|
||||
|
||||
def require_text(record: dict[str, Any], field: str) -> str:
|
||||
value = record.get(field)
|
||||
if not isinstance(value, str) or not value.strip():
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer declaration lacks {field}")
|
||||
return value.strip()
|
||||
|
||||
|
||||
def validate_consumer_manifest(
|
||||
path: str,
|
||||
data: bytes,
|
||||
entries: dict[str, dict[str, Any]],
|
||||
commit: str,
|
||||
) -> dict[str, Any]:
|
||||
try:
|
||||
record = json.loads(data.decode("utf-8", errors="strict"))
|
||||
except (UnicodeDecodeError, json.JSONDecodeError) as error:
|
||||
raise GateFailure("RUNNER_FAIL", f"invalid consumer manifest: {path}") from error
|
||||
if not isinstance(record, dict):
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer manifest is not an object: {path}")
|
||||
contract = SPEC["consumer_contract"]
|
||||
if record.get("schema") != contract["schema_marker"]:
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer manifest schema mismatch: {path}")
|
||||
consumer_class = require_text(record, "consumer_class")
|
||||
if consumer_class not in contract["allowed_classes"]:
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer class is not operational: {path}")
|
||||
if record.get("production_use") is not True:
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer is not declared in production use: {path}")
|
||||
access_mode = require_text(record, "access_mode")
|
||||
if access_mode != contract["required_access_mode"]:
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer access mode is not privileged: {path}")
|
||||
for field in (
|
||||
"consumer_id",
|
||||
"owner",
|
||||
"version",
|
||||
"entrypoint",
|
||||
"workflow",
|
||||
"deployment_reference",
|
||||
):
|
||||
require_text(record, field)
|
||||
signals = record.get("signal_ids")
|
||||
if (
|
||||
not isinstance(signals, list)
|
||||
or not signals
|
||||
or any(not isinstance(item, str) for item in signals)
|
||||
or len(set(signals)) != len(signals)
|
||||
or not set(signals).issubset(set(contract["allowed_signal_ids"]))
|
||||
):
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer signal set is invalid: {path}")
|
||||
implementation_path = require_text(record, "implementation_path")
|
||||
if not implementation_path.startswith("repo-pre-15/"):
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer implementation is outside DUT: {path}")
|
||||
if any(
|
||||
implementation_path.startswith(prefix)
|
||||
for prefix in contract["prohibited_implementation_prefixes"]
|
||||
):
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer implementation is nonqualifying: {path}")
|
||||
if implementation_path not in entries:
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer implementation is not tracked: {path}")
|
||||
implementation = source_at(commit, implementation_path)
|
||||
implementation_hash = sha256_bytes(implementation)
|
||||
if implementation_hash != require_text(record, "implementation_sha256"):
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer implementation hash mismatch: {path}")
|
||||
implementation_text = implementation.decode("utf-8", errors="replace").lower()
|
||||
if "sysctl" not in implementation_text:
|
||||
raise GateFailure("RUNNER_FAIL", f"consumer implementation does not invoke sysctl: {path}")
|
||||
missing_signals = [item for item in signals if item.lower() not in implementation_text]
|
||||
if missing_signals:
|
||||
raise GateFailure(
|
||||
"RUNNER_FAIL", f"consumer implementation omits signals {missing_signals}: {path}"
|
||||
)
|
||||
return {
|
||||
"manifest_path": path,
|
||||
"manifest_sha256": sha256_bytes(data),
|
||||
"consumer_id": record["consumer_id"],
|
||||
"consumer_class": consumer_class,
|
||||
"implementation_path": implementation_path,
|
||||
"implementation_sha256": implementation_hash,
|
||||
"signal_ids": signals,
|
||||
"access_mode": access_mode,
|
||||
"production_use": True,
|
||||
}
|
||||
|
||||
|
||||
def main() -> int:
|
||||
if SPEC.get("schema") != 1 or SPEC.get("candidate") != "P15-030":
|
||||
raise GateFailure("RUNNER_FAIL", "invalid P15-030 input identity")
|
||||
if SPEC.get("gate") != "G08" or SPEC.get("batch") != "B37a":
|
||||
raise GateFailure("RUNNER_FAIL", "invalid G08/B37a input identity")
|
||||
resolved = git_text("rev-parse", f"{REQUESTED_BASE}^{{commit}}")
|
||||
if resolved != SPEC["required_base"]:
|
||||
raise GateFailure(
|
||||
"INFRA_BLOCKED",
|
||||
f"P15-030 must replay {SPEC['required_base']}, got {resolved}",
|
||||
)
|
||||
for path, expected_oid in SPEC["scope_tree_oids"].items():
|
||||
actual_oid = git_text("rev-parse", f"{resolved}:{path}")
|
||||
if actual_oid != expected_oid:
|
||||
raise GateFailure("INFRA_BLOCKED", f"frozen scope tree changed: {path}")
|
||||
|
||||
source_hashes = {
|
||||
path: sha256_bytes(source_at(resolved, path))
|
||||
for path in SPEC["source_sha256"]
|
||||
}
|
||||
if source_hashes != SPEC["source_sha256"]:
|
||||
raise GateFailure("INFRA_BLOCKED", "frozen G08 source identity changed")
|
||||
write_json(OUTPUT / "source-sha256.json", source_hashes)
|
||||
addendum_paths = (
|
||||
"repo-pre-15/tests/pre15/gates/P15-030.sh",
|
||||
"repo-pre-15/tests/pre15/gates/P15-030-input.json",
|
||||
"repo-pre-15/docs/pre15-stage0/P15-030.md",
|
||||
)
|
||||
addendum_hashes = {
|
||||
path: sha256_bytes((ROOT / path).read_bytes()) for path in addendum_paths
|
||||
}
|
||||
write_json(OUTPUT / "gate-addendum-sha256.json", addendum_hashes)
|
||||
|
||||
entries = parse_ls_tree(
|
||||
run_bytes(
|
||||
[
|
||||
"git",
|
||||
"-C",
|
||||
str(ROOT),
|
||||
"ls-tree",
|
||||
"-r",
|
||||
"--long",
|
||||
"-z",
|
||||
resolved,
|
||||
"--",
|
||||
"repo-pre-15",
|
||||
"planning/pre15",
|
||||
]
|
||||
)
|
||||
)
|
||||
prohibited = set(SPEC["prohibited_paths"])
|
||||
scoped_entries = {path: value for path, value in entries.items() if path not in prohibited}
|
||||
if len(scoped_entries) != SPEC["consumer_inventory"]["expected_scoped_path_count"]:
|
||||
raise GateFailure("INFRA_BLOCKED", "frozen consumer scope path count changed")
|
||||
|
||||
reference_paths = grep_paths(
|
||||
resolved, SPEC["consumer_inventory"]["reference_terms"]
|
||||
)
|
||||
maximum_bytes = SPEC["consumer_inventory"]["maximum_candidate_bytes"]
|
||||
references = []
|
||||
reference_counts = {
|
||||
"planning-proposal": 0,
|
||||
"historical-evidence": 0,
|
||||
"test-only": 0,
|
||||
"project-report-or-documentation": 0,
|
||||
"possible-operational-consumer": 0,
|
||||
}
|
||||
for path in reference_paths:
|
||||
if path in prohibited:
|
||||
raise GateFailure("RUNNER_FAIL", "prohibited path entered consumer scan")
|
||||
entry = scoped_entries[path]
|
||||
if entry["size"] > maximum_bytes:
|
||||
raise GateFailure("INFRA_BLOCKED", f"consumer candidate exceeds bound: {path}")
|
||||
data = source_at(resolved, path)
|
||||
classification = classify_reference(path)
|
||||
reference_counts[classification] += 1
|
||||
references.append(
|
||||
{
|
||||
"path": path,
|
||||
"blob_oid": entry["oid"],
|
||||
"bytes": entry["size"],
|
||||
"sha256": sha256_bytes(data),
|
||||
"classification": classification,
|
||||
"qualifies": False,
|
||||
"reason": {
|
||||
"planning-proposal": "proposal or audit text is not an existing consumer",
|
||||
"historical-evidence": "historical gate output is not an existing consumer",
|
||||
"test-only": "a test or gate is explicitly nonqualifying",
|
||||
"project-report-or-documentation": "documentation is not an implemented consumer",
|
||||
"possible-operational-consumer": "requires a validated consumer declaration",
|
||||
}[classification],
|
||||
}
|
||||
)
|
||||
expected_counts = SPEC["consumer_inventory"]["expected_reference_counts"]
|
||||
if len(reference_paths) != expected_counts["total"]:
|
||||
raise GateFailure("INFRA_BLOCKED", "frozen sysctl/sysfs reference count changed")
|
||||
for classification, count in reference_counts.items():
|
||||
if count != expected_counts[classification]:
|
||||
raise GateFailure(
|
||||
"INFRA_BLOCKED", f"frozen reference classification changed: {classification}"
|
||||
)
|
||||
|
||||
marker = SPEC["consumer_contract"]["schema_marker"]
|
||||
manifest_paths = grep_paths(resolved, [marker], fixed=True)
|
||||
consumers = []
|
||||
manifest_hashes = {}
|
||||
for path in manifest_paths:
|
||||
entry = scoped_entries[path]
|
||||
if entry["size"] > maximum_bytes:
|
||||
raise GateFailure("INFRA_BLOCKED", f"consumer manifest exceeds bound: {path}")
|
||||
data = source_at(resolved, path)
|
||||
manifest_hashes[path] = sha256_bytes(data)
|
||||
consumers.append(validate_consumer_manifest(path, data, scoped_entries, resolved))
|
||||
if manifest_hashes != SPEC["approved_consumer_manifest_sha256"]:
|
||||
raise GateFailure("INFRA_BLOCKED", "declared consumer inventory changed")
|
||||
|
||||
inventory = {
|
||||
"schema": 1,
|
||||
"base": resolved,
|
||||
"scope": SPEC["consumer_inventory"]["scope"],
|
||||
"scoped_path_count": len(scoped_entries),
|
||||
"prohibited_path_read": False,
|
||||
"reference_terms": SPEC["consumer_inventory"]["reference_terms"],
|
||||
"reference_path_count": len(reference_paths),
|
||||
"reference_classification_counts": reference_counts,
|
||||
"references": references,
|
||||
"consumer_manifest_marker": marker,
|
||||
"consumer_manifest_count": len(consumers),
|
||||
"qualified_consumer_count": len(consumers),
|
||||
"qualified_consumers": consumers,
|
||||
"nonqualifying_examples": SPEC["consumer_contract"]["nonqualifying_examples"],
|
||||
}
|
||||
write_json(OUTPUT / "consumer-inventory.json", inventory)
|
||||
|
||||
consumer_present = bool(consumers)
|
||||
conditions = [
|
||||
{
|
||||
"id": "concrete-existing-diagnostic-or-operational-consumer",
|
||||
"status": "PASS" if consumer_present else "STOP",
|
||||
"observation": (
|
||||
f"{len(consumers)} qualified consumer declaration(s)"
|
||||
if consumer_present
|
||||
else "zero qualified consumers; all 54 broad references are planning, history, tests, or documentation"
|
||||
),
|
||||
},
|
||||
{
|
||||
"id": "bounded-atomic-counters",
|
||||
"status": "NOT_RUN",
|
||||
"reason": "existing-consumer prerequisite is absent",
|
||||
},
|
||||
{
|
||||
"id": "freebsd15-native-sysctl-ctx-lifecycle",
|
||||
"status": "NOT_RUN",
|
||||
"reason": "existing-consumer prerequisite is absent; no prototype was built",
|
||||
},
|
||||
{
|
||||
"id": "stable-permissions-abi-and-no-unauthenticated-metadata-leak",
|
||||
"status": "NOT_RUN",
|
||||
"reason": "existing-consumer prerequisite is absent",
|
||||
},
|
||||
]
|
||||
if consumer_present:
|
||||
raise GateFailure(
|
||||
"RUNNER_FAIL",
|
||||
"a consumer is now declared; run the FreeBSD 15 native lifecycle prototype before any GO",
|
||||
)
|
||||
if all(item["status"] == "PASS" for item in conditions):
|
||||
raise GateFailure("RUNNER_FAIL", "false-GO guard accepted incomplete conditions")
|
||||
|
||||
result = {
|
||||
"schema": 1,
|
||||
"gate": "G08",
|
||||
"candidate": "P15-030",
|
||||
"batch": "B37a",
|
||||
"status": "STOP",
|
||||
"reason": "no concrete existing diagnostic or operational consumer",
|
||||
"requested_base": REQUESTED_BASE,
|
||||
"resolved_base": resolved,
|
||||
"deadline_seconds": DEADLINE,
|
||||
"expected_exit_code": 22,
|
||||
"conditions": conditions,
|
||||
"false_go_guard": "GO requires all four conditions PASS; evaluated false",
|
||||
"consumer_inventory": "consumer-inventory.json",
|
||||
"b37a": "STOP-NO-SOURCE",
|
||||
"dependency_closure": {
|
||||
"candidate": "P15-068",
|
||||
"batch": "B37b",
|
||||
"status": "STOP",
|
||||
"batch_status": "STOP-NO-SOURCE",
|
||||
"reason": "P15-068 requires the P15-030 sysctl transport, which is STOP",
|
||||
"independent_identity_format_verdict": "NOT_RUN",
|
||||
"second_sysctl_lifecycle": "NOT_RUN",
|
||||
},
|
||||
"prototype": "NOT_RUN",
|
||||
"builds": "NOT_RUN",
|
||||
"qemu": "NOT_RUN",
|
||||
"full_feature_suite": "NOT_RUN",
|
||||
"smoke_suite": "NOT_RUN",
|
||||
"production_source_changed": False,
|
||||
"p15_068_gate_addendum_created": False,
|
||||
}
|
||||
write_json(OUTPUT / "result.json", result)
|
||||
print(json.dumps(result, ensure_ascii=True, sort_keys=True))
|
||||
return 22
|
||||
|
||||
|
||||
try:
|
||||
raise SystemExit(main())
|
||||
except GateFailure as error:
|
||||
failure = {
|
||||
"schema": 1,
|
||||
"gate": "G08",
|
||||
"candidate": "P15-030",
|
||||
"status": error.status,
|
||||
"reason": error.reason,
|
||||
"requested_base": REQUESTED_BASE,
|
||||
"deadline_seconds": DEADLINE,
|
||||
"b37a": "NOT_RUN",
|
||||
"p15_068": "NOT_RUN",
|
||||
"qemu": "NOT_RUN",
|
||||
"production_source_changed": False,
|
||||
}
|
||||
write_json(OUTPUT / "result.json", failure)
|
||||
print(json.dumps(failure, ensure_ascii=True, sort_keys=True))
|
||||
raise SystemExit({"RUNNER_FAIL": 20, "INFRA_BLOCKED": 21}.get(error.status, 20))
|
||||
PY
|
||||
gate_rc=$?
|
||||
set -e
|
||||
|
||||
cleanup_status=PASS
|
||||
if ! rm -rf -- "$work"; then
|
||||
cleanup_status=FAIL
|
||||
gate_rc=20
|
||||
fi
|
||||
trap - EXIT HUP INT TERM
|
||||
printf 'owned temporary path removed: %s\ncleanup=%s\n' \
|
||||
"$work" "$cleanup_status" >"$output/cleanup.log"
|
||||
|
||||
python3 -B - "$output" "$gate_rc" "$cleanup_status" <<'PY'
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
|
||||
|
||||
output = Path(sys.argv[1])
|
||||
exit_code = int(sys.argv[2])
|
||||
cleanup = sys.argv[3]
|
||||
if cleanup != "PASS":
|
||||
status = "RUNNER_FAIL"
|
||||
origin = "runner"
|
||||
elif exit_code == 22:
|
||||
status = "STOP"
|
||||
origin = "gate"
|
||||
elif exit_code in (124, 137):
|
||||
status = "INFRA_BLOCKED"
|
||||
origin = "infrastructure"
|
||||
else:
|
||||
status = "RUNNER_FAIL" if exit_code == 20 else "INFRA_BLOCKED"
|
||||
origin = "runner" if exit_code == 20 else "infrastructure"
|
||||
(output / "attempt.json").write_text(
|
||||
json.dumps(
|
||||
{
|
||||
"schema": 1,
|
||||
"exit_code": exit_code,
|
||||
"status": status,
|
||||
"failure_origin": origin,
|
||||
"cleanup": cleanup,
|
||||
"target_marker": "reached" if status == "STOP" else "not_reached",
|
||||
},
|
||||
ensure_ascii=True,
|
||||
indent=2,
|
||||
sort_keys=True,
|
||||
) + "\n",
|
||||
encoding="ascii",
|
||||
)
|
||||
lines = []
|
||||
for path in sorted(output.iterdir(), key=lambda item: item.name):
|
||||
if path.is_file() and path.name != "SHA256SUMS":
|
||||
digest = hashlib.sha256(path.read_bytes()).hexdigest()
|
||||
lines.append(f"{digest} {path.name}")
|
||||
(output / "SHA256SUMS").write_text("\n".join(lines) + "\n", encoding="ascii")
|
||||
PY
|
||||
|
||||
printf 'P15-030 gate exit=%s cleanup=%s output=%s\n' \
|
||||
"$gate_rc" "$cleanup_status" "$output"
|
||||
exit "$gate_rc"
|
||||
Reference in New Issue
Block a user