Files
cbb-refresh-verify-795/src/cbb_refresh_verify/native_repair.py
T

349 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:
try:
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)
finally:
worker.close()