316 lines
16 KiB
Python
316 lines
16 KiB
Python
"""Restore a complete same-CBB Work backup, then reopen through native Verify.
|
|
|
|
This restores project data for an existing library entry. It is not a native
|
|
cross-library import and does not delete library records or shared symbols.
|
|
"""
|
|
from contextlib import ExitStack
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from dataclasses import asdict, replace
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import shutil
|
|
import stat
|
|
from uuid import uuid4
|
|
|
|
from .verify_runner import VerifyResult, preflight
|
|
|
|
|
|
def _hash(path):
|
|
digest = hashlib.sha256()
|
|
with path.open('rb') as stream:
|
|
for data in iter(lambda: stream.read(1024 * 1024), b''):
|
|
digest.update(data)
|
|
return digest.hexdigest()
|
|
|
|
|
|
def _scan(root):
|
|
if root.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
|
|
raise ValueError(f'不支持通过目录链接恢复:{root}')
|
|
entries = {}
|
|
folders = [root]
|
|
while folders:
|
|
with os.scandir(folders.pop()) as scanned:
|
|
for entry in scanned:
|
|
metadata = entry.stat(follow_symlinks=False)
|
|
if metadata.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT:
|
|
raise ValueError(f'目录含文件或目录链接,停止恢复:{entry.path}')
|
|
path = Path(entry.path)
|
|
entries[path] = metadata
|
|
if stat.S_ISDIR(metadata.st_mode):
|
|
folders.append(path)
|
|
return dict(sorted(entries.items()))
|
|
|
|
|
|
def _paths(root):
|
|
return list(_scan(root))
|
|
|
|
|
|
def _manifest(root, *, exclude=None):
|
|
entries = _scan(root)
|
|
paths = [path for path in entries
|
|
if exclude is None or not path.is_relative_to(exclude)]
|
|
def entry(path):
|
|
return str(path.relative_to(root)), _hash(path) if stat.S_ISREG(entries[path].st_mode) else None
|
|
with ThreadPoolExecutor(max_workers=8) as pool:
|
|
return dict(pool.map(entry, paths))
|
|
|
|
|
|
def _copy_verified(source, destination, *, progress=None):
|
|
"""Copy every file, refusing links and changed files; lock native databases."""
|
|
import win32con, win32file
|
|
entries = _scan(source)
|
|
paths = list(entries)
|
|
destination.mkdir(parents=True, exist_ok=False)
|
|
record = {}
|
|
with ExitStack() as stack:
|
|
locks = {}
|
|
for path in paths:
|
|
if stat.S_ISREG(entries[path].st_mode) and (path.name.casefold() == 'icdb.dat' or path.suffix.casefold() == '.lmc'):
|
|
handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None,
|
|
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
|
|
stack.callback(handle.Close)
|
|
locks[path] = handle
|
|
files = []
|
|
for path in paths:
|
|
relative = str(path.relative_to(source))
|
|
copied = destination / relative
|
|
if stat.S_ISDIR(entries[path].st_mode):
|
|
copied.mkdir(parents=True, exist_ok=True)
|
|
record[relative] = None
|
|
continue
|
|
files.append(path)
|
|
def copy_file(path):
|
|
relative = str(path.relative_to(source))
|
|
copied = destination / relative
|
|
before = entries[path]
|
|
copied.parent.mkdir(parents=True, exist_ok=True)
|
|
if path in locks:
|
|
with copied.open('wb') as stream:
|
|
while True:
|
|
_, data = win32file.ReadFile(locks[path], 1024 * 1024)
|
|
if not data:
|
|
break
|
|
stream.write(data)
|
|
shutil.copystat(path, copied)
|
|
digest = _hash(copied)
|
|
else:
|
|
digest = _hash(path)
|
|
shutil.copy2(path, copied)
|
|
if _hash(copied) != digest:
|
|
raise OSError(f'副本校验失败:{path}')
|
|
after = path.stat()
|
|
if (before.st_size, before.st_mtime_ns) != (after.st_size, after.st_mtime_ns):
|
|
raise OSError(f'复制期间文件变化:{path}')
|
|
return relative, digest
|
|
with ThreadPoolExecutor(max_workers=8) as pool:
|
|
for count, (relative, digest) in enumerate(pool.map(copy_file, files), 1):
|
|
record[relative] = digest
|
|
if progress and (count % 256 == 0 or count == len(files)):
|
|
progress(count, len(files))
|
|
if _manifest(source) != record:
|
|
raise OSError(f'复制期间目录内容变化:{source}')
|
|
return record
|
|
|
|
|
|
def _idle_check(library, project, pcb):
|
|
from .mentor_adapter import pcb_processes, _process_details
|
|
from .icdb_ownership import unreleased_addresses
|
|
if pcb_processes() or any(_process_details(name) for name in (
|
|
'LibraryManager.exe', 'viewdraw.exe')):
|
|
raise ValueError('请先正常关闭 PCB、Library Manager 和原理图编辑器,再恢复备份。')
|
|
addresses = unreleased_addresses(library, project, pcb)
|
|
if addresses:
|
|
raise ValueError(f'数据库会话尚未释放,停止恢复:{addresses}')
|
|
|
|
|
|
def _project_text(path):
|
|
data = path.read_bytes()
|
|
if data.startswith((b'\xff\xfe', b'\xfe\xff')):
|
|
return data.decode('utf-16')
|
|
try:
|
|
return data.decode('utf-8-sig')
|
|
except UnicodeDecodeError:
|
|
return data.decode('mbcs')
|
|
|
|
|
|
def _source_check(source, name, original):
|
|
if not source.is_file() or source.suffix.casefold() != '.prj':
|
|
raise ValueError('请选择完整健康备份中的工程 .prj。')
|
|
_paths(source.parent)
|
|
text = _project_text(source)
|
|
roots = re.findall(r'^KEY RootBlock "([^"]+)"', text, re.M)
|
|
if (source.name.casefold() != original.name.casefold() or not roots
|
|
or any(root.casefold() != name.casefold() for root in roots)):
|
|
raise ValueError('当前仅支持同名 CBB 的完整工程备份,工程名和顶层块必须与目标一致。')
|
|
refs = re.findall(r'^KEY PCBDesignPath "([^"]+)"', text, re.M)
|
|
if len(refs) != 1:
|
|
raise ValueError('备份工程必须包含唯一的 PCBDesignPath。')
|
|
def require_relative(value):
|
|
if Path(value).drive or Path(value).root:
|
|
raise ValueError('备份工程、PCB 和数据库必须使用工程内的相对路径,不能指向原备份位置。')
|
|
require_relative(refs[0])
|
|
pcb = (source.parent / refs[0]).resolve()
|
|
if not pcb.is_relative_to(source.parent.resolve()):
|
|
raise ValueError('备份 PCB 引用越出工程目录。')
|
|
if not all(path.is_file() for path in (pcb, pcb.parent/'Layout/LayoutDB.lyt',
|
|
pcb.parent/'pcb.prj', source.parent/'database/icdb.dat')):
|
|
raise ValueError('备份不完整:需要原理图数据库、PCB、布局数据库和 PCB 工程文件。')
|
|
project_refs = re.findall(r'^KEY ProjectFile "([^"]+)"', _project_text(pcb), re.M)
|
|
for value in project_refs:
|
|
require_relative(value)
|
|
if len(project_refs) != 1 or (pcb.parent/project_refs[0]).resolve() != source.resolve():
|
|
raise ValueError('备份 PCB 必须引用所选工程,不能引用其他位置的工程。')
|
|
for project in (source, pcb.parent/'pcb.prj'):
|
|
data = _project_text(project)
|
|
for value in re.findall(r'^KEY iCDBDir "([^"]+)"', data, re.M):
|
|
require_relative(value)
|
|
if not (project.parent/value).resolve().is_relative_to(source.parent.resolve()):
|
|
raise ValueError('备份数据库引用越出工程目录。')
|
|
return pcb
|
|
|
|
|
|
def _align_library(project, pcb, library):
|
|
from .mentor_adapter import ensure_project_central_library, ensure_pcb_central_library
|
|
for path in (project, pcb.parent/'pcb.prj'):
|
|
if not re.findall(r'^KEY CentralLibrary "([^"]*)"', _project_text(path), re.M):
|
|
raise ValueError('备份工程缺少 CentralLibrary 引用。')
|
|
def already_references(path):
|
|
return all((path.parent/value).resolve() == Path(library).resolve()
|
|
for value in re.findall(r'^KEY CentralLibrary "([^"]*)"', _project_text(path), re.M))
|
|
if not already_references(project):
|
|
ensure_project_central_library(project, library)
|
|
if not already_references(pcb.parent/'pcb.prj'):
|
|
ensure_pcb_central_library(pcb, library)
|
|
|
|
|
|
def recover_from_backup(request, source, *, progress=None, verifier=None, idle_check=None):
|
|
"""Validate in copies before changing Work; preserve all recovery evidence."""
|
|
import pythoncom, win32con, win32event
|
|
from .network_path import absolute_preserving_drive
|
|
from .verify_runner import run_verify, read_library_flag_if_available
|
|
verifier = verifier or run_verify
|
|
idle_check = idle_check or _idle_check
|
|
source = Path(source).resolve()
|
|
library = absolute_preserving_drive(request.lmc_file)
|
|
library_root = library.parent.resolve()
|
|
root = Path(request.evidence_dir).resolve() / ('backup-restore-' + uuid4().hex[:12])
|
|
# Packaged desktop apps can redirect AppData to a very deep MSIX path.
|
|
# Keep native EE7.9 files in a genuinely short, user-owned directory.
|
|
validation_base = Path.home() / '.cbb-restore'
|
|
validation_dir = validation_base.resolve() / root.name.removeprefix('backup-restore-')
|
|
if root.is_relative_to(library_root) or library_root.is_relative_to(root):
|
|
return VerifyResult('BLOCKED', stderr='恢复记录目录与目标中心库不能相互包含。')
|
|
if root.is_relative_to(source.parent):
|
|
return VerifyResult('BLOCKED', stderr='恢复记录目录不能位于备份工程内。')
|
|
if validation_dir.is_relative_to(library_root) or validation_dir.is_relative_to(source.parent):
|
|
return VerifyResult('BLOCKED', stderr='本机验证目录不能位于目标库或备份工程内。')
|
|
mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795')
|
|
acquired = False
|
|
installed = False
|
|
record = {'operation': 'same_cbb_complete_project_restore', 'source': str(source),
|
|
'library': str(library), 'block': request.block_name, 'installed': False,
|
|
'validation_library': str(validation_dir/library.name)}
|
|
def emit(stage, message):
|
|
if progress:
|
|
progress({'stage': stage, 'block': request.block_name, 'message': message})
|
|
def save(result):
|
|
record.update({'installed': installed, 'result': asdict(result)})
|
|
root.mkdir(parents=True, exist_ok=True)
|
|
report = root/'recovery-result.json'
|
|
report.write_text(json.dumps(record, ensure_ascii=False, default=str, indent=2), encoding='utf-8')
|
|
return replace(result, evidence_path=report)
|
|
pythoncom.CoInitialize()
|
|
try:
|
|
acquired = win32event.WaitForSingleObject(mutex, 0) in (
|
|
win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED)
|
|
if not acquired:
|
|
return VerifyResult('BLOCKED', stderr='已有 CBB 任务运行,请等待结束。', safe_to_continue=False)
|
|
if source.is_relative_to(library_root):
|
|
raise ValueError('请选择目标中心库之外的独立备份工程。')
|
|
project, pcb = preflight(replace(request, lmc_file=library))
|
|
source_pcb = _source_check(source, request.block_name, project)
|
|
idle_check(library, project, pcb)
|
|
idle_check(library, source, source_pcb)
|
|
root.mkdir(parents=True, exist_ok=False)
|
|
validation_base.mkdir(parents=True, exist_ok=True)
|
|
library_size = sum(info.st_size for info in _scan(library_root).values() if stat.S_ISREG(info.st_mode))
|
|
source_size = sum(info.st_size for info in _scan(source.parent).values() if stat.S_ISREG(info.st_mode))
|
|
same_drive = root.anchor.casefold() == validation_dir.anchor.casefold()
|
|
required = library_size * (2 if same_drive else 1) + source_size * 3
|
|
if (shutil.disk_usage(root).free < required
|
|
or shutil.disk_usage(validation_base).free < library_size + source_size * 2):
|
|
raise ValueError('磁盘空间不足:需要容纳中心库回退副本和验证副本。')
|
|
(root/'recovery-request.json').write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8')
|
|
emit('backup', '正在保留完整中心库副本…')
|
|
original_manifest = _copy_verified(library_root, root/'library-before', progress=lambda n, total:
|
|
emit('backup', f'正在保留中心库副本:{n} / {total} 个文件…'))
|
|
(root/'library-before-manifest.json').write_text(json.dumps(original_manifest, indent=2), encoding='utf-8')
|
|
emit('prepare_source', '正在准备备份验证副本…')
|
|
source_manifest = _copy_verified(source.parent, root/'source-before')
|
|
_copy_verified(root/'library-before', validation_dir, progress=lambda n, total:
|
|
emit('prepare_source', f'正在准备验证库:{n} / {total} 个文件…'))
|
|
staged_library = validation_dir/library.name
|
|
staged_work = staged_library.parent/'ReusableBlocksLP'/request.block_name/'Work'
|
|
# Both paths are newly created private copies; originals are retained.
|
|
resolved_work = staged_work.resolve()
|
|
if not resolved_work.is_relative_to(validation_dir.resolve()):
|
|
raise ValueError('验证副本工程路径越界。')
|
|
shutil.rmtree(resolved_work)
|
|
_copy_verified(root/'source-before', staged_work)
|
|
staged_project = staged_work/source.name
|
|
staged_pcb = staged_work/source_pcb.relative_to(source.parent)
|
|
_align_library(staged_project, staged_pcb, staged_library)
|
|
_source_check(staged_project, request.block_name, project)
|
|
validation = replace(request, lmc_file=staged_library, evidence_dir=root/'source-verify',
|
|
auto_repair=False, libspec='', dms_login_config='', mapped_drive='', mapped_remote_root='',
|
|
native_lm_verify=False, interactive_input=False)
|
|
preflight(validation)
|
|
emit('validate_source', '正在副本中打开备份工程并执行原生校验…')
|
|
source_result = verifier(validation, progress=progress, flag_reader=read_library_flag_if_available)
|
|
record['source_validation'] = asdict(source_result)
|
|
if (source_result.status != 'PASS' or source_result.library_flag != 'GREEN'
|
|
or not source_result.safe_to_continue):
|
|
return save(replace(source_result, status='FAIL', stderr=
|
|
'备份校验未通过,目标未更改。\n' + (source_result.stderr or source_result.library_flag_detail)))
|
|
idle_check(library, project, pcb)
|
|
idle_check(staged_library, staged_project, staged_pcb)
|
|
if _manifest(source.parent) != source_manifest:
|
|
raise ValueError('备份来源在验证期间发生变化,目标未更改。')
|
|
token = root.name.removeprefix('backup-restore-')
|
|
work = project.parent.resolve()
|
|
incoming = work.with_name('Work.restore-' + token)
|
|
retained = work.with_name('Work.before-restore-' + token)
|
|
_copy_verified(staged_work, incoming)
|
|
_align_library(incoming/source.name, incoming/source_pcb.relative_to(source.parent), library)
|
|
if _manifest(library_root, exclude=incoming.resolve()) != original_manifest:
|
|
raise ValueError('目标中心库在验证期间发生变化,停止恢复。')
|
|
emit('install', '备份已通过验证,正在保留原工程并恢复…')
|
|
work.rename(retained)
|
|
try:
|
|
incoming.rename(work)
|
|
except Exception:
|
|
retained.rename(work)
|
|
raise
|
|
installed = True
|
|
record['retained_work'] = str(retained)
|
|
emit('verify_target', '正在重新打开恢复后的目标工程并校验…')
|
|
final = verifier(replace(request, lmc_file=library, evidence_dir=root/'target-verify',
|
|
auto_repair=False, native_lm_verify=False, interactive_input=False),
|
|
progress=progress, flag_reader=read_library_flag_if_available)
|
|
if final.status == 'PASS' and (final.library_flag != 'GREEN' or not final.safe_to_continue):
|
|
final = replace(final, status='FAIL', stderr='目标工程恢复后的 Ready 状态未确认。')
|
|
if final.status != 'PASS':
|
|
final = replace(final, stderr=(final.stderr + '\n原工程和完整库副本已保留,请查看恢复记录。').strip())
|
|
return save(final)
|
|
except Exception as error:
|
|
return save(VerifyResult('FAIL' if installed else 'BLOCKED', stderr=str(error),
|
|
safe_to_continue=False))
|
|
finally:
|
|
if acquired:
|
|
win32event.ReleaseMutex(mutex)
|
|
mutex.Close()
|
|
pythoncom.CoUninitialize()
|