"""Single-attempt recovery through the installed native tool.""" from dataclasses import dataclass import hashlib import json import os from pathlib import Path import shutil import subprocess import sys import time from uuid import uuid4 @dataclass(frozen=True) class RepairTarget: project: Path database: Path def select_repair_target(request, diagnosis): from .verify_runner import preflight if diagnosis.get('error_code') != 'ICDB_REPAIR_REQUIRED' or not diagnosis.get('session'): raise ValueError('REPAIR_TARGET_UNCONFIRMED: 缺少原生失联会话信息') if diagnosis.get('scope') == 'central_library': raise ValueError('SHARED_DATABASE_REPAIR_UNSUPPORTED: 当前原生 Repair 入口要求 PRJ,不能改修无关的 Work 工程') if diagnosis.get('scope') != 'project': raise ValueError('REPAIR_TARGET_UNCONFIRMED: 数据库所有权范围未知') project, pcb = preflight(request) try: reported = Path(diagnosis.get('database_path', '')).resolve(strict=True) except OSError as error: raise ValueError(f'REPAIR_TARGET_UNCONFIRMED: 报错数据库路径不可用:{error}') from error for candidate in (project, pcb.parent/'pcb.prj'): database = candidate.parent/'database' if (candidate.is_file() and database.resolve() == reported and reported.is_relative_to(project.parent.resolve())): if not (reported/'icdb.dat').is_file(): raise ValueError('REPAIR_TARGET_UNCONFIRMED: 未找到目标 icdb.dat') return RepairTarget(candidate.resolve(), reported) raise ValueError('REPAIR_TARGET_UNCONFIRMED: 报错数据库不属于本次工程,未猜测或改写路径') def _hash(path): digest = hashlib.sha256() with path.open('rb') as stream: for chunk in iter(lambda: stream.read(1024*1024), b''): digest.update(chunk) return digest.hexdigest() def check_repair_access(target): """Preserve the former pre-copy ownership checks without copying data.""" import win32con, win32file, pywintypes from .scoped_manifest import scan_tree scan_tree(target.project.parent) # Reject links before native traversal. try: handle = win32file.CreateFile(str(target.database/'icdb.dat'), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None) except pywintypes.error as error: raise OSError(f'REPAIR_DATABASE_IN_USE: 无法独占读取数据库:{error}') from error handle.Close() def backup_project(target, destination): """Keep every original file, holding icdb.dat exclusively during the copy.""" import win32con, win32file, pywintypes source = target.project.parent.resolve() destination = Path(destination).resolve() if destination.is_relative_to(source) or source.is_relative_to(destination): raise ValueError('REPAIR_BACKUP_INVALID: 备份与源工程不能相互包含') paths = list(source.rglob('*')) if any(path.is_symlink() or path.is_junction() for path in paths): raise ValueError('REPAIR_BACKUP_INVALID: 工程包含目录链接,不能完整备份') if (source/'backup-manifest.json').exists(): raise ValueError('REPAIR_BACKUP_INVALID: 原工程含同名备份清单') database_file = target.database/'icdb.dat' try: handle = win32file.CreateFile(str(database_file), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None) except pywintypes.error as error: raise OSError(f'REPAIR_DATABASE_IN_USE: 无法独占读取数据库:{error}') from error try: destination.mkdir(parents=True, exist_ok=False) files = {} for path in paths: relative = path.relative_to(source) copied = destination/relative if path.is_dir(): copied.mkdir(parents=True, exist_ok=True) continue before = path.stat() copied.parent.mkdir(parents=True, exist_ok=True) if path == database_file: with copied.open('wb') as stream: while True: try: _, data = win32file.ReadFile(handle, 1024*1024) except pywintypes.error as error: if error.winerror == 38: # ERROR_HANDLE_EOF break raise if not data: break stream.write(data) os.utime(copied, ns=(before.st_atime_ns, before.st_mtime_ns)) digest = _hash(copied) else: digest = _hash(path) shutil.copy2(path, copied) if _hash(copied) != digest: raise OSError(f'REPAIR_BACKUP_CHANGED: 文件副本校验失败:{path}') after = path.stat() if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns): raise OSError(f'REPAIR_BACKUP_CHANGED: 备份期间源文件变化:{path}') files[str(relative)] = {'size': before.st_size, 'sha256': digest} if {path.relative_to(source) for path in source.rglob('*')} != { path.relative_to(source) for path in paths}: raise OSError('REPAIR_BACKUP_CHANGED: 备份期间工程文件集合变化') record = {'complete': True, 'source': str(source), 'files': files} (destination/'backup-manifest.json').write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8') return record finally: handle.Close() def attempt_recovery(request, diagnosis, evidence_root, *, progress=None, stop=None): root = Path(evidence_root)/'native-repair' root.mkdir(exist_ok=True) marker = root/'attempt.json' if marker.exists(): return {'status': 'BLOCKED', 'detail': 'REPAIR_ALREADY_ATTEMPTED', 'evidence': str(root)} record = {'status': 'BLOCKED', 'evidence_path': str(root), 'release': {'safe_to_continue': False}} try: process_record = Path(evidence_root)/'content-check-process.json' if process_record.is_file(): state = json.loads(process_record.read_text('utf-8')).get('status') if state in {'RUNNING', 'RETAINED'}: raise ValueError('IMPORTER_RELEASE_UNCONFIRMED: 内容检查客户端仍占有数据库,未尝试 Repair') with marker.open('x', encoding='utf-8') as stream: json.dump({'status': 'PREPARING', 'diagnosis': diagnosis}, stream, ensure_ascii=False) target = select_repair_target(request, diagnosis) if progress: progress({'stage': 'native_repair_start', 'block': request.block_name, 'detail': '正在核对占用并尝试原生数据库修复;应用不自动备份', 'project': str(target.project)}) from .mentor_adapter import pcb_processes, _process_details if pcb_processes() or _process_details('LibraryManager.exe'): raise ValueError('REPAIR_DATABASE_IN_USE: 原生 PCB/Library Manager 会话尚未退出') for _pid, _exe, command, _parent in _process_details('cscript.exe'): if str(target.project).casefold() in str(command).casefold(): raise ValueError('REPAIR_DATABASE_IN_USE: 目标的保存/关闭助手尚未退出') callback = (lambda event: progress({'block': request.block_name, **event})) if progress else None record = run_native_repair(target, root, mentor_bin=request.mentor_bin, timeout_seconds=max(60, request.timeout_seconds), progress=callback, stop=stop) native_status = record.get('status') record['release'] = repair_release_state(request, target, record) if native_status == 'REPAIRED' and record['release']['safe_to_continue'] is not True: record.update(status='UNCONFIRMED', native_status=native_status, detail='NATIVE_REPAIR_EVIDENCE_UNCONFIRMED: 原生成功或释放证据不完整') record['evidence_path'] = str(root) except Exception as error: record['detail'] = str(error) marker.write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8') return record def _native_identity_and_exit_confirmed(target, record): if not isinstance(record, dict): return False release = record.get('release') if (not isinstance(release, dict) or release.get('safe_to_continue') is not True or release.get('native_exited') is not True or not isinstance(release.get('addresses'), list) or release['addresses'] or type(record.get('native_pid')) is not int or record['native_pid'] <= 0 or not isinstance(record.get('unknown_dialogs', []), list) or record.get('unknown_dialogs')): return False try: for name, expected in (('project', target.project), ('database', target.database)): path = record.get(name) if (not isinstance(path, str) or not Path(path).is_absolute() or Path(path).resolve(strict=True) != expected.resolve(strict=True)): return False except (OSError, ValueError): return False return True def native_success_confirmed(target, record): """Validate the worker's complete, consistent success before any reopening.""" if not _native_identity_and_exit_confirmed(target, record) or record.get('status') != 'REPAIRED': return False evidence = record.get('evidence') if (not isinstance(evidence, dict) or evidence.get('confirmed') is not True or evidence.get('native_backup') is not True or evidence.get('outcome') != 'UNCONFIRMED' or evidence.get('failure_complete') is not False or evidence.get('restore_complete') is not False or evidence.get('restored_from_backup') != ''): return False fields = ('diagnostic_tail', 'database_tail', 'restore_tail', 'output_tail') if any(not isinstance(evidence.get(field), str) for field in fields): return False if not evidence['diagnostic_tail'] or not evidence['database_tail']: return False from .native_repair_ui import classify_repair_evidence return (classify_repair_evidence(*(evidence[field] for field in fields))['outcome'] == 'UNCONFIRMED' and 'iCDB database restored from backup:' not in evidence['restore_tail']) def repair_release_state(request, target, native_result): """Require normal exit, owner/address absence and exclusive database access.""" from .mentor_adapter import pcb_processes, _process_details from .icdb_ownership import database_directories, unreleased_addresses from .verify_runner import preflight release = native_result.get('release') if isinstance(native_result, dict) else None result = {**(release if isinstance(release, dict) else {}), 'safe_to_continue': False, 'database_exclusive': False} try: if (not _native_identity_and_exit_confirmed(target, native_result) or (native_result.get('status') == 'REPAIRED' and not native_success_confirmed(target, native_result))): result['error'] = 'NATIVE_REPAIR_EVIDENCE_UNCONFIRMED' return result project, pcb = preflight(request) owners = [int(r[0]) for r in pcb_processes()] for name in ('LibraryManager.exe', 'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe'): owners.extend(int(r[0]) for r in _process_details(name)) for pid, _exe, command, _parent in _process_details('cscript.exe'): if (not command or str(project).casefold() in command.casefold() or str(pcb).casefold() in command.casefold()): owners.append(int(pid)) result.update(remaining_pids=sorted(set(owners)), addresses=unreleased_addresses(request.lmc_file, project, pcb)) if (native_result.get('release', {}).get('safe_to_continue') is not True or owners or result['addresses']): return result import win32con, win32file files = [target.database/'icdb.dat'] files.extend(folder/'icdb.dat' for folder in database_directories(request.lmc_file, project, pcb) if (folder/'icdb.dat').is_file()) result['exclusive_databases'] = [] for database_file in dict.fromkeys(files): handle = win32file.CreateFile(str(database_file), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None) handle.Close() result['exclusive_databases'].append(str(database_file)) result.update(database_exclusive=True, safe_to_continue=True) except Exception as error: result['error'] = str(error) return result def run_native_repair(target, root, *, mentor_bin='', timeout_seconds=300, progress=None, maintenance_context=None, inspection_only=False, stop=None): """Supervise the GUI on its own desktop; a repair timeout never kills it.""" if stop is not None and stop.is_set(): return {'status': 'CANCELLED', 'native_started': False, 'detail': '原生操作启动前已取消', 'release': {'safe_to_continue': True}} from .desktop_worker import DesktopWorker root = Path(root) root.mkdir(parents=True, exist_ok=True) job_path = root/'repair-request.json' cancel = root/'cancel-repair.signal' desktop = 'CbbRepair_'+uuid4().hex[:12] from .operation_queue import current_context context = current_context() library = (maintenance_context or {}).get('library') or (context.library if context else str(target.project)) job = {'project': str(target.project), 'database': str(target.database), 'root': str(root), 'mentor_bin': str(mentor_bin or ''), 'timeout': timeout_seconds, 'cancel_signal': str(cancel), 'supervisor_pid': os.getpid(), 'desktop': desktop, 'maintenance_context': maintenance_context, 'inspection_only': inspection_only, 'library': library, 'operation_id': root.name+'-'+uuid4().hex[:8], 'operation': 'inspect' if inspection_only else 'repair', 'block': (maintenance_context or {}).get('block'), 'session_record_path': str(root/'session.json'), 'start_gate': str(root/'start-repair.signal')} job['start_gate_protocol'] = 'event-v1' job_path.write_text(json.dumps(job, ensure_ascii=False), encoding='utf-8') command = ([sys.executable] if getattr(sys, 'frozen', False) else [sys.executable, '-m', 'cbb_refresh_verify']) + ['--repair-worker', str(job_path)] from .operation_queue import task_stop return _supervise_repair(command, desktop, cancel, root, timeout_seconds, progress, task_stop(stop), job) def _supervise_repair(command, desktop, cancel, root, timeout_seconds, progress, stop, job): from .desktop_worker import DesktopWorker worker = DesktopWorker(command, desktop) worker.bind_cancellation(cancel) from .operation_queue import check_active, native_channel, commit_worker_start native = native_channel(inspection_only=job.get('inspection_only') is True) entered = False # Worker admission includes filesystem/ownership checks before the native # timeout begins. Bound that preparation separately; never extend on polls. deadline = time.monotonic()+60+max(1, float(timeout_seconds))+5 event_count = 0 cancelled = False try: if hasattr(worker, 'bind_session'): worker.bind_session(job) check_active() native.__enter__() entered = True commit_worker_start(worker, job) while worker.poll() is None and time.monotonic()