"""Uploader-compatible exclusive sidecar lease. Metadata never proves ownership.""" from datetime import datetime, timezone from contextlib import contextmanager, ExitStack import json import re import os from pathlib import Path import socket import threading from uuid import uuid4 _guard = threading.RLock() _owners = {} class LibraryBusy(OSError): pass def inspect_residual_sessions(library, *, block_names=()): from .residual_sessions import inspect_residual_sessions as inspect return inspect(library, block_names=block_names) def release_residual_sessions(plan, evidence_dir, *, stop=None, force=False): from .residual_sessions import release_residual_sessions as release return release(plan, evidence_dir, stop=stop, force=force) def _key(path): return str(Path(path).resolve()).casefold() def blocker_path(library): library = Path(library).resolve() return library.with_name('.' + library.stem + '.cbb-upload.blocked.json') def checkpoint_record(path): """Recognize only our reserved filename and complete versioned protocol.""" path = Path(path) if not (path.name.endswith('.cbb-upload.blocked.json') or path.name.endswith('.cbb-upload.blocked.pending')): return None try: import stat if path.lstat().st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT: return None record = json.loads(path.read_text(encoding='utf-8')) library = Path(record['library']) expected = '.' + library.stem + '.cbb-upload.blocked' if (record.get('protocol') != 'cbb-refresh-verify-library-lease' or record.get('version') != 1 or not library.is_absolute() or library.suffix.casefold() != '.lmc' or path.name not in (expected+'.json', expected+'.pending') or not re.fullmatch('[0-9a-f]{32}', str(record.get('lease_id', ''))) or not isinstance(record.get('pid'), int) or record['pid'] <= 0 or record.get('status') not in ('OPERATION_IN_PROGRESS', 'OWNER_RELEASE_UNCONFIRMED') or not isinstance(record.get('time'), str)): return None return record except (OSError, ValueError, TypeError, KeyError): return None def has_blocker(library): path = blocker_path(library) # Complete snapshots retain every file, including their source lease # checkpoint. Only a valid relocated snapshot record can be ignored. for marker in (path, path.with_suffix('.pending')): if marker.exists(): record = checkpoint_record(marker) if record is None or _key(record['library']) == _key(library): return True return False def has_retained_library(library): """Include leases retained without a JSON checkpoint, such as PCB checks.""" path = Path(library).resolve() key = _key(path.with_name('.' + path.stem + '.cbb-upload.lock')) with _guard: owner = _owners.get(key) return bool(owner and owner['retained']) def recheck_previous_release(library, evidence_dir, *, block_name=None, required=False, progress=None): """Historical records trigger fresh proof, never process termination or repair.""" if not required: with _guard: owner = _owners.get(LibraryLock(library).key) marker = blocker_path(library) record = checkpoint_record(marker) if (owner and owner['thread'] == threading.get_ident() and owner['depth'] > 0 and not owner['retained'] and not marker.with_suffix('.pending').exists() and record and record['lease_id'] == owner['lease_id'] and record['pid'] == os.getpid() and record['status'] == 'OPERATION_IN_PROGRESS' and record.get('block_name') == owner.get('block_name') and owner.get('block_name') in (None, block_name) and 'export_analysis' not in record): return None # Nested Verify belongs to this live transaction, not a past crash. if not (required or has_blocker(library) or has_retained_library(library)): return None def notify(stage, **details): if progress is not None: try: progress({'stage': stage, 'block': block_name or '', **details}) except Exception: import logging logging.getLogger(__name__).warning('Release progress observer failed', exc_info=True) notify('previous_release_check', detail='正在复核历史记录对应的实际占用') try: proof = release_retained_library(library, evidence_dir, block_name=block_name) except Exception as error: notify('previous_release_unconfirmed', detail=str(error)) raise notify('previous_release_confirmed', release_proof=proof, detail='已确认会话释放并归档历史记录;这不表示历史数据已恢复') return proof def _persist_blocker(library, status='OWNER_RELEASE_UNCONFIRMED', *, lease_id, block_name=None): import win32api, win32process path = blocker_path(library) pending = path.with_suffix('.pending') previous = checkpoint_record(path) export_record = ({'export_analysis': previous['export_analysis']} if previous and previous['lease_id'] == lease_id and 'export_analysis' in previous else {}) if block_name is not None: export_record['block_name'] = block_name elif previous and previous['lease_id'] == lease_id and 'block_name' in previous: export_record['block_name'] = previous['block_name'] with pending.open('w', encoding='utf-8') as stream: json.dump({**export_record, 'protocol': 'cbb-refresh-verify-library-lease', 'version': 1, 'lease_id': lease_id, 'library': str(library), 'status': status, 'machine': socket.gethostname(), 'supervisor_created': win32process.GetProcessTimes(win32api.GetCurrentProcess())['CreationTime'].isoformat(), 'pid': os.getpid(), 'time': datetime.now(timezone.utc).isoformat()}, stream) stream.flush(); os.fsync(stream.fileno()) pending.replace(path) class LibraryLock: def __init__(self, library, *, safe_to_release=None, checkpoint=True, block_name=None): library = Path(library).resolve() self.library = library self.path = library.with_name('.' + library.stem + '.cbb-upload.lock') self.key = _key(self.path) self.entered = False self.safe_to_release = safe_to_release self.checkpoint = checkpoint self.block_name = block_name self.maintenance_guard = None self.maintenance_mutex = None @classmethod def for_maintenance(cls, library, archive, guard, *, safe_to_release=None): lease = cls(library, safe_to_release=safe_to_release) lease.maintenance_guard = guard lease.maintenance_archive = Path(archive) return lease def __enter__(self): with _guard: owner = _owners.get(self.key) if owner and owner['retained'] and owner['depth'] == 0 and owner.get('release_probe'): try: released = owner['release_probe']() is True except Exception: released = False if released: if owner.get('checkpoint', True): marker = blocker_path(self.library) record = checkpoint_record(marker) if (record is None or record['lease_id'] != owner['lease_id'] or 'export_analysis' in record or marker.with_suffix('.pending').exists()): raise LibraryBusy('协调检查点身份或导出会话尚未确认,保持库锁。') marker.unlink() owner['handle'].Close() del _owners[self.key] owner = None if self.maintenance_guard is not None: return _enter_maintenance(self) import win32con, win32file with _guard: owner = _owners.get(self.key) if owner: if owner['thread'] != threading.get_ident() or owner['retained']: raise LibraryBusy(f'中心库被其他任务占用:{self.path}') owner['depth'] += 1 else: if self.checkpoint and has_blocker(self.library): raise LibraryBusy(f'中心库存在未解除的会话阻止记录,请先执行释放检查:{blocker_path(self.library)}') try: lease_id = uuid4().hex handle = win32file.CreateFile(str(self.path), win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None, win32con.OPEN_ALWAYS, win32con.FILE_ATTRIBUTE_NORMAL, None) except Exception as error: if getattr(error, 'winerror', None) not in (32, 33): raise raise LibraryBusy(f'中心库已锁定或无法创建协调锁:{self.path}: {error}') from error try: data = (f'machine={socket.gethostname()}; pid={os.getpid()}; ' f'startedUtc={datetime.now(timezone.utc).isoformat()}; ' f'library={self.library}').encode('utf-8') win32file.SetFilePointer(handle, 0, win32con.FILE_BEGIN) win32file.SetEndOfFile(handle) win32file.WriteFile(handle, data) win32file.FlushFileBuffers(handle) # Closing flushes the last-write timestamp on Windows. Set # it explicitly before complete-copy metadata is captured. import pywintypes win32file.SetFileTime(handle, None, None, pywintypes.Time(datetime.now())) if self.checkpoint: _persist_blocker(self.library, 'OPERATION_IN_PROGRESS', lease_id=lease_id, block_name=self.block_name) except Exception: handle.Close() raise _owners[self.key] = {'thread': threading.get_ident(), 'depth': 1, 'handle': handle, 'retained': False, 'lease_id': lease_id, 'checkpoint': self.checkpoint, 'block_name': self.block_name, 'release_probe': self.safe_to_release} self.entered = True return self def snapshot_bytes(self): data = owned_snapshot(self.path) if data is None: raise LibraryBusy('当前线程不拥有此库协调锁') return data def retain(self): with _guard: if self.entered: _owners[self.key]['retained'] = True def __exit__(self, *_): try: self._exit_owned() finally: if self.maintenance_mutex is not None: import win32event win32event.ReleaseMutex(self.maintenance_mutex) self.maintenance_mutex.Close() self.maintenance_mutex = None def _exit_owned(self): with _guard: if not self.entered: return owner = _owners[self.key] if not owner.get('checkpoint', True): if self.safe_to_release is not None: try: released = self.safe_to_release() is True except Exception: released = False if not released: owner['retained'] = True owner['depth'] -= 1 self.entered = False if owner['depth'] == 0 and not owner['retained']: owner['handle'].Close() del _owners[self.key] return checkpoint = checkpoint_record(blocker_path(self.library)) if checkpoint is not None and 'export_analysis' in checkpoint: owner['retained'] = True if self.safe_to_release is not None: try: safe = self.safe_to_release() is True except Exception: safe = False if not safe: # A supervisor can time out while its native child still # owns the DB. Keep excluding the uploader until app exit. owner['retained'] = True owner['depth'] -= 1 self.entered = False if owner['depth'] == 0 and not owner['retained']: # This JSON is our durable operation checkpoint, not the # uploader's .lock file. Clear only after proven normal release. marker = blocker_path(self.library) record = checkpoint_record(marker) if marker.exists() and (record is None or record['lease_id'] != owner['lease_id']): owner['retained'] = True raise LibraryBusy('协调检查点被替换或损坏,保留冲突文件及库锁。') try: marker.unlink(missing_ok=True) except OSError: owner['retained'] = True raise owner['handle'].Close() del _owners[self.key] elif owner['retained']: marker = blocker_path(self.library) record = checkpoint_record(marker) if marker.exists() and (record is None or record['lease_id'] != owner['lease_id']): raise LibraryBusy('协调检查点被替换或损坏,保留冲突文件及库锁。') _persist_blocker(self.library, lease_id=owner['lease_id']) def _supervisor_alive(pid): import pywintypes, win32api, win32con, win32event try: handle = win32api.OpenProcess(win32con.SYNCHRONIZE, False, int(pid)) except pywintypes.error as error: if error.winerror == 87: return False raise LibraryBusy('无法确认原监督进程退出') from error try: return win32event.WaitForSingleObject(handle, 0) != win32con.WAIT_OBJECT_0 finally: handle.Close() def _recorded_supervisor_alive(record): """None means legacy/unknown identity; the native/file guard still applies.""" if record.get('machine') != socket.gethostname() or not record.get('supervisor_created'): return None import pywintypes, win32api, win32con, win32process try: handle = win32api.OpenProcess(win32con.SYNCHRONIZE | 0x1000, False, record['pid']) except pywintypes.error as error: return False if error.winerror == 87 else None try: return (win32process.GetProcessTimes(handle)['CreationTime'].isoformat() == record['supervisor_created'] and _supervisor_alive(record['pid'])) finally: handle.Close() def _owner_matches_scope(item, library, roots): """False requires an explicit other project; a missing path stays unknown.""" import ntpath from .failed_session import _command_args command = str(item.get('command') or '') if not command: return None try: args = _command_args(command) except (OSError, ValueError): return None candidates = [] worker_flags = {'--verify-worker', '--repair-worker', '--management-worker', '--native-backup-worker'} for index, arg in enumerate(args[1:], 1): if arg.casefold() in worker_flags and index + 1 < len(args): try: request = Path(args[index + 1]) if request.stat().st_size > 1024 * 1024: return None record = json.loads(request.read_text(encoding='utf-8')) for key in ('library', 'lmc_file', 'project', 'database'): if isinstance(record.get(key), str): candidates.append(record[key]) except (OSError, ValueError, TypeError, AttributeError): return None value = arg.split('=', 1)[1] if arg.startswith('-') and '=' in arg else arg if (ntpath.isabs(value) and (ntpath.splitext(value)[1].casefold() in ('.prj', '.pcb', '.lmc') or arg.casefold().startswith(('-project=', '-icdb=')) or args[index - 1].casefold() in ('-icdb', '-project', '-p'))): candidates.append(value) normalized_roots = [ntpath.normcase(ntpath.normpath(str(root))) for root in roots] expected_library = ntpath.normcase(ntpath.normpath(str(library))) for candidate in candidates: path = ntpath.normcase(ntpath.normpath(candidate)) if path == expected_library: return True for root in normalized_roots: try: if ntpath.commonpath((path, root)) == root: return True except ValueError: pass return False if candidates else None def _owner_is_blocking(item, library, roots): """Unknown external clients need resource proof, not a global exit rule.""" scope = _owner_matches_scope(item, library, roots) if scope is not None: return scope command = str(item.get('command') or '').casefold() flags = ('--verify-worker', '--repair-worker', '--management-worker', '--native-backup-worker') if any(flag in command for flag in flags): return True # An unreadable in-flight request is not proof of another library. from .failed_session import _command_args try: return any(Path(arg).name.casefold() in ('close_failed_block.vbs', 'save_verified_block.vbs') for arg in _command_args(command)[1:]) except (OSError, ValueError): return False def _enter_maintenance(lease): """Transfer only a valid known lease, after project admission under lock.""" import win32con, win32event, win32file mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795') acquired = False handle = None existing = None try: acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED) if not acquired: raise LibraryBusy('已有 CBB 操作运行,维护不能接续') with _guard: marker = blocker_path(lease.library) if marker.with_suffix('.pending').exists(): raise LibraryBusy('未完成检查点写入,不能自动接续') old = marker.read_bytes() if marker.exists() else None record = checkpoint_record(marker) if old is not None else None if old is not None and (record is None or _key(record['library']) != _key(lease.library)): raise LibraryBusy('维护拒绝未知、损坏或其他库的检查点') existing = _owners.get(lease.key) if existing: if (not existing['retained'] or existing['depth'] != 0 or record is None or record['pid'] != os.getpid() or record['lease_id'] != existing['lease_id']): raise LibraryBusy('本进程库锁仍在使用或检查点身份不符') handle = existing['handle'] else: if record is not None and record['pid'] != os.getpid() and _recorded_supervisor_alive(record) is True: raise LibraryBusy('原监督进程仍存在,不能接续其库锁') handle = win32file.CreateFile(str(lease.path), win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None, win32con.OPEN_ALWAYS, win32con.FILE_ATTRIBUTE_NORMAL, None) # All target/process/address/exclusive-file checks finish BEFORE # any old checkpoint replacement. Keep the exact sidecar open. from .native_export_guard import prove_export_copies_released if record is not None and _recorded_supervisor_alive(record) is None: from .maintenance_entry import assert_native_idle assert_native_idle() with prove_export_copies_released(lease.library), lease.maintenance_guard() as proof: if (marker.read_bytes() if marker.exists() else None) != old: raise LibraryBusy('维护检查期间检查点变化') if old is not None: lease.maintenance_archive.mkdir(parents=True, exist_ok=False) saved = lease.maintenance_archive/'previous-checkpoint.json' with saved.open('xb') as stream: stream.write(old); stream.flush(); os.fsync(stream.fileno()) if saved.read_bytes() != old: raise OSError('原检查点归档校验失败') lease_id = uuid4().hex _persist_blocker(lease.library, 'OPERATION_IN_PROGRESS', lease_id=lease_id) _owners[lease.key] = {'thread': threading.get_ident(), 'depth': 1, 'handle': handle, 'retained': False, 'lease_id': lease_id, 'checkpoint': True, 'release_probe': lease.safe_to_release, 'block_name': None} lease.maintenance_proof = proof lease.entered = True lease.maintenance_mutex = mutex return lease except Exception: if handle is not None and existing is None: handle.Close() if acquired: win32event.ReleaseMutex(mutex) mutex.Close() raise def owned_snapshot(path): """Read only a lease held by this thread, never reopen an exclusive file.""" import win32con, win32file with _guard: owner = _owners.get(_key(path)) if not owner or owner['thread'] != threading.get_ident() or owner['retained']: return None handle = owner['handle'] position = win32file.SetFilePointer(handle, 0, win32con.FILE_CURRENT) try: win32file.SetFilePointer(handle, 0, win32con.FILE_BEGIN) size = win32file.GetFileSize(handle) return win32file.ReadFile(handle, size)[1] if size else b'' finally: win32file.SetFilePointer(handle, position, win32con.FILE_BEGIN) @contextmanager def _prove_library_released(library, block_name=None, *, allow_unknown_checkpoint=False): """Hold all native database read handles during explicit lease release.""" import stat import win32con, win32file from .owner_probe import query_owners from .scoped_manifest import scan_tree from .native_management import _retained_workers from .native_export_guard import assert_retained_exports_idle, prove_export_copies_released from .native_engineering_identity import _OWNER_NAMES library = Path(library).resolve() assert_retained_exports_idle(library) if any(worker.poll() is None and (allow_unknown_checkpoint or not getattr(worker, 'cbb_library', None) or _key(worker.cbb_library) == _key(library)) for worker in _retained_workers): raise LibraryBusy('原生管理工作进程尚未返回,不能解除协调阻止。') from .com_runtime import initialize_com, uninitialize_com initialized = initialize_com() try: names = ('LibraryManager.exe', 'ExpeditionPCB.exe', 'viewdraw.exe', 'iCDBProjectBackup.exe', 'ReuseBlockImporter.exe', 'CleanWGLib.exe', 'cscript.exe', 'wscript.exe', 'python.exe', 'pythonw.exe', 'CbbRefreshVerify.exe', *sorted(_OWNER_NAMES)) scope_root = (Path(library).resolve().parent/'ReusableBlocksLP'/block_name/'Work').resolve() if block_name else None shared_root = Path(library).resolve().parent/'SymbolLibs' if allow_unknown_checkpoint and scope_root is not None: raise LibraryBusy('未知检查点必须执行完整库释放证明。') observed = [] def check_owners(): owners = [] observed.clear() from .session_record import active_write_records if active_write_records(library): raise LibraryBusy('本库原生调用或助手尚未确认返回,请等待当前操作结束。') for item in query_owners(names): if item['pid'] == os.getpid(): continue if not allow_unknown_checkpoint: roots = (scope_root, shared_root) if scope_root is not None else (Path(library).parent,) if not _owner_is_blocking(item, library, roots): if _owner_matches_scope(item, library, roots) is None: observed.append(item) continue automation = item['name'].casefold() in ('python.exe', 'pythonw.exe', 'cbbrefreshverify.exe') command = item['command'].casefold() if not automation or not command or any(flag in command for flag in ( '--verify-worker', '--repair-worker', '--management-worker', '--native-backup-worker')): owners.append(item) if owners: raise LibraryBusy(f'原生进程仍存在,不能解除协调阻止:{owners}') return owners check_owners() if scope_root is None: entries = scan_tree(Path(library).parent) else: entries = {Path(library): Path(library).lstat()} for root in (scope_root, shared_root): if root.exists(): entries.update(scan_tree(root)) addresses = [str(path) for path in entries if path.name.casefold() == 'saddress.adr' and (scope_root is None or path.is_relative_to(scope_root) or path.is_relative_to(shared_root))] if addresses: raise LibraryBusy(f'库中仍有数据库地址记录,不能自动解除:{addresses}') # scan_tree already rejects links; only native candidates need file opens. native = [path for path, metadata in entries.items() if stat.S_ISREG(metadata.st_mode) and ( path == library or (path.name.casefold() in ('icdb.dat', 'layoutdb.lyt') and (scope_root is None or path.is_relative_to(scope_root) or path.is_relative_to(shared_root))))] if library not in native: raise LibraryBusy('目标库身份缺失,不能解除协调阻止。') with ExitStack() as stack: export_proof = (prove_export_copies_released(library, allow_unknown_checkpoint=True) if allow_unknown_checkpoint else prove_export_copies_released(library)) export_copies = stack.enter_context(export_proof) for path in native: handle = win32file.CreateFile(str(path), win32con.GENERIC_READ, 0, None, win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None) stack.callback(handle.Close) owners = check_owners() yield {'native_owners': owners, 'observed_owners': list(observed), 'addresses': addresses, 'export_copies': export_copies, 'unknown_checkpoint_recovery': allow_unknown_checkpoint, 'exclusive_files': [str(path) for path in native]} finally: uninitialize_com(initialized) def release_retained_library(library, evidence_dir, *, block_name=None): """Reconcile historical leases after fresh owner/address/access proof. The upload sidecar is never deleted. This acknowledges process release, not the correctness of a partially changed library or its recovery state. """ import win32con, win32event, win32file library = Path(library).resolve(strict=True) from .session_record import (retained_session_snapshot, acknowledge_library_release, reconciled_retained_sessions) retained = retained_session_snapshot(library) evidence = Path(evidence_dir).resolve() if evidence.is_relative_to(library.parent) or library.parent.is_relative_to(evidence): raise ValueError('释放检查证据必须位于目标库之外。') lease = LibraryLock(library) mutex = win32event.CreateMutex(None, False, r'Local\CbbRefreshVerify795') acquired = False external = None try: acquired = win32event.WaitForSingleObject(mutex, 0) in (win32con.WAIT_OBJECT_0, win32con.WAIT_ABANDONED) if not acquired: raise LibraryBusy('另一个 CBB 操作仍在运行。') with _guard: owner = _owners.get(lease.key) if owner and (not owner['retained'] or owner['depth']): raise LibraryBusy('本应用操作仍在使用库锁。') if owner is None: try: external = win32file.CreateFile(str(lease.path), win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None, win32con.OPEN_ALWAYS, win32con.FILE_ATTRIBUTE_NORMAL, None) except Exception as error: if getattr(error, 'winerror', None) not in (32, 33): raise raise LibraryBusy('其他进程仍持有库锁,不能解除。') from error marker = blocker_path(library) checkpoints = (marker, marker.with_suffix('.pending')) before = {path: path.read_bytes() if path.exists() else None for path in checkpoints} unknown = any(data is not None and checkpoint_record(path) is None for path, data in before.items()) records = [checkpoint_record(path) for path, data in before.items() if data is not None] scoped = (block_name if block_name and all(record and record.get('block_name') == block_name for record in records) and (owner is None or owner.get('block_name') == block_name) else None) reconciled = [{'kind': 'checkpoint', 'path': str(path), 'recognized': metadata is not None, **{key: (metadata or {}).get(key) for key in ('block_name', 'lease_id', 'pid', 'status', 'time')}} for path, data in before.items() if data is not None for metadata in (checkpoint_record(path),)] if owner: reconciled.append({'kind': 'retained_owner', 'path': str(lease.path), 'block_name': owner.get('block_name'), 'lease_id': owner['lease_id'], 'status': 'OWNER_RELEASE_UNCONFIRMED'}) foreign = sorted({item['block_name'] for item in reconciled if block_name and item.get('block_name') and item['block_name'] != block_name}) proof_context = (_prove_library_released(library, allow_unknown_checkpoint=True) if unknown else _prove_library_released(library, block_name=scoped) if scoped else _prove_library_released(library)) with proof_context as proof: if unknown and proof.get('unknown_checkpoint_recovery') is not True: raise LibraryBusy('未知检查点缺少完整库释放证明,保留原文件。') if any((path.read_bytes() if path.exists() else None) != data for path, data in before.items()): raise LibraryBusy('释放检查期间协调检查点变化,保留原文件。') root = evidence/('release-' + uuid4().hex) root.mkdir(parents=True, exist_ok=False) reconciled_sessions = reconciled_retained_sessions(retained, block_name=scoped) reconciled_blocks = sorted({item['block_name'] for item in (*reconciled, *reconciled_sessions) if item.get('block_name')}) record = {'library': str(library), 'status': 'RELEASE_CONFIRMED', **proof, 'requested_block_name': block_name, 'proof_scope': 'BLOCK' if scoped else 'LIBRARY', 'proof_block_name': scoped, 'reconciled_checkpoints': reconciled, 'reconciled_foreign_blockers': sorted(set(foreign) | { block for block in reconciled_blocks if block_name and block != block_name}), 'reconciled_blocks': reconciled_blocks, 'reconciled_sessions': reconciled_sessions, 'unknown_checkpoint_archived': unknown, 'data_recovery_confirmed': False, 'evidence_path': str(root/'release.json')} (root/'release.json').write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8') for index, checkpoint in enumerate(checkpoints): if checkpoint.exists(): data = checkpoint.read_bytes() archived = root/f'blocker-before-{index}.json' archived.write_bytes(data) if archived.read_bytes() != data: raise OSError('阻止记录归档校验失败,保持库锁。') checkpoint.unlink() # Checkpoint JSON only; never .lock. if owner: owner['handle'].Close() del _owners[lease.key] acknowledge_library_release(record, retained, block_name=scoped) return record finally: if external is not None: external.Close() if acquired: win32event.ReleaseMutex(mutex) mutex.Close()