137 lines
9.4 KiB
Python
137 lines
9.4 KiB
Python
#!/usr/bin/env python3
|
|
"""Cloud APT diagnosis: no install/retry, actual pending + separate UI approval."""
|
|
import argparse
|
|
import datetime as dt
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import subprocess
|
|
import time
|
|
import uuid
|
|
import cloud_mvp_acceptance as cloud
|
|
import cloud_root_policy
|
|
|
|
ROOT=cloud.ROOT
|
|
require=cloud.require
|
|
STATE=ROOT/'devstate/cloud-apt-followup'
|
|
|
|
|
|
def narrow_policy(payload):
|
|
import datetime as dt
|
|
p=Path('/opt/rust-discovery/devstate/root-policy/policy.json')
|
|
require(not p.is_symlink() and p.stat().st_uid==10001 and p.stat().st_mode&0o777==0o600,'unsafe policy')
|
|
old=p.read_bytes();require(hashlib.sha256(old).hexdigest()==payload['expected_sha256'],'existing policy changed')
|
|
require(dt.datetime.fromisoformat(json.loads(old)['expires_at'])<dt.datetime.now(dt.timezone.utc),'previous scope still active')
|
|
policy=payload['policy'];require(len(policy['scopes'])==1,'one diagnosis scope')
|
|
scope=policy['scopes'][0]
|
|
require(scope['allow_root_scripts'] and not scope['allow_reboot'] and not scope['allowed_services'] and
|
|
scope['principals']==['simulated-testprincipal-a'] and 'apt' not in scope,'diagnosis-only root limits')
|
|
backup=p.parents[1]/('root-policy-bootstrap-'+payload['id']);backup.mkdir(mode=0o700)
|
|
fd=os.open(backup/'previous-policy.json',os.O_CREAT|os.O_EXCL|os.O_WRONLY|os.O_NOFOLLOW,0o600)
|
|
with os.fdopen(fd,'wb') as f:f.write(old);f.flush();os.fsync(f.fileno())
|
|
next_path=p.with_suffix('.diagnosis-next')
|
|
fd=os.open(next_path,os.O_CREAT|os.O_EXCL|os.O_WRONLY|os.O_NOFOLLOW,0o600)
|
|
with os.fdopen(fd,'w') as f:json.dump(policy,f);f.flush();os.fsync(f.fileno());os.fchown(f.fileno(),10001,10001)
|
|
os.replace(next_path,p)
|
|
return dict(policy_sha256=hashlib.sha256(p.read_bytes()).hexdigest(),backup=str(backup),expires_at=policy['expires_at'],approvals_created=False)
|
|
|
|
|
|
def identity():
|
|
return dict(tenant_id=cloud.TENANT,**cloud.contract.protected_json(ROOT/'devstate/remote-vm.json')['identity'])
|
|
|
|
|
|
def evidence(kind,**extra):
|
|
target=identity()
|
|
return cloud.bootstrap.rpc('server.conf',cloud.server,dict(kind=kind,tenant_id=target['tenant_id'],agent_id=target['agent_id'],**extra))
|
|
|
|
|
|
def activate():
|
|
require(evidence('gate')['unresolved']==0,'unresolved central job')
|
|
closed=list((ROOT/'devstate/cloud-root').glob('policy-closed-*.json'));require(len(closed)==1,'one prior closed policy')
|
|
previous=cloud.contract.protected_json(closed[0])
|
|
original=[cloud.contract.protected_json(p) for p in (ROOT/'devstate/cloud-root').glob('policy-*.json')]
|
|
original=next(p for p in original if 'policy' in p)['policy']
|
|
scope=next(s for s in original['scopes'] if s['allow_root_scripts'])
|
|
scope=dict(scope,allowed_services=[],acceptance_evidence_id='cloud-apt-readonly-diagnostic-v1')
|
|
policy=dict(schema_version=1,profile='development',expires_at=(dt.datetime.now(dt.timezone.utc)+dt.timedelta(hours=1)).isoformat(),scopes=[scope])
|
|
result=cloud.bootstrap.rpc('server.conf',narrow_policy,dict(id=str(uuid.uuid4()),expected_sha256=previous['policy_sha256'],policy=policy))
|
|
cloud.contract.write_private(STATE/'diagnostic-policy.json',result)
|
|
print('Diagnostic scope active; no APT/service/reboot permission or job approval')
|
|
|
|
|
|
def diagnose(case='apt_diagnostic_v1'):
|
|
m=cloud.contract;settings=identity();require(evidence('gate')['unresolved']==0,'unresolved central job')
|
|
backend=cloud.Backend();device=backend.call('inventory.get_device',{k:settings[k] for k in ('tenant_id','asset_id')})
|
|
require(device['presence']=='online' and {'root:run_script','rmm.sync.v1','helper.root.v1'}<=set(device['capabilities']),'online root helper required')
|
|
require(case in ('apt_diagnostic_v1','apt_acquisition_v1'),'fixed diagnostic case')
|
|
source=(ROOT/'deploy/linux'/('apt-diagnostic.py' if case=='apt_diagnostic_v1' else 'apt-acquisition-diagnostic.py')).read_text()
|
|
script="exec /usr/bin/python3 -I - <<'RMM_APT_DIAGNOSTIC'\n"+source+'\nRMM_APT_DIAGNOSTIC\n'
|
|
request=m.case_input('service_setup',settings)
|
|
request['parameters'].update(variants=[dict(os_family='linux',interpreter='posix_sh',encoding='utf-8',script_utf8=script)],
|
|
timeout_seconds=90,max_output_bytes=16384,expected_stdout=None)
|
|
request['reason']=('APT Exit 100 diagnosis: two dry-run solver checks; no package transaction; preserve failed attempt' if case=='apt_diagnostic_v1'
|
|
else 'APT Exit 100 acquisition diagnosis: download-only, copied dpkg DB, private scratch; no package transaction; preserve failed attempt')
|
|
folder=STATE/('diagnosis' if case=='apt_diagnostic_v1' else 'diagnosis-acquisition');folder.mkdir(mode=0o700,exist_ok=False)
|
|
prepare=folder/'prepare.json';output=folder/'prepared.json'
|
|
common=dict(profile='dev/test',case=case,expected_principal='simulated-testprincipal-a',**settings)
|
|
m.write_private(prepare,dict(common,phase='prepare',request=request,output_file=str(output)))
|
|
cloud.prepare_browser()
|
|
def browser(file):
|
|
process=subprocess.run(['node',str(ROOT/'deploy/browser/cloud_apt_diagnostic.cjs'),str(file)],capture_output=True,timeout=120)
|
|
require(process.returncode==0,'UI incomplete; preserve checkpoint; no automatic repeat')
|
|
print('Diagnostic: actual UI preparation',flush=True);browser(prepare)
|
|
prepared=m.protected_json(output);plan=prepared['plan'];operation=prepared['operation'];job=plan['jobs'][0]
|
|
require(len(plan['jobs'])==1 and hashlib.sha256(bytes(plan['plan_payload_bytes'])).hexdigest()==plan['plan_hash'],'fixed immutable plan')
|
|
stored=backend.call('jobs.get',dict(tenant_id=settings['tenant_id'],operation_id=operation['operation_id']))
|
|
before=evidence('gate',job_id=job['job_id'])
|
|
require(stored['approval_state']=='pending_approval' and stored['plan_hash']==plan['plan_hash'] and stored['job_count']==0
|
|
and stored['execution_state'] is None and all(before[k]==0 for k in ('jobs','outbox','permits')),'pending zero artifacts')
|
|
checkpoint=dict(common,plan=plan,operation_id=operation['operation_id'],preapproval=before,stage='pending_approval')
|
|
path=folder/'checkpoint.json'
|
|
def save():path.write_text(json.dumps(checkpoint,indent=2));path.chmod(0o600)
|
|
save();approve=folder/'approve.json'
|
|
m.write_private(approve,dict(checkpoint,phase='approve'))
|
|
print('Diagnostic: pending 0/0/0 verified; separate actual UI approval',flush=True);browser(approve)
|
|
finish_diagnosis(case)
|
|
|
|
|
|
def finish_diagnosis(case='apt_diagnostic_v1'):
|
|
"""Read/audit the existing fixed job only; never prepare or approve again."""
|
|
require(case in ('apt_diagnostic_v1','apt_acquisition_v1'),'fixed existing diagnostic case')
|
|
m=cloud.contract;settings=identity();folder=STATE/('diagnosis' if case=='apt_diagnostic_v1' else 'diagnosis-acquisition');path=folder/'checkpoint.json'
|
|
checkpoint=m.protected_json(path);plan=checkpoint['plan'];job=plan['jobs'][0]
|
|
require(all(checkpoint[k]==settings[k] for k in settings),'diagnostic target changed')
|
|
operation=dict(operation_id=checkpoint['operation_id']);common=checkpoint;backend=cloud.Backend()
|
|
def save():path.write_text(json.dumps(checkpoint,indent=2));path.chmod(0o600)
|
|
end=time.monotonic()+200
|
|
while True:
|
|
result=backend.call('jobs.get',dict(tenant_id=settings['tenant_id'],job_id=job['job_id']))
|
|
if result['state'] in m.TERMINAL or result['state']=='unknown':break
|
|
require(time.monotonic()<end,'diagnostic outcome unconfirmed; no repeat');time.sleep(3)
|
|
checkpoint.update(stage=result['state'],result=result);save()
|
|
require(result['state']=='succeeded' and result['result']['evidence']['postconditions_passed'],'diagnostic job failed; preserve result')
|
|
data=json.loads(bytes(result['result']['stdout']))
|
|
require(data['diagnostic_only'] is True and data['transaction_executed'] is False and data['preserved_state'] is True,'diagnostic preservation proof')
|
|
audit=evidence('audit',operation_id=operation['operation_id']);after=evidence('gate',job_id=job['job_id'])
|
|
require(audit==dict(origin='dev_test_browser_simulation',simulation=True,principal=common['expected_principal'],plan_hash=plan['plan_hash']),'simulation audit')
|
|
require([after[k] for k in ('jobs','outbox','permits')]==[1,1,1],'one diagnostic attempt')
|
|
checkpoint.update(verified=True,data=data,audit=audit,postapproval=after);save();print(json.dumps(data))
|
|
|
|
|
|
def close():
|
|
require(evidence('gate')['unresolved']==0,'unresolved central job')
|
|
previous=cloud.contract.protected_json(STATE/'diagnostic-policy.json')
|
|
result=cloud.bootstrap.rpc('server.conf',cloud_root_policy.close_policy,dict(expected_sha256=previous['policy_sha256'],backup=previous['backup']))
|
|
cloud.contract.write_private(STATE/'diagnostic-policy-closed.json',result);print('Diagnostic scope closed')
|
|
|
|
|
|
if __name__=='__main__':
|
|
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=('activate','diagnose','finish','diagnose-acquisition','finish-acquisition','close'));args=parser.parse_args()
|
|
try:
|
|
os.umask(0o077);STATE.mkdir(mode=0o700,exist_ok=True)
|
|
dict(activate=activate,diagnose=diagnose,finish=finish_diagnosis,close=close,
|
|
**{'diagnose-acquisition':lambda:diagnose('apt_acquisition_v1'),'finish-acquisition':lambda:finish_diagnosis('apt_acquisition_v1')})[args.action]()
|
|
except Exception as error:
|
|
print('APT_FOLLOWUP_INCOMPLETE:'+type(error).__name__);raise SystemExit(2) from None
|