| |
| """Merge independently sealed Morphosis conversion shards.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import lzma |
| import os |
| import shutil |
| import time |
| from collections import Counter |
| from pathlib import Path |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| while chunk := handle.read(8 << 20): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--shards-dir", type=Path, required=True) |
| parser.add_argument("--output-dir", type=Path, required=True) |
| args = parser.parse_args() |
| if args.output_dir.exists(): |
| raise FileExistsError(args.output_dir) |
|
|
| seals = [] |
| for index in range(8): |
| path = args.shards_dir / f"shard-{index:02d}/materialization-seal.json" |
| seal = json.loads(path.read_text()) |
| expected_roots = 13 if index < 4 else 12 |
| if ( |
| seal.get("kind") != "morphosis-dsv4-materialization" |
| or seal.get("shard") |
| != {"count": 8, "index": index, "input_roots_seen": 100} |
| or seal.get("roots") != expected_roots |
| ): |
| raise ValueError(f"shard {index} identity/count differs") |
| seals.append(seal) |
| if any(seal["source"] != seals[0]["source"] for seal in seals[1:]): |
| raise ValueError("source identities differ across shards") |
| if any(seal["target"] != seals[0]["target"] for seal in seals[1:]): |
| raise ValueError("target identities differ across shards") |
|
|
| stage = args.output_dir.with_name( |
| f"{args.output_dir.name}.stage-{os.getpid()}" |
| ) |
| if stage.exists(): |
| shutil.rmtree(stage) |
| stage.mkdir(parents=True) |
|
|
| archives = [] |
| totals: Counter[str] = Counter() |
| content_audit: Counter[str] = Counter() |
| token_audit_rows = [] |
| try: |
| for index, seal in enumerate(seals): |
| shard_dir = args.shards_dir / f"shard-{index:02d}" |
| for item in seal["archives"]: |
| source = shard_dir / item["archive"] |
| if source.stat().st_size != item["archive_bytes"]: |
| raise ValueError(f"archive size differs: {source}") |
| if sha256_file(source) != item["archive_sha256"]: |
| raise ValueError(f"archive hash differs: {source}") |
| target = stage / item["archive"] |
| if target.exists(): |
| raise ValueError(f"duplicate archive: {item['archive']}") |
| os.link(source, target) |
| archives.append(item) |
| for key, value in seal["totals"].items(): |
| if key.startswith("target_max_"): |
| totals[key] = max(totals[key], int(value)) |
| else: |
| totals[key] += int(value) |
| content_audit.update(seal.get("content_audit") or {}) |
| audit_path = shard_dir / seal["request_token_audit"]["path"] |
| with lzma.open(audit_path, "rt", encoding="utf-8") as handle: |
| token_audit_rows.extend(json.loads(line) for line in handle if line) |
|
|
| if len(archives) != 100 or len({row["root_id"] for row in archives}) != 100: |
| raise ValueError("merged archive inventory is not exactly 100 roots") |
| if len(token_audit_rows) != totals["requests"]: |
| raise ValueError("request token audit row count differs") |
| archives.sort(key=lambda row: row["root_id"]) |
| token_audit_rows.sort( |
| key=lambda row: ( |
| row["root_id"], |
| row["trace_id"], |
| row["generate_index"], |
| ) |
| ) |
| audit_output = stage / "request-token-audit.jsonl.xz" |
| with lzma.open(audit_output, "wt", encoding="utf-8", preset=1) as handle: |
| for row in token_audit_rows: |
| handle.write( |
| json.dumps(row, separators=(",", ":"), sort_keys=True) + "\n" |
| ) |
|
|
| with (stage / "archives.sha256").open("w") as handle: |
| for item in archives: |
| handle.write(f"{item['archive_sha256']} {item['archive']}\n") |
| global_seal = { |
| "schema_version": 1, |
| "kind": "morphosis-dsv4-materialization", |
| "created_at_s": time.time(), |
| "source": seals[0]["source"], |
| "target": seals[0]["target"], |
| "roots": len(archives), |
| "totals": dict(totals), |
| "content_audit": dict(sorted(content_audit.items())), |
| "request_token_audit": { |
| "path": audit_output.name, |
| "rows": len(token_audit_rows), |
| "sha256": sha256_file(audit_output), |
| }, |
| "archives": archives, |
| "shards": [ |
| { |
| "index": index, |
| "roots": seal["roots"], |
| "seal_sha256": sha256_file( |
| args.shards_dir |
| / f"shard-{index:02d}/materialization-seal.json" |
| ), |
| } |
| for index, seal in enumerate(seals) |
| ], |
| } |
| (stage / "materialization-seal.json").write_text( |
| json.dumps(global_seal, indent=2, sort_keys=True) + "\n" |
| ) |
| os.replace(stage, args.output_dir) |
| except BaseException: |
| shutil.rmtree(stage, ignore_errors=True) |
| raise |
|
|
| print( |
| json.dumps( |
| { |
| "output_dir": str(args.output_dir), |
| "roots": len(archives), |
| "requests": totals["requests"], |
| "materialization_seal_sha256": sha256_file( |
| args.output_dir / "materialization-seal.json" |
| ), |
| }, |
| sort_keys=True, |
| ) |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
