Files
rust-discovery/deploy/vm_mvp_adapters.py

244 lines
18 KiB
Python

#!/usr/bin/env python3
"""Concrete public-contract acceptance adapters. Importing performs no I/O."""
import datetime as dt
import hashlib
import json
import subprocess
import sys
import time
import uuid
import vm_mvp_acceptance as m
APT_CASES = ('apt_native_install','apt_native_update','ensure_package','apply_updates')
RECIPES = {'apt_native_install':'rmm-apt-fixture-install-1.0','ensure_package':'rmm-apt-fixture-update-1.1',
'apt_native_update':'rmm-apt-fixture-update-1.1','apply_updates':'rmm-apt-fixture-update-1.1'}
PINS = {'1.0':'74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867',
'1.1':'ef67c9fe0ba1443fcfe465768e1204763063c369a2a1da04af6027d8a9c00491'}
PLANNING_FIELDS = ('fixture_package','baseline_sha256','sealed_baseline_sha256','status_fingerprint',
'dpkg_updates_empty','pending_triggers_empty','host_reboot_required','runtime','runtime_sha256',
'provider_sha256','hook_sha256','apt_config_sha256','prefetch')
def canonical(value):
return json.dumps(value,sort_keys=True,separators=(',',':'),ensure_ascii=True).encode()
def digest(value):
return hashlib.sha256(value).hexdigest()
def planning_from_device(device,recovery=False):
"""Only already stored passive observation, never an SSH package scan."""
observations=(device.get('inventory') or {}).get('observations',[])
scope='linux.apt.recovery-planning' if recovery else 'linux.apt.planning'
observation=next((x for x in observations if x.get('scope')==scope),None)
m.require(observation is not None,'not_configured:stored_linux.apt.planning_observation_missing')
m.require(observation.get('quality')=='valid' and observation.get('completeness')=='complete'
and observation.get('truncated') is False and 0 <= (m.now()-m.timestamp(observation['observed_at'])).total_seconds()<90,
'not_configured:fresh_complete_apt_planning_required')
data=observation.get('data',{})
if recovery:
m.require(observation['source_id']=='root-helper:apt_recovery_planning_v1' and
data.get('fixture_package')==dict(version='1.0',status='install ok unpacked') and
set(data.get('native_recovery',{}))=={'schema_version','previous_grant_id','previous_attempt_id','partial_proof_sha256'},
'dedicated exact partial recovery observation required')
else:m.require(data.get('native_recovery') is None,'normal planning cannot use partial recovery')
missing=[key for key in PLANNING_FIELDS if key not in data]
m.require(not missing,'not_configured:apt_planning_fields_missing:'+','.join(missing))
m.require(data['dpkg_updates_empty'] is True and data['pending_triggers_empty'] is True,'not_configured:dpkg_dirty')
m.require(type(data['host_reboot_required']) is bool,'not_configured:actual_host_reboot_flag_required')
m.require(data['baseline_sha256']==data['sealed_baseline_sha256'] and __import__('re').fullmatch('[a-f0-9]{64}',data['baseline_sha256']),
'not_configured:actual_sealed_baseline_binding')
if 'baseline' in data:
m.require(digest(canonical(data['baseline']))==data['baseline_sha256'] and data['baseline'].get('rmm-mvp-test:all')==data['fixture_package'],'not_configured:full_baseline_hash_or_fixture_projection')
if 'status_records' in data:
m.require(digest(canonical(data['status_records']))==data['status_fingerprint'],'not_configured:resolver_fingerprint')
m.require(digest(canonical(data['runtime']))==data['runtime_sha256'] and
data['runtime']['apt_config_sha256']==data['apt_config_sha256'],'not_configured:runtime_config_binding')
for key in ('baseline_sha256','sealed_baseline_sha256','status_fingerprint','runtime_sha256','provider_sha256','hook_sha256','apt_config_sha256'):
m.require(isinstance(data[key],str) and __import__('re').fullmatch('[a-f0-9]{64}',data[key]),'not_configured:measured_sha256_required:'+key)
return data
def manifest(name,data,start):
recipe=RECIPES[name]; version='1.1' if recipe.endswith('1.1') else '1.0';old='1.0' if version=='1.1' else None
installed=data['fixture_package']
if old is None:
m.require(installed is None or installed.get('status') in ('purge ok not-installed','unknown ok not-installed'),
'not_configured:fixture_already_installed_no_approved_removal_or_idempotent_recipe')
else:
already_desired=name in ('ensure_package','apply_updates') and installed==dict(version=version,status='install ok installed')
m.require(already_desired or installed==dict(version=old,status='install ok installed'),'not_configured:fixture_upgrade_requires_actual_1.0_or_approved_exact_noop_baseline')
pin=PINS[version]
receipt=data['prefetch'].get(pin,{})
m.require(receipt.get('schema_version')==1 and receipt.get('sha256')==pin and receipt.get('size')==20672
and type(receipt.get('sealed_at_ms')) is int and receipt['sealed_at_ms']<=int(start.timestamp()*1000),
'not_configured:real_pregrant_prefetch_receipt_required')
transaction=dict(schema_version=1,recipe_id=recipe,recipe_version='1',platform='ubuntu-24.04-amd64',
resolver_config_version='rmm-apt-local-v1',no_reboot=True,status_fingerprint=data['status_fingerprint'],
baseline_sha256=data['baseline_sha256'],packages=[dict(name='rmm-mvp-test',architecture='all',old_version=old,
new_version=version,origin='rmm-test',sha256=pin,size=20672,archive_path='/var/lib/rmm-apt-transaction/archives/'+pin+'.deb')])
raw=canonical(transaction)
result=dict(type='rmm.apt.helper-action',schema_version=2,action='apt-native-acceptance' if name.startswith('apt_native_') else 'apt-execute',
execution_profile='dev-test',transaction_sha256=digest(raw),resolved_apt_transaction=transaction,transaction_bytes=list(raw),
**{key:data[key] for key in ('provider_sha256','hook_sha256','apt_config_sha256','runtime_sha256')},test_result_id='vm-'+uuid.uuid4().hex)
m.validate_apt_manifest(result)
return result
def advanced_input(name,settings,start,planning=None):
m.require(name not in ('duplicate_offer','lost_result_ack'),'existing_attempt_replay_has_no_new_plan')
identity='agent_service';timeout=60;end=start+dt.timedelta(minutes=15)
if name in APT_CASES:
m.require(planning is not None,'not_configured:stored_linux.apt.planning_required')
apt=manifest(name,planning,start);recipe=RECIPES[name];identity='root';timeout=300
if name.startswith('apt_native_'):
action='apt_native_acceptance';parameters=dict(recipe_id=recipe,recipe_version='1',apt_manifest=apt)
elif name=='ensure_package':
action='ensure_package';parameters=dict(provider='apt',package='rmm-mvp-test',version='1.1',architecture='all',
installation_context='system',recipe_id=recipe,recipe_version='1',apt_manifest=apt)
else:
action='apply_updates';parameters=dict(provider='apt',packages=['rmm-mvp-test'],reboot_policy='never',apt_manifest=apt)
elif name in ('cancel_queued','expired_offline'):
action='run_script';parameters=dict(variants=[dict(os_family='linux',interpreter='posix_sh',encoding='utf-8',script_utf8=m.HELLO)],
arguments=[],expected_stdout='Hello World\n')
if name=='cancel_queued':start=start+dt.timedelta(minutes=3);end=start+dt.timedelta(minutes=3)
else:end=start+dt.timedelta(seconds=60)
elif name=='reboot_last':
identity='root';timeout=240;action='reboot';parameters=dict(reason='Explicit final Linux VM dev/test acceptance',
dependency_group='single-test-vm',reconnect_timeout_seconds=180)
else:
raise m.GuardError('unknown_advanced_case')
parameters.update(execution_identity=identity,timeout_seconds=timeout,max_output_bytes=65536)
return dict(tenant_id=settings['tenant_id'],action=action,targets=dict(asset_ids=[settings['asset_id']]),parameters=parameters,
schedule=m.schedule(start,end),rollout=dict(max_parallel=1,halt_after_failures=1),reason='Explicit dev/test VM acceptance · '+name)
def authorize(backend,settings,artifact,name,folder,request,old_boot=None,verify_boot=None):
if request['parameters']['execution_identity']=='root':
# Default automation has no root:execute permission. Do not edit its
# membership or borrow cookies: the simulated human prepares root plans
# through actual UI interactions, then MCP reads the same stored request.
output=folder/(name+'-prepared.json')
preparation=folder/(name+'-prepare.json')
m.write_private(preparation,dict(profile='dev/test',case=name,phase='prepare',request=request,
asset_id=settings['asset_id'],tenant_id=settings['tenant_id'],agent_id=settings['agent_id'],
expected_principal=artifact['expected_principal'],output_file=str(output)))
process=subprocess.run([sys.executable,str(m.ROOT/'deploy/browser/run_mvp_actions.py'),'--case-file',str(preparation),
'--prepare-only','--dev-test-ui-approve'],timeout=120)
m.require(process.returncode==0,'root_UI_preparation_unconfirmed_no_requester_scope_bypass')
prepared=m.protected_json(output);plan=prepared['plan'];pending=prepared['operation']
stored=backend.call('jobs.get',dict(tenant_id=settings['tenant_id'],operation_id=pending['operation_id']))
m.require(stored['plan_hash']==plan['plan_hash'] and stored['approval_state']=='pending_approval','root_UI_preparation_MCP_binding')
else:
plan=backend.call('operations.plan',dict(tenant_id=settings['tenant_id'],input=request))
pending=backend.call('operations.submit',dict(tenant_id=settings['tenant_id'],plan_id=plan['plan_id'],idempotency_key='mvp-'+uuid.uuid4().hex))
m.require(digest(bytes(plan['plan_payload_bytes']))==plan['plan_hash'] and len(plan['jobs'])==1,'exact_advanced_plan_bytes_required')
job=plan['jobs'][0]
m.require(job['agent_id']==settings['agent_id'] and job['asset_id']==settings['asset_id']
and job['payload']['execution_identity']==request['parameters']['execution_identity'],'fixed_advanced_job_binding')
m.require(pending['approval_state']=='pending_approval' and pending['job_count']==0 and pending['execution_state'] is None
and backend.counts(settings['tenant_id'],job['job_id'])==[0,0,0],'preapproval_zero_artifacts')
checkpoint={**{key:settings[key] for key in ('tenant_id','asset_id','agent_id')},'operation_id':str(uuid.UUID(pending['operation_id'])),
'job_id':job['job_id'],'attempt_id':job['attempt_id'],'plan_hash':plan['plan_hash']}
if old_boot is not None:
m.require(verify_boot is not None and verify_boot()==old_boot,'preapproval_boot_changed_no_reboot_approval')
checkpoint['old_boot_id']=old_boot
m.write_private(folder/(name+'-checkpoint.json'),checkpoint)
expected=dict(profile='dev/test',case=name,tenant_id=settings['tenant_id'],asset_id=settings['asset_id'],agent_id=settings['agent_id'],
plan_hash=plan['plan_hash'],plan_payload_bytes=plan['plan_payload_bytes'],job_payload=job['payload'],job_payload_hash=job['job_payload_hash'],
expected_principal=artifact['expected_principal'],operation_id=checkpoint['operation_id'])
path=folder/(name+'-browser.json');m.write_private(path,expected)
process=subprocess.run([sys.executable,str(m.ROOT/'deploy/browser/run_mvp_actions.py'),'--case-file',str(path),'--dev-test-ui-approve'],timeout=120)
m.require(process.returncode==0,'browser_advanced_approval_unconfirmed_no_retry')
return checkpoint
def wait_job(backend,settings,job_id,timeout):
end=time.monotonic()+timeout
while True:
result=backend.call('jobs.get',dict(tenant_id=settings['tenant_id'],job_id=job_id))
if result['state'] in m.TERMINAL or result['state']=='unknown':return result
m.require(time.monotonic()<end,'unknown:advanced_result_timeout_no_retry')
time.sleep(2)
def audit(backend,settings,checkpoint,artifact):
tenant=str(uuid.UUID(settings['tenant_id']));operation=str(uuid.UUID(checkpoint['operation_id']))
result=json.loads(backend.sql(f"SELECT json_build_object('origin',approval_origin,'simulation',testsimulation,'principal',principal,'plan_hash',plan_hash) FROM authorizations WHERE tenant_id='{tenant}' AND operation_id='{operation}';"))
m.require(result==dict(origin='dev_test_browser_simulation',simulation=True,principal=artifact['expected_principal'],plan_hash=checkpoint['plan_hash']), 'advanced_simulation_audit_binding')
return result
def execute_advanced(backend,settings,artifact,name,folder,runtime):
m.require(runtime is not None,'not_configured:owned_native_runtime_required')
backend.outstanding_guard(settings)
if name in ('duplicate_offer','lost_result_ack'):
# Public API can replay a durable original result. It cannot synthesize
# a server JobOffer or deliberately withhold the native agent's ACK.
path=folder/'hello-result.json';m.require(path.exists(),'not_configured:completed_same_run_hello_required')
result=runtime.replay_original_result(m.protected_json(path))
result.update(case=name,fault_injection='unsupported_native_fault_injection',
regression='original_durable_mtls_result_replay',native_fault_test_passed=False)
m.write_private(folder/(name+'-result.json'),result)
return
device=backend.call('inventory.get_device',dict(tenant_id=settings['tenant_id'],asset_id=settings['asset_id']))
planning=planning_from_device(device) if name in APT_CASES else None
request=m.case_input(name,settings) if name in m.BASIC else advanced_input(name,settings,m.now(),planning)
runtime.require_action(request)
if name in APT_CASES:
probe=runtime.apt_probe()
pins=runtime.apt_metadata()
m.require(all(planning[key]==pins[key] for key in ('provider_sha256','hook_sha256','apt_config_sha256','runtime_sha256')),
'not_configured:passive_planning_and_actual_root_installed_pins_differ')
recipe=RECIPES[name]
if name.startswith('apt_native_'):
m.require(probe['fixture_acceptance_ready'] and recipe in probe['bootstrap_recipes'],'not_configured:native_apt_bootstrap_readiness')
else:m.require(recipe in probe['accepted_recipes'],'not_configured:genuine_native_recipe_acceptance_required')
before=runtime.server_state()
if name in ('cancel_queued','expired_offline'):runtime.pause_idle()
if name=='reboot_last':runtime.prepare_reboot()
checkpoint=authorize(backend,settings,artifact,name,folder,request,before['boot_id'] if name=='reboot_last' else None,
(lambda:runtime.server_state()['boot_id']) if name=='reboot_last' else None)
job_id=checkpoint['job_id']
if name=='cancel_queued':
m.require(backend.counts(settings['tenant_id'],job_id)==[1,1,0],'offline_cancel_must_have_no_grant')
backend.call('jobs.cancel',dict(tenant_id=settings['tenant_id'],job_id=job_id,reason='Cancel fixed queued no-start VM acceptance'))
result=wait_job(backend,settings,job_id,30)
m.require(result['state']=='cancelled' and backend.counts(settings['tenant_id'],job_id)==[1,1,0],'cancel_not_confirmed_or_grant_issued')
runtime.resume_after_offline(job_id)
elif name=='expired_offline':
remaining=(m.timestamp(request['schedule']['start_before'])-m.now()).total_seconds()
if remaining>0:time.sleep(min(remaining+2,62))
runtime.resume_after_offline(job_id)
result=wait_job(backend,settings,job_id,60)
m.require(result['state']=='expired' and backend.counts(settings['tenant_id'],job_id)==[1,1,0],'expired_offline_effect_not_excluded')
else:
if name=='reboot_last':runtime.recover_reboot(checkpoint['old_boot_id'])
result=wait_job(backend,settings,job_id,request['parameters']['timeout_seconds']+45)
evidence=(result.get('result') or {}).get('evidence',{})
m.require(result['state']=='succeeded' and evidence.get('postconditions_passed') is True,'advanced_effect_not_verified_no_retry')
m.require(backend.counts(settings['tenant_id'],job_id)==[1,1,1],'exactly_one_advanced_attempt_grant')
if name=='reboot_last':
m.validate_reboot_checkpoint(checkpoint,runtime.server_state()['boot_id'],result)
inventory=backend.call('inventory.get_device',dict(tenant_id=settings['tenant_id'],asset_id=settings['asset_id']))
m.require(inventory['agent_id']==settings['agent_id'] and m.timestamp(inventory['observed_at'])>=m.timestamp(request['schedule']['not_before']),
'unknown:authenticated_new_boot_inventory_missing')
if name in APT_CASES:
apt=evidence.get('apt',{});package=request['parameters']['apt_manifest']['resolved_apt_transaction']['packages'][0]
m.require(apt.get('packages')==[dict(name=package['name'],architecture=package['architecture'],version=package['new_version'])]
and apt.get('fixture_payload_sha256')==digest((package['new_version']+'\n').encode()),'independent_apt_version_payload_postconditions')
if name.startswith('apt_native_'):
m.require(apt.get('test_acceptance') is True and apt.get('noProductionEvidence') is True
and apt.get('test_result_id')==request['parameters']['apt_manifest']['test_result_id']
and isinstance(apt.get('native_record_sha256'),str),'genuine_native_acceptance_record_required')
elif planning['fixture_package']==dict(version=package['new_version'],status='install ok installed'):
m.require(apt.get('changed') is False and apt.get('already_desired') is True
and apt.get('postcondition_already_met') is True and apt.get('transaction_executed') is False,
'exact_desired_noop_must_not_execute_a_transaction')
if name=='service_setup':
m.require(result['result']['exit_code']==0 and bytes(result['result']['stdout'])==b'RMM test unit prepared\n','root_test_service_setup_exact_result')
record=dict(case=name,verified=True,**checkpoint,audit=audit(backend,settings,checkpoint,artifact),output_not_published=True)
m.write_private(folder/(name+'-result.json'),record)