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

308 lines
13 KiB
Python

"""Persistent, authoritative batch status scanning for CBB libraries.
This module only reads status through the Mentor bridge. It deliberately does
not infer ``READY`` from files, icons, or previous UI observations.
"""
from __future__ import annotations
from dataclasses import asdict, dataclass
from datetime import datetime, timezone
import hashlib
import json
import os
from pathlib import Path
from typing import Iterable
from .status_bridge import (BridgeResponseError, BridgeResult, BridgeUnavailable,
StatusBridgeClient, StatusBridgeServer)
from .network_path import absolute_preserving_drive
TERMINAL_ERRORS = frozenset({"ERROR", "TIMEOUT", "UNAVAILABLE", "MALFORMED", "CRASHED"})
VALID_STATUSES = frozenset({"READY", "PENDING"}) | TERMINAL_ERRORS
@dataclass(frozen=True)
class LmcFingerprint:
path: str
size: int
mtime_ns: int
sha256: str
reusable_blocks_sha256: str
@dataclass(frozen=True)
class BatchStatusRequest:
block_name: str
lmc_file: Path
block_type: str = "RULP"
@dataclass(frozen=True)
class BatchStatusRecord:
block_name: str
status: str
source: str = ""
raw_status: int | str | None = None
detail: str = ""
fingerprint: str = ""
timestamp: str = ""
block_type: str = "RULP"
@property
def completed(self) -> bool:
return self.status in VALID_STATUSES
def to_json(self) -> dict[str, object]:
return asdict(self)
def _sha256_file(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as handle:
for chunk in iter(lambda: handle.read(1024 * 1024), b""):
digest.update(chunk)
return digest.hexdigest()
def _fingerprint_tree(root: Path) -> str:
"""Fingerprint only the top-level CBB set; never descend into payloads."""
digest = hashlib.sha256()
if not root.is_dir():
digest.update(b"<missing>")
return digest.hexdigest()
entries: list[tuple[str, int]] = []
try:
children = os.scandir(root)
except OSError:
digest.update(b"<unavailable>")
return digest.hexdigest()
with children:
for entry in children:
try:
if not entry.is_dir(follow_symlinks=False):
continue
metadata = entry.stat(follow_symlinks=False)
entries.append((entry.name, metadata.st_mtime_ns))
except OSError:
entries.append((entry.name, 0))
for name, mtime_ns in sorted(entries, key=lambda item: item[0].casefold()):
digest.update(name.encode("utf-8", errors="surrogatepass"))
digest.update(b"\0" + str(mtime_ns).encode("ascii") + b"\n")
return digest.hexdigest()
def fingerprint_library(lmc: Path) -> LmcFingerprint:
"""Return a checkpoint fingerprint without reading the reusable payload.
The lightweight cache key includes LMC metadata and the top-level CBB set.
Authoritative state is still queried from Mentor; no CBB payload tree is
recursively traversed merely to decide whether a status scan can resume.
"""
path = absolute_preserving_drive(lmc)
stat = path.stat()
reusable = path.parent / "ReusableBlocksLP"
reusable_sha256 = _fingerprint_tree(reusable)
# Metadata alone is not a safe checkpoint key: on network shares and on
# file systems with coarse timestamp resolution, two different LMC
# contents can have the same size and mtime. Include the actual file
# digest so a changed central library can never reuse an old status row.
content_sha256 = _sha256_file(path)
combined = hashlib.sha256()
combined.update(str(path).casefold().encode('utf-8', errors='surrogatepass'))
combined.update(b'\0')
combined.update(content_sha256.encode("ascii"))
combined.update(b"\0" + str(stat.st_size).encode("ascii"))
combined.update(b"\0" + str(stat.st_mtime_ns).encode("ascii") + b"\0")
combined.update(reusable_sha256.encode("ascii"))
return LmcFingerprint(
path=str(path),
size=stat.st_size,
mtime_ns=stat.st_mtime_ns,
sha256=combined.hexdigest(),
reusable_blocks_sha256=reusable_sha256,
)
class BatchCheckpoint:
"""Read and append complete JSONL records without trusting torn lines."""
def __init__(self, records: dict[str, BatchStatusRecord] | None = None) -> None:
self.records = dict(records or {})
@property
def completed_names(self) -> set[str]:
return set(self.records)
def get(self, name: str) -> BatchStatusRecord | None:
return self.records.get(name)
@classmethod
def load(cls, path: Path) -> "BatchCheckpoint":
records: dict[str, BatchStatusRecord] = {}
checkpoint = Path(path)
if not checkpoint.is_file():
return cls(records)
with checkpoint.open("r", encoding="utf-8") as handle:
for line in handle:
line = line.strip()
if not line:
continue
try:
payload = json.loads(line)
except json.JSONDecodeError:
# A process may have been interrupted during the final write.
continue
if not isinstance(payload, dict):
continue
name = str(payload.get("block_name") or "").strip()
status = str(payload.get("status") or "").upper()
if not name or status not in VALID_STATUSES:
continue
records[name] = BatchStatusRecord(
block_name=name,
status=status,
source=str(payload.get("source") or ""),
raw_status=payload.get("raw_status"),
detail=str(payload.get("detail") or ""),
fingerprint=str(payload.get("fingerprint") or ""),
timestamp=str(payload.get("timestamp") or ""),
block_type=str(payload.get("block_type") or "RULP"),
)
return cls(records)
def append(self, path: Path, record: BatchStatusRecord) -> None:
checkpoint = Path(path)
checkpoint.parent.mkdir(parents=True, exist_ok=True)
with checkpoint.open("a", encoding="utf-8", newline="\n") as handle:
handle.write(json.dumps(record.to_json(), ensure_ascii=False, separators=(",", ":")) + "\n")
handle.flush()
self.records[record.block_name] = record
def _now() -> str:
return datetime.now(timezone.utc).isoformat()
class BatchStatusSession:
"""Supervised serial bridge session with checkpoint recovery."""
def __init__(self, bridge: StatusBridgeClient, *, timeout_seconds: float = 10.0,
rotate_every: int = 500) -> None:
self.bridge = bridge
self.timeout_seconds = max(0.1, float(timeout_seconds))
self.rotate_every = max(1, int(rotate_every))
self.restart_count = 0
def scan(self, names: Iterable[str], lmc_file: Path, checkpoint_path: Path,
*, block_type: str = "RULP", resume: bool = True) -> list[BatchStatusRecord]:
fingerprint = fingerprint_library(Path(lmc_file))
if resume:
checkpoint = BatchCheckpoint.load(checkpoint_path)
else:
checkpoint = BatchCheckpoint()
checkpoint_file = Path(checkpoint_path)
checkpoint_file.parent.mkdir(parents=True, exist_ok=True)
checkpoint_file.write_text('', encoding='utf-8')
results: list[BatchStatusRecord] = []
names = tuple(str(name) for name in names)
server = self.bridge if all(callable(getattr(self.bridge, method, None))
for method in ("start", "restart", "close")) else None
if server is not None:
server.start()
try:
queried = 0
for index, name in enumerate(names):
previous = checkpoint.get(name)
if (previous and previous.status in {'READY', 'PENDING'}
and previous.fingerprint == fingerprint.sha256 and previous.block_type == block_type):
results.append(previous)
continue
try:
result: BridgeResult = self.bridge.query(
Path(lmc_file), name, block_type=block_type,
timeout_seconds=self.timeout_seconds,
)
record = BatchStatusRecord(
block_name=name, status=result.status, source=result.source,
raw_status=result.raw_status, detail=result.detail,
fingerprint=fingerprint.sha256, timestamp=_now(),
block_type=block_type,
)
except BridgeUnavailable as error:
record = BatchStatusRecord(block_name=name, status="UNAVAILABLE",
detail=str(error), fingerprint=fingerprint.sha256,
timestamp=_now(), block_type=block_type)
except BridgeResponseError as error:
message = str(error)
lower_message = message.casefold()
unavailable = any(marker in message for marker in ("LMCDLL70", "私有 MFC", "未找到可用")) or any(
code in lower_message for code in ('0xc0000135', '-1073741515', '3221225781',
'0xc000007b', '-1073741701', '3221225595'))
malformed = (any(marker in message for marker in (
"路径不匹配", "请求标识不匹配", "CBB 标识不匹配",
)) or "mismatch" in lower_message)
status = ("TIMEOUT" if "超时" in message or "timeout" in lower_message
else "UNAVAILABLE" if unavailable
else "MALFORMED" if malformed else "ERROR")
record = BatchStatusRecord(block_name=name, status=status, detail=message,
fingerprint=fingerprint.sha256, timestamp=_now(), block_type=block_type)
if server is not None and status != "UNAVAILABLE":
try:
server.restart()
except BridgeUnavailable:
pass
except Exception as error: # bridge failures isolate one CBB
record = BatchStatusRecord(block_name=name, status="ERROR", detail=str(error),
fingerprint=fingerprint.sha256, timestamp=_now(), block_type=block_type)
if server is not None:
try:
server.restart()
except BridgeUnavailable:
pass
checkpoint.append(checkpoint_path, record)
results.append(record)
if record.status == "UNAVAILABLE" and index + 1 < len(names):
# Startup/protocol failures cannot be repaired by retrying
# the same request contract for every CBB.
# Preserve a terminal record for each remaining name so a
# later run can resume after the environment is fixed.
for remaining in names[index + 1:]:
unavailable_record = BatchStatusRecord(
block_name=remaining, status=record.status, detail=record.detail,
fingerprint=fingerprint.sha256, timestamp=_now(),
block_type=block_type,
)
checkpoint.append(checkpoint_path, unavailable_record)
results.append(unavailable_record)
break
queried += 1
if server is not None and queried % self.rotate_every == 0 and name != names[-1]:
server.restart()
finally:
if server is not None:
server.close()
return results
def authoritative_status_map(names: Iterable[str], lmc_file: Path, checkpoint_path: Path,
*, bridge_path: Path | None = None,
timeout_seconds: float = 10.0) -> dict[str, str]:
"""Return only bridge-backed statuses for an optional UI integration.
A missing bridge is represented as ``UNAVAILABLE``/``UNKNOWN`` by callers;
it is never promoted to ``READY``.
"""
bridge = StatusBridgeServer(bridge_path, env={"CBB_STATUS_BRIDGE_ALLOW_PRIVATE": "1"})
try:
names = tuple(str(name) for name in names)
try:
records = BatchStatusSession(bridge, timeout_seconds=timeout_seconds).scan(
names, lmc_file, checkpoint_path, resume=False)
return {record.block_name: record.status for record in records}
except BridgeUnavailable:
return {name: "UNAVAILABLE" for name in names}
finally:
bridge.close()