114 lines
6.7 KiB
Python
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())
|