sync/sync_dataset_source.py

#!/usr/bin/env python3
"""All-file dataset mirroring with frozen completion scope and remote SHA-256."""
import base64, concurrent.futures, hashlib, json, os, shlex, subprocess
from datetime import datetime, timezone
from pathlib import Path

def ssh(command,stdin=None):
    return subprocess.run(['ssh','-o','BatchMode=yes','centre',command],input=stdin,
                          stdout=subprocess.PIPE,stderr=subprocess.PIPE,check=True).stdout

def snapshot(src):
    # Inventory only finalized run directories; do not race simulator/exporter writes.
    script='''
import base64,hashlib,json,os
from pathlib import Path
from datetime import datetime,timezone
src=json.loads(CONFIG)
root=Path(src['remote'])
completed={}
if src.get('snapshot_completed'):
    for f in sorted((root/'runs').glob('*/complete.json')):
        completed[f.parent.name]=json.loads(f.read_text())
exclude_root={x.strip('/') for x in src['exclude'] if x.startswith('/')}
exclude_names={x.strip('/') for x in src['exclude'] if not x.startswith('/')}
files={}; captured={}
for parent,dirs,names in os.walk(root):
    p=Path(parent);rel=p.relative_to(root)
    dirs[:]=sorted(d for d in dirs if d not in exclude_names and str(rel/d) not in exclude_root)
    for name in sorted(names):
        f=p/name
        if not f.is_file():continue
        r=f.relative_to(root).as_posix();parts=Path(r).parts
        selected=not (src.get('snapshot_completed') and parts[0]=='runs' and len(parts)>1 and parts[1] not in completed)
        st=f.stat()
        files[r]={'size':st.st_size,'mtime_ns':st.st_mtime_ns,'selected':selected}
        if src.get('snapshot_completed') and len(parts)==1:
            data=f.read_bytes()
            captured[r]={'data':base64.b64encode(data).decode(),'sha256':hashlib.sha256(data).hexdigest()}
            files[r]['size']=len(data)
print(json.dumps({'source':src['remote'],'frozen_at_utc':datetime.now(timezone.utc).isoformat(),
                  'files':files,'captured':captured,'completed_records':list(completed.values())}))
'''.replace('CONFIG',repr(json.dumps(src)))
    return json.loads(ssh('python3 -',script.encode()))

def sha_file(path):
    h=hashlib.sha256()
    with path.open('rb') as f:
        for b in iter(lambda:f.read(8*1024*1024),b''):h.update(b)
    return h.hexdigest()

def remote_hashes(src,paths):
    result={}
    for i in range(0,len(paths),500):
        out=ssh('cd '+shlex.quote(src['remote'])+' && xargs -0 sha256sum --',
                b'\0'.join(p.encode() for p in paths[i:i+500])+b'\0')
        for line in out.decode().splitlines():
            digest,path=line.split('  ',1);result[path]=digest
    return result

def write_json(path,obj):
    tmp=path.with_suffix(path.suffix+'.tmp')
    tmp.write_text(json.dumps(obj,indent=2)+'\n');tmp.replace(path)

