| |
| """List, verify or restore the independent SHA256 + zstd experiment archive.""" |
| import argparse,hashlib,json,os,shutil,sqlite3,sys,io |
| from pathlib import Path |
| import zstandard as zstd |
| ROOT=Path(__file__).resolve().parent |
|
|
| class BoundedReader: |
| def __init__(self,path,offset,length):self.file=path.open('rb');self.file.seek(offset);self.remaining=length |
| def read(self,n=-1): |
| n=self.remaining if n<0 else min(n,self.remaining) |
| data=self.file.read(n);self.remaining-=len(data);return data |
| def readable(self):return True |
| def close(self):self.file.close() |
| def __enter__(self):return self |
| def __exit__(self,*args):self.close() |
|
|
| def safe(root,name): |
| p=root/name |
| if Path(name).is_absolute() or '..' in Path(name).parts:raise ValueError(name) |
| if not p.resolve().is_relative_to(root.resolve()):raise ValueError('Path escapes destination: '+name) |
| return p |
|
|
| def main(): |
| global ROOT |
| ap=argparse.ArgumentParser(description=__doc__) |
| ap.add_argument('action',choices=['list','verify','restore']) |
| ap.add_argument('--archive-root',type=Path,help='Checkpoint dataset directory; defaults to this script directory') |
| ap.add_argument('--prefix',action='append',default=[],help='Package-relative source prefix; repeat for multiple roots') |
| ap.add_argument('--release',choices=['KeyCorridor','MiniGridLoCA','DeepSea','SecureCourier']) |
| ap.add_argument('--output',type=Path,help='New restore directory; never overwrite existing data') |
| a=ap.parse_args() |
| if a.archive_root:ROOT=a.archive_root.resolve() |
| prefixes=a.prefix[:] |
| if a.release:prefixes.append(a.release) |
| db=sqlite3.connect('file:'+str(ROOT/'manifest.sqlite')+'?mode=ro',uri=True) |
| if db.execute('PRAGMA integrity_check').fetchone()[0]!='ok':raise RuntimeError('Manifest database is corrupt') |
| db.row_factory=sqlite3.Row |
| selected={r['path']:dict(r) for r in db.execute('SELECT * FROM files') if not prefixes or any(r['path']==p or r['path'].startswith(p.rstrip('/')+'/') for p in prefixes)} |
| if not selected:raise RuntimeError('No matching files') |
| select_all=not prefixes |
| links=json.loads((ROOT/'LINKS.json').read_text()) |
| chosen=[] |
| |
| for _ in range(len(links)+1): |
| changed=False |
| for link in links: |
| name=link.get('archive_path');target=link.get('archive_target') |
| if not name or not target or link in chosen:continue |
| if select_all or any(name==p or name.startswith(p.rstrip('/')+'/') for p in prefixes): |
| chosen.append(link);prefixes.append(target);changed=True |
| for r in db.execute('SELECT * FROM files WHERE path=? OR path LIKE ?', (target,target+'/%')):selected[r['path']]=dict(r) |
| if not changed:break |
| unique={r['sha256']:r for r in selected.values()} |
| restore_groups={(r['sha256'],r['mode'],r['mtime_ns']):r['bytes'] for r in selected.values()} |
| summary={'estimated_restored_bytes':sum(restore_groups.values()),'files':len(selected),'checkpoint_candidate_paths':sum(r['checkpoint_candidate'] for r in selected.values()),'unique_objects':len(unique),'logical_bytes':sum(r['bytes'] for r in selected.values()),'unique_bytes':sum(r['bytes'] for r in unique.values()),'links':len(chosen)} |
| print(json.dumps(summary),flush=True) |
| if a.action=='list':return |
| if a.action=='restore': |
| if a.output is None:ap.error('--output is required') |
| out=a.output.absolute() |
| if out.exists():raise FileExistsError(out) |
| out.parent.mkdir(parents=True,exist_ok=True) |
| if shutil.disk_usage(out.parent).free<summary['estimated_restored_bytes']+2**30:raise RuntimeError('Not enough space for independent restored files') |
| out.mkdir();restored={} |
| for i,(sha,r) in enumerate(unique.items()): |
| blob=ROOT/'objects'/sha[:2]/(sha+'.zst') |
| if blob.exists():source=blob.open('rb') |
| else: |
| record=db.execute('SELECT shard,offset,length FROM objects WHERE sha256=?',(sha,)).fetchone() |
| if record is None:raise FileNotFoundError(sha) |
| source=BoundedReader(ROOT/record[0],record[1],record[2]) |
| h=hashlib.sha256();count=0;dest=None;writer=None |
| if a.action=='restore': |
| dest=safe(out,r['path']);dest.parent.mkdir(parents=True,exist_ok=True);writer=dest.open('xb') |
| try: |
| with source as f,zstd.ZstdDecompressor().stream_reader(f) as stream: |
| for b in iter(lambda:stream.read(8<<20),b''): |
| h.update(b);count+=len(b) |
| if writer:writer.write(b) |
| finally: |
| if writer:writer.close() |
| if h.hexdigest()!=sha or count!=r['bytes']:raise RuntimeError('Payload verification failed: '+sha) |
| if dest: |
| dest.chmod(r['mode']);os.utime(dest,ns=(r['mtime_ns'],r['mtime_ns']));restored[sha]=dest |
| if (i+1)%2000==0:print('Verified objects:',i+1,'/',len(unique),flush=True) |
| if a.action=='restore': |
| copies={(sha,r['mode'],r['mtime_ns']):restored[sha] for sha,r in unique.items()} |
| for r in selected.values(): |
| first=restored[r['sha256']];dest=safe(out,r['path']) |
| if dest==first:continue |
| dest.parent.mkdir(parents=True,exist_ok=True) |
| key=(r['sha256'],r['mode'],r['mtime_ns']) |
| |
| if key in copies:os.link(copies[key],dest) |
| else: |
| shutil.copyfile(first,dest);dest.chmod(r['mode']);os.utime(dest,ns=(r['mtime_ns'],r['mtime_ns']));copies[key]=dest |
| for link in sorted(chosen,key=lambda x:len(Path(x['archive_path']).parts)): |
| dst=safe(out,link['archive_path']);target=safe(out,link['archive_target']) |
| dst.parent.mkdir(parents=True,exist_ok=True) |
| if os.path.lexists(dst):raise FileExistsError(dst) |
| dst.symlink_to(os.path.relpath(target,dst.parent)) |
| (out/'RESTORE_REPORT.json').write_text(json.dumps({'status':'PASS',**summary,'source_archive':str(ROOT)},indent=2)+'\n') |
| print('PASS:',a.action,flush=True) |
| if __name__=='__main__':main() |
|
|
