#!/usr/bin/env python3 """Preserving Cloud journal-capacity maintenance; never a job/history reset. The copy-only mode changes only its own private disposable database copy. Installation requires a separate explicit option and qualified artifact hashes. """ import argparse import base64 import hashlib import json import os from pathlib import Path import re import uuid import cloud_apt_recovery_upgrade as previous cloud = previous.cloud require = cloud.require STATE = previous.STATE def copy_reproducer(payload): import sqlite3 os.umask(0o077) source = Path('/var/lib/rmm-helper/consumption.sqlite') state = Path('/var/lib/rmm-agent-remote') require(json.loads((state/'identity.json').read_text())['agent_id'] == payload['agent_id'], 'fixed permanent Cloud identity') require(not source.is_symlink() and source.stat().st_uid == 0 and source.stat().st_mode&0o777 == 0o600, 'private original ledger') def fingerprint(db): h = hashlib.sha256() tables = db.execute("SELECT name,sql FROM sqlite_master WHERE type='table' ORDER BY name").fetchall() for name,sql in tables: require(name.replace('_','').isalnum(), 'fixed stored table name') h.update(json.dumps([name,sql],separators=(',',':')).encode()) for row in db.execute('SELECT * FROM "'+name+'" ORDER BY rowid'): data = [dict(blob_sha256=hashlib.sha256(v).hexdigest(),length=len(v)) if isinstance(v,bytes) else v for v in row] h.update(json.dumps(data,separators=(',',':'),ensure_ascii=True).encode()) return h.hexdigest() def identity(): s = source.stat() return dict(device=s.st_dev,inode=s.st_ino,size=s.st_size,sha256=hashlib.sha256(source.read_bytes()).hexdigest()) before = identity() with sqlite3.connect(source.as_uri()+'?mode=ro',uri=True) as original: require(original.execute('PRAGMA integrity_check').fetchone()[0] == 'ok', 'original integrity') require({r[0] for r in original.execute('SELECT grant_id FROM consumed')} == set(payload['expected_grants']) and len(payload['expected_grants']) == 10 and original.execute('SELECT count(*) FROM consumed WHERE result IS NULL').fetchone()[0] == 0 and original.execute('SELECT count(*) FROM helper_sync_meta WHERE fault IS NOT NULL').fetchone()[0] == 0, 'exact ten known closed Root consumptions') original_fingerprint = fingerprint(original) folder = Path('/var/lib/rmm-bootstrap-history')/('journal-capacity-copy-'+str(uuid.UUID(payload['id']))) folder.mkdir(mode=0o700) copy = folder/'ledger-copy.sqlite' fd = os.open(copy,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600);os.close(fd) with sqlite3.connect(copy) as duplicate: original.backup(duplicate) require(fingerprint(duplicate) == original_fingerprint, 'consistent private SQLite backup') page_size = duplicate.execute('PRAGMA page_size').fetchone()[0] page_count = duplicate.execute('PRAGMA page_count').fetchone()[0] old = duplicate.execute('PRAGMA max_page_count=16384').fetchone()[0] require(page_size == 4096 and old == 16384 and page_count <= old, 'actual bounded old capacity') failed = None try: duplicate.execute('BEGIN IMMEDIATE') duplicate.execute('CREATE TABLE journal_capacity_probe(payload BLOB NOT NULL)') duplicate.execute('INSERT INTO journal_capacity_probe VALUES(zeroblob(524288))') except sqlite3.DatabaseError as error: failed = getattr(error,'sqlite_errorcode',None) finally: duplicate.rollback() require(failed == sqlite3.SQLITE_FULL, 'old limit must fail with SQLITE_FULL13 on the copied actual DB') require(fingerprint(duplicate) == original_fingerprint, 'old-capacity test rolled back every row/schema change') bounded = duplicate.execute('PRAGMA max_page_count=65536').fetchone()[0] require(bounded == 65536, 'bounded 256 MiB new capacity') duplicate.execute('BEGIN IMMEDIATE') duplicate.execute('CREATE TABLE journal_capacity_probe(payload BLOB NOT NULL)') duplicate.execute('INSERT INTO journal_capacity_probe VALUES(zeroblob(524288))') require(duplicate.execute('SELECT length(payload) FROM journal_capacity_probe').fetchone()[0] == 524288, 'same copied-DB insertion passes at the new finite cap') duplicate.rollback() require(fingerprint(duplicate) == original_fingerprint and duplicate.execute('PRAGMA integrity_check').fetchone()[0] == 'ok', 'new-capacity test rolled back every row/schema change') after = identity() require(after == before, 'original DB bytes, size and inode must remain unchanged') report = dict(verified=True,backup=str(folder),old_cap_pages=16384,new_cap_pages=65536,page_size=page_size,page_count=page_count, old_error_code=failed,probe_bytes=524288,new_insert_passed=True,copy_original_content_sha256=original_fingerprint, original_before=before,original_after=after,original_unchanged=True,rows_and_schema_rolled_back=True, original_package_effects=False,original_sql_mutations=False) fd = os.open(folder/'report.json',os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600) with os.fdopen(fd,'w') as stream:json.dump(report,stream,indent=2);stream.flush();os.fsync(stream.fileno()) return report def install_capacity(payload): import fcntl import sqlite3 import time import traceback os.umask(0o077) base = Path('/var/lib/rmm-apt-transaction'); state = Path('/var/lib/rmm-agent-remote') ledger = Path('/var/lib/rmm-helper/consumption.sqlite') helper = Path('/usr/local/libexec/rmm-privileged-helper'); agent = Path('/usr/local/libexec/rmm-agent-remote') provider = Path('/usr/lib/rmm-apt-transaction/apt_transaction.py') config = Path('/etc/rmm/apt-helper.json'); proof_file = Path('/etc/rmm-remote/apt-helper-proof.json') metadata = base/'install-metadata.json'; readiness_file = base/'native-readiness.json' dropin = Path('/etc/systemd/system/rmm-agent-remote.service.d/30-cloud-root.conf') reduced = ('[Service]\nEnvironment=RMM_HELPER_SOCKET=/run/rmm-helper-cloud/control.sock\n' 'Environment=RMM_HELPER_POLICY_FILE=/etc/rmm-remote/general-helper-proof.json\n' 'Environment=RMM_LOG_UNITS_FILE=/etc/rmm-remote/log-units.json\n') def run(args, **kwargs): return subprocess.run(args, capture_output=True, check=True, timeout=90, **kwargs).stdout def sha(raw): return hashlib.sha256(raw).hexdigest() def canonical(value): return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True).encode() def fsync_dir(path): fd = os.open(path, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) try: os.fsync(fd) finally: os.close(fd) def create(path, raw, mode=0o600, gid=0): fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode) with os.fdopen(fd, 'wb') as stream: stream.write(raw); stream.flush(); os.fchown(stream.fileno(), 0, gid) os.fchmod(stream.fileno(), mode); os.fsync(stream.fileno()) fsync_dir(path.parent) def manifest(path): require(not path.is_symlink(), 'preserved directory symlink') if not path.exists(): return {'__absent__':True} require(path.is_dir(), 'preserved directory required') result = {} for p in [path, *sorted(path.rglob('*'))]: s = p.lstat(); require(not p.is_symlink() and (p.is_dir() or p.is_file()), 'preserved regular state required') result[str(p.relative_to(path))] = dict(dev=s.st_dev, inode=s.st_ino, mode=s.st_mode, uid=s.st_uid, gid=s.st_gid, sha256=sha(p.read_bytes()) if p.is_file() else None) return result def guard(): require(len(payload['expected_grants']) == 10, 'exact ten original closed Root grants') require(payload['partial_grant'] == '31ef5e5e-5dbd-4428-a9a1-cbd15de2f5a0' and payload['partial_proof_sha256'] == 'dc3bf3870ea77c12f9291bac712c53ae72194eaec980a8646155a7fb5c0dbe21', 'one reviewed closed partial only') with sqlite3.connect(ledger.as_uri()+'?mode=ro', uri=True) as db: require(db.execute('PRAGMA integrity_check').fetchone()[0] == 'ok', 'Root ledger integrity') require({r[0] for r in db.execute('SELECT grant_id FROM consumed')} == set(payload['expected_grants']) and db.execute('SELECT count(*) FROM consumed WHERE result IS NULL').fetchone()[0] == 0 and db.execute('SELECT count(*) FROM helper_sync_meta WHERE fault IS NOT NULL').fetchone()[0] == 0, 'exact known closed Root attempts') db.row_factory = sqlite3.Row rows = db.execute('SELECT * FROM apt_partial_reconciliations').fetchall() require(len(rows) == 1, 'one immutable partial proof required'); row = dict(rows[0]) expected = payload['proof_row'] for key in ('grant_id', 'original_request_sha256', 'previous_outcome_sha256', 'proof_sha256', 'checked_at_ms'): require(row[key] == expected[key], 'immutable partial binding drift') for key in ('previous_outcome', 'proof', 'classified_outcome'): require(sha(row[key]) == expected[key]['sha256'] and len(row[key]) == expected[key]['size'], 'immutable partial bytes drift') require(row['grant_id'] == payload['partial_grant'] and sha(row['proof']) == payload['partial_proof_sha256'], 'closed proof hash required') proof = json.loads(row['proof']); result = db.execute('SELECT c.result,e.outcome,e.start FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE grant_id=?', (payload['partial_grant'],)).fetchone() classified = json.loads(row['classified_outcome']) require(json.loads(result['result']) == json.loads(result['outcome']) == classified and classified['state'] == 'failed' and classified['error_code'] == 'APT_PARTIAL_UNCONFIGURED_VERIFIED', 'normal signed RootSync closure required') saved = json.loads(result['start']) # save_start nests Request through serde_json::Value (sorted keys), # whereas the immutable proof hashes serde's Request struct codec. request_fields = ('job_bytes','permit_bytes','signature','plan_hash','authorization_id') require(set(saved['request']) == set(request_fields), 'original Request fields required') request_bytes = json.dumps({key:saved['request'][key] for key in request_fields}, separators=(',', ':'), ensure_ascii=False).encode() require(sha(request_bytes) == row['original_request_sha256'], 'original signed request hash required') require(proof['grant_id'] == payload['partial_grant'] and proof['attempt_id'] == payload['partial_attempt'] and proof['snapshot']['rmm-mvp-test:all'] == {'version':'1.0','status':'install ok unpacked'}, 'exact partial fixture required') with sqlite3.connect((state/'journal.sqlite').as_uri()+'?mode=ro', uri=True) as db: require(db.execute('PRAGMA integrity_check').fetchone()[0] == 'ok' and db.execute("SELECT count(*) FROM job_attempts WHERE state NOT IN ('succeeded','failed','cancelled','expired')").fetchone()[0] == 0 and db.execute('SELECT count(*) FROM reconcile_meta WHERE fault IS NOT NULL').fetchone()[0] == 0, 'no unresolved or faulted agent attempt') require(Path('/usr/share/rmm-mvp-test/version').read_bytes() == b'1.0\n', 'existing unpacked fixture payload required') require(not list(base.glob('acceptance-*.json')) and not list(base.glob('pending-acceptance-*.json')) and not list(base.glob('recovery-*.json')) and not list(base.glob('pending-recovery-*.json')), 'no existing acceptance or recovery attempt') return proof def bound_partial(proof): keys = 'transaction_sha256 job_payload_sha256 effect_armed_ledger_id grant_id job_id attempt_id authorization_id plan_sha256'.split() value = json.loads(run(['/usr/bin/python3','-I',str(provider),'verify-partial'], input=canonical({k:proof[k] for k in keys}))) require(value['effect_state'] == 'known_failed' and value['code'] == 'APT_PARTIAL_UNCONFIGURED_VERIFIED' and {k:v for k,v in value['proof'].items() if k != 'checked_at_ms'} == {k:v for k,v in proof.items() if k != 'checked_at_ms'}, 'fresh original-bound partial state required') require(json.loads((state/'identity.json').read_text())['agent_id'] == payload['agent_id'], 'permanent Cloud identity required') require(not dropin.is_symlink() and dropin.read_text() == reduced, 'APT endpoint must remain absent') require(run(['systemctl','show','rmm-apt-helper.service','-p','ActiveState','--value']).strip() == b'inactive', 'APT helper must be stopped') for name, pin in payload['old_files'].items(): p = Path(name); require(not p.is_symlink() and p.stat().st_uid == 0 and p.stat().st_mode & 0o022 == 0 and sha(p.read_bytes()) == pin, 'installed file drift') require(Path('/etc/systemd/system/rmm-apt-helper.service').read_text() == payload['unit'], 'exact reviewed APT service required') markers = {base/'bootstrap-attempt-rmm-apt-fixture-install-1.0.json':'ec84aa4df8065f0b54b282bd273a6f342f07a6d47312289608389d05c7fb6053', base/'bootstrap-retry-rmm-apt-fixture-install-1.0.json':'a118072812553dca1a8ffee84550be0b2d514d555ad7cbcfc4722675a211a0e3'} require({p.name for p in base.glob('bootstrap-*.json')} == {p.name for p in markers} and all(sha(p.read_bytes()) == pin for p,pin in markers.items()), 'original/retry tombstones required') partial = guard(); bound_partial(partial) raw = {name:base64.b64decode(payload[name], validate=True) for name in ('helper','agent')} pins = {'helper':payload['helper_sha256'],'agent':payload['agent_sha256'], 'provider':'5ff260f75cb2959678f6be729d3a806a4ea29febd5ae4003317fed41afc25327'} require(all(sha(raw[name]) == pins[name] for name in ('helper','agent')) and sha(provider.read_bytes()) == pins['provider'], 'qualified exact capacity binaries and unchanged provider required') for name in ('helper','agent'): require(raw[name][:6] == b'\x7fELF\x02\x01' and raw[name][18:20] == b'\x3e\x00', 'Linux x64 binary required') if payload.get('preflight_only') is True: return dict(stage='preflight_validated', completed=False, preflight_only=True, package_effects=False, maintenance_mutations=False, expected_grants=len(payload['expected_grants']), partial_proof_sha256=payload['partial_proof_sha256'], apt_endpoint_enabled=False) backup = Path('/var/lib/rmm-bootstrap-history')/('cloud-journal-capacity-'+payload['id']); backup.mkdir(mode=0o700) report = dict(stage='validated', completed=False, backup=str(backup), package_effects=False, apt_endpoint_enabled=False, partial_proof_sha256=payload['partial_proof_sha256'], backups={}) def save(): next_path = backup/'.report-next.json'; create(next_path,json.dumps(report,indent=2).encode()) os.replace(next_path,backup/'report.json'); fsync_dir(backup) def replace(path, staged=None): target = backup/str(path).lstrip('/').replace('/','__') require(not path.is_symlink() and path.stat().st_dev == backup.stat().st_dev and not target.exists(), 'exclusive same-filesystem versioned replacement') os.rename(path,target); fsync_dir(path.parent); fsync_dir(backup) report['backups'][str(path)] = str(target); save() if staged is not None: os.rename(staged,path); fsync_dir(path.parent); fsync_dir(backup) lock = None try: save() for name in ('helper','agent'): create(backup/(name+'-next'), raw[name], 0o755) for name in ('helper','agent'): run(['/lib64/ld-linux-x86-64.so.2','--list',str(backup/(name+'-next'))]) run(['systemctl','stop','rmm-agent-remote.service','rmm-helper-cloud.service','rmm-apt-helper.service']) lock = os.open(ledger.parent/'executor.lock', os.O_RDWR | os.O_NOFOLLOW) fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) partial = guard(); bound_partial(partial) preserved = {str(p):manifest(p) for p in (state,Path('/var/lib/rmm-agent'),ledger.parent)} preserved_base = manifest(base) witnesses = {} for p in (Path('/var/lib/dpkg/status'),Path('/usr/share/rmm-mvp-test/version'),dropin, Path('/etc/systemd/system/rmm-apt-helper.service'),Path('/usr/lib/rmm-apt-transaction/hook'), Path('/etc/rmm-remote/general-helper-proof.json'),Path('/etc/rmm-remote/helper-general.json'),provider,metadata): s = p.stat(); witnesses[str(p)] = (s.st_dev,s.st_ino,sha(p.read_bytes())) general_bytes = Path('/etc/rmm-remote/general-helper-proof.json').read_bytes() general_config = Path('/etc/rmm-remote/helper-general.json').read_bytes() old_metadata = json.loads(metadata.read_text()); old_config = json.loads(config.read_text()) require(old_metadata['schema_version'] == 2 and old_metadata['provider_sha256'] == sha(provider.read_bytes()) and old_metadata['hook_sha256'] == sha(Path('/usr/lib/rmm-apt-transaction/hook').read_bytes()) and old_metadata['unit_sha256'] == sha(payload['unit'].encode()), 'old install metadata required') for path,name in ((helper,'helper'),(agent,'agent')): replace(path,backup/(name+'-next')) command = ['/usr/bin/python3','-I',str(provider)] config_bytes = run(command+['print-config']); config_sha = sha(config_bytes) require(config_sha == payload['reviewed_config_sha256'] and all(line in config_bytes for line in ( b'DPkg::ConfigurePending "false";', b'DPkg::TriggersPending "false";', b'dpkg::selection::remove::approved "false";')), 'reviewed exact configure/no-pending settings') runtime = json.loads(run(command+['inspect-runtime'])); runtime_sha = sha(canonical(runtime)) old_config['apt_provider'].update(runtime_sha256=runtime_sha,apt_config_sha256=config_sha) create(backup/'config-next',json.dumps(old_config).encode()); replace(config,backup/'config-next') pin = json.loads(run([str(helper),'--inspect-apt-profile'],env=dict(os.environ,RMM_HELPER_CONFIG=str(config)))) require(pin['identity'] == json.loads(general_bytes)['identity'], 'same helper identity required') create(backup/'proof-next',json.dumps(pin).encode(),0o640,984); replace(proof_file,backup/'proof-next') general = json.loads(run([str(helper),'--inspect-general-profile'],env=dict(os.environ,RMM_HELPER_CONFIG='/etc/rmm-remote/helper-general.json'))) require(general == json.loads(general_bytes) and Path('/etc/rmm-remote/helper-general.json').read_bytes() == general_config, 'General helper policy unchanged') for name,values in preserved.items(): require(manifest(Path(name)) == values, 'identity/journal/Root ledger bytes or inode changed') def preserved_original_base(): current = manifest(base) require(all(current.get(name) == value for name,value in preserved_base.items() if name not in ('install-metadata.json','native-readiness.json')), 'original APT state/archive/hook/probe changed') for name,value in witnesses.items(): p=Path(name);s=p.stat();require((s.st_dev,s.st_ino,sha(p.read_bytes())) == value, 'original package/control file bytes or inode changed') return current preserved_original_base(); bound_partial(guard()) report.update(stage='installed_preserved',preserved_state=True,helper_sha256=pins['helper'],agent_sha256=pins['agent'],journal_page_size=4096,journal_max_page_count=65536,journal_capacity_bytes=268435456, provider_sha256=pins['provider'],runtime_sha256=runtime_sha,apt_config_sha256=config_sha,apt_pin=pin,general_pin=general) save() # No client can reach this endpoint; it exists only for the service's # ExecStartPre copied-database probe, then is stopped before restart. run(['systemd-analyze','verify','/etc/systemd/system/rmm-apt-helper.service']) replace(readiness_file) # Daemon startup itself takes executor.lock to open the existing DB. # Installation is complete; agent/General remain stopped during probe. fcntl.flock(lock,fcntl.LOCK_UN);os.close(lock);lock=None run(['systemctl','start','rmm-apt-helper.service']) for _ in range(3): status = run(['systemctl','show','rmm-apt-helper.service','-p','ActiveState','-p','SubState','-p','NRestarts']).decode() require('ActiveState=active\n' in status and 'SubState=running\n' in status and 'NRestarts=0\n' in status, 'stable native probe helper required') time.sleep(1) run(['systemctl','stop','rmm-apt-helper.service']) lock = os.open(ledger.parent/'executor.lock', os.O_RDWR | os.O_NOFOLLOW) fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) ready = json.loads(readiness_file.read_text()) require(ready['runtime'] == runtime and ready['readiness_only'] is True and ready['native_acceptance'] is False and ready['host_status_sha256'] == sha(Path('/var/lib/dpkg/status').read_bytes()), 'exact new copied-database probe required') workspace = base/'probes'/str(uuid.UUID(ready['probe_id'])) require((workspace/'dpkg/status').read_bytes() == Path('/var/lib/dpkg/status').read_bytes() and (workspace/'apt.conf').read_bytes().count(b'dpkg::selection::remove::approved "false";') == 1, 'partial copied status and configure fix required') current = preserved_original_base() require(all(name in preserved_base or name.startswith('probes/'+ready['probe_id']+'/') or name == 'probes/'+ready['probe_id'] for name in current), 'only generated readiness probe metadata may be added') for name,values in preserved.items(): require(manifest(Path(name)) == values, 'journal/ledger bytes or inode changed during probe') bound_partial(guard()) require(dropin.read_text() == reduced and Path('/etc/rmm-remote/general-helper-proof.json').read_bytes() == general_bytes, 'endpoint/General proof unchanged') report.update(stage='native_probe_preserved',readiness_only=True,native_acceptance=False, journals_preserved_before_restart=True,readiness_sha256=sha(readiness_file.read_bytes()),probe_id=ready['probe_id']) save() fcntl.flock(lock,fcntl.LOCK_UN);os.close(lock);lock=None run(['systemctl','start','rmm-helper-cloud.service','rmm-agent-remote.service']) require(run(['systemctl','show','rmm-apt-helper.service','-p','ActiveState','--value']).strip() == b'inactive', 'APT endpoint must remain stopped') report.update(stage='qualified_runtime_started',completed=True);save() except Exception as error: report.update(error_class=type(error).__name__,frames=[dict(function=f.name,line=f.lineno) for f in traceback.extract_tb(error.__traceback__)]) save() finally: if lock is not None: fcntl.flock(lock,fcntl.LOCK_UN);os.close(lock) subprocess.run(['systemctl','stop','rmm-apt-helper.service'],capture_output=True,timeout=30) return report def main(): parser = argparse.ArgumentParser(description=__doc__) mode = parser.add_mutually_exclusive_group(required=True) mode.add_argument('--copy-only',action='store_true') mode.add_argument('--preflight-only',action='store_true') mode.add_argument('--install-reviewed-artifacts',action='store_true') parser.add_argument('--agent-sha256');parser.add_argument('--helper-sha256') args = parser.parse_args();os.umask(0o077) require(previous.previous.apt.prior.evidence('gate')['unresolved'] == 0, 'no unsettled central job') payload = previous.build_payload() require(len(payload['expected_grants']) == 10, 'exact completed Root/log history') if args.copy_only: report = cloud.bootstrap.rpc('linux-vm.conf',copy_reproducer,dict(id=str(uuid.uuid4()),agent_id=payload['agent_id'],expected_grants=payload['expected_grants'])) cloud.contract.write_private(STATE/('journal-capacity-copy-'+Path(report['backup']).name.removeprefix('journal-capacity-copy-')+'.json'),report) print({k:report[k] for k in ('verified','old_error_code','new_insert_passed','original_unchanged','rows_and_schema_rolled_back','original_sql_mutations')}) return require(not (STATE/'journal-capacity-runtime.json').exists(), 'existing capacity runtime retained; no automatic maintenance repeat') reviewed = {'agent':'2ce885cf5e6881e77383482b7d3a87a02c6847aa26b82e5fd70d2ebd8a45360d', 'helper':'332eae004d9416234eabf7ed3d5c9ece5440d1e0c764ea63357961c16b673b6b'} for name,pin in reviewed.items(): require(getattr(args,name+'_sha256') == pin and re.fullmatch('[0-9a-f]{64}',pin), 'independently reviewed capacity artifact pin required') raw = (STATE/(name+'-journal-capacity')).read_bytes() require(hashlib.sha256(raw).hexdigest() == pin, 'qualified capacity artifact drift') payload[name] = base64.b64encode(raw).decode();payload[name+'_sha256'] = pin payload.pop('provider') previous_runtime = cloud.contract.protected_json(STATE/'configure-runtime.json') require(previous_runtime['completed'] and previous_runtime['helper_sha256'] == previous.PINS['helper'] and previous_runtime['agent_sha256'] == previous.PINS['agent'] and previous_runtime['provider_sha256'] == previous.PINS['provider'], 'exact independently qualified previous runtime') installed = cloud.contract.protected_json(cloud.ROOT/'devstate/remote-vm.json') require(installed['binary_sha256'] == previous.PINS['agent'], 'old permanent agent record required') policy = cloud.bootstrap.rpc('server.conf',previous.closed_policy,{}) old = cloud.bootstrap.rpc('linux-vm.conf',previous.installed_metadata,previous.PINS) payload.update(old_files=old['files'],preflight_only=args.preflight_only) report = cloud.bootstrap.rpc('linux-vm.conf',install_capacity,payload) if args.preflight_only: require(report.get('preflight_only') and report.get('maintenance_mutations') is False, 'read-only maintenance preflight required') cloud.contract.write_private(STATE/('journal-capacity-preflight-'+payload['id']+'.json'),dict(report,closed_policy=policy)) print(report);return cloud.contract.write_private(STATE/('journal-capacity-install-'+payload['id']+'.json'),dict(report,closed_policy=policy)) require(report['completed'] and report['preserved_state'] and report['journals_preserved_before_restart'] and report['provider_sha256'] == previous.PINS['provider'], 'preserving bounded-capacity installation incomplete; retain report and do not repeat') previous.previous.record_agent_upgrade(report,installed) cloud.contract.write_private(STATE/'journal-capacity-runtime.json',report) print({k:report[k] for k in ('completed','stage','preserved_state','journals_preserved_before_restart','readiness_only','apt_endpoint_enabled')}) if __name__ == '__main__': try:main() except Exception as error: print('CLOUD_JOURNAL_CAPACITY_INCOMPLETE:'+type(error).__name__) if str(error).startswith('remote bootstrap incomplete: '):print(str(error)) raise SystemExit(2) from None