def sync_dataset_source(src,root,dry=False):
    started=datetime.now(timezone.utc).isoformat()
    snap=snapshot(src);inv=snap['files'];selected={p:r for p,r in inv.items() if r['selected']}
    dest=root/src['dest'];meta=dest/'_sync'
    print(json.dumps({'source':src['name'],'selected_files':len(selected),
                      'selected_bytes':sum(r['size'] for r in selected.values()),
                      'completed_cases':len(snap['completed_records']),'destination':str(dest)}),flush=True)
    if dry:return
    meta.mkdir(parents=True,exist_ok=True)
    write_json(meta/'REMOTE_SNAPSHOT.json',{k:v for k,v in snap.items() if k!='captured'})
    listing=meta/'files_selected.null'
    transfer=[p for p in selected if p not in snap['captured']]
    listing.write_bytes(b'\0'.join(p.encode() for p in transfer)+b'\0')
    cachepath=meta/'hash_cache.json'
    cache=json.loads(cachepath.read_text()) if cachepath.exists() else {}
    todo=[]
    for p,r in selected.items():
        f=dest/p;old=cache.get(p,{})
        if (p in snap['captured'] or not f.exists() or old.get('source_size')!=r['size']
            or old.get('source_mtime_ns')!=r['mtime_ns'] or f.stat().st_size!=r['size']
            or old.get('local_mtime_ns')!=f.stat().st_mtime_ns):todo.append(p)
    # Disjoint file lists permit concurrent SSH streams without concurrent writes
    # to any file. Balance by source byte size, and compress only useful formats.
    shards=[[] for _ in range(4)];weights=[0]*4
    for p in sorted(transfer,key=lambda p:selected[p]['size'],reverse=True):
        k=min(range(4),key=lambda j:weights[j]);shards[k].append(p);weights[k]+=selected[p]['size']
    def copy_shard(k):
        paths=sorted(shards[k]);lst=meta/f'files_selected_{k}.null'
        lst.write_bytes(b'\0'.join(p.encode() for p in paths)+b'\0')
        with (meta/f'transfer_{k}.log').open('w') as log:
            subprocess.run(['rsync','-a','--partial','-z','--compress-choice=zstd','--compress-level=3',
                            '--info=stats2,progress2','--from0','--files-from='+str(lst),
                            '-e','ssh -o BatchMode=yes -o Compression=no',
                            'centre:'+src['remote'].rstrip('/')+'/',str(dest)+'/'],check=True,stdout=log,stderr=subprocess.STDOUT)
        print('TRANSFER_SHARD_COMPLETE',k,flush=True)
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as pool:
        future=pool.submit(remote_hashes,src,[p for p in todo if p not in snap['captured']])
        copies=[pool.submit(copy_shard,k) for k in range(4)]
        for copy in copies:copy.result()
        expected=future.result()
    for p,v in snap['captured'].items():
        f=dest/p;f.parent.mkdir(parents=True,exist_ok=True)
        f.write_bytes(base64.b64decode(v['data']))
        os.utime(f,ns=(selected[p]['mtime_ns'],selected[p]['mtime_ns']))
        expected[p]=v['sha256']
    print('Verifying local SHA-256 for',len(todo),'new/changed files',flush=True)
    mismatches=[]
    for i,p in enumerate(todo):
        f=dest/p;digest=sha_file(f)
        if digest!=expected[p]:mismatches.append(p);continue
        cache[p]={'source_size':selected[p]['size'],'source_mtime_ns':selected[p]['mtime_ns'],
                  'local_mtime_ns':f.stat().st_mtime_ns,'sha256':digest}
        if (i+1)%1000==0:print('HASHED',i+1,'/',len(todo),flush=True)
    write_json(cachepath,cache)
    (meta/'SHA256SUMS').write_text(''.join(cache[p]['sha256']+'  '+p+'\n' for p in sorted(selected) if p in cache))
    inventory=['path\tsize\tremote_mtime_ns\tstatus']
    inventory.extend(f"{p}\t{r['size']}\t{r['mtime_ns']}\t"+('local_verified' if p in selected and p not in mismatches else 'remote_only(incomplete_run)' if p not in selected else 'sha256_mismatch') for p,r in sorted(inv.items()))
    (meta/'REMOTE_INVENTORY.tsv').write_text('\n'.join(inventory)+'\n')
    records=snap['completed_records']
    if records:
        (meta/'COMPLETED_CASES.jsonl').write_text(''.join(json.dumps(r)+'\n' for r in records))
        rows=['case_id\tsuccess\tdataset_passed\tdataset_frames\tdataset_root']
        rows.extend('\t'.join(str(r.get(k,'')) for k in ['case_id','success','dataset_passed','dataset_frames','dataset_root']) for r in records)
        (meta/'RUNS_SUMMARY.tsv').write_text('\n'.join(rows)+'\n')
    report={'source':src['name'],'remote':'centre:'+src['remote'],'dest':src['dest'],
            'started_at':started,'finished_at':datetime.now(timezone.utc).isoformat(),'frozen_at_utc':snap['frozen_at_utc'],
            'local_files':len(selected),'local_bytes':sum(r['size'] for r in selected.values()),
            'hdf5_copied':sum(p.endswith('.hdf5') for p in selected),'newly_verified':len(todo)-len(mismatches),
            'sha256_mismatches':mismatches,'completed_cases':len(records),
            'successes':sum(bool(r.get('success')) for r in records),
            'datasets':sum(bool(r.get('dataset_passed')) for r in records),
            'frames':sum(r.get('dataset_frames') or 0 for r in records),
            'remote_only_files':sum(not r['selected'] for r in inv.values()),
            'note':'Original remote layout preserved; no deletions; active runs excluded; root campaign metadata captured at snapshot time.'}
    if not records and (dest/'dataset/meta/info.json').is_file():
        info=json.loads((dest/'dataset/meta/info.json').read_text())
        report.update(completed_cases=None,successes=None,datasets=1,
                      episodes=info['total_episodes'],frames=info['total_frames'],
                      note='Complete immutable dataset bundle; remote layout preserved; no deletions. Case-level success counters do not apply.')
    write_json(meta/'LAST_SYNC.json',report)
    with (root/'sync/SYNC_LOG.jsonl').open('a') as f:f.write(json.dumps(report)+'\n')
    print(json.dumps(report,indent=2),flush=True)
    if mismatches:raise RuntimeError('SHA-256 mismatches: '+repr(mismatches))