199 lines
12 KiB
Python
199 lines
12 KiB
Python
"""Multi-project regression with real storage/BOM/queues and a simulated CAD worker.
|
||
|
||
This measures software overhead, never native CAD replacement throughput.
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import csv
|
||
from dataclasses import asdict
|
||
import json
|
||
from pathlib import Path
|
||
import subprocess
|
||
import sys
|
||
from threading import Event
|
||
import time
|
||
|
||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))
|
||
|
||
from dx_productivity.trial_task_center.bom_plan import write_bom_template
|
||
from dx_productivity.trial_task_center.inventory import HEADER
|
||
from dx_productivity.trial_task_center.logging_setup import configure_logging
|
||
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer, _decode_vbs_field, _encode_vbs_field
|
||
from dx_productivity.trial_task_center.service import TaskCenterService
|
||
from dx_productivity.trial_task_center.store import TaskStore
|
||
from dx_productivity.trial_task_center.target_plan import ComponentTarget
|
||
from dx_productivity.trial_task_center.task_queue import execute_task_queue
|
||
from dx_productivity.trial_task_center.ui.messages import _format_task_log_lines
|
||
|
||
|
||
class SimulatedReleasedRuntime:
|
||
"""The injected executor starts no owned process; admission proof is explicit."""
|
||
def __init__(self, root):
|
||
self.root, self.stop_event, self.cad, self.desktop = root, None, None, None
|
||
def bind_logs(self, *args):
|
||
pass
|
||
def release_failed_project(self, error, evidence_root):
|
||
return True
|
||
|
||
|
||
def run_scenario(output: Path, *, projects=3, sheets=2, rules=2, behavior='success') -> dict:
|
||
output = Path(output).resolve()
|
||
output.mkdir(parents=True, exist_ok=False)
|
||
started = time.perf_counter()
|
||
timings, calls, targets, model = [], [], {}, {}
|
||
stop = Event()
|
||
|
||
def measured(phase, action):
|
||
tick = time.perf_counter()
|
||
value = action()
|
||
timings.append({'layer': 'workflow', 'phase': phase, 'elapsed_seconds': time.perf_counter() - tick})
|
||
return value
|
||
|
||
def write_tsv(path, header, rows):
|
||
path.write_text('\t'.join(header) + '\n' + ''.join(
|
||
'\t'.join(_encode_vbs_field(str(value)) for value in row) + '\n' for row in rows), encoding='utf-8')
|
||
|
||
root = output / 'projects'
|
||
for index in range(projects):
|
||
path = root / f'board-{index:03}' / 'board.prj'
|
||
path.parent.mkdir(parents=True)
|
||
path.write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
|
||
inventory = tuple(ComponentTarget(path, 'MAIN', str(sheet), f'{sheet}-{part}-{ref}',
|
||
f'R{part * 3 + ref}', f'OLD-{part}', '10K/NC' if ref == 1 else '10K')
|
||
for sheet in range(1, sheets + 1) for part in range(rules) for ref in range(1, 4))
|
||
targets[str(path).casefold()] = inventory
|
||
model.update({target.key: target.old_part_number for target in inventory})
|
||
|
||
def worker(command, timeout):
|
||
evidence = Path(command[3])
|
||
with (evidence / ('current-command.tsv' if (evidence / 'current-command.tsv').exists() else 'command.tsv')).open(encoding='utf-8-sig') as stream:
|
||
item = next(csv.DictReader(stream, delimiter='\t'))
|
||
path = Path(item['project_path'])
|
||
inventory = targets[str(path).casefold()]
|
||
if (evidence / 'sheet-discovery.request').exists():
|
||
write_tsv(evidence / 'sheets.tsv', ('project_path', 'schematic_name', 'sheet_number'),
|
||
((path, 'MAIN', s) for s in range(1, sheets + 1)))
|
||
write_tsv(evidence / 'inventory.tsv', ('project_path', 'schematic_name', 'sheet_number', 'old_part'),
|
||
((path, 'MAIN', s, f'OLD-{p}') for s in range(1, sheets + 1) for p in range(rules)))
|
||
write_tsv(evidence / 'components.tsv', HEADER,
|
||
((path, t.schematic_name, t.sheet_number, t.uid, t.refdes, t.old_part_number, t.old_value) for t in inventory))
|
||
return subprocess.CompletedProcess(command, 0, '', '')
|
||
assert item['target_scope'] == 'targets'
|
||
selected = [entry.split('\x1f') for entry in _decode_vbs_field(item['target_selectors']).split('\x1e')]
|
||
matched = [t for t in inventory if t.sheet_number == item['sheet_number'] and t.uid in {s[0] for s in selected}]
|
||
assert len(selected) == len(matched) == 1
|
||
assert {(t.uid, t.refdes, t.old_value) for t in matched} == {tuple(s) for s in selected}
|
||
assert all(model[t.key] == item['old_part'] for t in matched)
|
||
state = 'saved_ok'
|
||
if not calls and behavior in {'failure_continue', 'uncertain_stop'}:
|
||
state = 'batch_failed' if behavior == 'failure_continue' else 'batch_saved_unverified'
|
||
if state == 'saved_ok':
|
||
for target in matched:
|
||
model[target.key] = item['new_part']
|
||
job = command[-1]
|
||
assert item['job_id'] == job
|
||
assert job not in {call['job_id'] for call in calls}
|
||
calls.append({'job_id': job, 'project': path.parent.name, 'task_id': item['task_id'],
|
||
'sheet': item['sheet_number'], 'old': item['old_part'], 'new': item['new_part'],
|
||
'refdes': [t.refdes for t in matched], 'state': state})
|
||
message = ('Native replacement and parameter readback passed on current sheet. Replacements: '
|
||
+ '; '.join(f'{t.refdes} {item["old_part"]} -> {item["new_part"]}' for t in matched)
|
||
+ ' Display verified: attributes=2. Saved, reopened for readback, and closed.')
|
||
if state != 'saved_ok':
|
||
message = 'Injected worker failure for regression; no native CAD operation.'
|
||
with (evidence / 'status.tsv').open('a', encoding='utf-8') as stream:
|
||
# failure_continue models a preflight rejection before any
|
||
# native mutation. Awaiting + missing native evidence must stop.
|
||
if state != 'batch_failed':
|
||
stream.write(f'{job}\tawaiting_native_replace\t\tcaptured\n')
|
||
stream.write(f'{job}\t{state}\tbatch_closed\t{message}\n')
|
||
if behavior == 'pause_resume' and len(calls) == 2:
|
||
stop.set()
|
||
return subprocess.CompletedProcess(command, 0, '', '')
|
||
|
||
store = TaskStore(output / 'tasks.db')
|
||
service = TaskCenterService(store, configure_logging(output / 'data'),
|
||
quick_run_preparer=QuickRunPreparer(output / 'data', process_runner=worker,
|
||
cscript_resolver=lambda: Path('simulated-cscript'),
|
||
sheet_discoverer=lambda _: tuple(('MAIN', str(s)) for s in range(1, sheets + 1))))
|
||
try:
|
||
tasks = measured('create_tasks', lambda: service.create_project_tasks(root))
|
||
assert len(tasks) == projects
|
||
for part in range(rules):
|
||
service.add_rule(tasks[0].task_id, f'OLD-{part}', f'NEW-{part}')
|
||
for task in tasks:
|
||
rows = measured('collect_inventory', lambda: service.collect_target_inventory(task.task_id))
|
||
assert len(rows) == sheets * rules * 3
|
||
bom = output / f'{task.task_id}.xlsx'
|
||
records = []
|
||
for sheet in range(1, sheets + 1):
|
||
for part in range(rules):
|
||
records.append({'old_part_number': f'OLD-{part}', 'new_part_number': f'NEW-{part}',
|
||
'refdes': f'R{part * 3 + 1}, R{part * 3 + 2}', 'schematic_name': 'MAIN',
|
||
'sheet_number': str(sheet), 'sync_nc': part % 2 == 0})
|
||
measured('write_bom', lambda: write_bom_template(bom, records))
|
||
preview = measured('import_bom', lambda: service.preview_bom_plan(task.task_id, bom))
|
||
measured('save_plan', lambda: service.replace_target_plan(task.task_id, preview))
|
||
ids = tuple(task.task_id for task in tasks)
|
||
simulated_runtime = SimulatedReleasedRuntime(service._logging.root)
|
||
result = measured('queue_wall', lambda: execute_task_queue(service, ids, stop_event=stop, runtime=simulated_runtime))
|
||
if behavior == 'pause_resume':
|
||
assert result.paused and len(calls) == 2
|
||
stop.clear()
|
||
result = measured('queue_resume_wall', lambda: execute_task_queue(service, ids, stop_event=stop, queue_id=result.queue_id, runtime=simulated_runtime))
|
||
expected_steps = projects * sheets * rules * 2
|
||
expected_calls = 1 + (projects - 1) * sheets * rules * 2 if behavior == 'uncertain_stop' else expected_steps
|
||
assert len(calls) == expected_calls
|
||
if behavior == 'uncertain_stop':
|
||
assert not result.paused and result.entries[0].state == 'blocked'
|
||
assert all(entry.state == 'completed' for entry in result.entries[1:])
|
||
else:
|
||
assert not result.paused
|
||
assert [entry.state for entry in result.entries] == ['failed' if behavior == 'failure_continue' and i == 0 else 'completed' for i in range(projects)]
|
||
# Every task runs contiguously and each unselected RefDes keeps its baseline.
|
||
order = [call['task_id'] for call in calls]
|
||
assert order == sorted(order, key=ids.index)
|
||
changed = sum(model[t.key] != t.old_part_number for inventory in targets.values() for t in inventory)
|
||
assert changed == sum(call['state'] == 'saved_ok' for call in calls)
|
||
assert all(model[t.key] == t.old_part_number for inventory in targets.values() for t in inventory if int(t.uid.split('-')[-1]) == 3)
|
||
for task in tasks:
|
||
events = [json.loads(line) for line in service.tail_log(task.task_id, limit=None)]
|
||
timings.extend(event['details'] | {'layer': 'execution', 'task_id': task.task_id, 'project': service.projects(task.task_id)[0].path.parent.name}
|
||
for event in events if event['operation'] == 'execution_timing')
|
||
timings.extend(event['details']['timing'] | {'layer': 'execution', 'task_id': task.task_id,
|
||
'project': service.projects(task.task_id)[0].path.parent.name}
|
||
for event in events if event['operation'] == 'quick_run_executed' and 'timing' in event['details'])
|
||
executed = [event for event in events if event['operation'] == 'quick_run_executed']
|
||
own = [call for call in calls if call['task_id'] == task.task_id]
|
||
assert len(executed) == len(own)
|
||
rendered = '\n'.join(_format_task_log_lines(tuple(json.dumps(event) for event in executed)))
|
||
for call in own:
|
||
if call['state'] == 'saved_ok':
|
||
assert all(f'位号 {ref}:{call["old"]} → {call["new"]}' in rendered for ref in call['refdes'])
|
||
report = {'mode': 'simulated_cad_worker_real_storage_bom_and_queue', 'behavior': behavior,
|
||
'projects': projects, 'sheets_per_project': sheets, 'rules_per_sheet': rules,
|
||
'executed_steps': len(calls), 'changed_components': changed,
|
||
'unselected_components_preserved': projects * sheets * rules,
|
||
'elapsed_seconds': time.perf_counter() - started, 'result': asdict(result),
|
||
'calls': calls, 'timings': timings, 'checks': 'passed'}
|
||
(output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
|
||
fields = sorted({key for row in timings for key in row})
|
||
with (output / 'timings.csv').open('w', newline='', encoding='utf-8-sig') as stream:
|
||
writer = csv.DictWriter(stream, fieldnames=fields); writer.writeheader(); writer.writerows(timings)
|
||
return report
|
||
finally:
|
||
store.close()
|
||
|
||
|
||
if __name__ == '__main__':
|
||
parser = argparse.ArgumentParser(description=__doc__)
|
||
parser.add_argument('--output', type=Path, required=True)
|
||
parser.add_argument('--projects', type=int, default=3)
|
||
parser.add_argument('--sheets', type=int, default=2)
|
||
parser.add_argument('--rules', type=int, default=2)
|
||
parser.add_argument('--behavior', choices=('success', 'failure_continue', 'uncertain_stop', 'pause_resume'), default='success')
|
||
args = parser.parse_args()
|
||
result = run_scenario(args.output, projects=args.projects, sheets=args.sheets, rules=args.rules, behavior=args.behavior)
|
||
print(json.dumps({key: result[key] for key in ('mode', 'behavior', 'projects', 'executed_steps', 'elapsed_seconds', 'checks')}))
|