347 lines
18 KiB
Python
347 lines
18 KiB
Python
"""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()<deadline:
|
|
if not cancelled and stop is not None and stop.is_set():
|
|
worker.request_stop()
|
|
cancelled = True
|
|
deadline = min(deadline, time.monotonic()+5)
|
|
event_file = root/'repair-events.jsonl'
|
|
if progress and event_file.is_file():
|
|
lines = event_file.read_text('utf-8').splitlines()
|
|
for line in lines[event_count:]:
|
|
try:
|
|
progress(json.loads(line))
|
|
except json.JSONDecodeError:
|
|
break
|
|
event_count += 1
|
|
time.sleep(.2)
|
|
if worker.poll() is not None:
|
|
native.__exit__(None, None, None)
|
|
entered = False
|
|
outcome = root/'repair-result.json'
|
|
if worker.poll() is None or not outcome.is_file():
|
|
worker.request_stop()
|
|
return {'status': 'CANCELLED_UNRELEASED' if cancelled else 'TIMEOUT_UNRELEASED', 'worker_pid': worker.pid, 'desktop': desktop,
|
|
'release': {'safe_to_continue': False},
|
|
'detail': '原生修复尚未确认结束,保留操作并停止批次', 'evidence_path': str(root)}
|
|
result = json.loads(outcome.read_text('utf-8'))
|
|
if cancelled:
|
|
result.update(status='CANCELLED', repair_required=False)
|
|
if worker.returncode != 0 and result.get('status') in ('REPAIRED', 'NOT_IN_USE', 'IN_USE'):
|
|
result['status'] = 'UNCONFIRMED'
|
|
return {**result, 'evidence_path': str(root)}
|
|
except BaseException:
|
|
worker.request_stop()
|
|
raise
|
|
finally:
|
|
if entered:
|
|
native.__exit__(None, None, None)
|
|
if worker.poll() is None and getattr(worker, 'session_record_path', None):
|
|
from .session_record import handoff_session
|
|
from .operation_queue import hold_native_handoff
|
|
handoff_session(worker.session_record_path, evidence_root=root, process=worker)
|
|
hold_native_handoff(worker, worker.session_record_path)
|
|
worker.close()
|