| |
| """Check saved-output archive integrity without running scientific analysis.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import gzip |
| import hashlib |
| import json |
| from pathlib import Path |
| import zipfile |
|
|
|
|
| def require(condition: bool, message: str) -> None: |
| if not condition: |
| raise ValueError(message) |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for block in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(block) |
| return digest.hexdigest() |
|
|
|
|
| def validate(root: Path, original_archive_manifest: Path | None = None) -> dict: |
| root = root.resolve() |
|
|
| def local_path(name: str) -> Path: |
| candidate = (root / name).resolve() |
| require(candidate.is_relative_to(root), f"Manifest path escapes archive root: {name}") |
| return candidate |
|
|
| summary = json.loads((root / "archive_summary.json").read_text()) |
| with gzip.open(root / "file_manifest.csv.gz", "rt", newline="") as handle: |
| rows = list(csv.DictReader(handle)) |
| packaged = [row for row in rows if row["status"] == "packaged_byte_for_byte"] |
| verified = 0 |
| expected_archive_names = {policy["archive"] for policy in summary["policies"]} |
| require({path.name for path in root.glob("*.zip")} == expected_archive_names, |
| "ZIP files differ from the archive summary") |
|
|
| for policy in summary["policies"]: |
| archive_name = policy["archive"] |
| archive_path = local_path(archive_name) |
| matching = [row for row in packaged if row["archive"] == archive_name] |
| expected = {row["archive_member"]: row for row in matching} |
| require(len(expected) == len(matching), f"Duplicate manifest members: {archive_name}") |
| require(len(expected) == policy["packaged_files"], f"Incorrect packaged count: {archive_name}") |
| require(archive_path.stat().st_size == policy["archive_bytes"], f"Archive size mismatch: {archive_name}") |
| require(sha256(archive_path) == policy["archive_sha256"], f"Archive hash mismatch: {archive_name}") |
| with zipfile.ZipFile(archive_path) as archive: |
| names = archive.namelist() |
| require(len(names) == len(set(names)), f"Duplicate ZIP members: {archive_name}") |
| require(set(names) == set(expected), f"ZIP member set mismatch: {archive_name}") |
| for name in names: |
| |
| payload = archive.read(name) |
| row = expected[name] |
| require(len(payload) == int(row["source_bytes"]), f"Payload size mismatch: {name}") |
| require(hashlib.sha256(payload).hexdigest() == row["sha256"], f"Payload hash mismatch: {name}") |
| verified += 1 |
|
|
| require(verified == len(packaged), "Some packaged manifest rows were not verified") |
| mirrors = [row for row in packaged if row["summary_mirror"]] |
| expected_mirrors = {row["summary_mirror"] for row in mirrors} |
| require(len(expected_mirrors) == len(mirrors), "Duplicate mirror paths in manifest") |
| actual_mirrors = {path.relative_to(root).as_posix() for path in (root / "summary_tables").rglob("*.csv")} |
| require(actual_mirrors == expected_mirrors, "Missing or stale generated summary mirrors") |
| for row in mirrors: |
| require(sha256(local_path(row["summary_mirror"])) == row["sha256"], |
| f"Summary mirror hash mismatch: {row['summary_mirror']}") |
| require(sum(policy["source_files"] for policy in summary["policies"]) == len(rows), |
| "Original file count differs between summary and manifest") |
| missing = len(rows) - verified |
| require(sum(policy["missing_files"] for policy in summary["policies"]) == missing, |
| "Missing file count differs between summary and manifest") |
| require(summary["all_saved_files_packaged"] == (missing == 0), "Incorrect completeness flag") |
| original_members_verified = None |
| if original_archive_manifest is not None: |
| original = json.loads(original_archive_manifest.read_text()) |
| source_members = {item["member"]: item for item in original["files"]} |
| require(len(source_members) == len(original["files"]), "Duplicate original archive members") |
| prefix = summary["source_directory_name"] + "/" |
| require({prefix + row["archive_member"] for row in rows} == set(source_members), |
| "Original archive and packaged inventory describe different source CSVs") |
| for row in packaged: |
| member = prefix + row["archive_member"] |
| source = source_members[member] |
| require(row["sha256"] == source["sha256"] and int(row["source_bytes"]) == source["bytes"], |
| f"Original archive member identity mismatch: {member}") |
| original_members_verified = len(packaged) |
| return { |
| "scope": "release_archive_integrity_only_not_scientific_reproduction", |
| "original_csv_files_in_manifest": len(rows), |
| "verified_zip_members": verified, |
| "verified_summary_mirrors": len(mirrors), |
| "zip_crc_ok": True, |
| "all_packaged_member_sha256_matches": True, |
| "archive_sha256_matches": True, |
| "stale_summary_mirrors": 0, |
| "missing_original_csv_payloads": missing, |
| "all_original_csv_payloads_packaged": missing == 0, |
| "verified_original_archive_member_hashes": original_members_verified, |
| "new_scientific_experiments": False, |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--output-dir", type=Path, |
| default=Path(__file__).resolve().parents[2] / "results/downstream") |
| parser.add_argument("--write-report", action="store_true", |
| help="Write verification.json after successful integrity checks") |
| parser.add_argument("--require-complete", action="store_true", |
| help="Return nonzero if any original CSV payload remains unavailable") |
| parser.add_argument("--original-archive-manifest", type=Path, |
| help="Also compare member identities to the original archive recovery manifest") |
| args = parser.parse_args() |
| report = validate(args.output_dir, args.original_archive_manifest) |
| if args.write_report: |
| (args.output_dir / "verification.json").write_text(json.dumps(report, indent=2) + "\n") |
| print(json.dumps(report, indent=2)) |
| if args.require_complete and not report["all_original_csv_payloads_packaged"]: |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
