| """Materialize pinned evaluator dependencies without following host symlinks.""" |
| import hashlib |
| import json |
| import os |
| from pathlib import Path |
| import re |
| import shutil |
| import subprocess |
| import tarfile |
|
|
|
|
| def sha(p): |
| h=hashlib.sha256() |
| with Path(p).open('rb') as f: |
| for b in iter(lambda:f.read(1024*1024),b''):h.update(b) |
| return h.hexdigest() |
|
|
|
|
| def validate_runtime_descriptor(resource): |
| assert resource['kind']=='frozen-evaluator-dependencies' and resource['container_path']=='/crossswe-evaluator' |
| assert re.fullmatch(r'[^@\s]+@sha256:[0-9a-f]{64}',resource['image_ref']) |
| files=resource['files'];assert files and len({r['path'] for r in files})==len(files) |
| for r in files: |
| p=Path(r['path']);assert not p.is_absolute() and '..' not in p.parts and str(p)==r['path'] |
| assert r['kind'] in ['file','symlink'] and type(r['bytes']) is int and r['bytes']>=0 |
| assert re.fullmatch(r'[0-9a-f]{64}',r['sha256']) |
| if r['kind']=='symlink':assert isinstance(r['target'],str) and hashlib.sha256(r['target'].encode()).hexdigest()==r['sha256'] |
| manifest=next(r for r in files if r['path']=='bundle-manifest.json') |
| assert manifest['kind']=='file' and manifest['sha256']==resource['manifest_sha256'] |
|
|
|
|
| def verify_runtime_files(root,resource): |
| validate_runtime_descriptor(resource);root=Path(root) |
| assert sha(root/'bundle-manifest.json')==resource['manifest_sha256'] |
| bundle=json.loads((root/'bundle-manifest.json').read_text()) |
| if resource.get('manifest_contains_inventory'): |
| assert bundle['instance_id']==resource['instance_id'] and len(bundle['files'])==resource['full_file_count'] |
| all_files=bundle['files']+resource['files'] |
| else:all_files=resource['files'] |
| expected={r['path']:r for r in all_files};assert len(expected)==len(all_files) |
| for name in expected: |
| q=Path(name);assert not q.is_absolute() and '..' not in q.parts and str(q)==name |
| actual={str(p.relative_to(root)) for p in root.rglob('*') if p.is_symlink() or p.is_file()} |
| assert actual==set(expected),'Evaluator resource inventory mismatch' |
| for name,r in expected.items(): |
| p=root/name;assert p.parent.resolve().is_relative_to(root.resolve()) |
| if r['kind']=='symlink':assert p.is_symlink() and os.readlink(p)==r['target'] |
| else: |
| assert p.is_file() and not p.is_symlink() and p.stat().st_size==r['bytes'] and sha(p)==r['sha256'] |
| if 'mode' in r:assert p.stat().st_mode&0o777==r['mode'] |
| assert sha(root/'bundle-manifest.json')==resource['manifest_sha256'] |
|
|
|
|
| def materialize_runtime(resource,destination,provided=None): |
| validate_runtime_descriptor(resource);destination=Path(destination) |
| assert not destination.exists() |
| if provided:shutil.copytree(provided,destination,symlinks=True) |
| else: |
| subprocess.run(['docker','pull','--platform','linux/amd64',resource['image_ref']],check=True) |
| cid=subprocess.check_output(['docker','create','--network','none','--label','crossswe.owner=portable-baseline',resource['image_ref'],'/bin/true'],text=True).strip() |
| destination.mkdir();seen=set() |
| try: |
| q=subprocess.Popen(['docker','cp',cid+':/crossswe-evaluator','-'],stdout=subprocess.PIPE) |
| with tarfile.open(fileobj=q.stdout,mode='r|') as tf: |
| for m in tf: |
| rel=Path(m.name).relative_to('crossswe-evaluator');assert not rel.is_absolute() and '..' not in rel.parts |
| p=destination/rel;assert p==destination or p.parent.resolve().is_relative_to(destination.resolve()) |
| if m.isdir():p.mkdir(parents=True,exist_ok=True);continue |
| name=str(rel);assert name not in seen;seen.add(name) |
| p.parent.mkdir(parents=True,exist_ok=True) |
| if m.issym():p.symlink_to(m.linkname) |
| elif m.isfile(): |
| with p.open('xb') as f:shutil.copyfileobj(tf.extractfile(m),f) |
| p.chmod(m.mode&0o777) |
| elif m.islnk(): |
| origin=destination/Path(m.linkname).relative_to('crossswe-evaluator') |
| assert origin.is_file() and not origin.is_symlink() and origin.resolve().is_relative_to(destination.resolve());os.link(origin,p) |
| else:raise ValueError('Unsupported evaluator archive entry') |
| assert q.wait()==0 |
| finally:subprocess.run(['docker','rm',cid],check=True,stdout=subprocess.DEVNULL) |
| verify_runtime_files(destination,resource) |
| return destination |
|
|
