Files
dxdesigner-part-replacement/tools/verify_dsh_blocker_recovery.py
阿白叔 de9cb2908d
Core regression / Python core and release configuration (push) Successful in 18s
Core regression / JavaScript syntax (push) Successful in 2s
Core regression / Python core and release configuration (pull_request) Successful in 16s
Core regression / JavaScript syntax (pull_request) Successful in 3s
feat(dsh): intervene on blocking states and verify resource recovery
2026-11-04 23:39:33 +08:00

195 lines
10 KiB
Python

"""Run real native-Harness blocker diagnosis with memory-only resource fixtures."""
from __future__ import annotations
import json
import os
from pathlib import Path
from queue import Queue
import subprocess
import sys
from threading import Event, Thread
from time import monotonic
from uuid import uuid4
REPO = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(REPO / 'src'))
class NativeDiagnosis:
"""Use the production stdin/stdout protocol without exposing provider values."""
def __init__(self, root):
from dx_productivity.dsh.native_runtime import launch_environment, node_executable
from dx_productivity.dsh.provider_config import load_provider
from dx_productivity.trial_task_center.application import resolve_data_root
directory = root / 'dsh'
directory.mkdir(parents=True, exist_ok=True)
(directory / 'task-context.json').write_text(json.dumps({
'task_id': 'unrelated-live-task', 'revision': 'unrelated-live-revision'}), encoding='utf8')
provider = load_provider(resolve_data_root(None) / 'dsh')
environment = launch_environment(directory) | provider
assert all(environment.get(key) for key in ('DSH_API_BASE', 'DSH_MODEL', 'DSH_API_KEY')), 'provider_not_configured'
self.process = subprocess.Popen([node_executable(), str(REPO / 'integration/dsh/start.mjs')],
cwd=REPO, env=environment, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL, text=True, encoding='utf8',
creationflags=subprocess.CREATE_NO_WINDOW if os.name == 'nt' else 0)
self.events, self.calls = Queue(), []
Thread(target=self._read, daemon=True).start()
def _read(self):
for line in self.process.stdout:
if line.startswith('DX_DSH_READY '):
self.events.put({'status': 'ready'})
elif line.startswith('DX_DSH_DIAGNOSIS '):
self.events.put(json.loads(line[len('DX_DSH_DIAGNOSIS '):]))
self.events.put({'status': 'runtime_exited'})
def __enter__(self):
try:
assert self.events.get(timeout=65)['status'] == 'ready', 'native_runtime_not_ready'
except BaseException:
self.close()
raise
return self
def __call__(self, incident_id, snapshot, evidence, phase):
request_id = uuid4().hex
request = {'type': 'diagnose', 'request_id': request_id, 'incident_id': incident_id,
'snapshot': snapshot, 'evidence': evidence, 'phase': phase}
self.process.stdin.write(json.dumps(request, ensure_ascii=False) + '\n')
self.process.stdin.flush()
deadline = monotonic() + 240
while True:
remaining = deadline - monotonic()
if remaining <= 0:
raise TimeoutError('native_diagnosis_deadline')
value = self.events.get(timeout=remaining)
assert value.get('status') != 'runtime_exited', 'native_runtime_exited'
if value.get('request_id') != request_id or value.get('status') == 'started':
continue
assert value.get('status') == 'completed', 'native_diagnosis_did_not_complete'
self.calls.append({'incident_id': incident_id, 'phase': phase,
'session_id': value.get('session_id', '')})
return value
def close(self):
if self.process.stdin:
self.process.stdin.close()
try:
self.process.wait(timeout=8)
except subprocess.TimeoutExpired:
self.process.kill()
self.process.wait(timeout=8)
self.process.stdout.close()
def __exit__(self, *args):
self.close()
class OwnedResourceFixture:
"""No CAD, OS process handles, or engineering files exist in this fixture."""
def __init__(self):
self.pending = [{'session_id': 'controlled-owned-session', 'state': 'blocked',
'resource_type': 'in-memory-owned-resource-fixture'}]
self.calls, self.context_calls, self.pending_reads = [], 0, 0
def task_context(self, task_id):
self.context_calls += 1
raise AssertionError('cached_snapshot_must_not_read_live_task_context')
def pending_batch_resources(self):
self.pending_reads += 1
return tuple(dict(item) for item in self.pending)
def cleanup_batch_resources(self):
self.calls.append('cleanup')
self.pending.clear()
return ()
def prepare_failed_quick_run(self, *args, **kwargs):
self.calls.append('forbidden_prepare')
raise AssertionError('engineering_mutation_forbidden')
def execute_quick_run_queue(self, *args, **kwargs):
self.calls.append('forbidden_execute')
raise AssertionError('engineering_mutation_forbidden')
def main():
from dx_productivity.dsh.incidents import IncidentRunner, decision
root = REPO / 'build' / ('dsh-blocker-recovery-' + uuid4().hex[:8])
root.mkdir(parents=True)
report_path = root / 'report.json'
service, publication_attempts = OwnedResourceFixture(), []
report = {'status': 'running', 'model': 'real configured API through native Harness',
'executor': 'in-memory fixture; no CAD or OS process writes', 'remoteIssueWrites': 0}
def local_outbox(record, archive):
assert archive.is_file(), 'missing_local_evidence_archive'
publication_attempts.append(record['incident_id'])
return {'status': 'unavailable', 'reason': 'remote_publication_disabled_for_acceptance'}
try:
with NativeDiagnosis(root) as native:
permission = Event()
permission.set()
runner = IncidentRunner(root, service, native, local_outbox)
cleanup = runner.run('controlled-resource-task', 'batch_resources_pending',
'受控资源释放验收:任务队列已空闲,仅有一个本验收持有的内存资源待释放。'
'资源所有权已在受控服务中确认;cleanup_allowed=true。'
'资源释放不会打开工程、恢复队列或执行 CAD;不需要原始 CAD 执行授权。',
run_id='controlled-resource-run', execution_enabled=permission, cleanup_allowed=True,
snapshot_override={'task_id': 'controlled-resource-task', 'task_name': '受控自有资源释放',
'status': 'blocked', 'progress': {}},
trigger={'operation': 'release_resources', 'source': 'controlled-owned-resource-fixture',
'outcome': 'resources_pending', 'task_queue_idle': True,
'ownership_verified': True, 'pending_resources': service.pending_batch_resources()})
report['cleanupIncident'] = cleanup
assert decision(cleanup['analyses'][0]['reply'])['action'] == 'cleanup_resources', 'model_did_not_recommend_cleanup'
assert cleanup['status'] == 'resolved', 'cleanup_not_resolved'
assert cleanup['verification']['resources_released'] is True, 'resources_not_verified_released'
assert cleanup['verification']['remaining_resources'] == [], 'resources_still_pending'
assert service.calls == ['cleanup'], 'unexpected_cleanup_or_engineering_call'
assert service.pending_reads >= 3, 'missing_independent_resource_reread'
assert service.context_calls == 0, 'cleanup_read_live_task_context'
assert not publication_attempts, 'resolved_cleanup_attempted_publication'
stall = runner.run('controlled-stall-task', 'operation_stalled',
'受控停滞验收:BOM 检查轮询连续未产生新进度。当前只有缓存事件,'
'活动操作可能持有服务锁,执行结果尚不确定。应诊断并保留证据供人工核对。',
run_id='controlled-stall-run', execution_enabled=permission,
snapshot_override={'task_id': 'controlled-stall-task', 'task_name': '受控 BOM 轮询停滞',
'status': 'running', 'progress': {'completed': 0, 'total': 1}},
trigger={'operation': 'inspect_bom_batch', 'source': 'controlled-stall-event',
'outcome': 'stalled', 'last_progress_age_seconds': 180,
'result_unverified': True, 'worker_active': True})
report['stallIncident'] = stall
assert stall['status'] == 'pending_issue', 'stall_did_not_remain_in_local_outbox'
assert stall['attempts'] == 0, 'stall_retried_engineering'
assert service.calls == ['cleanup'], 'stall_mutated_resources_or_engineering'
assert service.context_calls == 0, 'stall_read_live_task_context'
assert publication_attempts == [stall['incident_id']], 'unexpected_publication_attempts'
assert [row['phase'] for row in stall['analyses']] == ['diagnose', 'reflect'], 'missing_real_stall_diagnosis_or_reflection'
sessions = [row.get('session_id') for row in stall['analyses']]
assert sessions[0] and sessions[0] == sessions[1], 'reflection_did_not_reuse_native_session'
directory = Path(stall['evidence_dir'])
assert all((directory / name).is_file() for name in ('trigger.json', 'issue.md', 'evidence.zip', 'ticket.json')), 'missing_local_stall_evidence'
report.update(status='passed', actualCalls=service.calls, contextCalls=service.context_calls,
resourceReads=service.pending_reads, modelCalls=native.calls,
resources_released=True, localOutboxCount=len(publication_attempts))
except BaseException as error:
report.update(status='failed', errorType=type(error).__name__, actualCalls=service.calls,
contextCalls=service.context_calls, localOutboxCount=len(publication_attempts))
raise
finally:
report_path.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf8')
print(json.dumps({'status': report['status'], 'report': str(report_path),
'actualCalls': service.calls, 'contextCalls': service.context_calls,
'modelCallCount': len(report.get('modelCalls', [])),
'localOutboxCount': len(publication_attempts)}, ensure_ascii=False))
if __name__ == '__main__':
main()