diff --git a/src/cbb_refresh_verify/residual_sessions.py b/src/cbb_refresh_verify/residual_sessions.py index 62971c1..d55201d 100644 --- a/src/cbb_refresh_verify/residual_sessions.py +++ b/src/cbb_refresh_verify/residual_sessions.py @@ -651,7 +651,11 @@ def _cancelled_diagnostic_record(row): if baseline is None or _load_evidence(job,row['pid'],baseline,require_autosave=False) is None: continue matches.append(dict(job=job, record_path=str(path), operation_id=operation, - closed_frame=closes[0]['hwnd'] if closes else None)) + closed_frame=closes[0]['hwnd'] if closes else None, + declined_buttons=[e['hwnd'] for e in events if e.get('stage')=='startup_prompt_no' + and e.get('pcb_pid')==row['pid'] and e.get('control_id')==7 and e.get('hwnd')], + dismissed_tips=[e['hwnd'] for e in events if e.get('stage')=='startup_tip_dismissed' + and e.get('pcb_pid')==row['pid'] and e.get('hwnd')])) except (OSError, pywintypes.error, ValueError, KeyError, TypeError): continue return matches[0] if len(matches) == 1 else None @@ -680,12 +684,12 @@ def _legacy_diagnostic_windows(row): return result -def _close_registered_startup(row, handle, proof, *, stop=None): +def _close_registered_startup(row, handle, proof, *, stop=None, deadline=None): import pywintypes, win32con, win32event from .diagnostic_open import cancelled_startup_step from .operation_queue import check_active job = proof['job']; bound = dict(row, cleanup_desktop=job['desktop']) - deadline = time.monotonic()+30 # One proved cancelled-startup intent; generic close still uses 3 seconds. + if deadline is None:deadline = time.monotonic()+30 def active_owner(): check_active() if stop is not None and stop.is_set(): @@ -704,7 +708,13 @@ def _close_registered_startup(row, handle, proof, *, stop=None): if not active_owner() or time.monotonic() >= deadline: raise ValueError('STARTUP_ACTION_UNCONFIRMED') _post_window_message({'desktop':job['desktop']}, hwnd, row['pid'], message) - state = {'clicked':set()}; closed = proof['closed_frame']; dismissed_tips = set() + state = {'clicked':set()}; closed = proof['closed_frame']; dismissed_tips = set(proof.get('dismissed_tips',())) + def read_bound_windows(): + windows=_legacy_diagnostic_windows(bound) + for window in windows: + if any(c['hwnd'] in proof.get('declined_buttons',()) for c in window['children']): + state['clicked'].add(window['hwnd']) + return windows try: while time.monotonic() < deadline: if win32event.WaitForSingleObject(handle, 0) == win32con.WAIT_OBJECT_0: @@ -732,7 +742,7 @@ def _close_registered_startup(row, handle, proof, *, stop=None): break # Never stack another Close after a legacy Tip acknowledgement. try: closed,_ = cancelled_startup_step(job,row['pid'],state,closed_frame=closed,deadline=deadline, - post=post,emit=lambda **event:None,read_windows=lambda:_legacy_diagnostic_windows(bound), + post=post,emit=lambda **event:None,read_windows=read_bound_windows, identity_check=confirmed) except RuntimeError as error: if not str(error).startswith('STARTUP_WINDOW_CHANGED:'): @@ -745,6 +755,69 @@ def _close_registered_startup(row, handle, proof, *, stop=None): return {'release_status':'WAITING','detail':'已请求取消启动清理,等待原生退出后重新检查'} +def _ordinary_startup_close(row, handle, proof, *, stop=None): + """One persisted retained phase, serialized with existing explicit release.""" + import win32con, win32event + from .session_record import read_session_record, write_session_record + from .operation_queue import native_phase + waiting = {'release_status':'WAITING','detail':'取消启动清理已交接或原生执行通道忙,继续观察'} + mutex=win32event.CreateMutex(None,False,r'Local\CbbRefreshVerify795') + acquired=False + try: + acquired=win32event.WaitForSingleObject(mutex,0) in (win32con.WAIT_OBJECT_0,win32con.WAIT_ABANDONED) + if not acquired or stop is not None and stop.is_set():return waiting + path=Path(proof['record_path']) + record=read_session_record(path,evidence_root=path.parent) + if 'retained_startup_cleanup' in record or _cancelled_diagnostic_record(row)!=proof:return waiting + # Complete loaded identity and every prompt are checked before consuming + # the one-shot intent. Unknown/multiple documents remain observation-only. + from .diagnostic_open import _target_frame, _pending_prompt + windows=_legacy_diagnostic_windows(dict(row,cleanup_desktop=proof['job']['desktop'])) + frame=_target_frame(windows,Path(proof['job']['pcb']).stem,require_ready=False) + if frame is None:return waiting + for window in windows: + _pending_prompt([window],closing=proof['closed_frame'] is not None,frame=frame, + pcb_name=Path(proof['job']['pcb']).name) + if _cancelled_diagnostic_record(row)!=proof or stop is not None and stop.is_set():return waiting + deadline=time.monotonic()+30 + record['retained_startup_cleanup']=dict(operation_id=proof['operation_id'], + pcb_pid=row['pid'],owner_pid=os.getpid(),state='CLAIMED',closed_frame=proof['closed_frame'], + deadline_monotonic=deadline,identity={k:row[k] for k in ('created_handle','image','owner_sid','session_id')}) + write_session_record(path,record) # Durable before No/Close; never removed or retried. + with native_phase(read_only=True): + return _close_registered_startup(row,handle,proof,stop=stop,deadline=deadline) + except (OSError,ValueError,RuntimeError): + return waiting + finally: + if acquired:win32event.ReleaseMutex(mutex) + mutex.Close() + + +def resume_cancelled_startup(path, *, stop=None): + """Observer-only entry for one late loaded, positively proved ordinary cancel.""" + from .session_record import _session + from .failed_session import cancelled_prewrite_startup + path=Path(path) + try: + session,state,identities=_session(path,path.parent) + if 'retained_startup_cleanup' in session or stop is not None and stop.is_set():return False + job=json.loads(path.with_name('request.json').read_text(encoding='utf-8')) + if job.get('diagnostic_only') is not False:return False + native=[p for p in identities if p.get('role')=='native' + and Path(p['image']).name.casefold()=='expeditionpcb.exe'] + if len(native)!=1 or cancelled_prewrite_startup(job,native[0]['pid']) is None:return False + plan=inspect_residual_sessions(session['library'],block_names=(session['block'],)) + rows=[r for r in plan['sessions'] if r['pid']==native[0]['pid']] + if len(rows)!=1:return False + row=dict(rows[0],session_records=[dict(path=str(path),operation_id=session['operation_id'])]) + proof=_cancelled_diagnostic_record(row) + if proof is None:return False # Includes exact worker/helper exit and fresh loaded logs. + _request_close(row,stop=stop) + return True + except (OSError,ValueError,KeyError,TypeError,RuntimeError): + return False + + def _request_close(row, *, stop=None): import win32con, win32event with _process_handle(row['pid']) as handle: @@ -766,6 +839,8 @@ def _request_close(row, *, stop=None): return {'release_status':'WAITING','detail':'取消启动会话的用户或 Windows 会话未确认'} if stop is not None and stop.is_set(): return {'release_status':'CANCELLED','detail':'已停止释放'} + if proof['job'].get('diagnostic_only') is False: + return _ordinary_startup_close(row,handle,proof,stop=stop) from .session_record import handoff_session record_path = Path(proof['record_path']) handoff_session(record_path, evidence_root=record_path.parent, observe_only=False) diff --git a/src/cbb_refresh_verify/session_record.py b/src/cbb_refresh_verify/session_record.py index 6050ab6..68ba480 100644 --- a/src/cbb_refresh_verify/session_record.py +++ b/src/cbb_refresh_verify/session_record.py @@ -1,4 +1,4 @@ -"""Bounded, observation-only journal for native calls that outlive a task.""" +"""Bounded registration and observation for native calls that outlive a task.""" from contextlib import ExitStack from datetime import datetime, timezone import json @@ -407,6 +407,15 @@ def observe_retained_session(path, *, evidence_root, stop=None, progress=None, p session={'library': str(process.cbb_library)}, proof=proof) except Exception: pass + if result['status'] == 'ACTIVE' and not observation_only and not stop.is_set(): + try: + from .residual_sessions import resume_cancelled_startup + if resume_cancelled_startup(path, stop=stop): + # Cleanup is not release proof. Re-read all held identities + # and independently prove the resource release as usual. + result = _reconcile(Path(path), Path(evidence_root), handles, stack) + except Exception: + logging.getLogger(__name__).warning('Retained startup cleanup unavailable', exc_info=True) if result['status'] == 'IDENTITY_CHANGED' and not observation_only: try: from .library_lock import release_retained_library diff --git a/tests/test_cancelled_ordinary_startup.py b/tests/test_cancelled_ordinary_startup.py index 4c8cb99..1fa7d5a 100644 --- a/tests/test_cancelled_ordinary_startup.py +++ b/tests/test_cancelled_ordinary_startup.py @@ -13,7 +13,7 @@ def ordinary_proof(job,root,baseline,*,worker=None,pid=12): library=job['lmc_file'],session_record_path=str(root/'session.json'),interactive_input=False) job.pop('diagnostic_log_baseline',None) session_record.write_session_record(root/'session.json',dict(operation_id=job['operation_id'],operation='verify', - library=job['library'],desktop=job['desktop'],cancel_signal=job['cancel_signal'],processes=[dict(role='worker',**worker)], + library=job['library'],block=job.get('block',job.get('block_name')),desktop=job['desktop'],cancel_signal=job['cancel_signal'],processes=[dict(role='worker',**worker)], resource_scope=dict(scope_state='DECLARED',library=job['library'],operation_id=job['operation_id'],projects=[job['project']]))) binding={k:job[k] for k in ('operation_id','project','pcb','desktop')} events=[dict(stage='startup_supervisor_no_write',**binding), diff --git a/tests/test_observer_startup_cleanup.py b/tests/test_observer_startup_cleanup.py new file mode 100644 index 0000000..901dd41 --- /dev/null +++ b/tests/test_observer_startup_cleanup.py @@ -0,0 +1,163 @@ +import json +from pathlib import Path +import threading + +import pytest + +from cbb_refresh_verify import diagnostic_open, residual_sessions, session_record +from test_registered_startup_release import registered_fixture +from test_cancelled_ordinary_startup import ordinary_proof + + +def fixture(tmp_path, monkeypatch, *, obstacle='', closed=False): + load=diagnostic_open._load_evidence + job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch,obstacle=obstacle,closed=closed) + monkeypatch.setattr(diagnostic_open,'_load_evidence',load) + events=ordinary_proof(job,tmp_path,state['prelaunch_baseline']) + if closed:events.append(dict(stage='startup_close_requested',pcb_pid=12,hwnd=100)) + (tmp_path/'events.jsonl').write_text(''.join(json.dumps(e)+'\n' for e in events)) + (tmp_path/'request.json').write_text(json.dumps(job)) + monkeypatch.setattr(residual_sessions,'inspect_residual_sessions',lambda *a,**k:dict(sessions=[row])) + return job,row,records,messages,state + + +@pytest.mark.parametrize('closed',[False,True]) +def test_registered_observer_finishes_late_loaded_ordinary_startup_once(tmp_path,monkeypatch,closed): + job,row,records,messages,state=fixture(tmp_path,monkeypatch,closed=closed) + original=(tmp_path/'result.json').read_bytes() + states=[] + def reconcile(*a,**kw): + states.append(1) + return dict(status='ACTIVE' if records else 'RELEASED',operation_id=job['operation_id'], + release_proof=None if records else dict(status='RELEASE_CONFIRMED')) + monkeypatch.setattr(session_record,'_reconcile',reconcile) + stop=threading.Event() + def progress(value): + if len(states)>2:stop.set() + result=session_record.observe_retained_session(tmp_path/'session.json',evidence_root=tmp_path,stop=stop,progress=progress) + assert result['status']=='RELEASED' + assert messages==([(31,245)] if closed else [(31,245),(100,16)]) + assert (tmp_path/'result.json').read_bytes()==original + claim=json.loads((tmp_path/'session.json').read_text())['retained_startup_cleanup'] + assert claim['operation_id']==job['operation_id'] and claim['pcb_pid']==12 + + +@pytest.mark.parametrize('obstacle',['live_worker','other_write','save','foreign_identity','missing_cancel']) +def test_automatic_observer_does_not_consume_intent_or_act_without_positive_proof(tmp_path,monkeypatch,obstacle): + job,row,records,messages,state=fixture(tmp_path,monkeypatch,obstacle=obstacle) + residual_sessions.resume_cancelled_startup(tmp_path/'session.json') + assert not messages and records + assert 'retained_startup_cleanup' not in json.loads((tmp_path/'session.json').read_text()) + + +def test_timed_out_retained_phase_is_not_restarted_by_observer_or_explicit_release(tmp_path,monkeypatch): + job,row,records,messages,state=fixture(tmp_path,monkeypatch) + read=residual_sessions._legacy_diagnostic_windows + def progress(bound): + values=read(bound) + if state['declined']:values[0]['children'].append(dict(hwnd=123,**{'class':'msctls_progress32'},visible=True)) + return values + monkeypatch.setattr(residual_sessions,'_legacy_diagnostic_windows',progress) + residual_sessions.resume_cancelled_startup(tmp_path/'session.json') + first=state['ticks'] + assert 30<=first<30.2 and messages==[(31,245)] + residual_sessions.resume_cancelled_startup(tmp_path/'session.json') + assert residual_sessions._request_close(row)['release_status']=='WAITING' + assert state['ticks']==first and messages==[(31,245)] and records + + +def test_claim_is_persisted_before_any_native_action_and_failure_prevents_action(tmp_path,monkeypatch): + job,row,records,messages,state=fixture(tmp_path,monkeypatch) + def denied(*a,**kw):raise OSError('journal unavailable') + monkeypatch.setattr(session_record,'write_session_record',denied) + residual_sessions.resume_cancelled_startup(tmp_path/'session.json') + assert not messages and records + + +def test_retained_phase_never_repeats_worker_no_on_still_visible_prompt(tmp_path,monkeypatch): + job,row,records,messages,state=fixture(tmp_path,monkeypatch) + with (tmp_path/'events.jsonl').open('a') as stream: + stream.write(json.dumps(dict(stage='startup_prompt_no',pcb_pid=12,hwnd=31,control_id=7))+'\n') + residual_sessions.resume_cancelled_startup(tmp_path/'session.json') + assert not messages and records and 30<=state['ticks']<30.2 + + +@pytest.mark.parametrize('obstacle',['unknown','hidden_document','revoked']) +def test_late_observer_preserves_unknown_or_changed_loaded_state_before_claim(tmp_path,monkeypatch,obstacle): + job,row,records,messages,state=fixture(tmp_path,monkeypatch) + read=residual_sessions._legacy_diagnostic_windows + def windows(bound): + values=read(bound) + if obstacle=='unknown':values.append(dict(hwnd=999,pid=12,**{'class':'#32770'},text='Unknown',children=[])) + if obstacle=='hidden_document':values[0]['children'].append(dict(hwnd=888,**{'class':'Afx:document'},text='Other',parent=101,visible=False)) + if obstacle=='revoked': + with (tmp_path/'events.jsonl').open('a') as stream:stream.write('{"stage":"startup_write_admitted"}\n') + return values + monkeypatch.setattr(residual_sessions,'_legacy_diagnostic_windows',windows) + residual_sessions.resume_cancelled_startup(tmp_path/'session.json') + assert not messages and records + assert 'retained_startup_cleanup' not in json.loads((tmp_path/'session.json').read_text()) + + +def test_duplicate_observer_explicit_release_and_process_restart_share_persisted_claim(tmp_path): + """Real process/mutex/file race; only native evidence and action boundary are stubs.""" + import os,subprocess,sys,time + path=tmp_path/'session.json' + session_record.write_session_record(path,dict(operation_id='one',block='B',library=str(tmp_path/'lib.lmc'))) + (tmp_path/'request.json').write_text(json.dumps(dict(diagnostic_only=False))) + script=tmp_path/'race.py' + script.write_text(''' +import json,sys,time +from pathlib import Path +from contextlib import nullcontext +import win32api +from cbb_refresh_verify import session_record as s,residual_sessions as r,diagnostic_open as d,failed_session as f +root=Path(sys.argv[1]);mode=sys.argv[2];tag=sys.argv[3];path=root/'session.json' +job=dict(diagnostic_only=False,desktop='CbbVerify_test',pcb=str(root/'B.pcb')) +row=dict(pid=1,name='ExpeditionPCB.exe',created_handle='bound',image='ExpeditionPCB.exe',owner_sid='owner',session_id=1) +proof=dict(job=job,record_path=str(path),operation_id='one',closed_frame=None) +r._process_handle=lambda *a,**k:nullcontext(win32api.GetCurrentProcess()) +r._handle_identity=lambda h:dict(created_handle='bound',image='ExpeditionPCB.exe') +r._force_ownership=lambda *a:dict(force_user_confirmed=True,owner_sid='owner',session_id=1) +r._process_windows=lambda *a:{} +r._cancelled_diagnostic_record=lambda *a:proof +r._legacy_diagnostic_windows=lambda *a:[dict(hwnd=100,pid=1)] +d._target_frame=lambda *a,**k:dict(hwnd=100,pid=1) +d._pending_prompt=lambda *a,**k:False +f.cancelled_prewrite_startup=lambda *a:{} +r.inspect_residual_sessions=lambda *a,**k:dict(sessions=[row]) +s._session=lambda *a:(s.read_session_record(path,evidence_root=root),{},[dict(role='native',pid=1,image='ExpeditionPCB.exe')]) +def close(*a,**k): + assert 'retained_startup_cleanup' in json.loads(path.read_text()) + (root/('action-'+tag)).write_text('one native phase') + until=time.monotonic()+8 + while not (root/'release').exists() and time.monotonic()