tricu

bootstrap_retention_probe.py (5682B)

---

 #!/usr/bin/env python3
 """Isolated retained-toolchain probes, invoked only by bootstrap_retention.py.
 No compiler generation checkpoint or fixture publication is created here.
 """
 import argparse
 import hashlib
 import json
 from pathlib import Path
 import subprocess
 import sys
 
 from bootstrap_retention import REPO, sha, save
 from bootstrap_acceptance import verify
 
 
 def main():
     p = argparse.ArgumentParser(description=__doc__)
     p.add_argument('--root', type=Path, required=True)
     p.add_argument('--plan', type=Path, required=True)
     p.add_argument('--directory', type=Path, required=True)
     a = p.parse_args()
     plan = json.loads(a.plan.read_text()); config = plan['config']
     root, out = a.root, a.directory
     # Refuse a non-isolated invocation; every removal target must be invisible.
     if any((root / row['objects']).exists() for row in plan['stores']):
         raise ValueError('obsolete object stores are still visible')
     report = dict(complete=False, obsolete_stores_hidden=True, toolchains=[])
     def run(label, command, seconds=900):
         with (out / (label + '.log')).open('w') as log:
             subprocess.run(command, stdout=log, stderr=subprocess.STDOUT, check=True, timeout=seconds)
     try:
         for t in config['toolchains']:
             role = t['role']; generation = root / t['generation']; source = root / t['source']
             acceptance = root / t['acceptance']; runtime = t['runtime']
             accepted = json.loads(acceptance.read_text())
             # These cohorts still include first generation, so rerun full-pair
             # acceptance as well as the generation-two audit. Portable-only
             # retirement of first generation needs an explicitly different gate.
             fresh = verify(Path(accepted['generations'][0]), generation, Path(runtime), source)
             if fresh['artifacts'] != accepted['artifacts']:
                 raise ValueError('retained acceptance artifacts differ')
             run(role + '-portable', [sys.executable, str(REPO / 'test/portable_cli.py'), runtime,
                 '--backend', 'stable', '--indexed', '--compiler-bundle', str(generation / 'build-stable.arboricx')])
             run(role + '-smoke', [sys.executable, str(REPO / 'test/bootstrap_smoke.py'), runtime,
                 '--generation', str(generation), '--acceptance', str(acceptance),
                 '--source-root', str(source), '--directory', str(out / (role + '-smoke'))])
             scoped = out / (role + '-map')
             run(role + '-map', [sys.executable, str(REPO / 'test/bootstrap_generations.py'),
                 str(generation), str(scoped), '--tricu', runtime, '--source-root', str(source),
                 '--map', str(generation / 'source-map.v1'), '--root', 'native_math', '--backend', 'stable',
                 '--fresh', '--adapter', str(generation / 'io-adapter.arboricx'), '--capabilities', '2',
                 '--memory-mib', '8192', '--wall-seconds', '900'])
             run(role + '-map-audit', [sys.executable, str(REPO / 'test/bootstrap_store_check.py'),
                 str(scoped), '--source-root', str(source), '--root', 'native_math'])
             old = (generation / 'cas/cache/source-build/native_math').read_text().split('\t')[2]
             new = (scoped / 'cas/cache/source-build/native_math').read_text().split('\t')[2]
             if old != new:
                 raise ValueError('scoped map-builder changed complete native_math manifest')
             smoke = json.loads((out / (role + '-smoke/report.json')).read_text())
             if not smoke['complete'] or not smoke['wrong_output_rejected']:
                 raise ValueError('incomplete retained compiler smoke')
             report['toolchains'].append(dict(role=role, artifacts=fresh['artifacts'],
                 acceptance_sha256=sha(acceptance), runtime_sha256=sha(runtime),
                 fresh_pair_audits=fresh['audits'], portable_cli=True,
                 complete_results=len(smoke['cases']), scoped_map_manifest=new))
         support = config['support']
         runtime = next(t['runtime'] for t in config['toolchains'] if t['role'] == support['toolchain'])
         publication = out / 'support-reproduced'
         command = [sys.executable, str(REPO / 'test/repair_support_fixture.py'), runtime,
             str(root / support['preparation']), '--output-directory', str(publication),
             '--capabilities', '2', '--verification-memory-mib', '8192']
         if support.get('relocate_patterns'):
             command += ['--relocate-patterns']
         run('support', command, seconds=1500)
         compared = {}
         for name in ['support-library.arboricx', 'support-rebuilt.arboricx', 'support-library.v1']:
             if sha(publication / name) != sha(REPO / 'test/fixtures' / name):
                 raise ValueError('current support fixture did not reproduce: ' + name)
             compared[name] = sha(publication / name)
         expected = REPO / 'test/fixtures/support-receipts'
         actual = publication / 'support-receipts'
         if {p.name: sha(p) for p in actual.iterdir()} != {p.name: sha(p) for p in expected.iterdir()}:
             raise ValueError('support receipt/manifests did not reproduce')
         run('fixture-freshness', [sys.executable, str(REPO / 'test/fixture_sources.py'), 'current'])
         report.update(complete=True, support_sha256=compared,
                       support_receipts_reproduced=True, fixture_sources_current=True)
     finally:
         save(out / 'report.json', report)
     print('PASS isolated pair audits, CLI integrity/diagnostics, correctness smokes, scoped map-builds and support reproduction')
 
 
 if __name__ == '__main__':
     main()