VMP 保护范围变化后怎样做影响分析

#!/usr/bin/env python3
import hashlib
import json
import re
import sys
from pathlib import Path

SHA256 = re.compile(r"^[a-f0-9]{64}$")
ALLOWED_PERFORMANCE = {"startup", "main-thread", "background", "low-frequency"}

def fail(message, code):
    print(message, file=sys.stderr)
    raise SystemExit(code)

def load_document(path):
    try:
        document = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError) as exc:
        fail("cannot read inventory: " + str(exc), 3)
    if not isinstance(document, dict):
        fail("inventory root must be an object", 4)
    return document

def require_digest(document, field):
    value = document.get(field)
    if not isinstance(value, str) or not SHA256.fullmatch(value):
        fail("invalid digest field: " + field, 5)
    return value

def require_strings(record, field, allow_empty=False):
    value = record.get(field)
    if not isinstance(value, list):
        fail("invalid list field: " + field, 6)
    items = []
    for item in value:
        if not isinstance(item, str) or not item.strip():
            fail("invalid item in: " + field, 7)
        items.append(item.strip())
    if not allow_empty and not items:
        fail("empty required list: " + field, 8)
    if len(items) != len(set(items)):
        fail("duplicate item in: " + field, 9)
    return sorted(items)

def normalize_methods(document):
    methods = document.get("methods")
    if not isinstance(methods, list):
        fail("methods must be a list", 10)
    index = {}
    for method in methods:
        if not isinstance(method, dict):
            fail("method entry must be an object", 11)
        method_id = method.get("id")
        role = method.get("role")
        performance = method.get("performanceClass")
        if not isinstance(method_id, str) or not method_id.strip():
            fail("method id is missing", 12)
        if not isinstance(role, str) or not role.strip():
            fail("method role is missing", 13)
        if performance not in ALLOWED_PERFORMANCE:
            fail("invalid performanceClass for " + method_id, 14)
        if method_id in index:
            fail("duplicate method id: " + method_id, 15)
        index[method_id] = {
            "role": role.strip(),
            "callPaths": require_strings(method, "callPaths"),
            "failureModes": require_strings(method, "failureModes", True),
            "performanceClass": performance,
            "contractTests": require_strings(method, "contractTests"),
        }
    return index

def document_identity(document, path):
    return {
        "inventorySha256": hashlib.sha256(path.read_bytes()).hexdigest(),
        "artifactSha256": require_digest(document, "artifactSha256"),
        "mappingSha256": require_digest(document, "mappingSha256"),
        "policySha256": require_digest(document, "policySha256"),
    }

def compare(baseline, candidate):
    baseline_ids = set(baseline)
    candidate_ids = set(candidate)
    added = sorted(candidate_ids - baseline_ids)
    removed = sorted(baseline_ids - candidate_ids)
    changed = []
    fields = ["role", "callPaths", "failureModes", "performanceClass", "contractTests"]
    for method_id in sorted(baseline_ids & candidate_ids):
        changed_fields = [field for field in fields if baseline[method_id][field] != candidate[method_id][field]]
        if changed_fields:
            changed.append({"id": method_id, "fields": changed_fields})
    tests = set()
    reasons = {}
    for method_id in added:
        tests.update(candidate[method_id]["contractTests"])
        reasons[method_id] = ["added"]
    for method_id in removed:
        tests.update(baseline[method_id]["contractTests"])
        reasons[method_id] = ["removed"]
    for change in changed:
        method_id = change["id"]
        tests.update(baseline[method_id]["contractTests"])
        tests.update(candidate[method_id]["contractTests"])
        reasons[method_id] = ["changed:" + field for field in change["fields"]]
    return {
        "added": added,
        "removed": removed,
        "changed": changed,
        "requiredContractTests": sorted(tests),
        "reasonsByMethod": reasons,
    }

def main():
    if len(sys.argv) != 3:
        print("Usage: scope_diff.py BASELINE_JSON CANDIDATE_JSON", file=sys.stderr)
        raise SystemExit(2)
    baseline_path = Path(sys.argv[1])
    candidate_path = Path(sys.argv[2])
    if not baseline_path.is_file() or not candidate_path.is_file():
        print("required inventory file missing", file=sys.stderr)
        raise SystemExit(2)
    baseline_doc = load_document(baseline_path)
    candidate_doc = load_document(candidate_path)
    baseline = normalize_methods(baseline_doc)
    candidate = normalize_methods(candidate_doc)
    if not baseline or not candidate:
        fail("both inventories must contain methods", 16)
    result = {
        "status": "tests-required",
        "baseline": document_identity(baseline_doc, baseline_path),
        "candidate": document_identity(candidate_doc, candidate_path),
        "impact": compare(baseline, candidate),
    }
    print(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True))

if __name__ == "__main__":
    main()