Datasets:
File size: 9,594 Bytes
4878bd3 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 | """ZIP64 container around seekable EOZ frames; no second lossy encoding."""
from pathlib import Path
import hashlib
import json
import os
import struct
import time
import zipfile
from .core import VERSION, json_write, sha256_file
PREFIX = 'processed_data/v1/prithvi/'
CONTENTS = 'ARCHIVE_CONTENTS.json'
class ArchiveFrames:
def __init__(self, root, storage):
self.path = (Path(root)/storage['archive']).resolve()
stat = self.path.stat()
if stat.st_size != storage['size'] or stat.st_mtime_ns != storage['mtime_ns']:
raise ValueError('Archive changed or moved without reattaching; run attach-prithvi')
self.stream = self.path.open('rb')
with zipfile.ZipFile(self.path) as z:
entries = z.infolist()
if len(entries) != len({i.filename for i in entries}):
raise ValueError('Duplicate archive members')
self.entries = {i.filename: i for i in entries}
self.offsets = {}
def read(self, loc):
member = PREFIX+'packs/'+loc['shard']
info = self.entries[member]
if info.compress_type != zipfile.ZIP_STORED or info.flag_bits & 1:
raise ValueError('EOZ members must be stored and unencrypted for direct seeking')
if member not in self.offsets:
self.stream.seek(info.header_offset)
header = self.stream.read(30)
if header[:4] != b'PK\x03\x04':
raise ValueError('Invalid ZIP local header')
name_len, extra_len = struct.unpack_from('<HH', header, 26)
name = self.stream.read(name_len).decode('utf-8')
if name != member:
raise ValueError('ZIP local/central member mismatch')
self.offsets[member] = info.header_offset+30+name_len+extra_len
offset, length = loc['offset'], loc['length']
if offset < 0 or length <= 0 or offset+length > info.file_size:
raise ValueError('Frame exceeds stored shard')
self.stream.seek(self.offsets[member]+offset)
frame = self.stream.read(length)
if len(frame) != length:
raise ValueError('Truncated archive frame')
return frame
def close(self):
self.stream.close()
def verify_archive(path):
path = Path(path).resolve()
started = time.time()
with zipfile.ZipFile(path) as z:
members = z.infolist()
manifest = json.loads(z.read(CONTENTS))
names = [i.filename for i in members]
if len(names) != len(set(names)) or set(names) != set(manifest['files']) | {CONTENTS}:
raise ValueError('Archive member inventory mismatch')
for n, (member, expected) in enumerate(manifest['files'].items(), 1):
info = z.getinfo(member)
if info.file_size != expected['size'] or info.compress_type != expected['compression']:
raise ValueError(f'Archive member schema mismatch: {member}')
h = hashlib.sha256()
with z.open(member) as source:
for block in iter(lambda: source.read(8*1024*1024), b''):
h.update(block)
if h.hexdigest() != expected['sha256']:
raise ValueError(f'Archive content hash mismatch: {member}')
if n % 64 == 0:
print(json.dumps({'phase':'verify_archive','files':n,'total':len(manifest['files'])}), flush=True)
bundle = json.loads(z.read(PREFIX+'bundle.json'))
for shard in bundle['shards']:
assert manifest['files'][PREFIX+'packs/'+shard['name']]['sha256'] == shard['sha256']
print('Archive members verified; computing whole-file SHA-256', flush=True)
digest = sha256_file(path)
report = {'status':'passed','path':str(path),'size':path.stat().st_size,'mtime_ns':path.stat().st_mtime_ns,
'sha256':digest,'members':len(members),'records':bundle['records'],
'all_member_sha256_verified':True,'seconds':time.time()-started}
json_write(path.with_suffix(path.suffix+'.verification.json'), report)
path.with_suffix(path.suffix+'.sha256').write_text(f'{digest} {path.name}\n', encoding='utf-8')
return report
def create_archive(root, destination, prepared=None):
root = Path(root).resolve()
directory = Path(prepared or root/'processed_data/v1')/'prithvi'
destination = Path(destination).resolve()
if destination.exists():
raise FileExistsError(destination)
temporary = destination.with_suffix(destination.suffix+'.partial')
if temporary.exists():
raise FileExistsError(f'Previous partial archive needs inspection: {temporary}')
destination.parent.mkdir(parents=True, exist_ok=True)
bundle = json.loads((directory/'bundle.json').read_text(encoding='utf-8'))
if bundle['status'] != 'ready' or not bundle['all_packed_records_byte_verified']:
raise ValueError('A completed and byte-verified Prithvi build is required')
expected = {PREFIX+'packs/'+s['name']:s['sha256'] for s in bundle['shards']}
expected.update({PREFIX+k:v for k,v in bundle['artifacts'].items()})
expected.update({PREFIX+v['index']:v['sha256'] for v in bundle['samples'].values()})
expected.update({PREFIX+'original_aux/'+k:v['sha256'] for k,v in bundle['auxiliary'].items()})
files = [(directory/'packs'/s['name'], PREFIX+'packs/'+s['name'], zipfile.ZIP_STORED) for s in bundle['shards']]
excluded = {'storage.json','.prepare.lock'}
for p in sorted(directory.rglob('*')):
if p.is_file() and p.parent != directory/'packs' and p.name not in excluded and not p.name.endswith(('-wal','-shm','.tmp')):
files.append((p, PREFIX+p.relative_to(directory).as_posix(), zipfile.ZIP_DEFLATED))
package = Path(__file__).parent
for p in sorted(package.glob('*.py')) + [package/'README.md',package/'requirements.txt']:
if p.exists(): files.append((p,'eo_data/'+p.name,zipfile.ZIP_DEFLATED))
manifest = {'format':'eoz-in-zip64-v1','dataset':'prithvi','data_version':VERSION,'files':{}}
with zipfile.ZipFile(temporary,'w',allowZip64=True,compresslevel=3) as z:
for n,(source,member,compression) in enumerate(files,1):
info = zipfile.ZipInfo(member, time.localtime(source.stat().st_mtime)[:6])
info.compress_type = compression
info.external_attr = 0o100644 << 16
h = hashlib.sha256(); size = 0
with source.open('rb') as src, z.open(info,'w',force_zip64=True) as dst:
for block in iter(lambda: src.read(8*1024*1024), b''):
h.update(block); dst.write(block); size += len(block)
digest = h.hexdigest()
if member in expected and digest != expected[member]:
raise ValueError(f'Frozen source changed while archiving: {source}')
manifest['files'][member] = {'size':size,'sha256':digest,'compression':compression}
if n % 32 == 0 or n == len(files):
print(json.dumps({'phase':'create_archive','files':n,'total':len(files),'GiB_written':temporary.stat().st_size/2**30}),flush=True)
z.writestr(CONTENTS,json.dumps(manifest,indent=2).encode(),compress_type=zipfile.ZIP_DEFLATED)
temporary.replace(destination)
return verify_archive(destination)
def attach_archive(root, archive, prepared=None, verified_report=None):
root = Path(root).resolve(); archive = Path(archive).resolve()
directory = Path(prepared or root/'processed_data/v1')/'prithvi'
directory.mkdir(parents=True,exist_ok=True)
with zipfile.ZipFile(archive) as z:
manifest = json.loads(z.read(CONTENTS))
bundle = json.loads(z.read(PREFIX+'bundle.json'))
if bundle['version'] != VERSION or bundle['dataset'] != 'prithvi':
raise ValueError('Unsupported dataset archive')
frozen = set(bundle['artifacts']) | {'bundle.json'} | {v['index'] for v in bundle['samples'].values()}
frozen |= {'original_aux/'+k for k in bundle['auxiliary']}
for member, expected in manifest['files'].items():
if not member.startswith(PREFIX) or member.startswith(PREFIX+'packs/'):
continue
relative = member[len(PREFIX):]
target = (directory/relative).resolve()
if not target.is_relative_to(directory.resolve()):
raise ValueError('Unsafe archive path')
payload = z.read(member)
if hashlib.sha256(payload).hexdigest() != expected['sha256']:
raise ValueError(f'Archive metadata hash mismatch: {member}')
if target.exists():
if relative in frozen and sha256_file(target) != expected['sha256']:
raise ValueError(f'Existing frozen metadata differs: {target}')
else:
target.parent.mkdir(parents=True,exist_ok=True)
target.write_bytes(payload)
stat = archive.stat()
storage = {'backend':'zip64_eoz','archive':archive.relative_to(root).as_posix() if archive.is_relative_to(root) else str(archive),
'size':stat.st_size,'mtime_ns':stat.st_mtime_ns,'archive_sha256':None}
if verified_report:
if (verified_report['status']!='passed' or verified_report['size']!=stat.st_size
or Path(verified_report['path']).resolve()!=archive
or verified_report['mtime_ns']!=stat.st_mtime_ns):
raise ValueError('Archive verification report mismatch')
storage['archive_sha256'] = verified_report['sha256']
json_write(directory/'storage.json',storage)
return storage
|