| |
| """NYARION V fixed-pool immutable page-tree research image engine. |
| |
| Regular POSIX files only. All logical values are held in RAM. Capsule commits |
| use one fsync; checkpoints copy changed trie paths and publish through two |
| protected seal banks. The fixed object pool is reclaimed by root reachability. |
| This is not a mounted filesystem or a hardware durability qualification. |
| """ |
| from __future__ import annotations |
| import argparse,base64,errno,hashlib,heapq,json,os,re,stat,struct,sys,uuid |
| from pathlib import Path |
| try: |
| import fcntl |
| except ImportError: |
| fcntl=None |
|
|
| FORMAT=5 |
| MAGIC=b'NYPAGES5' |
| SLOTS=64 |
| SPAN=65536 |
| SECTOR=512 |
| BLOCK_SIZE=4096 |
| SEAL_OFFSETS=(0,4096,8192,12288) |
| RING_START=16384 |
| POOL_START=RING_START+2*SLOTS*SPAN |
| APPEND_START=POOL_START |
| DEFAULT_POOL_BLOCKS=16384 |
| MAX_POOL_BLOCKS=1<<20 |
| MAX_U64=(1<<64)-1 |
| K_SEAL,K_CATALOG,K_TRIE,K_BLOB,K_DATA,K_CAPSULE=1,2,3,4,5,6 |
| PREFIX=struct.Struct('>8sHHIQ16s32s') |
| HEADER=struct.Struct('>8sHHIQ16s32s32s') |
| PAGE_PAYLOAD=BLOCK_SIZE-HEADER.size |
| MAX_CAPSULE=SPAN-HEADER.size |
| INLINE_LIMIT=256 |
| ZERO='0'*64 |
| HEX32=re.compile(r'^[0-9a-f]{32}$') |
| HEX64=re.compile(r'^[0-9a-f]{64}$') |
| TOKEN=re.compile(r'^[A-Za-z0-9_.:-]{1,64}$') |
| HEX='0123456789abcdef' |
|
|
| class StoreError(Exception):pass |
| class InvalidImage(StoreError):pass |
| class RecoveryBlocked(StoreError):pass |
| class SplitIdentity(RecoveryBlocked):pass |
| class UnsupportedFormat(RecoveryBlocked):pass |
| class WriterFenced(StoreError):pass |
| class TransactionConflict(StoreError):pass |
|
|
| def canonical(obj):return json.dumps(obj,sort_keys=True,separators=(',',':'),ensure_ascii=True,allow_nan=False).encode('ascii') |
| def digest(raw):return hashlib.sha256(raw).hexdigest() |
| def uint(x,maximum=MAX_U64):return type(x) is int and 0<=x<=maximum |
| def hash_key(key):return hashlib.sha256(key.encode('utf8')).hexdigest() |
| def path_key(path): |
| if not isinstance(path,str) or not path.startswith('/') or '\\' in path or '\0' in path or len(path.encode('utf8'))>1024 or len(canonical(path))>PAGE_PAYLOAD-512 or any(p in ('','.','..') for p in path[1:].split('/')): |
| raise ValueError('canonical absolute flat path key required') |
| return path |
| def token_key(token): |
| if not isinstance(token,str) or not TOKEN.fullmatch(token):raise ValueError('safe ASCII token required') |
| return token |
| def b64(raw):return base64.b64encode(raw).decode('ascii') |
| def unb64(value): |
| if not isinstance(value,str):raise InvalidImage('base64 type') |
| try:raw=base64.b64decode(value,validate=True) |
| except (ValueError,UnicodeError) as exc:raise InvalidImage('base64 encoding') from exc |
| if b64(raw)!=value:raise InvalidImage('noncanonical base64') |
| return raw |
| def unpack_json(raw): |
| def pairs(items): |
| d={} |
| for k,v in items: |
| if k in d:raise InvalidImage('duplicate JSON field') |
| d[k]=v |
| return d |
| try:obj=json.loads(raw.decode('ascii'),object_pairs_hook=pairs,parse_constant=lambda _:(_ for _ in ()).throw(ValueError())) |
| except (ValueError,UnicodeError,RecursionError) as exc:raise InvalidImage('invalid JSON') from exc |
| if not isinstance(obj,dict) or canonical(obj)!=raw:raise InvalidImage('noncanonical JSON object') |
| return obj |
| def pack(kind,payload,epoch,volume,fixed=None): |
| if not uint(epoch) or not isinstance(volume,str) or not HEX32.fullmatch(volume):raise ValueError('record identity') |
| prefix=PREFIX.pack(MAGIC,FORMAT,kind,len(payload),epoch,bytes.fromhex(volume),hashlib.sha256(payload).digest()) |
| raw=prefix+hashlib.sha256(prefix).digest()+payload |
| if fixed is not None: |
| if len(raw)>fixed:raise ValueError('record exceeds reserved unit') |
| raw+=bytes(fixed-len(raw)) |
| return raw |
| def read_header(raw,kind,maximum): |
| if len(raw)<HEADER.size:raise InvalidImage('short header') |
| magic,version,k,n,e,vol,h,check=HEADER.unpack_from(raw) |
| if magic!=MAGIC or k!=kind or hashlib.sha256(raw[:PREFIX.size]).digest()!=check:raise InvalidImage('header identity/checksum') |
| if version!=FORMAT:raise UnsupportedFormat('checksum-valid unsupported format') |
| if n>maximum:raise RecoveryBlocked('checksum-valid length exceeds bound') |
| return {'epoch':e,'volume':vol.hex(),'length':n,'digest':h.hex()} |
| def read_payload(raw,head): |
| body=raw[HEADER.size:HEADER.size+head['length']] |
| if len(body)!=head['length'] or digest(body)!=head['digest']:raise InvalidImage('payload length/digest') |
| return body |
| def capsule_offset(epoch,replica):return RING_START+(replica*SLOTS+epoch%SLOTS)*SPAN |
| def block_offset(index):return POOL_START+index*BLOCK_SIZE |
|
|
| class PageStore: |
| """Single serialized publisher; fixed-capacity mirrored object arena.""" |
| def __init__(self,path,*,writable=True,minimum_epoch=None): |
| if fcntl is None:raise StoreError('POSIX flock required') |
| self.path=os.fspath(path);self.fd=None;self.writable=writable;self.fenced=False;self.reset_stats() |
| fd=os.open(self.path,(os.O_RDWR if writable else os.O_RDONLY)|getattr(os,'O_NOFOLLOW',0)) |
| try: |
| if not stat.S_ISREG(os.fstat(fd).st_mode):raise InvalidImage('regular image file required') |
| fcntl.flock(fd,(fcntl.LOCK_EX if writable else fcntl.LOCK_SH)|fcntl.LOCK_NB);self.fd=fd |
| self._recover() |
| if minimum_epoch is not None and (not uint(minimum_epoch) or self.epoch<minimum_epoch):raise RecoveryBlocked('below caller minimum epoch') |
| if writable:self._reprotect() |
| except BaseException:os.close(fd);self.fd=None;raise |
| @classmethod |
| def create(cls,path,*,initial_files=None,pool_blocks=DEFAULT_POOL_BLOCKS): |
| if fcntl is None:raise StoreError('POSIX flock required') |
| if not uint(pool_blocks,MAX_POOL_BLOCKS) or pool_blocks<16:raise ValueError('pool_blocks must be 16..1048576') |
| if initial_files is not None and not isinstance(initial_files,dict):raise TypeError('initial_files dictionary required') |
| files={} |
| for key,value in (initial_files or {}).items(): |
| path_key(key) |
| if not isinstance(value,bytes):raise TypeError('bytes values required') |
| if len(value)>MAX_CAPSULE:raise ValueError('initial value exceeds supported size') |
| files[key]=value |
| fd=os.open(os.fspath(path),os.O_RDWR|os.O_CREAT|os.O_EXCL|getattr(os,'O_NOFOLLOW',0),0o600) |
| self=cls.__new__(cls);self.path=os.fspath(path);self.fd=fd;self.writable=True;self.fenced=False;self.reset_stats() |
| try: |
| if not stat.S_ISREG(os.fstat(fd).st_mode):raise InvalidImage('regular image file required') |
| fcntl.flock(fd,fcntl.LOCK_EX|fcntl.LOCK_NB);os.ftruncate(fd,POOL_START+pool_blocks*BLOCK_SIZE) |
| self.volume=uuid.uuid4().hex;self.pool_blocks=pool_blocks;self.generation=-1;self.epoch=0;self.checkpoint_epoch=0;self.history=ZERO |
| self.files_root=None;self.tokens_root=None;self.catalog_desc=None;self._files=files;self._tokens={};self.active={} |
| self._dirty_files=dict(files);self._dirty_tokens={};self._cache={};self._graph_cache={};self._repair_records=[];self._selected_valid_slots=set();self._live_blocks=set() |
| self._free=list(range(pool_blocks));heapq.heapify(self._free) |
| self._refs={};self._block_owner={};self._pending=set() |
| self.checkpoint(initial=True) |
| parent=os.open(str(Path(path).resolve().parent),os.O_RDONLY|getattr(os,'O_DIRECTORY',0)) |
| try:os.fsync(parent) |
| finally:os.close(parent) |
| return self |
| except BaseException:self.close();raise |
| def __enter__(self):return self |
| def __exit__(self,*exc):self.close() |
| def close(self): |
| if self.fd is not None:os.close(self.fd);self.fd=None |
| def _live(self): |
| if self.fd is None:raise StoreError('closed') |
| if self.fenced:raise WriterFenced('uncertain state: close and recover') |
| def _writable(self): |
| self._live() |
| if not self.writable:raise WriterFenced('read-only image') |
| def reset_stats(self): |
| self.stats={'bytes_written':0,'write_calls':0,'fsync_calls':0,'capsule_batches':0,'checkpoints':0, |
| 'page_allocations':0,'reclaimed_blocks':0,'arena_live_blocks':0,'full_graph_scans':0, |
| 'incremental_validations':0,'graph_nodes_validated':0,'refcount_steps':0,'pool_rebuilds':0} |
| def _pwrite(self,raw,offset): |
| view=memoryview(raw) |
| while view: |
| n=os.pwrite(self.fd,view,offset) |
| if n<=0:raise OSError('zero-length write') |
| self.stats['bytes_written']+=n;self.stats['write_calls']+=1;view=view[n:];offset+=n |
| def _sync(self):self.stats['fsync_calls']+=1;os.fsync(self.fd) |
| def _valid_desc(self,desc,kind=None): |
| if not isinstance(desc,list) or len(desc)!=6:return False |
| a,b,g,k,n,h=desc |
| return (uint(a,self.pool_blocks-1) and uint(b,self.pool_blocks-1) and a!=b and uint(g) and |
| type(k) is int and k in (K_CATALOG,K_TRIE,K_BLOB,K_DATA) and (kind is None or k==kind) |
| and uint(n,PAGE_PAYLOAD) and isinstance(h,str) and bool(HEX64.fullmatch(h))) |
| def _alloc_object(self,kind,body): |
| if len(body)>PAGE_PAYLOAD:raise StoreError('object exceeds page payload') |
| if len(self._free)<2:raise OSError(errno.ENOSPC,'fixed object arena lacks COW checkpoint headroom') |
| a,b=heapq.heappop(self._free),heapq.heappop(self._free) |
| desc=[a,b,self._writing_generation,kind,len(body),digest(body)] |
| key=tuple(desc);self._pending.add(key) |
| for index in (a,b): |
| if index in self._block_owner:raise InvalidImage('allocator selected an owned block') |
| self._block_owner[index]=key |
| raw=pack(kind,body,self._writing_generation,self.volume,fixed=BLOCK_SIZE) |
| for index in (a,b):self._pwrite(raw,block_offset(index)) |
| self._cache[tuple(desc)]=body;self.stats['page_allocations']+=2 |
| return desc |
| def _read_object(self,desc,kind=None): |
| if not self._valid_desc(desc,kind):raise InvalidImage('object descriptor bounds/identity') |
| key=tuple(desc) |
| if key in self._cache:return self._cache[key] |
| good=None;bad=[] |
| for index in desc[:2]: |
| try: |
| raw=os.pread(self.fd,BLOCK_SIZE,block_offset(index));head=read_header(raw,desc[3],PAGE_PAYLOAD);body=read_payload(raw,head) |
| if head['epoch']!=desc[2] or head['volume']!=self.volume or len(body)!=desc[4] or digest(body)!=desc[5]:raise InvalidImage('object generation/digest mismatch') |
| good=body |
| except (InvalidImage,OSError):bad.append(index) |
| if good is None:raise RecoveryBlocked('required object has no valid mirror; fallback refused') |
| expected=pack(desc[3],good,desc[2],self.volume,fixed=BLOCK_SIZE) |
| for index in bad:self._repair_records.append((block_offset(index),expected)) |
| self._cache[key]=good;return good |
| def _put_json(self,kind,obj):return self._alloc_object(kind,canonical(obj)) |
| def _file_value(self,data): |
| if len(data)>MAX_CAPSULE:raise ValueError('value exceeds supported size') |
| if len(data)<=INLINE_LIMIT:return {'inline':b64(data)} |
| chunks=[self._alloc_object(K_DATA,data[i:i+PAGE_PAYLOAD]) for i in range(0,len(data),PAGE_PAYLOAD)] |
| return {'blob':self._put_json(K_BLOB,{'length':len(data),'digest':digest(data),'chunks':chunks})} |
| def _build_tree(self,family,entries,depth=0): |
| if not entries:return None |
| leaf={'family':family,'type':'leaf','depth':depth,'entries':entries};raw=canonical(leaf) |
| if len(raw)<=PAGE_PAYLOAD:return self._alloc_object(K_TRIE,raw) |
| if depth>=64:raise StoreError('hash collision leaf exceeds page capacity') |
| groups={} |
| for key,value in entries.items():groups.setdefault(hash_key(key)[depth],{})[key]=value |
| children={nib:self._build_tree(family,group,depth+1) for nib,group in groups.items()} |
| return self._put_json(K_TRIE,{'family':family,'type':'branch','depth':depth,'children':children}) |
| def _update_tree(self,desc,family,changes,depth=0): |
| if not changes:return desc |
| if desc is None:return self._build_tree(family,{k:v for k,v in changes.items() if v is not None},depth) |
| node=unpack_json(self._read_object(desc,K_TRIE)) |
| if node.get('family')!=family or node.get('depth')!=depth:raise InvalidImage('trie update identity/depth') |
| if node.get('type')=='leaf': |
| entries=dict(node['entries']) |
| for key,value in changes.items(): |
| if value is None:entries.pop(key,None) |
| else:entries[key]=value |
| if entries==node['entries']:return desc |
| return self._build_tree(family,entries,depth) |
| if node.get('type')!='branch' or depth>=64:raise InvalidImage('trie branch update') |
| children=dict(node['children']);groups={} |
| for key,value in changes.items():groups.setdefault(hash_key(key)[depth],{})[key]=value |
| for nib,group in groups.items(): |
| child=self._update_tree(children.get(nib),family,group,depth+1) |
| if child is None:children.pop(nib,None) |
| else:children[nib]=child |
| if children==node['children']:return desc |
| if not children:return None |
| return self._put_json(K_TRIE,{'family':family,'type':'branch','depth':depth,'children':children}) |
| def _scan_graph(self,catalog_desc,*,decode=False,generation=None,incremental=False): |
| """Full recovery validation, or validation of newly reserved objects only. |
| |
| An unchanged pointer is accepted only when its complete identity is live |
| and its validated family/routing/owner context matches the new edge. |
| """ |
| self.stats['incremental_validations' if incremental else 'full_graph_scans']+=1 |
| seen=set();identities=set();files={};tokens={} |
| selected_generation=self.generation if generation is None else generation |
| if not self._valid_desc(catalog_desc,K_CATALOG) or catalog_desc[2]!=selected_generation:raise InvalidImage('catalogue birth differs from selected generation') |
| def known(desc,kind,context): |
| if not self._valid_desc(desc,kind) or desc[2]>selected_generation:raise InvalidImage('invalid reachable descriptor/birth') |
| if not incremental:return False |
| key=tuple(desc) |
| if any(self._block_owner.get(index)!=key for index in desc[:2]):raise InvalidImage('descriptor does not own its reserved/live blocks') |
| if self._refs.get(key,0): |
| info=self._graph_cache.get(key) |
| if info is None or info['context']!=context or info['max_epoch']>cat['epoch']:raise InvalidImage('unchanged object context/epoch mismatch') |
| return True |
| if key not in self._pending:raise InvalidImage('pointer is neither live nor reserved') |
| return False |
| def claim(desc,kind): |
| if not self._valid_desc(desc,kind) or desc[2]>selected_generation:raise InvalidImage('invalid reachable descriptor/birth') |
| if seen.intersection(desc[:2]):raise InvalidImage('object block alias/cycle') |
| seen.update(desc[:2]);identities.add(tuple(desc));self.stats['graph_nodes_validated']+=1 |
| return self._read_object(desc,kind) |
| if incremental: |
| key=tuple(catalog_desc) |
| if key not in self._pending or any(self._block_owner.get(index)!=key for index in catalog_desc[:2]):raise InvalidImage('candidate catalogue not reserved') |
| cat=unpack_json(claim(catalog_desc,K_CATALOG)) |
| if (set(cat)!={'format','volume','epoch','history','files_root','tokens_root'} or type(cat['format']) is not int or cat['format']!=FORMAT or |
| cat['volume']!=self.volume or not uint(cat['epoch']) or not isinstance(cat['history'],str) or not HEX64.fullmatch(cat['history'])):raise InvalidImage('catalogue schema') |
| if incremental and (cat['epoch']!=self.epoch or cat['history']!=self.history):raise InvalidImage('candidate logical head mismatch') |
| def remember(desc,links,context,max_epoch=0): |
| self._graph_cache[tuple(desc)]={'links':links,'context':context,'max_epoch':max_epoch} |
| def file_value(path,obj): |
| if not isinstance(obj,dict):raise InvalidImage('file value schema') |
| if set(obj)=={'inline'}: |
| data=unb64(obj['inline']) |
| if len(data)>INLINE_LIMIT:raise InvalidImage('oversized inline value') |
| return data,[] |
| if set(obj)!={'blob'}:raise InvalidImage('file encoding') |
| desc=obj['blob'];links=[(desc,K_BLOB)] |
| if known(desc,K_BLOB,('blob',path)):return None,links |
| manifest=unpack_json(claim(desc,K_BLOB)) |
| if (set(manifest)!={'length','digest','chunks'} or not uint(manifest['length'],MAX_CAPSULE) or manifest['length']<=INLINE_LIMIT or |
| not isinstance(manifest['digest'],str) or not HEX64.fullmatch(manifest['digest']) or |
| not isinstance(manifest['chunks'],list) or len(manifest['chunks'])!=(manifest['length']+PAGE_PAYLOAD-1)//PAGE_PAYLOAD):raise InvalidImage('blob manifest') |
| parts=[] |
| for i,chunk in enumerate(manifest['chunks']): |
| context=('data',path,i) |
| if known(chunk,K_DATA,context):part=self._read_object(chunk,K_DATA) |
| else: |
| part=claim(chunk,K_DATA);remember(chunk,[],context) |
| if len(part)!=min(PAGE_PAYLOAD,manifest['length']-i*PAGE_PAYLOAD):raise InvalidImage('blob chunk length') |
| parts.append(part) |
| data=b''.join(parts) |
| if len(data)!=manifest['length'] or digest(data)!=manifest['digest']:raise InvalidImage('blob data mismatch') |
| remember(desc,[(chunk,K_DATA) for chunk in manifest['chunks']],('blob',path)) |
| return data,links |
| def walk(desc,family,depth=0,prefix=''): |
| if desc is None:return |
| context=('trie',family,depth,prefix) |
| if known(desc,K_TRIE,context):return |
| node=unpack_json(claim(desc,K_TRIE)) |
| if node.get('family')!=family or type(node.get('depth')) is not int or node['depth']!=depth or depth>64:raise InvalidImage('trie identity/depth') |
| links=[];max_epoch=0 |
| if node.get('type')=='leaf': |
| if set(node)!={'family','type','depth','entries'} or not isinstance(node['entries'],dict) or not node['entries']:raise InvalidImage('leaf schema') |
| for key,value in node['entries'].items(): |
| try:path_key(key) if family=='files' else token_key(key) |
| except ValueError as exc:raise InvalidImage('trie key') from exc |
| if not hash_key(key).startswith(prefix):raise InvalidImage('trie key routing') |
| if family=='files': |
| data,dependencies=file_value(key,value);links.extend(dependencies) |
| if decode:files[key]=data |
| else: |
| if not isinstance(value,list) or len(value)!=2 or not uint(value[0],cat['epoch']) or not value[0] or not isinstance(value[1],str) or not HEX64.fullmatch(value[1]):raise InvalidImage('token receipt') |
| max_epoch=max(max_epoch,value[0]) |
| if decode:tokens[key]=value |
| remember(desc,links,context,max_epoch);return |
| if (node.get('type')!='branch' or set(node)!={'family','type','depth','children'} or depth>=64 or |
| not isinstance(node['children'],dict) or not node['children'] or any(nib not in HEX or len(nib)!=1 for nib in node['children'])):raise InvalidImage('branch schema') |
| for nib,child in node['children'].items(): |
| walk(child,family,depth+1,prefix+nib);links.append((child,K_TRIE)) |
| max_epoch=max(max_epoch,self._graph_cache[tuple(child)]['max_epoch']) |
| remember(desc,links,context,max_epoch) |
| walk(cat['files_root'],'files');walk(cat['tokens_root'],'tokens') |
| remember(catalog_desc,[(desc,K_TRIE) for desc in (cat['files_root'],cat['tokens_root']) if desc is not None],('catalog',)) |
| return cat,seen,files,tokens |
| def _acquire(self,desc): |
| """Activate outgoing edges only on the object's zero-to-one transition.""" |
| key=tuple(desc);previous=self._refs.get(key,0);self._refs[key]=previous+1;self.stats['refcount_steps']+=1 |
| if previous:return |
| info=self._graph_cache.get(key) |
| if info is None:raise InvalidImage('acquiring unvalidated object') |
| self._pending.discard(key);self._live_blocks.update(desc[:2]) |
| for child,kind in info['links']:self._acquire(child) |
| def _release(self,desc): |
| """Retire outgoing edges and recycle blocks only at the last reference.""" |
| key=tuple(desc);count=self._refs.get(key,0);self.stats['refcount_steps']+=1 |
| if count<=0:raise InvalidImage('reference count underflow') |
| if count>1:self._refs[key]=count-1;return |
| del self._refs[key];info=self._graph_cache.pop(key) |
| for child,kind in info['links']:self._release(child) |
| self._cache.pop(key,None) |
| for index in desc[:2]: |
| if self._block_owner.pop(index,None)!=key:raise InvalidImage('releasing object ownership mismatch') |
| self._live_blocks.remove(index);heapq.heappush(self._free,index) |
| self.stats['reclaimed_blocks']+=2 |
| def _discard_unreachable_reservations(self): |
| |
| for key in self._pending: |
| if self._refs.get(key,0):raise InvalidImage('live allocation remained reserved') |
| self._cache.pop(key,None);self._graph_cache.pop(key,None) |
| for index in key[:2]: |
| if self._block_owner.pop(index,None)!=key:raise InvalidImage('reservation ownership mismatch') |
| heapq.heappush(self._free,index) |
| self.stats['reclaimed_blocks']+=2 |
| self._pending.clear() |
| def _validate_capsule(self,obj,head): |
| if (set(obj)!={'format','volume','epoch','parent','token','intent','changes'} or type(obj['format']) is not int or obj['format']!=FORMAT or |
| obj['volume']!=self.volume or obj['epoch']!=head['epoch'] or not uint(obj['epoch']) or not obj['epoch'] or |
| not isinstance(obj['parent'],str) or not HEX64.fullmatch(obj['parent']) or not isinstance(obj['changes'],list) or not obj['changes']):raise InvalidImage('capsule schema') |
| try:token_key(obj['token']) |
| except ValueError as exc:raise InvalidImage('capsule token') from exc |
| previous=None;items=[] |
| for change in obj['changes']: |
| if not isinstance(change,list) or len(change)!=2:raise InvalidImage('change schema') |
| path,value=change |
| try:path_key(path) |
| except ValueError as exc:raise InvalidImage('capsule path') from exc |
| if previous is not None and path<=previous:raise InvalidImage('unsorted/duplicate changes') |
| previous=path;raw=None if value is None else unb64(value) |
| items.append([path,None if raw is None else [len(raw),digest(raw)]]) |
| if digest(canonical(items))!=obj['intent']:raise InvalidImage('intent mismatch') |
| return obj |
| def _apply(self,obj): |
| if obj['token'] in self._tokens:raise RecoveryBlocked('duplicate committed token') |
| for path,value in obj['changes']: |
| data=None if value is None else unb64(value) |
| if data is None:self._files.pop(path,None) |
| else:self._files[path]=data |
| self._dirty_files[path]=data |
| entry=[obj['epoch'],obj['intent']];self._tokens[obj['token']]=entry;self._dirty_tokens[obj['token']]=entry |
| def _recover(self): |
| self._cache={};self._graph_cache={};self._repair_records=[];seals=[];places=[] |
| for slot,off in enumerate(SEAL_OFFSETS): |
| try: |
| raw=os.pread(self.fd,SECTOR,off);head=read_header(raw,K_SEAL,SECTOR-HEADER.size);obj=unpack_json(read_payload(raw,head)) |
| if (set(obj)!={'generation','volume','pool_blocks','root'} or not uint(obj['generation']) or obj['generation']!=head['epoch'] or |
| obj['volume']!=head['volume'] or not uint(obj['pool_blocks'],MAX_POOL_BLOCKS) or obj['pool_blocks']<16):raise InvalidImage('seal schema') |
| seals.append(obj);places.append((slot,obj)) |
| except (InvalidImage,OSError):continue |
| if not seals:raise RecoveryBlocked('no valid catalogue seal') |
| if len({s['volume'] for s in seals})!=1:raise SplitIdentity('volume disagreement') |
| g=max(s['generation'] for s in seals);newest=[s for s in seals if s['generation']==g] |
| if len({canonical(s) for s in newest})!=1:raise SplitIdentity('same-generation disagreement') |
| self.seal=newest[0];self.generation=g;self.volume=self.seal['volume'];self.pool_blocks=self.seal['pool_blocks'] |
| if os.fstat(self.fd).st_size!=POOL_START+self.pool_blocks*BLOCK_SIZE:raise InvalidImage('fixed image capacity mismatch') |
| self._selected_valid_slots={i for i,s in places if canonical(s)==canonical(self.seal)} |
| self.catalog_desc=self.seal['root'] |
| cat,live,files,tokens=self._scan_graph(self.catalog_desc,decode=True) |
| self.files_root=cat['files_root'];self.tokens_root=cat['tokens_root'];self.epoch=self.checkpoint_epoch=cat['epoch'];self.history=cat['history'] |
| self._files=files;self._tokens=tokens;self._dirty_files={};self._dirty_tokens={};self._live_blocks=live |
| self._free=[i for i in range(self.pool_blocks) if i not in live];heapq.heapify(self._free);self.stats['pool_rebuilds']+=1 |
| self._refs={key:1 for key in self._graph_cache} |
| self._block_owner={index:key for key in self._refs for index in key[:2]};self._pending=set() |
| headers={};complete={};valid={} |
| for slot in range(SLOTS): |
| for replica in range(2): |
| off=RING_START+(replica*SLOTS+slot)*SPAN |
| try:rawhead=os.pread(self.fd,HEADER.size,off);head=read_header(rawhead,K_CAPSULE,MAX_CAPSULE) |
| except (InvalidImage,OSError):continue |
| if head['volume']!=self.volume:raise SplitIdentity('capsule volume disagreement') |
| e=head['epoch'] |
| if e<=self.checkpoint_epoch:continue |
| if e%SLOTS!=slot or e-self.checkpoint_epoch>SLOTS:raise RecoveryBlocked('capsule outside bounded window') |
| identity=(head['length'],head['digest']);headers.setdefault(e,set()).add(identity) |
| if len(headers[e])!=1:raise SplitIdentity('same-epoch capsule disagreement') |
| try: |
| body=read_payload(rawhead+os.pread(self.fd,head['length'],off+HEADER.size),head) |
| obj=self._validate_capsule(unpack_json(body),head) |
| except (InvalidImage,OSError):continue |
| complete[e]={'body':body,'obj':obj,'digest':digest(body)};valid.setdefault(e,set()).add(replica) |
| if any(e not in complete for e in headers):raise RecoveryBlocked('newer valid header lacks complete capsule') |
| for e,item in sorted(complete.items()): |
| if e!=self.epoch+1 or item['obj']['parent']!=self.history:raise RecoveryBlocked('capsule history gap/parent mismatch') |
| self._apply(item['obj']);self.epoch=e;self.history=item['digest'] |
| raw=pack(K_CAPSULE,item['body'],e,self.volume) |
| for replica in range(2): |
| if replica not in valid[e]:self._repair_records.append((capsule_offset(e,replica),raw)) |
| self.active=complete;self.stats['arena_live_blocks']=len(live) |
| def _reprotect(self): |
| try: |
| for off,raw in self._repair_records:self._pwrite(raw,off) |
| if self._repair_records:self._sync() |
| targets=[i for i in range((self.generation%2)*2,(self.generation%2)*2+2) if i not in self._selected_valid_slots] |
| if targets: |
| raw=pack(K_SEAL,canonical(self.seal),self.generation,self.volume,fixed=SECTOR) |
| for i in targets:self._pwrite(raw,SEAL_OFFSETS[i]) |
| self._sync();self._selected_valid_slots.update(targets) |
| except BaseException:self.fenced=True;raise |
| self._repair_records=[] |
| def checkpoint(self,initial=False): |
| self._writable() |
| if initial and self.generation!=-1:raise ValueError('initial checkpoint restricted to creation') |
| if self.generation==MAX_U64:raise StoreError('catalogue generation exhausted') |
| generation=self.generation+1;self._writing_generation=generation |
| old_root=self.catalog_desc |
| try: |
| changes={path:None if value is None else self._file_value(value) for path,value in self._dirty_files.items()} |
| files_root=self._update_tree(self.files_root,'files',changes) |
| tokens_root=self._update_tree(self.tokens_root,'tokens',self._dirty_tokens) |
| cat={'format':FORMAT,'volume':self.volume,'epoch':self.epoch,'history':self.history,'files_root':files_root,'tokens_root':tokens_root} |
| root=self._put_json(K_CATALOG,cat) |
| seal={'generation':generation,'volume':self.volume,'pool_blocks':self.pool_blocks,'root':root} |
| raw=pack(K_SEAL,canonical(seal),generation,self.volume,fixed=SECTOR) |
| self._scan_graph(root,generation=generation,incremental=True) |
| self._acquire(root) |
| self._sync() |
| targets=range(4) if initial else range((generation%2)*2,(generation%2)*2+2) |
| for i in targets:self._pwrite(raw,SEAL_OFFSETS[i]) |
| self._sync() |
| |
| self.generation=generation;self.seal=seal;self.catalog_desc=root;self.files_root=files_root;self.tokens_root=tokens_root |
| self.checkpoint_epoch=self.epoch;self._selected_valid_slots=set(targets) |
| if old_root is not None:self._release(old_root) |
| self._discard_unreachable_reservations() |
| self._repair_records=[];self.active={};self._dirty_files={};self._dirty_tokens={} |
| self.stats['checkpoints']+=1;self.stats['arena_live_blocks']=len(self._live_blocks) |
| except BaseException:self.fenced=True;raise |
| return self.checkpoint_epoch |
| def transact(self,changes,token): |
| self._writable();token_key(token) |
| if not isinstance(changes,dict) or not changes:raise ValueError('nonempty changes dictionary required') |
| encoded=[];items=[] |
| for path,value in sorted(changes.items()): |
| path_key(path) |
| if value is not None and not isinstance(value,bytes):raise TypeError('bytes or None values required') |
| encoded.append([path,None if value is None else b64(value)]);items.append([path,None if value is None else [len(value),digest(value)]]) |
| intent=digest(canonical(items));old=self._tokens.get(token) |
| if old: |
| if old[1]!=intent:raise TransactionConflict('token reused with different intent') |
| return old[0] |
| if self.epoch==MAX_U64:raise StoreError('epoch exhausted') |
| e=self.epoch+1;obj={'format':FORMAT,'volume':self.volume,'epoch':e,'parent':self.history,'token':token,'intent':intent,'changes':encoded} |
| body=canonical(obj) |
| if len(body)>MAX_CAPSULE:raise ValueError('capsule payload exceeds bound') |
| if len(self.active)>=SLOTS:self.checkpoint() |
| raw=pack(K_CAPSULE,body,e,self.volume) |
| try: |
| for replica in range(2):self._pwrite(raw,capsule_offset(e,replica)) |
| self._sync();self._apply(obj);self.epoch=e;self.history=digest(body) |
| self.active[e]={'body':body,'obj':obj,'digest':self.history};self.stats['capsule_batches']+=1 |
| except BaseException:self.fenced=True;raise |
| return e |
| def get(self,path): |
| self._live();path_key(path) |
| try:return self._files[path] |
| except KeyError:raise FileNotFoundError(path) from None |
| def files(self):self._live();return sorted(self._files) |
| def query(self,token): |
| self._live();token_key(token);entry=self._tokens.get(token) |
| return None if entry is None else {'epoch':entry[0],'intent_sha256':entry[1]} |
| def inspect(self): |
| self._live();return {'format':FORMAT,'volume':self.volume,'epoch':self.epoch,'checkpoint_epoch':self.checkpoint_epoch, |
| 'generation':self.generation,'pool_blocks':self.pool_blocks,'live_blocks':len(self._live_blocks),'free_blocks':len(self._free), |
| 'files':self.files(),'tokens':len(self._tokens),'fixed_image_bytes':POOL_START+self.pool_blocks*BLOCK_SIZE,'io':dict(self.stats)} |
|
|
| CutStore=ImageStore=PageStore |
| def main(argv=None): |
| parser=argparse.ArgumentParser(description=__doc__);sub=parser.add_subparsers(dest='command',required=True) |
| for name in ('init','demo','inspect','ls'): |
| p=sub.add_parser(name);p.add_argument('image') |
| args=parser.parse_args(argv) |
| try: |
| if args.command in ('init','demo'): |
| with PageStore.create(args.image) as store: |
| if args.command=='demo':store.transact({'/measurement':b'12.345','/index':b'revision=1'},'demo') |
| print(json.dumps(store.inspect(),indent=2)) |
| else: |
| with PageStore(args.image,writable=False) as store: |
| print('\n'.join(store.files()) if args.command=='ls' else json.dumps(store.inspect(),indent=2)) |
| return 0 |
| except (StoreError,OSError,ValueError,TypeError) as exc:print('error: '+str(exc),file=sys.stderr);return 2 |
| if __name__=='__main__':raise SystemExit(main()) |
|
|
