| """Command-line access to NYARION's POSIX regular-file image engine.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import base64 |
| import hashlib |
| import json |
| import os |
| from pathlib import Path |
| import sys |
|
|
| import pagefs |
| from . import __version__ |
|
|
| INPUT_LIMIT = 1024 * 1024 |
|
|
|
|
| def _json(value): |
| print(json.dumps(value, sort_keys=True, ensure_ascii=True, indent=2)) |
|
|
|
|
| def _read(path, limit=INPUT_LIMIT): |
| if path == '-': |
| data = sys.stdin.buffer.read(limit + 1) |
| else: |
| with open(path, 'rb') as stream: |
| data = stream.read(limit + 1) |
| if len(data) > limit: |
| raise ValueError(f'input exceeds {limit} byte command limit') |
| return data |
|
|
|
|
| def _write(path, data): |
| """Exclusive creation keeps output paths from replacing an image or input.""" |
| if path == '-': |
| sys.stdout.buffer.write(data) |
| sys.stdout.buffer.flush() |
| return |
| descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, 'O_NOFOLLOW', 0), 0o600) |
| with os.fdopen(descriptor, 'wb') as stream: |
| stream.write(data) |
| stream.flush() |
| os.fsync(stream.fileno()) |
|
|
|
|
| def _pairs(items): |
| obj = {} |
| for key, value in items: |
| if key in obj: |
| raise ValueError(f'duplicate JSON key: {key!r}') |
| obj[key] = value |
| return obj |
|
|
|
|
| def _transaction(path): |
| try: |
| obj = json.loads(_read(path).decode('utf8'), object_pairs_hook=_pairs, |
| parse_constant=lambda value: (_ for _ in ()).throw(ValueError('invalid JSON constant'))) |
| except (UnicodeError, RecursionError) as exc: |
| raise ValueError('transaction must be bounded UTF-8 JSON') from exc |
| if not isinstance(obj, dict) or set(obj) != {'token', 'changes'}: |
| raise ValueError('transaction fields must be exactly token and changes') |
| pagefs.token_key(obj['token']) |
| changes = obj['changes'] |
| if not isinstance(changes, dict) or not changes: |
| raise ValueError('transaction changes must be a nonempty map') |
| decoded = {} |
| for key, entry in changes.items(): |
| pagefs.path_key(key) |
| if entry is None: |
| decoded[key] = None |
| elif isinstance(entry, dict) and set(entry) == {'base64'}: |
| decoded[key] = pagefs.unb64(entry['base64']) |
| else: |
| raise ValueError('each change must be null or an object containing only base64') |
| return decoded, obj['token'] |
|
|
|
|
| def _snapshot(store): |
| files = [] |
| for path in store.files(): |
| data = store.get(path) |
| files.append({'path': path, 'base64': base64.b64encode(data).decode('ascii'), |
| 'length': len(data), 'sha256': hashlib.sha256(data).hexdigest()}) |
| |
| |
| receipts = [{'token': token, **store.query(token)} for token in sorted(store._tokens)] |
| body = {'export_format': 1, 'engine_format': pagefs.FORMAT, 'volume': store.volume, |
| 'epoch': store.epoch, 'files': files, 'receipts': receipts} |
| body['snapshot_sha256'] = hashlib.sha256(pagefs.canonical(body)).hexdigest() |
| return body |
|
|
|
|
| def parser(): |
| result = argparse.ArgumentParser( |
| prog='nyarion', |
| description='NYARION regular-file storage engine. Requires Python 3 and POSIX; this is not a mounted filesystem.') |
| result.add_argument('--version', action='version', version='NYARION ' + __version__) |
| commands = result.add_subparsers(dest='command', required=True) |
| init = commands.add_parser('init', help='exclusively create an empty image') |
| init.add_argument('image') |
| init.add_argument('--pool-blocks', type=int, default=pagefs.DEFAULT_POOL_BLOCKS, |
| help='number of 4 KiB physical arena blocks, including replicas') |
| put = commands.add_parser('put', help='durably replace one complete logical file value') |
| put.add_argument('image'); put.add_argument('key'); put.add_argument('--token', required=True) |
| data = put.add_mutually_exclusive_group(required=True) |
| data.add_argument('--file', metavar='PATH', help='input bytes; - reads stdin') |
| data.add_argument('--text', help='UTF-8 text value') |
| get = commands.add_parser('get', help='read a logical value as raw bytes') |
| get.add_argument('image'); get.add_argument('key') |
| get.add_argument('--output', default='-', help='new output file; default is stdout') |
| ls = commands.add_parser('ls', aliases=['list'], help='list logical keys as JSON') |
| ls.add_argument('image') |
| delete = commands.add_parser('delete', help='durably remove one logical key') |
| delete.add_argument('image'); delete.add_argument('key'); delete.add_argument('--token', required=True) |
| tx = commands.add_parser('transact', help='apply one atomic JSON transaction') |
| tx.add_argument('image'); tx.add_argument('transaction', help='UTF-8 JSON path, or - for stdin') |
| for command, help_text in ( |
| ('checkpoint', 'materialize and publish the complete outstanding prefix'), |
| ('inspect', 'inspect recovered metadata without repairing'), |
| ('plan', 'show an exact checkpoint publication summary without writing'), |
| ('verify', 'validate recovery and report a logical snapshot digest without repairing'), |
| ('repair', 'open writable, restore available mirror redundancy, and inspect'), |
| ): |
| cmd = commands.add_parser(command, help=help_text); cmd.add_argument('image') |
| query = commands.add_parser('query', help='query a durable retry receipt') |
| query.add_argument('image'); query.add_argument('token') |
| export = commands.add_parser('export', help='export bytes and receipt metadata as audit JSON') |
| export.add_argument('image'); export.add_argument('--output', default='-', help='new output file; default is stdout') |
| return result |
|
|
|
|
| def main(argv=None): |
| args = parser().parse_args(argv) |
| try: |
| command = args.command |
| if command == 'init': |
| with pagefs.PageStore.create(args.image, pool_blocks=args.pool_blocks) as store: |
| _json(store.inspect()) |
| return 0 |
| if command == 'put': |
| value = args.text.encode('utf8') if args.text is not None else _read(args.file) |
| changes, token = {args.key: value}, args.token |
| elif command == 'delete': |
| changes, token = {args.key: None}, args.token |
| elif command == 'transact': |
| changes, token = _transaction(args.transaction) |
| writable = command in ('put', 'delete', 'transact', 'checkpoint', 'repair') |
| with pagefs.PageStore(args.image, writable=writable) as store: |
| if command in ('put', 'delete', 'transact'): |
| epoch = store.transact(changes, token) |
| _json({'epoch': epoch, 'receipt': store.query(token)}) |
| elif command == 'get': |
| _write(args.output, store.get(args.key)) |
| elif command in ('ls', 'list'): |
| _json(store.files()) |
| elif command == 'checkpoint': |
| _json({'checkpoint_epoch': store.checkpoint(), 'state': store.inspect()}) |
| elif command in ('inspect', 'repair'): |
| _json(store.inspect()) |
| elif command == 'plan': |
| _json(store.checkpoint_plan()) |
| elif command == 'query': |
| _json(store.query(args.token)) |
| elif command in ('verify', 'export'): |
| snapshot = _snapshot(store) |
| if command == 'export': |
| _write(args.output, (json.dumps(snapshot, sort_keys=True, ensure_ascii=True, indent=2) + '\n').encode('ascii')) |
| else: |
| _json({'valid': True, 'epoch': store.epoch, 'files': len(snapshot['files']), |
| 'receipts': len(snapshot['receipts']), 'snapshot_sha256': snapshot['snapshot_sha256']}) |
| return 0 |
| except (pagefs.StoreError, OSError, ValueError, TypeError) as exc: |
| print('nyarion: ' + str(exc), file=sys.stderr) |
| return 2 |
|
|
|
|
| if __name__ == '__main__': |
| raise SystemExit(main()) |
|
|
|
|
