fix: reconcile cancelled sessions and resume queued native work
This commit is contained in:
1 parent
845ae58690
commit
7cc65f78da
10 files changed
+637
-18
No files matched your search
@@ -365,14 +365,16 @@ def _pending_prompt(windows, *, closing=False, frame=None, session=None, clicked
|
||||
return False
|
||||
|
||||
|
||||
def cancelled_startup_step(job, pcb_pid, state, *, closed_frame, deadline, post, emit):
|
||||
def cancelled_startup_step(job, pcb_pid, state, *, closed_frame, deadline, post, emit,
|
||||
read_windows=None, identity_check=None):
|
||||
"""Finish only the owned no-write diagnostic startup; never establish PASS.
|
||||
|
||||
Cancellation already ended supervisor polling. Cleanup is its sole prompt
|
||||
actor and uses the caller's original deadline and single-close state.
|
||||
"""
|
||||
from types import SimpleNamespace
|
||||
windows = _windows(pcb_pid)
|
||||
read_windows = read_windows or (lambda: _windows(pcb_pid))
|
||||
windows = read_windows()
|
||||
if any(window['pid'] != pcb_pid for window in windows):
|
||||
raise RuntimeError('STARTUP_PROCESS_UNCONFIRMED')
|
||||
current = _target_frame(windows, Path(job['pcb']).stem, require_ready=False)
|
||||
@@ -387,7 +389,11 @@ def cancelled_startup_step(job, pcb_pid, state, *, closed_frame, deadline, post,
|
||||
if closed_frame is not None and frame['hwnd'] != closed_frame:
|
||||
raise RuntimeError('STARTUP_DOCUMENT_CHANGED')
|
||||
if old is None:
|
||||
if _load_evidence(job, pcb_pid, job['diagnostic_log_baseline'], require_autosave=False) is None:
|
||||
# Explicit legacy cleanup supplies already checked registration. It is
|
||||
# revalidated immediately before every action, never used as open proof.
|
||||
confirmed = (identity_check is not None or
|
||||
_load_evidence(job, pcb_pid, job['diagnostic_log_baseline'], require_autosave=False) is not None)
|
||||
if not confirmed:
|
||||
return closed_frame, False
|
||||
state['frame'] = frame
|
||||
# Validate every window before allowing a known No. An unknown sibling
|
||||
@@ -402,7 +408,8 @@ def cancelled_startup_step(job, pcb_pid, state, *, closed_frame, deadline, post,
|
||||
raise
|
||||
actions = []
|
||||
def act(hwnd, message):
|
||||
if _windows(pcb_pid) != windows or time.monotonic() >= deadline:
|
||||
if (read_windows() != windows or identity_check is not None and not identity_check()
|
||||
or time.monotonic() >= deadline):
|
||||
raise RuntimeError('STARTUP_ACTION_UNCONFIRMED: native state or deadline changed')
|
||||
post(hwnd, message)
|
||||
actions.append((hwnd, message))
|
||||
|
||||
@@ -390,6 +390,13 @@ class NativeQueue:
|
||||
|
||||
def run(self, action, *, stop=None, waiting=None, ready=lambda: True, wait_state=None,
|
||||
context=None, timeout_seconds=10):
|
||||
def available_now():
|
||||
if not ready():
|
||||
return False
|
||||
if context is None:
|
||||
return True # Explicit recovery controls must still reach their retained clients.
|
||||
from .session_record import _live_library_available
|
||||
return all(_live_library_available(path) for path in (context.library, *context.aliases))
|
||||
ticket = [object(), False]
|
||||
acquired, notified = False, False
|
||||
previous_state = None
|
||||
@@ -401,7 +408,7 @@ class NativeQueue:
|
||||
self.pending.append(ticket)
|
||||
try:
|
||||
while not acquired:
|
||||
available = ready() # Call only this ticket's predicate, outside the queue lock.
|
||||
available = available_now() # Cached predicates only, outside the queue lock.
|
||||
with self.condition:
|
||||
if (self.closed or stop is not None and stop.is_set()
|
||||
or context is not None and (context.stop.is_set() or context.stop_after_current.is_set())):
|
||||
@@ -412,7 +419,7 @@ class NativeQueue:
|
||||
self.active = acquired = True
|
||||
else:
|
||||
self.condition.wait(.1)
|
||||
if acquired and not ready():
|
||||
if acquired and not available_now():
|
||||
with self.condition:
|
||||
ticket[1] = self.active = acquired = False
|
||||
self.condition.notify_all()
|
||||
|
||||
@@ -570,6 +570,161 @@ def _dismiss_startup_tip(row, handle, windows, *, incomplete=None, dismissed=(),
|
||||
return tip['hwnd']
|
||||
|
||||
|
||||
def _cancelled_diagnostic_record(row):
|
||||
"""Existing complete registration can authorize cleanup, never validation."""
|
||||
import stat
|
||||
import pywintypes, win32con, win32event
|
||||
from .session_record import _session, IDENTITY_KEYS, active_write_records
|
||||
from .failed_session import _command_args
|
||||
if row.get('scope_confirmed') is not True or row.get('name', '').casefold() != 'expeditionpcb.exe':
|
||||
return None
|
||||
def same(a, b):
|
||||
return os.path.normcase(os.path.abspath(str(a))) == os.path.normcase(os.path.abspath(str(b)))
|
||||
def read(path, *, lines=False):
|
||||
if path.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
|
||||
raise ValueError('STARTUP_RECORD_REPARSE_POINT')
|
||||
with path.open('rb') as stream:
|
||||
data = stream.read(1024*1024+1)
|
||||
if len(data) > 1024*1024:
|
||||
raise ValueError('STARTUP_RECORD_TOO_LARGE')
|
||||
return [json.loads(line) for line in data.splitlines()] if lines else json.loads(data)
|
||||
matches = []
|
||||
for record in row.get('session_records', ()):
|
||||
try:
|
||||
path = Path(record['path']); root = path.parent
|
||||
session, state, identities = _session(path, root)
|
||||
job, result = read(root/'request.json'), read(root/'result.json')
|
||||
operation = session['operation_id']
|
||||
scope = session.get('resource_scope', {})
|
||||
if (record.get('operation_id') != operation or job.get('operation_id') != operation
|
||||
or job.get('diagnostic_only') is not True or job.get('interactive_input') is not False
|
||||
or job.get('operation') != 'verify' or session.get('operation') != 'verify'
|
||||
or not all(same(value, row['library']) for value in (job['library'], job['lmc_file'], session['library']))
|
||||
or not same(job['root'], root) or not same(job['session_record_path'], path)
|
||||
or job.get('desktop') != session.get('desktop') or not job['desktop'].startswith('CbbVerify_')
|
||||
or scope.get('scope_state') != 'DECLARED' or scope.get('operation_id') != operation
|
||||
or not same(scope.get('library', ''), row['library'])
|
||||
or scope.get('projects') != [job['project']]
|
||||
or not Path(job['pcb']).is_relative_to(Path(job['project']).parent)
|
||||
or not same(job['cancel_signal'], session['cancel_signal'])
|
||||
or Path(job['cancel_signal']).parent != root or not Path(job['cancel_signal']).is_file()
|
||||
or result.get('status') != 'CANCELLED' or result.get('error_stage') != 'PCB_STARTING'
|
||||
or result.get('write_outcome', {}).get('save_state') != 'UNKNOWN'
|
||||
or state.get('phase') != 'UNCONFIRMED' or (root/'save.log').exists()):
|
||||
continue
|
||||
native = [p for p in identities if p.get('role') == 'native' and p['pid'] == row['pid']]
|
||||
workers = [p for p in identities if p.get('role') in ('worker', 'helper')]
|
||||
if (len(native) != 1 or not workers
|
||||
or any(native[0][k] != row.get(k) for k in IDENTITY_KEYS)
|
||||
or any(p.get('role') not in ('worker','helper','native','supervisor') for p in identities)):
|
||||
continue
|
||||
for worker in workers:
|
||||
try:
|
||||
with _process_handle(worker['pid']) as held:
|
||||
if win32event.WaitForSingleObject(held, 0) != win32con.WAIT_OBJECT_0:
|
||||
raise ValueError('STARTUP_WORKER_STILL_ACTIVE')
|
||||
except (OSError, pywintypes.error) as error:
|
||||
if getattr(error, 'winerror', None) != 87:
|
||||
raise
|
||||
args = _command_args(row['command'])
|
||||
if ('-reusablecircuit' not in [a.casefold() for a in args]
|
||||
or not any(same(a, job['pcb']) for a in args[1:])):
|
||||
continue
|
||||
events = read(root/'events.jsonl', lines=True)
|
||||
if (not any(e.get('stage') == 'pcb_worker_started' and e.get('pcb_pid') == row['pid'] for e in events)
|
||||
or not any(e.get('stage') == 'pcb_baseline' and row['pid'] not in e.get('pids', []) for e in events)
|
||||
or any(str(e.get('stage', '')).startswith(('save', 'integration', 'validate', 'failure_close'))
|
||||
or e.get('stage') == 'diagnostic_complete' for e in events)):
|
||||
continue
|
||||
closes = [e for e in events if e.get('stage') in ('startup_close_requested', 'diagnostic_wm_close')]
|
||||
if len(closes) > 1 or any(e.get('pcb_pid') != row['pid'] or not e.get('hwnd') for e in closes):
|
||||
continue
|
||||
if any(r.get('operation_id') != operation for r in active_write_records(row['library'])):
|
||||
continue
|
||||
matches.append(dict(job=job, record_path=str(path), operation_id=operation,
|
||||
closed_frame=closes[0]['hwnd'] if closes else None))
|
||||
except (OSError, pywintypes.error, ValueError, KeyError, TypeError):
|
||||
continue
|
||||
return matches[0] if len(matches) == 1 else None
|
||||
|
||||
|
||||
def _legacy_diagnostic_windows(row):
|
||||
"""Adapt the existing complete private-desktop snapshot for diagnostic policy."""
|
||||
import win32con, win32gui
|
||||
snapshot = _process_windows({row['pid']})
|
||||
if _window_error(snapshot, row['pid']):
|
||||
raise ValueError('STARTUP_WINDOW_UNCONFIRMED')
|
||||
result = []
|
||||
for window in snapshot.get(row['pid'], []):
|
||||
if window.get('desktop') != row['cleanup_desktop']:
|
||||
raise ValueError('STARTUP_DESKTOP_UNCONFIRMED')
|
||||
benign = (not window['title'] and window['class'] in ('UAC_InputIndicatorOverlayWnd', 'UAC Input Indicator'))
|
||||
benign = benign or (window['class'] == 'Internet Explorer_Hidden' and not window['title']
|
||||
and not window['children'] and window.get('rect', [1,1,2,2])[:2] == window.get('rect', [1,1,2,2])[2:])
|
||||
if benign:
|
||||
continue
|
||||
with _window_desktop(window['desktop']):
|
||||
children = [dict(c, parent=win32gui.GetParent(c['hwnd']), visible=True) for c in window['children']]
|
||||
result.append(dict(hwnd=window['hwnd'], pid=row['pid'], **{'class':window['class']},
|
||||
text=window['title'], enabled=window['enabled'], children=children,
|
||||
owner=int(win32gui.GetWindow(window['hwnd'], win32con.GW_OWNER) or 0)))
|
||||
return result
|
||||
|
||||
|
||||
def _close_registered_startup(row, handle, proof, *, stop=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()+3
|
||||
def active_owner():
|
||||
check_active()
|
||||
if stop is not None and stop.is_set():
|
||||
return False
|
||||
owner = _force_ownership(handle,row['pid'])
|
||||
return (owner.get('force_user_confirmed') is True
|
||||
and win32event.WaitForSingleObject(handle,0) == win32con.WAIT_TIMEOUT
|
||||
and _handle_identity(handle) == {k:row.get(k) for k in ('created_handle','image')}
|
||||
and all(owner.get(k) == row.get(k) for k in ('owner_sid','session_id')))
|
||||
def confirmed():
|
||||
if not active_owner():return False
|
||||
fresh = next((p for p in query_process_snapshot() if p['pid'] == row['pid']), None)
|
||||
return (fresh is not None and all(fresh.get(k) == row.get(k) for k in ('created','command','executable','name'))
|
||||
and _cancelled_diagnostic_record(row) == proof)
|
||||
def post(hwnd, message):
|
||||
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']
|
||||
try:
|
||||
while time.monotonic() < deadline:
|
||||
if win32event.WaitForSingleObject(handle, 0) == win32con.WAIT_OBJECT_0:
|
||||
return {'release_status':'RELEASED','detail':'已正常结束已取消的诊断启动'}
|
||||
if not active_owner():
|
||||
break
|
||||
snapshot = _process_windows({row['pid']})
|
||||
# Only this fully proved no-write operation may bypass its historical
|
||||
# UNCONFIRMED label; other operations were vetoed by the proof above.
|
||||
tip_row = {k:v for k,v in row.items() if k not in ('runtime_phase','library')}
|
||||
if closed is not None:
|
||||
tip_row['startup_frame'] = closed
|
||||
has_tip = any(w['title'] == 'Tip of the Day' for w in snapshot.get(row['pid'],[]))
|
||||
if has_tip and confirmed() and _dismiss_startup_tip(tip_row,handle,snapshot.get(row['pid'],[]),
|
||||
incomplete=_window_error(snapshot,row['pid']),deadline=deadline,stop=stop) is not None:
|
||||
while time.monotonic() < deadline:
|
||||
if win32event.WaitForSingleObject(handle,100) == win32con.WAIT_OBJECT_0:
|
||||
return {'release_status':'RELEASED','detail':'已关闭启动提示并正常退出'}
|
||||
if stop is not None and stop.is_set():break
|
||||
break # Never stack another Close after a legacy Tip acknowledgement.
|
||||
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),
|
||||
identity_check=confirmed)
|
||||
time.sleep(.1)
|
||||
except (OSError, pywintypes.error, ValueError, RuntimeError) as error:
|
||||
return {'release_status':'WAITING','detail':str(error)}
|
||||
return {'release_status':'WAITING','detail':'已请求取消启动清理,等待原生退出后重新检查'}
|
||||
|
||||
|
||||
def _request_close(row, *, stop=None):
|
||||
import win32con, win32event
|
||||
with _process_handle(row['pid']) as handle:
|
||||
@@ -584,6 +739,8 @@ def _request_close(row, *, stop=None):
|
||||
return {'release_status': 'WAITING', 'detail': '该会话窗口读取不完整,请重新检查:'+error}
|
||||
if stop is not None and stop.is_set():
|
||||
return {'release_status': 'CANCELLED', 'detail': '已停止释放'}
|
||||
if proof := _cancelled_diagnostic_record(row):
|
||||
return _close_registered_startup(row, handle, proof, stop=stop)
|
||||
if _dismiss_startup_tip(row, handle, windows, stop=stop) is not None:
|
||||
# Legacy startup cleanup may already have sent WM_CLOSE. Only wait
|
||||
# for it here; never stack another close behind this acknowledgement.
|
||||
@@ -795,6 +952,9 @@ def _release_residual_sessions(plan, evidence_dir, *, stop=None, force=False, ca
|
||||
if not save():
|
||||
return result
|
||||
try:
|
||||
if not force and not cancel_native:
|
||||
row['session_records'] = [{k:r.get(k) for k in ('path','operation_id')}
|
||||
for r in plan.get('runtime_sessions', []) if r.get('path')]
|
||||
outcome = (_request_native_cancel(row, stop=stop) if cancel_native else
|
||||
(_force_close if force else _request_close)(row, stop=stop))
|
||||
except Exception as error:
|
||||
|
||||
@@ -22,13 +22,30 @@ def _library_key(library):
|
||||
return os.path.normcase(os.path.normpath(str(library)))
|
||||
|
||||
|
||||
def library_available(library):
|
||||
def library_available(library, *, live_only=False):
|
||||
"""Cached queue predicate: no file, process or network queries."""
|
||||
if live_only:
|
||||
return _live_library_available(library)
|
||||
key = _library_key(library)
|
||||
with _observer_guard:
|
||||
return not any(key in aliases for aliases in _retained_libraries.values())
|
||||
|
||||
|
||||
def _live_library_available(library):
|
||||
"""Ignore stale retention, but wait for an actual registered observer."""
|
||||
key = _library_key(library)
|
||||
with _observer_guard:
|
||||
for path, aliases in _retained_libraries.items():
|
||||
observer = _observers.get(path)
|
||||
if key not in aliases or observer is None or not observer[0].is_alive():
|
||||
continue
|
||||
state = _retained_results.get(path, {})
|
||||
if (state.get('observer_initializing') is True or state.get('status') == 'ACTIVE'
|
||||
or state.get('owned_worker_alive') is True):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def retained_session_snapshot(library):
|
||||
key = _library_key(library)
|
||||
with _observer_guard:
|
||||
@@ -396,6 +413,10 @@ def observe_retained_session(path, *, evidence_root, stop=None, progress=None, p
|
||||
result = {**result, 'status': 'RELEASED', 'identity_changed': True, 'release_proof': proof}
|
||||
except Exception as error:
|
||||
result['detail'] += f';资源释放待确认:{error}'
|
||||
try:
|
||||
result['owned_worker_alive'] = process is not None and process.poll() is None
|
||||
except Exception:
|
||||
result['owned_worker_alive'] = False
|
||||
try:
|
||||
write_session_record(observation, {**result, 'operation_id': result['operation_id'] or 'unknown'})
|
||||
except (OSError, ValueError):
|
||||
@@ -432,12 +453,14 @@ def handoff_session(path, *, evidence_root, process=None, progress=None, stop=No
|
||||
_retained_libraries[key] = aliases
|
||||
_retained_results[key] = {'status': 'UNCONFIRMED', 'phase': 'UNCONFIRMED',
|
||||
'library': str(library) if library else None, 'block': session.get('block'),
|
||||
'detail': '正在核对残留会话', 'operation_id': session.get('operation_id')}
|
||||
'detail': '正在核对残留会话', 'operation_id': session.get('operation_id'),
|
||||
'observer_initializing': True}
|
||||
def notify(value):
|
||||
with _observer_guard:
|
||||
if _retained_libraries.get(key) is aliases:
|
||||
previous = _retained_results[key]
|
||||
_retained_results[key] = {**previous, **value,
|
||||
'observer_initializing': False,
|
||||
'library': value.get('library') or previous['library'],
|
||||
'operation_id': value.get('operation_id') or previous['operation_id'],
|
||||
'block': value.get('block') or previous['block']}
|
||||
|
||||
@@ -136,7 +136,7 @@ class IcdbCheckTask(QObject):
|
||||
return None, str(error)
|
||||
def bounded_write():
|
||||
try:
|
||||
return BatchTaskContext(str(self.requests[0].lmc_file)).run(write)
|
||||
return BatchTaskContext(str(self.requests[0].lmc_file)).run(write, metadata_only=True)
|
||||
except Exception as error:
|
||||
return None, str(error)
|
||||
self.worker = ServiceWorker(bounded_write)
|
||||
|
||||
@@ -230,7 +230,7 @@ def _run_process(command, timeout_seconds, cwd, *, evidence_root=None):
|
||||
return run_content_check(command, timeout_seconds, cwd, evidence_root=evidence_root)
|
||||
|
||||
|
||||
def _stop_worker(process, *, timeout=5):
|
||||
def _stop_worker(process, *, timeout=5, wait_for_native_write=True):
|
||||
"""Request stop without interrupting a possibly unreturned native call."""
|
||||
try:
|
||||
if hasattr(process, 'request_stop'):
|
||||
@@ -243,7 +243,7 @@ def _stop_worker(process, *, timeout=5):
|
||||
process.wait(timeout=timeout)
|
||||
except Exception:
|
||||
pending = getattr(process, 'native_write_pending', lambda: False)()
|
||||
if pending is not False and not getattr(process, '_stop_wait_complete', False):
|
||||
if wait_for_native_write and pending is not False and not getattr(process, '_stop_wait_complete', False):
|
||||
from .defaults import NATIVE_WRITE_STOP_WAIT_SECONDS
|
||||
try:
|
||||
process.wait(timeout=max(0, NATIVE_WRITE_STOP_WAIT_SECONDS - timeout))
|
||||
@@ -1070,7 +1070,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
'已请求停止,等待当前原生操作返回')
|
||||
_notify_progress(progress, {'stage': 'save_stop_requested', 'block': request.block_name,
|
||||
'detail': detail})
|
||||
_stop_worker(process)
|
||||
_stop_worker(process, wait_for_native_write=not request.diagnostic_only)
|
||||
return finish(VerifyResult('CANCELLED', stderr='已取消当前校验。',
|
||||
safe_to_continue=False, error_stage=phase.value))
|
||||
if events.exists():
|
||||
@@ -1237,7 +1237,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
target_pid=target_pid,
|
||||
observation=last_post_verify_observation,
|
||||
)
|
||||
_stop_worker(process)
|
||||
_stop_worker(process, wait_for_native_write=not request.diagnostic_only)
|
||||
if dispatch_failure is not None:
|
||||
status, detail = dispatch_failure
|
||||
if progress:
|
||||
@@ -1260,7 +1260,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
result = VerifyResult(**outcome)
|
||||
except Exception as error:
|
||||
if 'process' in locals() and process.poll() is None:
|
||||
_stop_worker(process)
|
||||
_stop_worker(process, wait_for_native_write=not request.diagnostic_only)
|
||||
launch_release = getattr(error, 'worker_launch_release', None) if 'process' not in locals() else None
|
||||
if not worker_launch_attempted:
|
||||
launch_release = {'process_created': False, 'worker_exited': True,
|
||||
@@ -1279,6 +1279,7 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
finally:
|
||||
close_errors = []
|
||||
worker_exited = False
|
||||
observer_started = False
|
||||
automation_release = {'safe_to_continue': False}
|
||||
if 'process' not in locals() or process.poll() is not None or getattr(process, 'session_record_path', None):
|
||||
# A gated worker owns its writer barrier and inherited sidecar.
|
||||
@@ -1293,18 +1294,17 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
try:
|
||||
worker_exited = process.poll() is not None
|
||||
if not worker_exited:
|
||||
worker_exited = _stop_worker(process)
|
||||
worker_exited = _stop_worker(process, wait_for_native_write=not request.diagnostic_only)
|
||||
if hasattr(process, 'automation_release_state'):
|
||||
automation_release = process.automation_release_state()
|
||||
else:
|
||||
automation_release = {'safe_to_continue': worker_exited, 'remaining_pids': []}
|
||||
if worker_exited:
|
||||
process.close()
|
||||
elif getattr(process, 'session_record_path', None):
|
||||
if not worker_exited and getattr(process, 'session_record_path', None):
|
||||
from .session_record import handoff_session
|
||||
handoff_session(process.session_record_path, evidence_root=root,
|
||||
process=process, progress=lambda state: _notify_progress(progress,
|
||||
{'stage': 'session_observation', 'block': request.block_name, **state}))
|
||||
observer_started = True
|
||||
_notify_progress(progress, {'stage': 'session_handoff', 'block': request.block_name,
|
||||
'detail': '已转后台观察,可查看状态'})
|
||||
from .operation_queue import hold_native_handoff
|
||||
@@ -1353,6 +1353,25 @@ def _run_verify(request, *, timing, progress=None, flag_reader=None, process_run
|
||||
'automation_release': automation_release, 'worker_exited': worker_exited}
|
||||
release_result['remaining_pids'] = sorted(set(release_result.get('remaining_pids', []))
|
||||
| set(automation_release.get('remaining_pids', [])))
|
||||
if worker_exited:
|
||||
try:
|
||||
if (release_result.get('safe_to_continue') is not True
|
||||
and getattr(process, 'session_record_path', None)):
|
||||
if not observer_started:
|
||||
from .session_record import handoff_session
|
||||
# Retain the exact worker handle until registered
|
||||
# native clients exit and the observer obtains proof.
|
||||
handoff_session(process.session_record_path, evidence_root=root,
|
||||
process=process, progress=lambda state: _notify_progress(progress,
|
||||
{'stage': 'session_observation', 'block': request.block_name, **state}))
|
||||
observer_started = True
|
||||
_notify_progress(progress, {'stage': 'session_handoff', 'block': request.block_name,
|
||||
'detail': '工作进程已退出,原生会话继续后台观察'})
|
||||
else:
|
||||
process.close()
|
||||
except Exception as error:
|
||||
release_result = {**release_result, 'safe_to_continue': False,
|
||||
'close_errors': [*close_errors, str(error)]}
|
||||
try:
|
||||
from .operation_lifecycle import classify_save_state
|
||||
save_lines = ((root/'save.log').read_text('utf-8', errors='replace').splitlines()
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
from threading import Event
|
||||
|
||||
import pytest
|
||||
|
||||
from cbb_refresh_verify.operation_queue import BatchTaskContext, NativeQueue, TaskHandoff, hold_native_handoff
|
||||
from cbb_refresh_verify.ui.icdb_check_task import IcdbCheckTask
|
||||
from cbb_refresh_verify.verify_runner import VerifyResult
|
||||
from test_verify_runner import fixture, request
|
||||
|
||||
|
||||
def test_cancelled_diagnostic_report_survives_ongoing_handoff_finalization(qtbot,tmp_path):
|
||||
fixture(tmp_path)
|
||||
req=request(tmp_path,diagnostic_only=True)
|
||||
context=BatchTaskContext(str(req.lmc_file),native_policy='external')
|
||||
entered,finish=Event(),Event()
|
||||
def finalize():
|
||||
try:
|
||||
hold_native_handoff(None,tmp_path/'session.json')
|
||||
except TaskHandoff:
|
||||
entered.set()
|
||||
assert finish.wait(5)
|
||||
try:
|
||||
with pytest.raises(TaskHandoff):context.run(finalize)
|
||||
assert entered.is_set()
|
||||
task=IcdbCheckTask([req],NativeQueue(),tmp_path/'reports')
|
||||
task.active=True
|
||||
task.results=[VerifyResult('CANCELLED',safe_to_continue=False,stderr='已转后台观察')]
|
||||
task._report()
|
||||
qtbot.waitUntil(lambda:not task.active,timeout=3000)
|
||||
assert task.report is not None and task.report.exists(),task.report_error
|
||||
assert not task.report_error and task.results[0].status=='CANCELLED'
|
||||
finally:
|
||||
finish.set()
|
||||
context.close(timeout_seconds=2)
|
||||
@@ -0,0 +1,129 @@
|
||||
import json
|
||||
from pathlib import Path
|
||||
from threading import Event
|
||||
|
||||
import pytest
|
||||
|
||||
from cbb_refresh_verify import desktop_worker, session_record, verify_runner as runner
|
||||
from cbb_refresh_verify.dialog_supervisor import DialogPollResult
|
||||
from test_verify_runner import fixture, request, PORTS_OK
|
||||
|
||||
|
||||
def worker_fixture(tmp_path, monkeypatch, *, exited=False):
|
||||
fixture(tmp_path)
|
||||
state = dict(waits=[], closed=False, observers=[], polling=False, polls=0)
|
||||
stop = Event()
|
||||
class Worker:
|
||||
desktop=None; pid=700; companion_pids=[]; returncode=1 if exited else None
|
||||
def __init__(self, command, name):
|
||||
self.name=name
|
||||
path=Path(command[-1]); state.update(path=path,job=json.loads(path.read_text()),worker=self)
|
||||
self.session_record_path=path.with_name('session.json')
|
||||
session_record.write_session_record(self.session_record_path, dict(
|
||||
operation_id=state['job']['operation_id'],library=state['job']['library'],
|
||||
block=state['job']['block']))
|
||||
path.with_name('events.jsonl').write_text(json.dumps(dict(stage='pcb_worker_started',pcb_pid=901))+'\n')
|
||||
path.with_name('outcome.json').write_text(json.dumps(dict(status='CANCELLED',safe_to_continue=False)))
|
||||
def poll(self):return self.returncode
|
||||
def request_stop(self):
|
||||
assert not state['polling']
|
||||
Path(state['job']['cancel_signal']).touch()
|
||||
def native_write_pending(self):return True
|
||||
def wait(self,timeout=5):
|
||||
state['waits'].append(timeout)
|
||||
if timeout <= 5:raise TimeoutError('native startup still closing')
|
||||
self.returncode=1;return 1
|
||||
def automation_release_state(self):return {'safe_to_continue':self.poll() is not None,'remaining_pids':[]}
|
||||
def close(self):state['closed']=True
|
||||
class Supervisor:
|
||||
def poll(self,*args):
|
||||
assert not state['observers']
|
||||
state['polling']=True;state['polls']+=1;stop.set();state['polling']=False
|
||||
return DialogPollResult()
|
||||
monkeypatch.setattr(desktop_worker,'DesktopWorker',Worker)
|
||||
monkeypatch.setattr(runner,'_cleanup_session_processes',lambda *a,**kw:
|
||||
{'safe_to_continue':False,'remaining_pids':[901]})
|
||||
monkeypatch.setattr(session_record,'handoff_session',lambda path,**kw:
|
||||
state['observers'].append((path,kw,state['closed'])))
|
||||
# Keep the task runner deterministic while exercising real supervisor ownership decisions.
|
||||
monkeypatch.setattr('cbb_refresh_verify.operation_queue.hold_native_handoff',lambda *a:None)
|
||||
return state,stop,lambda diagnostic:runner.run_verify(request(tmp_path,diagnostic_only=diagnostic),
|
||||
port_check=PORTS_OK,stop=stop,dialog_supervisor_factory=lambda **kw:Supervisor())
|
||||
|
||||
|
||||
@pytest.mark.parametrize('diagnostic',[True,False])
|
||||
def test_diagnostic_cancel_yields_after_five_seconds_but_write_wait_is_unchanged(tmp_path,monkeypatch,diagnostic):
|
||||
state,stop,run=worker_fixture(tmp_path,monkeypatch)
|
||||
assert run(diagnostic).status=='CANCELLED'
|
||||
assert state['waits']==([5] if diagnostic else [5,115])
|
||||
assert state['observers'] and state['observers'][0][1]['process'] is state['worker']
|
||||
assert not state['observers'][0][2] and not state['closed']
|
||||
assert state['polls']==1
|
||||
|
||||
|
||||
def test_exited_worker_with_live_native_clients_keeps_ownership_for_observer(tmp_path,monkeypatch):
|
||||
state,stop,run=worker_fixture(tmp_path,monkeypatch,exited=True)
|
||||
result=run(True)
|
||||
assert result.status=='CANCELLED' and not result.safe_to_continue
|
||||
assert len(state['observers'])==1, 'worker exit must not orphan the still-live registered native client'
|
||||
path,options,already_closed=state['observers'][0]
|
||||
assert path==state['worker'].session_record_path
|
||||
assert options['process'] is state['worker'] and not already_closed and not state['closed']
|
||||
original=json.loads(state['path'].with_name('result.json').read_text())
|
||||
assert original['status']=='CANCELLED' and not original['safe_to_continue']
|
||||
|
||||
|
||||
def test_failed_observer_registration_preserves_original_cancelled_result_and_handle(tmp_path,monkeypatch):
|
||||
state,stop,run=worker_fixture(tmp_path,monkeypatch,exited=True)
|
||||
def fail(*args,**kwargs):raise OSError('observation journal unavailable')
|
||||
monkeypatch.setattr(session_record,'handoff_session',fail)
|
||||
result=run(True)
|
||||
assert result.status=='CANCELLED' and not result.safe_to_continue
|
||||
assert not state['closed']
|
||||
|
||||
|
||||
def test_natural_native_exit_gets_fresh_release_and_admits_waiting_scope_without_click(tmp_path,monkeypatch):
|
||||
import subprocess,sys,time
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from types import SimpleNamespace
|
||||
from cbb_refresh_verify import library_lock
|
||||
from cbb_refresh_verify.operation_queue import NativeQueue,BatchTaskContext
|
||||
from test_issue15_resource_release import library_file,cleanup
|
||||
library=library_file(tmp_path)
|
||||
gate=tmp_path/'native-exit'
|
||||
native=subprocess.Popen([sys.executable,'-c',
|
||||
'from pathlib import Path; import time,sys\nwhile not Path(sys.argv[1]).exists(): time.sleep(.02)',str(gate)])
|
||||
evidence=tmp_path/'evidence';evidence.mkdir();path=evidence/'session.json'
|
||||
session_record.write_session_record(path,dict(operation_id='cancelled-owned',operation='verify',
|
||||
library=str(library),block='A',processes=[dict(role='native',**session_record.process_identity(native.pid))]))
|
||||
original=evidence/'result.json';original.write_text('{"status":"CANCELLED","safe_to_continue":false}')
|
||||
before=original.read_bytes()
|
||||
with library_lock.LibraryLock(library,block_name='A',safe_to_release=lambda:False) as lease:pass
|
||||
monkeypatch.setattr('cbb_refresh_verify.owner_probe.query_owners',lambda *a,**kw:[])
|
||||
active=Event();stop=Event();closed=[]
|
||||
owner=SimpleNamespace(pid=700,poll=lambda:0,close=lambda:closed.append(native.poll()))
|
||||
thread=None
|
||||
try:
|
||||
session_record.handoff_session(path,evidence_root=evidence,process=owner,stop=stop,
|
||||
progress=lambda state:active.set() if state['status']=='ACTIVE' else None)
|
||||
assert active.wait(3) and not closed
|
||||
key=str(path.absolute()).casefold()
|
||||
thread=session_record._observers[key][0]
|
||||
assert not session_record.library_available(library)
|
||||
queue=NativeQueue()
|
||||
def admitted():
|
||||
with library_lock.LibraryLock(library,checkpoint=False):return 'fresh admission'
|
||||
with ThreadPoolExecutor(1) as pool:
|
||||
future=pool.submit(queue.run,admitted,context=BatchTaskContext(str(library)),stop=stop)
|
||||
time.sleep(.15);assert not future.done()
|
||||
gate.touch();native.wait(5)
|
||||
assert future.result(8)=='fresh admission'
|
||||
thread.join(3)
|
||||
assert not thread.is_alive() and closed==[0]
|
||||
observations=[json.loads(p.read_text()) for p in evidence.glob('observation-*.json')]
|
||||
assert any(o.get('status')=='RELEASED' and o['release_proof']['proof_block_name']=='A' for o in observations)
|
||||
assert original.read_bytes()==before
|
||||
finally:
|
||||
gate.touch();native.wait(5);stop.set()
|
||||
if thread:thread.join(3)
|
||||
cleanup(lease)
|
||||
@@ -0,0 +1,90 @@
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from threading import Event
|
||||
from types import SimpleNamespace
|
||||
|
||||
import pytest
|
||||
|
||||
from cbb_refresh_verify import session_record as sessions
|
||||
from cbb_refresh_verify.operation_queue import BatchTaskContext,NativeQueue
|
||||
|
||||
|
||||
def observed(tmp_path,monkeypatch,*,status='ACTIVE',initializing=False,registered=True,alive=True,worker_alive=False):
|
||||
library=tmp_path/'lib.lmc';key='record'
|
||||
states={key:dict(status=status,observer_initializing=initializing,owned_worker_alive=worker_alive)}
|
||||
monkeypatch.setattr(sessions,'_retained_libraries',{key:{sessions._library_key(library)}})
|
||||
monkeypatch.setattr(sessions,'_retained_results',states)
|
||||
monkeypatch.setattr(sessions,'_observers',{key:(SimpleNamespace(is_alive=lambda:alive),None)} if registered else {})
|
||||
return library,states[key]
|
||||
|
||||
|
||||
@pytest.mark.parametrize('initializing',[False,True])
|
||||
def test_same_library_waits_for_actual_observer_and_other_library_can_run(tmp_path,monkeypatch,initializing):
|
||||
library,state=observed(tmp_path,monkeypatch,status='UNCONFIRMED' if initializing else 'ACTIVE',initializing=initializing)
|
||||
queue=NativeQueue();waiting=Event();entered=Event();stop=Event()
|
||||
# Queue predicates may not perform filesystem/process probes.
|
||||
monkeypatch.setattr(sessions,'query_process_snapshot',lambda *a,**kw:pytest.fail('queue probed native clients'),raising=False)
|
||||
context=BatchTaskContext(str(library),native_policy='external')
|
||||
with ThreadPoolExecutor(2) as pool:
|
||||
future=pool.submit(queue.run,lambda:entered.set() or 'resumed',context=context,stop=stop,waiting=waiting.set)
|
||||
try:
|
||||
assert waiting.wait(.5) and not entered.is_set()
|
||||
other=pool.submit(queue.run,lambda:'unrelated',context=BatchTaskContext(str(tmp_path/'other.lmc')))
|
||||
assert other.result(1)=='unrelated'
|
||||
state.update(status='RELEASED',observer_initializing=False)
|
||||
assert future.result(2)=='resumed'
|
||||
finally:
|
||||
stop.set();queue.wake()
|
||||
|
||||
|
||||
@pytest.mark.parametrize('case',['orphaned','dead_thread','unconfirmed','released'])
|
||||
def test_stale_or_nonlive_cache_does_not_prevent_fresh_scoped_admission(tmp_path,monkeypatch,case):
|
||||
library,state=observed(tmp_path,monkeypatch,status='RELEASED' if case=='released' else 'UNCONFIRMED',
|
||||
registered=case!='orphaned',alive=case!='dead_thread')
|
||||
assert not sessions.library_available(library) # Historical cache is deliberately stale.
|
||||
assert NativeQueue().run(lambda:'fresh admission',context=BatchTaskContext(str(library)))=='fresh admission'
|
||||
|
||||
|
||||
def test_live_owned_worker_still_blocks_when_its_journal_cannot_be_read(tmp_path,monkeypatch):
|
||||
library,state=observed(tmp_path,monkeypatch,status='UNCONFIRMED',worker_alive=True)
|
||||
queue=NativeQueue();waiting=Event();stop=Event();entered=Event()
|
||||
with ThreadPoolExecutor(1) as pool:
|
||||
future=pool.submit(queue.run,lambda:entered.set(),context=BatchTaskContext(str(library)),
|
||||
stop=stop,waiting=waiting.set)
|
||||
try:
|
||||
assert waiting.wait(.5) and not entered.is_set()
|
||||
state['owned_worker_alive']=False
|
||||
future.result(2)
|
||||
finally:
|
||||
stop.set();queue.wake()
|
||||
|
||||
|
||||
def test_actual_observer_initialization_closes_queue_race_then_unconfirmed_cache_releases_it(tmp_path,monkeypatch):
|
||||
library=tmp_path/'lib.lmc';path=tmp_path/'session.json'
|
||||
sessions.write_session_record(path,dict(operation_id='initializing',library=str(library)))
|
||||
entered,finish,waiting,stop=Event(),Event(),Event(),Event()
|
||||
def first_scan(*args,**kwargs):
|
||||
entered.set();assert finish.wait(3)
|
||||
return dict(status='UNCONFIRMED',operation_id='initializing',library=str(library),
|
||||
detail='No live client; fresh admission must recheck resource proof')
|
||||
monkeypatch.setattr(sessions,'_reconcile',first_scan)
|
||||
queue=NativeQueue();thread=None
|
||||
try:
|
||||
sessions.handoff_session(path,evidence_root=tmp_path,observe_only=True,stop=stop)
|
||||
assert entered.wait(2)
|
||||
thread=sessions._observers[str(path.absolute()).casefold()][0]
|
||||
assert not sessions.library_available(library,live_only=True)
|
||||
with ThreadPoolExecutor(1) as pool:
|
||||
future=pool.submit(queue.run,lambda:'fresh scoped admission',context=BatchTaskContext(str(library)),
|
||||
waiting=waiting.set,stop=stop)
|
||||
try:
|
||||
assert waiting.wait(1) and not future.done()
|
||||
finish.set()
|
||||
assert future.result(2)=='fresh scoped admission'
|
||||
finally:
|
||||
stop.set();queue.wake()
|
||||
thread.join(2)
|
||||
assert not sessions.library_available(library) # Unproved historical state remains visible.
|
||||
assert sessions.library_available(library,live_only=True)
|
||||
finally:
|
||||
finish.set();stop.set()
|
||||
if thread:thread.join(2)
|
||||
@@ -0,0 +1,150 @@
|
||||
from contextlib import nullcontext
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from cbb_refresh_verify import diagnostic_open, residual_sessions as sessions, session_record
|
||||
from test_cancelled_loaded_startup import loaded_fixture
|
||||
|
||||
|
||||
def registered_fixture(tmp_path,monkeypatch,*,closed=False,obstacle=''):
|
||||
import win32con,win32event
|
||||
job,records,messages,state=loaded_fixture(tmp_path,monkeypatch)
|
||||
state.update(tip=False,closing=closed)
|
||||
job.update(operation_id='verify-old',operation='verify',library=job['lmc_file'],block='IP101GR',
|
||||
session_record_path=str(tmp_path/'session.json'),interactive_input=False)
|
||||
job.pop('diagnostic_log_baseline') # Old builds never persisted this; do not invent it.
|
||||
identity=dict(pid=12,created_handle='native-created',image=records[0][1],owner_sid='current',session_id=1)
|
||||
worker=dict(pid=11,created_handle='worker-created',image='C:/App/CbbRefreshVerify.exe',owner_sid='current',session_id=1)
|
||||
session_record.write_session_record(tmp_path/'session.json',dict(operation_id='verify-old',operation='verify',
|
||||
library=job['library'],block=job['block'],desktop=job['desktop'],cancel_signal=job['cancel_signal'],
|
||||
processes=[dict(role='worker',**worker)],resource_scope=dict(scope_state='DECLARED',
|
||||
library=job['library'],operation_id='verify-old',projects=[job['project']])))
|
||||
session_record.write_session_record(tmp_path/'worker-state.json',dict(operation_id='verify-old',
|
||||
phase='UNCONFIRMED',processes=[dict(role='native',**identity)]))
|
||||
result=dict(status='CANCELLED',error_stage='PCB_STARTING',safe_to_continue=False,
|
||||
write_outcome=dict(save_state='UNKNOWN'))
|
||||
events=[dict(stage='pcb_baseline',pids=[]),dict(stage='pcb_worker_started',pcb_pid=12,command=records[0][2])]
|
||||
if closed:events.append(dict(stage='startup_close_requested',pcb_pid=12,hwnd=100))
|
||||
if obstacle=='ordinary':job['diagnostic_only']=False
|
||||
if obstacle=='interactive':job['interactive_input']=True
|
||||
if obstacle=='other_project':job['project']=str(tmp_path/'Other.prj')
|
||||
if obstacle=='wrong_operation':job['operation_id']='other'
|
||||
if obstacle=='missing_cancel':Path(job['cancel_signal']).unlink()
|
||||
if obstacle=='save':(tmp_path/'save.log').write_text('SAVE_ENTERED')
|
||||
if obstacle=='save_event':events.append(dict(stage='save_start'))
|
||||
if obstacle=='not_cancelled':result['status']='FAIL'
|
||||
if obstacle=='wrong_stage':result['error_stage']='SAVING'
|
||||
(tmp_path/'request.json').write_text(json.dumps(job))
|
||||
(tmp_path/'result.json').write_text(json.dumps(result))
|
||||
(tmp_path/'events.jsonl').write_text(''.join(json.dumps(e)+'\n' for e in events))
|
||||
row=dict(pid=12,name='ExpeditionPCB.exe',command=records[0][2],created='native-created',
|
||||
executable=identity['image'],library=job['library'],scope_confirmed=True,runtime_phase='UNCONFIRMED',
|
||||
session_records=[dict(path=str(tmp_path/'session.json'),operation_id='verify-old')],**{k:v for k,v in identity.items() if k!='pid'})
|
||||
if obstacle=='foreign_identity':row['created_handle']='replacement'
|
||||
if obstacle=='unscoped':row['scope_confirmed']=False
|
||||
monkeypatch.setattr(sessions,'_process_handle',lambda pid,**kw:nullcontext(pid))
|
||||
monkeypatch.setattr(sessions,'_handle_identity',lambda handle:{k:v for k,v in (worker if handle==11 else identity).items() if k in ('created_handle','image')})
|
||||
monkeypatch.setattr(sessions,'_force_ownership',lambda h,p:{'owner_sid':'current','session_id':1,'force_user_confirmed':True})
|
||||
def wait(handle,ms):
|
||||
state['ticks']+=ms/1000
|
||||
return win32con.WAIT_OBJECT_0 if handle==11 and obstacle!='live_worker' or handle==12 and not records else win32con.WAIT_TIMEOUT
|
||||
monkeypatch.setattr(win32event,'WaitForSingleObject',wait)
|
||||
monkeypatch.setattr(sessions,'time',diagnostic_open.time)
|
||||
monkeypatch.setattr(sessions,'query_process_snapshot',lambda:[row])
|
||||
monkeypatch.setattr(sessions,'_legacy_diagnostic_windows',lambda r:diagnostic_open._windows(r['pid']),raising=False)
|
||||
monkeypatch.setattr(sessions,'_window_desktop',lambda *a,**kw:nullcontext())
|
||||
monkeypatch.setattr(sessions,'_post_window_message',lambda w,h,p,m:__import__('win32gui').PostMessage(h,m,0,0))
|
||||
monkeypatch.setattr(session_record,'active_write_records',lambda library:
|
||||
[dict(operation_id='other-write' if obstacle=='other_write' else 'verify-old',phase='UNCONFIRMED')])
|
||||
monkeypatch.setattr(diagnostic_open,'_load_evidence',lambda *a,**kw:
|
||||
pytest.fail('legacy cleanup may not manufacture missing prelaunch log evidence'))
|
||||
return job,row,records,messages,state
|
||||
|
||||
|
||||
@pytest.mark.parametrize('closed',[False,True])
|
||||
def test_normal_release_finishes_exact_registered_cancelled_startup_without_save_or_second_close(tmp_path,monkeypatch,closed):
|
||||
job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch,closed=closed)
|
||||
original=(tmp_path/'result.json').read_bytes()
|
||||
result=sessions._request_close(row)
|
||||
assert result['release_status']=='RELEASED'
|
||||
assert messages==([(31,245)] if closed else [(31,245),(100,16)])
|
||||
assert not records and (tmp_path/'result.json').read_bytes()==original
|
||||
|
||||
|
||||
@pytest.mark.parametrize('obstacle',['ordinary','interactive','other_project','wrong_operation','missing_cancel',
|
||||
'save','save_event','not_cancelled','wrong_stage','foreign_identity','unscoped','live_worker','other_write'])
|
||||
def test_registered_startup_release_rejects_partial_foreign_or_writing_evidence(tmp_path,monkeypatch,obstacle):
|
||||
job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch,obstacle=obstacle)
|
||||
assert sessions._request_close(row)['release_status'] in ('WAITING','IDENTITY_CHANGED')
|
||||
assert not messages and records
|
||||
|
||||
|
||||
@pytest.mark.parametrize('error_code',[87,5])
|
||||
def test_registered_worker_exit_requires_kernel_exit_or_missing_pid_not_access_denial(tmp_path,monkeypatch,error_code):
|
||||
import pywintypes
|
||||
job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch)
|
||||
original=sessions._process_handle
|
||||
def open_process(pid,**kwargs):
|
||||
if pid==11:raise pywintypes.error(error_code,'OpenProcess','worker probe')
|
||||
return original(pid,**kwargs)
|
||||
monkeypatch.setattr(sessions,'_process_handle',open_process)
|
||||
result=sessions._request_close(row)
|
||||
assert result['release_status']==('RELEASED' if error_code==87 else 'WAITING')
|
||||
assert messages==([(31,245),(100,16)] if error_code==87 else [])
|
||||
|
||||
|
||||
def test_completed_identity_snapshots_fit_existing_release_budget_without_duplicate_polling(tmp_path,monkeypatch):
|
||||
job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch)
|
||||
def snapshot():
|
||||
state['ticks']+=.4
|
||||
return [row]
|
||||
monkeypatch.setattr(sessions,'query_process_snapshot',snapshot)
|
||||
assert sessions._request_close(row)['release_status']=='RELEASED'
|
||||
assert messages==[(31,245),(100,16)] and state['ticks']<3
|
||||
|
||||
|
||||
@pytest.mark.parametrize('change',['result','stop','identity'])
|
||||
def test_legacy_no_rechecks_registered_state_after_fresh_windows(tmp_path,monkeypatch,change):
|
||||
from threading import Event
|
||||
job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch)
|
||||
stop=Event();reads=[]
|
||||
original=sessions._legacy_diagnostic_windows
|
||||
def windows(bound):
|
||||
value=original(bound);reads.append(1)
|
||||
if len(reads)==2:
|
||||
if change=='result':(tmp_path/'result.json').write_text('{"status":"PASS"}')
|
||||
if change=='stop':stop.set()
|
||||
if change=='identity':row['created_handle']='replacement'
|
||||
return value
|
||||
monkeypatch.setattr(sessions,'_legacy_diagnostic_windows',windows)
|
||||
assert sessions._request_close(row,stop=stop)['release_status']=='WAITING'
|
||||
assert records and not messages
|
||||
|
||||
|
||||
@pytest.mark.parametrize('frame_handle',[100,999])
|
||||
def test_normal_release_clears_registered_late_tip_despite_historical_unknown_phase(tmp_path,monkeypatch,frame_handle):
|
||||
import win32con,win32gui
|
||||
from copy import deepcopy
|
||||
job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch,closed=True)
|
||||
state['tip']=True
|
||||
windows=[dict(hwnd=frame_handle,**{'class':'Afx:main'},title='Expedition PCB',enabled=False,
|
||||
desktop=job['desktop'],children=[],documents=[]),
|
||||
dict(hwnd=200,**{'class':'#32770'},title='Tip of the Day',enabled=True,
|
||||
desktop=job['desktop'],documents=[],children=[dict(hwnd=201,**{'class':'Button'},id=1,text='OK',enabled=True)])]
|
||||
monkeypatch.setattr(sessions,'_process_windows',lambda pids:{12:deepcopy(windows)})
|
||||
monkeypatch.setattr(win32gui,'GetWindow',lambda h,k:frame_handle if h==200 and k==win32con.GW_OWNER else 0)
|
||||
def post(hwnd,message,*args):messages.append((hwnd,message));records.clear()
|
||||
monkeypatch.setattr(win32gui,'PostMessage',post)
|
||||
result=sessions._request_close(row)
|
||||
assert result['release_status']==('RELEASED' if frame_handle==100 else 'WAITING')
|
||||
assert messages==([(201,245)] if frame_handle==100 else [])
|
||||
|
||||
|
||||
def test_registered_cleanup_cannot_act_from_another_windows_user_session(tmp_path,monkeypatch):
|
||||
job,row,records,messages,state=registered_fixture(tmp_path,monkeypatch)
|
||||
monkeypatch.setattr(sessions,'_force_ownership',lambda h,p:
|
||||
dict(owner_sid='current',session_id=1,force_user_confirmed=False))
|
||||
assert sessions._request_close(row)['release_status']=='WAITING'
|
||||
assert not messages and records
|
||||
Reference in new issue
Block a user