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

302 lines
15 KiB
Python

"""Open the official backup UI; version selection and writes stay native."""
from dataclasses import dataclass
import json
import hashlib
import os
from pathlib import Path
from pathlib import PureWindowsPath
import re
import stat
import subprocess
import sys
import time
from uuid import uuid4
def native_backup_executable(mentor_bin=''):
from .mentor_paths import discover_sdd_home
home = discover_sdd_home(mentor_bin)
executable = home/'iCDB/win32/bin/iCDBProjectBackup.exe' if home else None
if executable is None or not executable.is_file():
raise ValueError('未找到 iCDB Project Backup,请检查 Mentor 安装位置。')
return executable
def native_backup_project(library, block):
from .verify_runner import INVALID_NAME_CHARS
library = Path(library).absolute()
if not block or block in ('.', '..') or any(c in block for c in INVALID_NAME_CHARS):
raise ValueError('CBB 名称非法。')
if not library.is_file():
raise ValueError('中心库文件不存在。')
work = library.parent/'ReusableBlocksLP'/block/'Work'
expected = library.parent.resolve()/'ReusableBlocksLP'/block/'Work'
if work.resolve() != expected:
raise ValueError('工程路径通过链接指向其他位置。')
projects = list(work.glob('*.prj'))
if len(projects) != 1 or not projects[0].is_file():
raise ValueError('无法唯一确定所选 CBB 的工程 PRJ。')
project = projects[0]
if (project.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT
or not project.resolve().is_relative_to(expected)):
raise ValueError('工程文件通过链接指向其他位置。')
return project
def native_backup_target(request, *, mode='versions', target_database=None):
"""Bind the official tool without requiring an openable/healthy PCB."""
from .backup_recovery import _project_text
from .maintenance_entry import maintenance_project_files
if mode not in ('versions', 'repair'):
raise ValueError('NATIVE_TARGET_MODE_INVALID')
project = native_backup_project(request.lmc_file, request.block_name)
candidates = (project,)
if target_database is not None:
pcbs = list((project.parent/'PCB').glob('*.pcb'))
if len(pcbs) != 1:
raise ValueError('NATIVE_TARGET_UNCONFIRMED: 无法唯一绑定 PCB 工程')
candidates = maintenance_project_files(project, pcbs[0])
matches = []
for config in candidates:
values = re.findall(r'^KEY iCDBDir "([^"\r\n]+)"\s*$', _project_text(config), re.M)
if len(values) != 1 or not values[0] or PureWindowsPath(values[0]).root or PureWindowsPath(values[0]).drive:
if config == project or target_database is None:
raise ValueError('NATIVE_TARGET_UNCONFIRMED: 主 PRJ 的 iCDBDir 必须唯一且为工程内相对路径,不支持绝对路径或多条记录')
continue
database = (config.parent/values[0]).resolve()
if not database.is_relative_to(project.parent.resolve()):
raise ValueError('NATIVE_TARGET_UNCONFIRMED: 数据库不在当前工程内')
if target_database is None or database == Path(target_database).resolve():
matches.append((config, database))
if len(matches) != 1:
raise ValueError('NATIVE_TARGET_UNCONFIRMED: 诊断数据库未绑定唯一工程 PRJ')
return matches[0]
@dataclass
class NativeBackupSession:
process: object
job: Path
library: Path
block: str
path_lease: object = None
mode: str = 'versions'
project: Path | None = None
database: Path | None = None
session_record_path: Path | None = None
operation_id: str | None = None
def launch_native_backup(request, *, mode='versions', target_database=None):
from .library_lock import recheck_previous_release
from .session_record import register_worker_session
from .operation_queue import check_active, native_channel, task_stop, commit_worker_start
project, database = native_backup_target(request, mode=mode, target_database=target_database)
native_backup_executable(request.mentor_bin)
root = Path(request.evidence_dir).resolve()/('native-backup-'+uuid4().hex[:12])
library_root = Path(request.lmc_file).resolve().parent
if root.is_relative_to(library_root) or library_root.is_relative_to(root):
raise ValueError('运行记录目录需位于中心库之外。')
root.mkdir(parents=True)
job = root/'request.json'
recheck_previous_release(request.lmc_file, root/'previous-release',
block_name=request.block_name, stop=task_stop(None))
record = {'library': str(request.lmc_file), 'block': request.block_name,
'project': str(project), 'database': str(database), 'mode': mode,
'project_sha256': hashlib.sha256(project.read_bytes()).hexdigest(),
'target_database': str(target_database) if target_database is not None else None,
'mentor_bin': request.mentor_bin, 'automatic_repair': False,
'operation': 'native_backup', 'operation_id': root.name,
'session_record_path': str(root/'session.json'), 'start_gate': str(root/'start-worker.signal'),
'start_gate_protocol': 'event-v1',
'cancel_signal': str(root/'cancel-worker.signal'), 'supervisor_pid': os.getpid(), 'desktop': None}
job.write_text(json.dumps(record, ensure_ascii=False), 'utf-8')
command = ([sys.executable] if getattr(sys, 'frozen', False) else
[sys.executable, '-m', 'cbb_refresh_verify'])+['--native-backup-worker', str(job)]
try:
check_active()
process = subprocess.Popen(command, creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
register_worker_session(process, record)
with native_channel():
check_active()
commit_worker_start(process, record)
except BaseException:
Path(record['cancel_signal']).touch() # The unadmitted child exits without native launch.
raise
return NativeBackupSession(process, job, Path(request.lmc_file), request.block_name,
mode=mode, project=project, database=database, session_record_path=Path(record['session_record_path']),
operation_id=record['operation_id'])
class _BackupJobWriter:
"""Independent Job handle keeps future descendants inside the writer boundary."""
def __init__(self, job):
import win32api, win32con
current = win32api.GetCurrentProcess()
self.job = win32api.DuplicateHandle(current, job, current, 0, False, win32con.DUPLICATE_SAME_ACCESS)
def poll(self):
import win32job
if self.job is None:
return 0
if win32job.QueryInformationJobObject(self.job, win32job.JobObjectBasicProcessIdList):
return None
self.job.Close(); self.job = None
return 0
class _NativeBackupProcess:
"""Track this visible tool and its descendants without killing on close."""
def __init__(self, command, cwd, *, before_resume=None):
import win32con, win32job, win32process
self.job = win32job.CreateJobObject(None, '')
startup = win32process.STARTUPINFO()
try:
self.handle, thread, self.pid, _ = win32process.CreateProcess(
command[0], subprocess.list2cmdline(command), None, None, False,
win32con.CREATE_SUSPENDED, None, str(cwd), startup)
except Exception:
self.job.Close()
raise
try:
win32job.AssignProcessToJobObject(self.job, self.handle)
if before_resume is not None:
before_resume(self)
win32process.ResumeThread(thread)
except Exception:
# No native code has run while suspended; there can be no DB write.
win32process.TerminateProcess(self.handle, 1)
self.handle.Close(); self.job.Close()
raise
finally:
thread.Close()
def poll(self):
import win32process
code = win32process.GetExitCodeProcess(self.handle)
return None if code == 259 else code
def session_pids(self):
import win32job
return win32job.QueryInformationJobObject(self.job, win32job.JobObjectBasicProcessIdList)
def close(self):
self.handle.Close(); self.job.Close()
def run_native_backup_worker(job, *, admission_state=None):
"""Publish admission refusal only when this exact worker never entered native work."""
from .desktop_worker import run_native_worker
from .management import _write_json
from .session_record import IDENTITY_KEYS, process_identity, read_session_record
job = Path(job)
entered = False
request = json.loads(job.read_text('utf-8'))
identity = process_identity(os.getpid())
def registered():
try:
path = Path(request['session_record_path'])
session = read_session_record(path, evidence_root=job.parent)
return (session['operation_id'] == request['operation_id']
and session.get('operation') == 'native_backup'
and session.get('library') == request['library'] and session.get('block') == request['block']
and request.get('project') in session.get('resource_scope', {}).get('projects', ())
and any(all(process.get(key) == identity[key] for key in IDENTITY_KEYS)
for process in session.get('processes', ()) if process.get('role') == 'worker'))
except (OSError, ValueError, KeyError, TypeError):
return False # Unknown registration never establishes a safe terminal result.
def execute(path):
nonlocal entered
if not registered():
raise ValueError('NATIVE_BACKUP_ADMISSION_UNCONFIRMED: 当前工程与工作进程未登记')
entered = True
return native_backup_worker_main(path)
try:
return run_native_worker(execute, job, admission_state=admission_state)
except Exception as error:
bound = registered()
_write_json(job.with_name('result.json'), {'status': 'FAILED', 'detail': str(error),
'operation_id': request.get('operation_id'), 'worker_identity': identity,
'library': request.get('library'), 'block': request.get('block'),
'mode': request.get('mode', 'versions'), 'project': request.get('project'),
'database': request.get('database'), 'worker_entered': entered,
'native_started': None if entered else False,
'safe_to_continue': bound and not entered, 'restore_confirmed': False,
'repair_confirmed': False, 'validation_passed': False, 'automatic_repair': False})
return 1
def native_backup_worker_main(job, *, process_factory=None):
from .library_lock import LibraryLock
from .management import _write_json
job = Path(job)
result = {'status': 'FAILED', 'safe_to_continue': True, 'restore_confirmed': False,
'repair_confirmed': False, 'validation_passed': False, 'automatic_repair': False}
native = None
def write_evidence(name, value):
try:
_write_json(job.with_name(name), value)
except Exception as error:
# Evidence storage must never end supervision of a live transaction.
result['evidence_error'] = str(error)
try:
record = json.loads(job.read_text('utf-8'))
library, block = Path(record['library']), record['block']
result.update(library=str(library), block=block, operation_id=record.get('operation_id'))
from types import SimpleNamespace
mode = record.get('mode', 'versions')
project, database = native_backup_target(SimpleNamespace(lmc_file=library, block_name=block),
mode=mode, target_database=record.get('target_database'))
if project != Path(record['project']):
raise ValueError('工程身份已变化,未打开原生工具。')
if record.get('project_sha256') and hashlib.sha256(project.read_bytes()).hexdigest() != record['project_sha256']:
raise ValueError('工程内容身份已变化,未打开原生工具。')
if record.get('database') and database != Path(record['database']):
raise ValueError('数据库身份已变化,未打开原生工具。')
result.update(mode=mode, project=str(project), database=str(database),
session_record_path=record.get('session_record_path'))
executable = native_backup_executable(record.get('mentor_bin', ''))
released = True
with LibraryLock(library, checkpoint=bool(record.get('session_record_path')),
block_name=block, safe_to_release=lambda: released):
from .maintenance_entry import _assert_native_idle_for
_assert_native_idle_for(SimpleNamespace(project=project, database=database, library=library))
def admitted(process):
from .session_record import update_worker_state
from .desktop_worker import register_native_writer
if record.get('session_record_path'):
update_worker_state(record, 'NATIVE_CALL', identities=(('native', process.pid),), required=True)
register_native_writer(_BackupJobWriter(process.job))
command = [str(executable), '-p', str(project)] # User alone invokes Repair in the official UI.
native = (process_factory(command, project.parent) if process_factory else
_NativeBackupProcess(command, project.parent, before_resume=admitted))
released = False
result.update(status='OPEN', native_pid=native.pid, project=str(project), safe_to_continue=False)
write_evidence('state.json', result)
waiting = False
while True:
try:
pids, exit_code = native.session_pids(), native.poll()
except Exception as error:
write_evidence('state.json', {**result,
'status': 'RELEASE_UNCONFIRMED', 'detail': str(error)})
time.sleep(.5)
continue # Keep the lease while the live session cannot be observed.
if not pids and exit_code is not None:
break
if exit_code is not None and not waiting:
waiting = True
write_evidence('state.json', {**result, 'status': 'WAITING_RELEASE'})
time.sleep(.25)
released = True
result.update(status='CLOSED', native_exit_code=exit_code, safe_to_continue=True)
result['release'] = {'native_exited': True, 'remaining_pids': [], 'safe_to_continue': True}
return 0 if result['native_exit_code'] == 0 else 1
except Exception as error:
result.update(status='FAILED', detail=str(error), safe_to_continue=native is None)
return 1
finally:
write_evidence('result.json', result)
if native is not None:
native.close() # No kill-on-close: never interrupt a native transaction.