Files
rust-discovery/tests/apt_transaction/test_native_recovery.py

179 lines
12 KiB
Python

"""Bound configure-only recovery on temporary sealed files; no package effects."""
import copy
from contextlib import contextmanager
from dataclasses import replace
from pathlib import Path
import tempfile
import uuid
from unittest import TestCase
from unittest.mock import patch
from test_guard import apt
from test_native_acceptance import context, fixture_transaction, action_manifest, signed_job, prechecks, host_before
import test_native_retry as retry_fixture
def recovery_transaction():
obj = fixture_transaction()
obj.update(schema_version=2, operation='configure_only')
obj['packages'][0]['old_version'] = '1.0'
return obj
@contextmanager
def recovery_files():
with tempfile.TemporaryDirectory(dir='/tmp/opencode') as temp:
base = Path(temp)
def read(path, *args, **kwargs):
if path == apt.CODE: return b'code'
if path == Path(apt.HOOK): return apt.hook_script()
if path == Path('/usr/share/rmm-mvp-test/version'): return b'1.0\n'
return path.read_bytes()
with patch.object(apt, 'BASE', base), patch.object(apt, 'ACTIVE', base/'active'), \
patch.object(apt, 'secure_path', side_effect=lambda path, **kwargs: path), \
patch.object(apt, 'sealed_read', side_effect=read):
tx, old, action, _, _, _ = retry_fixture.NativeRetryTests().setup_history(base)
old = replace(old, job_id=str(uuid.uuid4()), authorization_id=str(uuid.uuid4()))
old_job = apt.canonical(signed_job(old, action))
old = replace(old, job_payload_sha256=apt.digest(old_job))
active = apt.ACTIVE
(active/'context.json').write_bytes(apt.canonical(old.__dict__))
(active/'signed-action.json').write_bytes(old_job)
(active/'apt.conf').write_bytes(apt.apt_config())
marker, binding = apt.bootstrap_binding(tx, old, action)
apt.durable_once(marker, binding)
files = {'launch.json': {'transaction_sha256': old.transaction_sha256,
'effect_armed_ledger_id': old.effect_armed_ledger_id},
'native-prechecks.json': prechecks(old),
'sandbox-ready.json': {'sandbox_version': 1, 'transaction_sha256': old.transaction_sha256},
'sandbox-result.json': {'transaction_sha256': old.transaction_sha256,
'apt_exit_code': 0, 'reboot_required': False},
'hook-armed.json': {'armed_at_ms': 2000, 'effect_armed_ledger_id': old.effect_armed_ledger_id,
'grant_id': old.grant_id, 'transaction_sha256': old.transaction_sha256,
'protocol_sha256': 'e'*64}}
for name, obj in files.items(): (active/name).write_bytes(apt.canonical(obj))
snapshot = {'rmm-mvp-test:all': {'version': '1.0', 'status': 'install ok unpacked'}}
fields = ('transaction_sha256 job_payload_sha256 effect_armed_ledger_id grant_id '
'job_id attempt_id authorization_id plan_sha256')
with patch.object(apt.os, 'geteuid', return_value=0), \
patch.object(Path, 'read_text', return_value=old.boot_id), \
patch.object(apt, 'observe_host_frontend_lock', return_value=False), \
patch.object(apt, 'status_fingerprint', return_value='a'*64), \
patch.object(apt, 'partial_installed_snapshot', return_value=snapshot), \
patch.object(apt, 'verify_archive'):
proof = apt.verify_partial({key: getattr(old, key) for key in fields.split()})['proof']
previous = base/'history'/old.grant_id
active.rename(previous)
active.mkdir()
obj = recovery_transaction()
obj.update(status_fingerprint=proof['status_fingerprint'], baseline_sha256=proof['observed_snapshot_sha256'])
tx = apt.ResolvedAptTransaction.parse(obj)
new = replace(context(), transaction_sha256=apt.digest(apt.canonical(obj)),
grant_id=str(uuid.uuid4()), attempt_id=str(uuid.uuid4()), job_id=str(uuid.uuid4()),
authorization_id=str(uuid.uuid4()), plan_sha256='f'*64)
action = action_manifest(new, obj, {})
action.update(schema_version=4, native_recovery={'schema_version': 1,
'previous_grant_id': old.grant_id, 'previous_attempt_id': old.attempt_id,
'partial_proof_sha256': apt.digest(apt.canonical(proof))})
new_job = apt.canonical(signed_job(new, action))
new = replace(new, job_payload_sha256=apt.digest(new_job))
for name, data in {'context.json': apt.canonical(new.__dict__), 'signed-action.json': new_job,
'expectation.json': apt.canonical(obj), 'baseline.json': apt.canonical(snapshot),
'partial-proof.json': apt.canonical(proof), 'apt.conf': apt.apt_config(),
'host-reboot-before.json': apt.canonical(host_before(new)),
'native-prechecks.json': apt.canonical(prechecks(new,host_before(new))),
'sandbox-result.json': apt.canonical({'transaction_sha256':new.transaction_sha256,'apt_exit_code':0,'reboot_required':False}),
'hook-armed.json': b'{}'}.items():
(active/name).write_bytes(data)
yield base, tx, new, action, proof, previous
class NativeRecoveryTests(TestCase):
def test_configure_only_schema_and_actual_action_set_are_fixed(self):
obj = recovery_transaction()
tx = apt.ResolvedAptTransaction.parse(obj)
configure = apt.Action('rmm-mvp-test','1.0','all','none','=','1.0','all','none','**CONFIGURE**')
apt.validate_actions(tx, (configure,))
for actions in ((), (configure,configure), (replace(configure, action=tx.packages[0].archive_path),),
(replace(configure, direction='<'),), (replace(configure, name='other'),),
(replace(configure, new_version='1.1'),)):
with self.subTest(actions=actions), self.assertRaises(apt.Veto): apt.validate_actions(tx, actions)
for change in ({'schema_version':1}, {'operation':'repair_pending'}, {'recipe_id':'other'}):
bad = copy.deepcopy(obj);bad.update(change)
with self.subTest(change=change), self.assertRaises(apt.Veto): apt.ResolvedAptTransaction.parse(bad)
for old,new in ((None,'1.0'),('1.0','1.1'),('1.1','1.1')):
bad = copy.deepcopy(obj);bad['packages'][0].update(old_version=old,new_version=new)
with self.assertRaises(apt.Veto): apt.ResolvedAptTransaction.parse(bad)
def test_new_signed_recovery_preserves_history_and_cannot_create_install_acceptance(self):
with recovery_files() as (base,tx,ctx,action,proof,previous):
original = {str(p.relative_to(base)): p.read_bytes() for p in base.rglob('*')
if p.is_file() and 'active/' not in str(p.relative_to(base))}
self.assertEqual(apt.load_signed_action(tx,ctx),action)
self.assertEqual(apt.verify_recovery_reference(tx,ctx,action),proof)
apt.check_native_gate(tx,ctx,action,{},True)
path,binding = apt.bootstrap_binding(tx,ctx,action)
self.assertEqual(path.name,'recovery-attempt-'+proof['grant_id']+'.json')
apt.durable_once(path,binding)
with self.assertRaisesRegex(apt.Veto,'ALREADY_HANDED_OFF'): apt.durable_once(path,binding)
with patch.object(apt,'runtime_identity',return_value={}),patch.object(Path,'read_text',return_value=ctx.boot_id):
evidence = apt.complete_acceptance(tx,ctx,action,{}, {'reboot_required':False})
self.assertTrue(evidence['native_recovery'])
self.assertNotIn('native_record_sha256',evidence)
record = apt.json_bytes((base/('recovery-'+proof['grant_id']+'.json')).read_bytes())
self.assertEqual(record['operation'],'configure_only')
self.assertEqual(record['native_recovery'],action['native_recovery'])
self.assertFalse(apt.record_path(tx).exists())
for name,data in original.items(): self.assertEqual((base/name).read_bytes(),data)
with self.assertRaisesRegex(apt.Veto,'RECOVERY_ALREADY_RECORDED'):
apt.check_native_gate(tx,ctx,action,{},True)
def test_recovery_rejects_proof_history_approval_and_current_state_mismatch(self):
with recovery_files() as (_,tx,ctx,action,proof,previous):
for changed in (replace(ctx,grant_id=proof['grant_id']),replace(ctx,job_id=proof['job_id']),
replace(ctx,authorization_id=proof['authorization_id']),replace(ctx,plan_sha256=proof['plan_sha256'])):
with self.assertRaises(apt.Veto): apt.verify_recovery_reference(tx,changed,action)
bad = copy.deepcopy(action);bad['native_recovery']['partial_proof_sha256']='0'*64
with self.assertRaises(apt.Veto): apt.verify_recovery_reference(tx,ctx,bad)
(previous/'sandbox-result.json').write_bytes(b'{}')
with self.assertRaisesRegex(apt.Veto,'RECOVERY_HISTORY_CHANGED'): apt.verify_recovery_reference(tx,ctx,action)
with patch.object(apt,'status_fingerprint',return_value=tx.status_fingerprint), \
patch.object(apt,'partial_installed_snapshot',return_value={}), \
patch.object(apt,'installed_snapshot',side_effect=AssertionError('ordinary parser stays strict')):
with self.assertRaisesRegex(apt.Veto,'STATUS_BASELINE_CHANGED'):
apt.check_preconditions(tx,proof['snapshot'])
def test_passive_recovery_planning_rechecks_original_and_seals_only_exact_partial_baseline(self):
with recovery_files() as (base,tx,ctx,action,proof,previous):
apt.ACTIVE.rename(base/'new-staged')
previous.rename(apt.ACTIVE)
old = apt.json_bytes((apt.ACTIVE/'context.json').read_bytes())
(base/'archives').mkdir();(base/'baselines').mkdir()
for version,sha in apt.FIXTURE_SHA256.items():
(base/'archives'/(sha+'.deb')).write_bytes(apt.fixture_archive(version))
(base/('prefetch-'+sha+'.json')).write_bytes(apt.canonical({
'schema_version':1,'sha256':sha,'size':20672,'sealed_at_ms':1000}))
request = {'native_recovery':action['native_recovery'],'proof':proof}
before = {p:p.read_bytes() for p in base.rglob('*') if p.is_file()}
with patch.object(apt.os,'geteuid',return_value=0), \
patch.object(Path,'read_text',return_value=old['boot_id']), \
patch.object(apt,'observe_host_frontend_lock',return_value=False), \
patch.object(apt,'status_fingerprint',return_value=proof['status_fingerprint']), \
patch.object(apt,'partial_installed_snapshot',return_value=proof['snapshot']), \
patch.object(apt,'installed_snapshot',side_effect=apt.Veto('DPKG_INCONSISTENT')), \
patch.object(apt,'verify_archive'),patch.object(apt,'archive_metadata'), \
patch.object(apt,'runtime_identity',return_value={}):
result = apt.recovery_planning(request)
self.assertEqual(result['native_recovery'],request['native_recovery'])
self.assertEqual(result['baseline_sha256'],proof['observed_snapshot_sha256'])
self.assertEqual(result['fixture_package'],{'version':'1.0','status':'install ok unpacked'})
with self.assertRaisesRegex(apt.Veto,'DPKG_INCONSISTENT'): apt.planning_status()
changed = copy.deepcopy(request);changed['proof']['original_evidence_sha256']='0'*64
changed['native_recovery']['partial_proof_sha256']=apt.digest(apt.canonical(changed['proof']))
with self.assertRaisesRegex(apt.Veto,'RECOVERY_PLANNING_STATE_CHANGED'): apt.recovery_planning(changed)
with patch.object(apt,'observe_host_frontend_lock',return_value=True):
with self.assertRaisesRegex(apt.Veto,'FOREIGN_PACKAGE_LOCK'): apt.recovery_planning(request)
for path,data in before.items(): self.assertEqual(path.read_bytes(),data)
self.assertEqual((base/'baselines'/(proof['observed_snapshot_sha256']+'.json')).read_bytes(),apt.canonical(proof['snapshot']))
self.assertFalse((base/('recovery-attempt-'+proof['grant_id']+'.json')).exists())