Files
dxdesigner-part-replacement/tools/probe_private_single_step.py
T

114 lines
6.7 KiB
Python

"""Native single-step and saved-recovery regression on a new disposable copy."""
import argparse
from dataclasses import asdict
import json
from pathlib import Path
import re
import shutil
import sys
import time
import traceback
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer, _write_uncertain_flag
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow
from private_desktop_observer import PrivateDesktopObserver
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--source', type=Path, required=True)
parser.add_argument('--inventory', type=Path, required=True)
parser.add_argument('--library', type=Path, required=True)
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--refdes', default='RL06')
parser.add_argument('--new', default='4100-CA3300-2200')
args = parser.parse_args()
output, source = args.output.resolve(), args.source.resolve()
assert not output.is_relative_to(source.parent)
assert args.library.is_file()
output.mkdir(parents=True, exist_ok=False)
shutil.copytree(source.parent, output / 'project')
project = output / 'project' / source.name
text, count = re.subn(r'(?m)^KEY CentralLibrary .*$',
lambda _: f'KEY CentralLibrary "{args.library.resolve().as_posix()}"', project.read_text(encoding='utf-8-sig'))
assert count == 1
project.write_text(text, encoding='utf-8')
source_inventory = json.loads(args.inventory.read_text(encoding='utf-8'))
sheets = tuple(tuple(row) for row in source_inventory['sheets'])
inventory = tuple(ComponentTarget(project, row['schematic_name'], row['sheet_number'], row['uid'],
row['refdes'], row['old_part_number'], row['old_value']) for row in source_inventory['components'])
assert sum(row.refdes == args.refdes for row in inventory) == 1
target = next(row for row in inventory if row.refdes == args.refdes)
store = TaskStore(output / 'tasks.db')
service = TaskCenterService(store, configure_logging(output / 'data'),
quick_run_preparer=QuickRunPreparer(output / 'data', sheet_discoverer=lambda _: sheets))
report = {'project': str(project), 'refdes': args.refdes}
try:
with PrivateDesktopObserver(output):
task = service.create_project_tasks(project.parent)[0]
report['task_id'] = task.task_id
service.add_rule(task.task_id, target.old_part_number, args.new)
store.record_target_inventory(task.task_id, inventory)
service.replace_target_plan(task.task_id, tuple(TargetPlanRow(row, row.refdes == args.refdes, args.new)
for row in inventory))
progress = service.quick_run_progress(task.task_id)
started = time.perf_counter()
result = service.execute_quick_run(task.task_id, expected_item=(str(project),
progress.next_old_part_number, progress.next_new_part_number, 'preserve'))
report['single_step_seconds'] = time.perf_counter() - started
report['single_step'] = asdict(result)
assert result.state == 'saved_ok'
root = result.status_path.parent
assert tuple(root.parent.glob('quick-run-history/batch-*/.dxpartreplace-backup.json'))
report['single_step_session'] = json.loads((root / 'private-desktop.json').read_text(encoding='utf-8'))
assert report['single_step_session']['clean']
print('SINGLE_STEP_SAVED_AND_RELEASED', flush=True)
# Fault injection is limited to this disposable task's status file.
# Keep the immutable snapshot/native transaction evidence intact.
status = result.status_path.read_text(encoding='utf-8-sig').splitlines()
(output / 'status-before-injected-interruption.tsv').write_text('\n'.join(status) + '\n', encoding='utf-8')
fields = status[-1].split('\t')
fields[1:] = ['batch_saved_unverified', 'regression_injected', 'simulate interruption after disk save']
status[-1] = '\t'.join(fields)
result.status_path.write_text('\n'.join(status) + '\n', encoding='utf-8')
_write_uncertain_flag(root / 'uncertain.flag', 'regression_injected_after_save')
started = time.perf_counter()
recovered = service.recover_quick_run(task.task_id, confirmed=True)
report['recovery_seconds'] = time.perf_counter() - started
report['recovery'] = asdict(recovered)
assert recovered.state == 'restored_ok' and not (root / 'uncertain.flag').exists()
report['recovery_session'] = json.loads((recovered.log_path.parent / 'worker/private-desktop.json').read_text(encoding='utf-8'))
assert report['recovery_session']['clean']
print('RECOVERY_SAVED_AND_RELEASED', flush=True)
actual = QuickRunPreparer(output / 'independent-read')._discover_project_sheets(project,
(target.old_part_number, args.new), collect_components=True)
by_uid = {row.uid: row for row in actual.components}
report['comparisons'] = []
for before in inventory:
after = by_uid[before.uid]
expected = args.new if before.refdes == args.refdes else before.old_part_number
report['comparisons'].append({'refdes': before.refdes, 'expected': expected, 'actual': after.old_part_number})
assert after.refdes == before.refdes and after.old_part_number == expected
observation = json.loads((output / 'desktop-observation.json').read_text(encoding='utf-8'))
assert observation['input_desktop_before'] == observation['input_desktop_after']
assert not observation['owned_cad_became_foreground'] and not observation['owned_cad_on_input_desktop']
assert all(observation['cad_exit_confirmed'].values()) and all(observation['desktop_absent'].values())
assert not observation['observer_errors']
report['verified'] = True
except Exception as error:
report['error'] = str(error)
traceback.print_exc()
finally:
store.close()
(output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2, default=str), encoding='utf-8')
print(json.dumps({key: report[key] for key in ('verified', 'error') if key in report}), flush=True)
return 0 if report.get('verified') else 1
if __name__ == '__main__':
raise SystemExit(main())