diff --git a/src/dx_productivity/trial_task_center/batch_attempt.py b/src/dx_productivity/trial_task_center/batch_attempt.py index 1be9ea1..a4b3f3a 100644 --- a/src/dx_productivity/trial_task_center/batch_attempt.py +++ b/src/dx_productivity/trial_task_center/batch_attempt.py @@ -8,15 +8,16 @@ import os from pathlib import Path import re import tempfile -import time from uuid import uuid4 +from .path_access import canonical_path, internal_path, retry_sharing_violation + _IDENTITY = ('session_id', 'generation', 'attempt_id', 'task_id', 'job_id', 'project_path') def _project(value): - return os.path.normcase(os.path.abspath(value)) + return os.path.normcase(str(canonical_path(value))) def _validate(record): @@ -37,22 +38,14 @@ def _validate(record): def _publish(path, record): - path = Path(path) + path = internal_path(path) descriptor, temporary = tempfile.mkstemp(prefix=f'.{path.name}.', suffix='.tmp', dir=path.parent) try: with os.fdopen(descriptor, 'w', encoding='utf-8', newline='') as handle: json.dump(record, handle, ensure_ascii=False, indent=2) handle.flush() os.fsync(handle.fileno()) - deadline = time.monotonic() + 1 - while True: - try: - os.replace(temporary, path) - break - except PermissionError: - if time.monotonic() >= deadline: - raise - time.sleep(.02) + retry_sharing_violation(lambda: os.replace(temporary, path)) # POSIX needs a directory sync for the atomic rename; Windows does not # expose fsync on directories through the CRT. if os.name != 'nt': @@ -69,13 +62,13 @@ def prepare_attempt(path, *, session_id, generation, task_id, job_id, project_pa record = _validate(dict(schema_version=1, session_id=str(session_id), generation=generation, task_id=str(task_id), job_id=str(job_id), project_path=_project(project_path), attempt_id=uuid4().hex if attempt_id is None else attempt_id, state='prepared')) - Path(path).parent.mkdir(parents=True, exist_ok=True) + retry_sharing_violation(lambda: internal_path(path).parent.mkdir(parents=True, exist_ok=True)) _publish(path, record) return record def read_attempt(path): - return _validate(json.loads(Path(path).read_text(encoding='utf-8'))) + return _validate(json.loads(internal_path(path).read_text(encoding='utf-8'))) def _bound_attempt(path=None, *, job_id=None, task_id=None, project_path=None): @@ -86,7 +79,7 @@ def _bound_attempt(path=None, *, job_id=None, task_id=None, project_path=None): raw_path = os.environ.get('DXPART_ATTEMPT_FILE') if path is None else os.fspath(path) if not raw_path or not Path(raw_path).is_absolute(): raise ValueError('invalid batch attempt file') - path = Path(raw_path) + path = internal_path(raw_path) job_id = str(job_id) if job_id is not None else os.environ.get('DXPART_JOB_ID') task_id = str(task_id) if task_id is not None else os.environ.get('DXPART_TASK_ID') if path.is_dir(): diff --git a/src/dx_productivity/trial_task_center/batch_resources.py b/src/dx_productivity/trial_task_center/batch_resources.py index dc2319b..7238ffd 100644 --- a/src/dx_productivity/trial_task_center/batch_resources.py +++ b/src/dx_productivity/trial_task_center/batch_resources.py @@ -9,6 +9,7 @@ import time from uuid import uuid4 from .errors import TaskCenterError +from .path_access import canonical_path, internal_path, retry_sharing_violation # Recovery retains owned native handles after failed cleanup. This registry is @@ -17,29 +18,24 @@ LIVE_RESOURCES = {} class BatchResourceCleanupError(TaskCenterError): - def __init__(self, message, *, completed_result=None): + def __init__(self, message, *, completed_result=None, primary_error=None, cleanup_error=None): super().__init__('batch_resources_pending', message) self.completed_result = completed_result + self.primary_error = primary_error + self.cleanup_error = cleanup_error + self.bom_report = getattr(primary_error, "bom_report", None) def write_record(path, record): - path = Path(path) - path.parent.mkdir(parents=True, exist_ok=True) + path = internal_path(path) + retry_sharing_violation(lambda: path.parent.mkdir(parents=True, exist_ok=True)) temporary = path.with_name(path.name + '.' + uuid4().hex + '.tmp') try: with temporary.open('w', encoding='utf-8', newline='\n') as stream: json.dump(record, stream, ensure_ascii=False, indent=2) stream.flush() os.fsync(stream.fileno()) - deadline = time.monotonic() + 1.0 - while True: - try: - os.replace(temporary, path) - break - except PermissionError: - if time.monotonic() >= deadline: - raise - time.sleep(.02) + retry_sharing_violation(lambda: os.replace(temporary, path)) finally: temporary.unlink(missing_ok=True) @@ -70,9 +66,10 @@ def _valid_record(record, path): def pending_resources(root): pending = [] - for path in sorted((Path(root).resolve() / 'batch-resources').glob('*/session.json')): + for path in sorted(internal_path(canonical_path(root) / 'batch-resources').glob('*/session.json')): + path = canonical_path(path) try: - record = json.loads(path.read_text(encoding='utf-8')) + record = json.loads(internal_path(path).read_text(encoding='utf-8')) if not _valid_record(record, path): raise ValueError('invalid resource ownership record') if record.get('state') != 'released': @@ -169,11 +166,11 @@ def cleanup_pending_resources(root, *, logging_context=None): def project_checkpoint_released(root): - root = Path(root).resolve() + root = canonical_path(root) try: - checkpoint = json.loads((root / 'project-checkpoint.json').read_text(encoding='utf-8')) + checkpoint = json.loads(internal_path(root / 'project-checkpoint.json').read_text(encoding='utf-8')) path = Path(checkpoint['resource_record']).resolve() - record = json.loads(path.read_text(encoding='utf-8')) + record = json.loads(internal_path(path).read_text(encoding='utf-8')) key = str(root).casefold() return (_valid_record(record, path) and checkpoint.get('version') == 1 and type(checkpoint.get('generation')) is int diff --git a/src/dx_productivity/trial_task_center/batch_runtime.py b/src/dx_productivity/trial_task_center/batch_runtime.py index 68689e1..023269f 100644 --- a/src/dx_productivity/trial_task_center/batch_runtime.py +++ b/src/dx_productivity/trial_task_center/batch_runtime.py @@ -6,11 +6,12 @@ import json from pathlib import Path import subprocess import time -from uuid import uuid4 +from uuid import UUID, uuid4 from .batch_resources import (BatchResourceCleanupError, LIVE_RESOURCES, cleanup_pending_resources, guard_pending_resources, pending_resources, process_identity, project_checkpoint_released, write_record) from .errors import TaskCenterError +from .path_access import canonical_path, internal_path, legacy_path from .isolated_desktop import PrivateDesktop from .operation_control import check_cancelled from .worker_monitor import WorkerMonitorError @@ -43,8 +44,12 @@ class _DesktopLease: return {'session_id': self.owner.session_id, 'generation': self.generation, 'attempt_id': self.attempt_id} - def __exit__(self, *_exc): - self.close() + def __exit__(self, error_type, error, traceback): + try: + self.close() + except BatchResourceCleanupError as cleanup: + raise BatchResourceCleanupError(cleanup.message, primary_error=error, + cleanup_error=cleanup) from cleanup def start_process(self, command, **options): available = self.owner.record['state'] == 'ready' or ( @@ -78,10 +83,10 @@ class _DesktopLease: class BatchCadRuntime: - def __init__(self, root, kind, stop_event=None, *, desktop_factory=None, cad_factory=None): - self.root = Path(root).resolve() + def __init__(self, root, kind, stop_event=None, *, desktop_factory=None, cad_factory=None, session_id=None): + self.root = canonical_path(root) self.kind, self.stop_event = kind, stop_event - self.session_id = uuid4().hex + self.session_id = uuid4().hex if session_id is None else UUID(str(session_id)).hex self.path = self.root / 'batch-resources' / self.session_id / 'session.json' self.desktop_factory = desktop_factory or PrivateDesktop self.cad_factory = cad_factory @@ -114,8 +119,20 @@ class BatchCadRuntime: try: self.close() except Exception as cleanup: - raise BatchResourceCleanupError('批次资源释放待处理;已核验任务结果保留。' + str(cleanup), - completed_result=self.result) from cleanup + def detail(failure): + return {'type': type(failure).__name__, 'message': str(failure), + 'code': getattr(failure, 'code', None)} + self.record['primary_error'] = detail(error) if error is not None else None + self.record['cleanup_error'] = detail(cleanup) + try: + self._save() + except Exception: + pass # Journal failure must not replace either original failure. + context = ('BOM 导入读取已停止;未生成可执行预览。' + if self.kind == 'bom_import' else + '已核验任务结果保留。' if self.result is not None else '本批操作已停止。') + raise BatchResourceCleanupError('批次资源释放待处理;' + context + str(cleanup), + completed_result=self.result, primary_error=error, cleanup_error=cleanup) from cleanup def _save(self, **values): record = dict(self.record, **values) @@ -188,26 +205,26 @@ class BatchCadRuntime: self._save(state='ready', cad_pid=cad.binding.pid, cad_guid=cad.binding.guid) return self.cad - def _prepare_attempts(self, root, command, attempt_id): + def _prepare_attempts(self, root, command, attempt_id, generation): from .batch_attempt import prepare_attempt from .quick_run import _read_commands - rows = _read_commands(root / 'command.tsv') + rows = _read_commands(internal_path(root / 'command.tsv')) selected_rows = [row for row in rows if row[1] == command[-1]] if len(selected_rows) != 1 or len({row[1] for row in rows}) != len(rows): raise TaskCenterError('target_identity', '批次工作命令身份缺失或重复,已停止。') selected = selected_rows[0] - project = Path(selected[2]).resolve() - self._save(active_project=str(project), active_task=selected[0], active_job=selected[1]) - directory = root / 'batch-attempts' / (self.session_id + f'-g{self.generation}-' + attempt_id) + project = canonical_path(selected[2]) + self.record.update(active_project=str(project), active_task=selected[0], active_job=selected[1]) + directory = self.path.parent / 'attempts' / f'g{generation}' / attempt_id expected = [] for row in rows: - if Path(row[2]).resolve() == project: + if canonical_path(row[2]) == project: path = directory / (row[1] + '.json') - record = prepare_attempt(path, session_id=self.session_id, generation=self.generation, + record = prepare_attempt(path, session_id=self.session_id, generation=generation, task_id=row[0], job_id=row[1], project_path=str(project), attempt_id=attempt_id) expected.append((path, record)) self._project_attempts.setdefault(str(project).casefold(), []).extend(expected) - return project, directory, expected + return project, legacy_path(directory), expected def _can_retry(self, project, expected): from .batch_attempt import can_retry_attempt @@ -229,18 +246,21 @@ class BatchCadRuntime: from .discovery_cache import project_fingerprint from .isolated_cad import PrivateCadStartupError, is_identity_conflict from .worker_monitor import run_monitored_process - root = Path(command[3]).resolve() - self._ensure_desktop(abort_event) + root = canonical_path(command[3]) while True: check_cancelled(abort_event or self.stop_event) attempt_id = uuid4().hex # No previous empty-project certificate may authorize continuation # once another operation could attach or open a project. self.record['checkpoints'].pop(str(root).casefold(), None) - self._save(active_attempt=attempt_id) - project, directory, expected = self._prepare_attempts(root, command, attempt_id) + self.record['active_attempt'] = attempt_id + if self.generation: + self._save() + generation = self.generation + (self.desktop is None) + project, directory, expected = self._prepare_attempts(root, command, attempt_id, generation) + self._ensure_desktop(abort_event) before = project_fingerprint(project, self.root) - status = root / 'status.tsv' + status = internal_path(root / 'status.tsv') status_before = status.read_bytes() if status.exists() else None started = time.monotonic() failure = None @@ -270,7 +290,7 @@ class BatchCadRuntime: # available for a failed read, use the stricter full fingerprint. safe = (not is_identity_conflict(failure) and before is not None and before == after and status_before == status_after and self._can_retry(project, expected) - and not (root / 'recovery.request').exists() + and not internal_path(root / 'recovery.request').exists() and not (abort_event is not None and abort_event.is_set()) and not (self.stop_event is not None and self.stop_event.is_set())) if not safe: @@ -281,7 +301,6 @@ class BatchCadRuntime: self._save(state='recycling') self.close(rebuilding=True) # Prove disappearance before creating another. self.desktop = self.cad = None - self._ensure_desktop(abort_event) def recover_native_failure(self, project, evidence, reason): """One read-only recovery, based on durable source and worker proof.""" diff --git a/src/dx_productivity/trial_task_center/legacy_paths.py b/src/dx_productivity/trial_task_center/legacy_paths.py index 40c59f2..2da3b06 100644 --- a/src/dx_productivity/trial_task_center/legacy_paths.py +++ b/src/dx_productivity/trial_task_center/legacy_paths.py @@ -11,6 +11,7 @@ import tempfile from threading import RLock from .errors import TaskCenterError +from .path_access import canonical_path, internal_path, retry_sharing_violation, strip_extended_prefix def _short_path(path: Path) -> str | None: @@ -18,8 +19,8 @@ def _short_path(path: Path) -> str | None: function.argtypes = [ctypes.c_wchar_p, ctypes.c_wchar_p, ctypes.c_uint] function.restype = ctypes.c_uint buffer = ctypes.create_unicode_buffer(32768) - count = function(str(path), buffer, len(buffer)) - return buffer.value if count and count < len(buffer) else None + count = function(str(internal_path(path)), buffer, len(buffer)) + return strip_extended_prefix(buffer.value) if count and count < len(buffer) else None def _fits(root) -> bool: @@ -34,12 +35,13 @@ class _AliasPool: self.lock = RLock() def alias(self, root: Path) -> Path: + root = canonical_path(root, strict=True) import _winapi with self.lock: if self.directory is None: local = Path(os.environ.get('LOCALAPPDATA') or tempfile.gettempdir()) parent = local / 'DxProductivity' / 'path-links' - parent.mkdir(parents=True, exist_ok=True) + internal_path(parent).mkdir(parents=True, exist_ok=True) self.directory = Path(tempfile.mkdtemp(prefix='dxp-', dir=parent)) key = hashlib.sha256(os.path.normcase(str(root)).encode('utf-8')).hexdigest()[:20] link = self.directory / key @@ -50,7 +52,7 @@ class _AliasPool: # junction contains no copies and never changes the target. _winapi.CreateJunction(str(root), str(link)) self.links[link] = root - if not link.is_junction() or link.resolve(strict=True) != root: + if not link.is_junction() or canonical_path(link, strict=True) != root: raise OSError('compatibility directory no longer points to the confirmed evidence') return link @@ -60,7 +62,7 @@ class _AliasPool: for link, target in tuple(self.links.items()): try: if link.is_junction(): - if link.resolve() != target: + if canonical_path(link) != target: raise OSError('refusing to remove a redirected compatibility directory') link.rmdir() # Remove only the link, never the target tree. elif link.exists(): @@ -88,11 +90,12 @@ atexit.register(cleanup_worker_aliases) def worker_paths(script: Path, root: Path) -> tuple[str, str]: + script, root = canonical_path(script), canonical_path(root) if os.name == 'nt': _prepare_project_access(root) if os.name != 'nt' or _fits(root): return str(script), str(root) - canonical = root.resolve(strict=True) + canonical = canonical_path(internal_path(root), strict=True) short = _short_path(canonical) if short and _fits(short): return str(Path(short) / script.name), short @@ -106,7 +109,7 @@ def worker_paths(script: Path, root: Path) -> tuple[str, str]: def _prepare_project_access(root: Path): """Keep command identities canonical while giving legacy CAD short entry paths.""" - command = root / 'command.tsv' + command = internal_path(root / 'command.tsv') if not command.is_file(): return rows = [] @@ -117,32 +120,32 @@ def _prepare_project_access(root: Path): if not value or value in seen: continue seen.add(value) - project = Path(value).resolve(strict=False) - if (_fits(project.parent) and len(str(project)) < 260) or not project.is_file(): + project = canonical_path(internal_path(value)) + if (_fits(project.parent) and len(str(project)) < 260) or not internal_path(project).is_file(): continue short = _short_path(project) if short and _fits(Path(short).parent) and len(short) < 260: access = Path(short) else: access = _aliases.alias(project.parent) / project.name - if not _fits(access.parent) or len(str(access)) >= 260 or access.resolve(strict=True) != project: + if not _fits(access.parent) or len(str(access)) >= 260 or canonical_path(access, strict=True) != project: raise TaskCenterError('quick_run_path_length', '工程短路径入口不能与原工程身份对应,未启动 CAD 操作。') pair = (str(project), str(access)) if pair not in rows: rows.append(pair) - target = root / 'project-access.tsv' + target = internal_path(root / 'project-access.tsv') if rows or target.exists(): temporary = target.with_suffix('.tmp') with temporary.open('w', encoding='utf-8', newline='') as stream: writer = csv.writer(stream, delimiter='\t', lineterminator='\n') writer.writerow(('project_path', 'access_path')) writer.writerows(rows) - temporary.replace(target) + retry_sharing_violation(lambda: temporary.replace(target)) def validate_project_access(root: Path): """Reject disappeared/redirected entry paths before and after a native worker.""" - target = Path(root) / 'project-access.tsv' + target = internal_path(Path(root) / 'project-access.tsv') if not target.is_file(): return with target.open(encoding='utf-8-sig', newline='') as stream: @@ -151,7 +154,7 @@ def validate_project_access(root: Path): raise TaskCenterError('target_identity', '工程路径入口清单格式已改变') for row in reader: try: - same = Path(row['access_path']).resolve(strict=True) == Path(row['project_path']).resolve(strict=True) + same = canonical_path(internal_path(row['access_path']), strict=True) == canonical_path(internal_path(row['project_path']), strict=True) except (OSError, ValueError, KeyError): same = False if not same: diff --git a/src/dx_productivity/trial_task_center/native_inventory.py b/src/dx_productivity/trial_task_center/native_inventory.py index 3497b06..1669deb 100644 --- a/src/dx_productivity/trial_task_center/native_inventory.py +++ b/src/dx_productivity/trial_task_center/native_inventory.py @@ -7,11 +7,13 @@ import os from pathlib import Path import re import shutil +import sys import tempfile import time from uuid import uuid4 from .errors import TaskCenterError +from .path_access import canonical_path, internal_path, retry_sharing_violation from .isolated_desktop import PrivateDesktop from .native_inventory_protocol import NativeInventoryUnsupported, read_ascii_discovery, read_native_text from .operation_control import check_cancelled, report_progress @@ -27,20 +29,20 @@ class _NativeInventoryProcessError(NativeInventoryUnsupported): def _hash(path): - with path.open('rb') as stream: + with internal_path(path).open('rb') as stream: return hashlib.file_digest(stream, 'sha256').hexdigest() def _verify_sources(hashes): try: - if any(path.resolve(strict=True) != path or _hash(path) != digest for path, digest in hashes.items()): + if any(canonical_path(internal_path(path), strict=True) != path or _hash(path) != digest for path, digest in hashes.items()): raise OSError('source identity changed') except OSError as error: raise TaskCenterError('target_identity', '原生采集期间源工程或数据库已变化或无法核验,请重新导入') from error def _project_options(project): - text = read_native_text(project) + text = read_native_text(internal_path(project)) def option(name, default=None): values = set(re.findall(r'^KEY ' + name + r' "([^"\r\n]*)"\s*$', text, re.MULTILINE)) if not values and default is not None: @@ -54,8 +56,8 @@ def _project_options(project): snapshot = option('FrontEndSnapshot', 'DxD') if snapshot.casefold() != 'dxd': raise NativeInventoryUnsupported('当前工程不是已验证的 DxD 数据库快照') - database = (project.parent / option('iCDBDir') / 'icdb.dat').resolve(strict=True) - if not database.is_relative_to(project.parent) or not database.is_file(): + database = canonical_path(internal_path(project.parent / option('iCDBDir') / 'icdb.dat'), strict=True) + if not database.is_relative_to(project.parent) or not internal_path(database).is_file(): raise NativeInventoryUnsupported('数据库不在当前工程目录内') return text, block, snapshot, database @@ -83,7 +85,7 @@ class NativeInventoryReader: def read(self, project, old_part_numbers, *, stop_event=None, on_progress=None, runtime=None): check_cancelled(stop_event) try: - project = Path(project).resolve(strict=True) + project = canonical_path(internal_path(project), strict=True) text, block, snapshot, database = _project_options(project) tools = self._tools() except (NativeInventoryUnsupported, OSError, ImportError, UnicodeError, TaskCenterError) as error: @@ -99,13 +101,13 @@ class NativeInventoryReader: def _read(self, project, text, block, snapshot, database, tools, old_part_numbers, *, stop_event, on_progress, runtime=None, allow_retry=False): token = uuid4().hex - evidence = self.data_root / 'quick-run-history' / ('native-inventory-' + token) - evidence.mkdir(parents=True, exist_ok=False) + evidence = internal_path(self.data_root / 'quick-run-history' / ('native-inventory-' + token)) + retry_sharing_violation(lambda: evidence.mkdir(parents=True, exist_ok=False)) base = Path(self.temporary_root or Path(os.environ.get('LOCALAPPDATA') or tempfile.gettempdir()) / 'DxProductivity' / 'native-inventory').resolve() base.mkdir(parents=True, exist_ok=True) workspace = Path(tempfile.mkdtemp(prefix='dx-cli-', dir=base)).resolve() - desktop = (runtime.native_scope(evidence) if runtime is not None + desktop = (runtime.native_scope(canonical_path(evidence)) if runtime is not None else self.desktop_factory('dx-cli-' + token, enabled=True)) record = {'backend': 'native_cli', 'project': str(project), 'state': 'reading', 'workspace': str(workspace), 'tools': []} @@ -115,12 +117,12 @@ class NativeInventoryReader: source_hashes = {} try: source_hashes = {project: _hash(project), database: _hash(database)} - if read_native_text(project) != text: + if read_native_text(internal_path(project)) != text: raise TaskCenterError('target_identity', '创建原生采集快照时工程配置已变化,请重新导入') source = workspace / 'input.prj' target_database = workspace / 'database' target_database.mkdir() - shutil.copyfile(database, target_database / 'icdb.dat') + shutil.copyfile(internal_path(database), target_database / 'icdb.dat') # No server address files or running database directory are copied. text = re.sub(r'^KEY iCDBDir "[^"\r\n]*"\s*$', 'KEY iCDBDir "database"', text, flags=re.MULTILINE) @@ -145,17 +147,21 @@ class NativeInventoryReader: self._run_tool(desktop, command, workspace, environment, output, record, stop_event) finally: + primary_error = sys.exception() try: desktop.close() clean = True except Exception as error: - record.update(state='uncertain', cleanup_error=str(error)) + record.update(state='uncertain', cleanup_error=str(error), + primary_error=str(primary_error) if primary_error is not None else None) try: (evidence / 'uncertain.flag').write_text(str(error), encoding='utf-8') except OSError as marker_error: record['uncertain_marker_error'] = str(marker_error) - raise TaskCenterError('inventory_cleanup', - f'原生采集进程未能确认安全释放,请保留诊断记录:{evidence}') from error + failure = TaskCenterError('inventory_cleanup', + f'原生采集进程未能确认安全释放,请保留诊断记录:{canonical_path(evidence)}') + failure.primary_error, failure.cleanup_error = primary_error, error + raise failure from error _verify_sources(source_hashes) check_cancelled(stop_event) result = read_ascii_discovery(project, output / 'scope.txt', old_part_numbers, @@ -178,7 +184,7 @@ class NativeInventoryReader: write_record(evidence / 'native-retry-proof.json', { 'version': 1, 'native_read_only': True, 'project_path': str(project), 'source_hashes': {str(path): digest for path, digest in source_hashes.items()}, - 'workers_closed': True, 'evidence_root': str(evidence.resolve()), + 'workers_closed': True, 'evidence_root': str(canonical_path(evidence)), 'binding': dict(desktop.identity), }) _verify_sources(source_hashes) @@ -248,11 +254,15 @@ class NativeInventoryReader: if metric['exit_code'] != 0: raise NativeInventoryUnsupported(f'{name} 返回退出码 {metric["exit_code"]}') finally: + primary_error = sys.exception() metric['seconds'] = time.monotonic() - started if process is not None and callable(getattr(process, 'close', None)): try: process.close() except Exception as error: - record.update(state='uncertain', cleanup_error=str(error)) - raise TaskCenterError('inventory_cleanup', - f'原生读取进程及其子进程未能确认退出:{error}') from error + record.update(state='uncertain', cleanup_error=str(error), + primary_error=str(primary_error) if primary_error is not None else None) + failure = TaskCenterError('inventory_cleanup', + f'原生读取进程及其子进程未能确认退出:{error}') + failure.primary_error, failure.cleanup_error = primary_error, error + raise failure from error diff --git a/src/dx_productivity/trial_task_center/path_access.py b/src/dx_productivity/trial_task_center/path_access.py new file mode 100644 index 0000000..b1a5b41 --- /dev/null +++ b/src/dx_productivity/trial_task_center/path_access.py @@ -0,0 +1,62 @@ +"""Filesystem access paths never replace canonical project/resource identities.""" +from __future__ import annotations + +import ntpath +import os +from pathlib import Path +import time + + +def strip_extended_prefix(value): + value = os.fspath(value) + if value.startswith('\\\\?\\UNC\\'): + return '\\\\' + value[8:] + if value.startswith('\\\\?\\'): + return value[4:] + return value + + +def windows_extended_path(value): + value = os.fspath(value) + if value.startswith('\\\\?\\'): + return value + value = ntpath.abspath(value) + return '\\\\?\\UNC\\' + value[2:] if value.startswith('\\\\') else '\\\\?\\' + value + + +def canonical_path(value, *, strict=False): + return Path(strip_extended_prefix(internal_path(value).resolve(strict=strict))) + + +def internal_path(value): + """Use Unicode extended Windows paths only at internal filesystem boundaries.""" + return Path(windows_extended_path(value)) if os.name == 'nt' else Path(value) + + +def retry_sharing_violation(operation, *, sleep=time.sleep): + """At most three attempts and 150ms delay; access denial is never replayed.""" + for attempt in range(3): + try: + return operation() + except OSError as error: + if getattr(error, 'winerror', None) not in (32, 33) or attempt == 2: + raise + sleep(.05 * (attempt + 1)) + + +def legacy_path(value): + """Give CAD/WSH a short entry while retaining canonical identity elsewhere.""" + from .legacy_paths import _aliases, _fits, _short_path + path = canonical_path(value, strict=True) + if os.name != 'nt' or (_fits(path.parent) and len(str(path)) < 260): + return path + short = _short_path(internal_path(path)) + if short and _fits(Path(short).parent) and len(short) < 260: + access = Path(short) + elif path.is_dir(): + access = _aliases.alias(path) + else: + access = _aliases.alias(path.parent) / path.name + if canonical_path(access, strict=True) != path: + raise OSError('compatibility entry does not identify the canonical path') + return access diff --git a/src/dx_productivity/trial_task_center/project_discovery.py b/src/dx_productivity/trial_task_center/project_discovery.py index e59da95..76954ca 100644 --- a/src/dx_productivity/trial_task_center/project_discovery.py +++ b/src/dx_productivity/trial_task_center/project_discovery.py @@ -10,6 +10,7 @@ import subprocess from uuid import uuid4 from .errors import TaskCenterError +from .path_access import canonical_path, internal_path, retry_sharing_violation from .quick_run_protocol import ProjectDiscovery, _encode_vbs_field from .operation_control import check_cancelled, report_progress @@ -64,13 +65,13 @@ def discover_project( ) -> ProjectDiscovery: """Enumerate sheets and requested source parts while the owned project is open.""" check_cancelled(stop_event) - project = project_path.resolve(strict=True) + project = canonical_path(internal_path(project_path), strict=True) token = uuid4().hex job_id = "discover_" + token - root = data_root / "quick-run-history" / ("sheet-discovery-" + token) - root.mkdir(parents=True, exist_ok=False) + root = internal_path(data_root / "quick-run-history" / ("sheet-discovery-" + token)) + retry_sharing_violation(lambda: root.mkdir(parents=True, exist_ok=False)) script = root / "QuickPartReplace.vbs" - shutil.copyfile(script_source, script) + shutil.copyfile(internal_path(script_source), script) (root / "command.tsv").write_text( "task_id\tjob_id\tproject_path\told_part\tnew_part\tvalue_mode\r\n" f"sheet_discovery\t{job_id}\t{project}\tDISCOVERY_OLD\tDISCOVERY_NEW\tpreserve\r\n", @@ -93,7 +94,7 @@ def discover_project( ) if collect_components: (root / "component-inventory.request").write_text(job_id, encoding="ascii") - script_argument, root_argument = runtime.worker_paths(script, root) + script_argument, root_argument = runtime.worker_paths(canonical_path(script), canonical_path(root)) command = ( str(runtime.cscript_resolver()), "//nologo", diff --git a/tests/v1_1/test_batch_attempt.py b/tests/v1_1/test_batch_attempt.py index a62c0fd..2e166a8 100644 --- a/tests/v1_1/test_batch_attempt.py +++ b/tests/v1_1/test_batch_attempt.py @@ -161,3 +161,39 @@ def test_native_failure_does_not_reuse_previous_attempt_transaction(prepared, tm assert report['stage'] == 'preflight' and 'transaction' not in report assert report['batch_attempt']['job_id'] == 'job-a' assert attempts.read_attempt(path)['state'] == 'prepared' + +def test_attempt_write_handles_long_unicode_evidence_and_keeps_canonical_identity(tmp_path, monkeypatch): + from pathlib import Path + directory = tmp_path / ('long-' + 'x' * 110) / ('more-' + 'y' * 80) + path = directory / 'attempt.json' + real_mkdir = Path.mkdir + def strict_mkdir(target, *args, **kwargs): + if len(str(target)) >= 260 and not str(target).startswith(chr(92) * 2 + '?'): + raise OSError('legacy MAX_PATH') + return real_mkdir(target, *args, **kwargs) + monkeypatch.setattr(Path, 'mkdir', strict_mkdir) + project = tmp_path / 'board.prj' + record = attempts.prepare_attempt(path, session_id='session', generation=1, + task_id='task', job_id='job', project_path=project) + assert record['project_path'] == os.path.normcase(str(project.resolve())) + assert attempts.can_retry_attempt(path, record) + assert not str(record['project_path']).startswith(chr(92) * 2 + '?') + + +def test_publication_retries_sharing_violation_only_and_keeps_original_record(tmp_path, monkeypatch): + path = tmp_path / 'attempt.json' + first = attempts.prepare_attempt(path, session_id='session', generation=1, + task_id='task', job_id='job', project_path=tmp_path / 'board.prj') + calls = [] + def fail(source, target): + calls.append((source, target)) + error = PermissionError('sharing violation') + error.winerror = 32 + raise error + monkeypatch.setattr(os, 'replace', fail) + with pytest.raises(PermissionError): + attempts.prepare_attempt(path, session_id='session', generation=2, + task_id='task', job_id='job', project_path=tmp_path / 'board.prj') + assert len(calls) == 3 + assert attempts.read_attempt(path) == first + assert list(tmp_path.iterdir()) == [path] diff --git a/tests/v1_1/test_batch_runtime.py b/tests/v1_1/test_batch_runtime.py index d2ebda2..6a751d1 100644 --- a/tests/v1_1/test_batch_runtime.py +++ b/tests/v1_1/test_batch_runtime.py @@ -199,7 +199,7 @@ def test_possible_mutation_prevents_automatic_replay(tmp_path, monkeypatch): calls = [] def monitor(*args, **kwargs): calls.append(1) - path = next((Path(command[3]) / 'batch-attempts').rglob('job.json')) + path = next((runtime.path.parent / 'attempts').rglob('job.json')) record = json.loads(path.read_text()) record['state'] = 'mutation_possible' path.write_text(json.dumps(record)) @@ -228,7 +228,7 @@ def test_previous_checkpoint_invalidated_before_new_worker(tmp_path, monkeypatch raise WorkerMonitorError('cannot certify empty project') runtime.cad.checkpoint = fail_checkpoint # No retry after evidence has been marked as possibly modified. - path = next((Path(command[3]) / 'batch-attempts').rglob('job.json')) + path = next((runtime.path.parent / 'attempts').rglob('job.json')) record = json.loads(path.read_text()) record['state'] = 'mutation_possible' path.write_text(json.dumps(record)) @@ -247,6 +247,9 @@ def test_attempt_publication_failure_never_launches_worker(tmp_path, monkeypatch with runtime, pytest.raises(OSError): runtime.run_worker(command, 5) assert not Cad.created + assert not Desktop.created + from dx_productivity.trial_task_center.batch_resources import pending_resources + assert pending_resources(runtime.root) == () def test_boundary_pause_does_not_abort_current_cad_startup(tmp_path, monkeypatch): @@ -498,3 +501,45 @@ def test_identity_conflict_never_rebuilds_or_launches_another_worker(tmp_path, m assert len(workers) == (1 if conflict.startswith('checkpoint') or conflict == 'worker_identity' else 0) assert runtime.generation == 1 and not runtime.record['retries'] assert Desktop.created[0].released + + +def test_request_session_identity_is_uuid_bound(tmp_path): + from dx_productivity.trial_task_center.batch_runtime import BatchCadRuntime + session = '12345678-1234-5678-1234-567812345678' + runtime = BatchCadRuntime(tmp_path, 'bom_import', session_id=session) + assert runtime.session_id == session.replace('-', '') + with pytest.raises(ValueError): + BatchCadRuntime(tmp_path, 'bom_import', session_id='../escape') + + +def test_cleanup_preserves_primary_bom_error_and_report(tmp_path): + from dx_productivity.trial_task_center.batch_runtime import BatchCadRuntime + primary = TaskCenterError('bom_inspection', 'read failed') + primary.bom_report = object() + Desktop.fail_release = True + with pytest.raises(TaskCenterError) as caught: + with BatchCadRuntime(tmp_path, 'bom_import', desktop_factory=Desktop) as runtime: + with runtime.native_scope(tmp_path / 'operation'): + pass + raise primary + error = caught.value + assert error.primary_error is primary + assert error.cleanup_error is not None + assert error.bom_report is primary.bom_report + assert 'BOM' in error.message and '已核验任务结果保留' not in error.message + assert runtime.record['primary_error']['code'] == primary.code + assert runtime.record['cleanup_error'] + Desktop.fail_release = False + from dx_productivity.trial_task_center.batch_resources import cleanup_pending_resources + cleanup_pending_resources(tmp_path) + + +def test_attempts_live_under_short_session_root(tmp_path, monkeypatch): + import subprocess + command, _ = command_for(tmp_path) + runtime = worker_runtime(tmp_path, monkeypatch, lambda command, *a, **k: + subprocess.CompletedProcess(command, 0, '', '')) + with runtime: + runtime.run_worker(command, 5) + assert list((runtime.path.parent / 'attempts').rglob('job.json')) + assert not (Path(command[3]) / 'batch-attempts').exists() diff --git a/tests/v1_1/test_native_inventory_reader.py b/tests/v1_1/test_native_inventory_reader.py index e412d73..64ee352 100644 --- a/tests/v1_1/test_native_inventory_reader.py +++ b/tests/v1_1/test_native_inventory_reader.py @@ -231,6 +231,8 @@ def test_native_cleanup_failure_blocks_fallback_and_keeps_recovery_evidence(tmp_ with pytest.raises(TaskCenterError) as caught: reader.read(project, ('OLD',), stop_event=stop) assert caught.value.code == 'inventory_cleanup' + assert caught.value.primary_error.code == 'operation_cancelled' + assert isinstance(caught.value.cleanup_error, OSError) assert released == [True] and list((tmp_path / 'evidence').rglob('uncertain.flag')) assert list((tmp_path / 'temporary').iterdir()) diff --git a/tests/v1_1/test_path_access.py b/tests/v1_1/test_path_access.py new file mode 100644 index 0000000..7ef1c15 --- /dev/null +++ b/tests/v1_1/test_path_access.py @@ -0,0 +1,70 @@ +import pytest + + +def test_windows_extended_paths_keep_canonical_identity(): + from dx_productivity.trial_task_center.path_access import windows_extended_path, strip_extended_prefix + slash = chr(92) + local = 'C:' + slash + ('nested' + slash) * 45 + 'file.json' + assert windows_extended_path(local) == slash * 2 + '?' + slash + local + assert strip_extended_prefix(windows_extended_path(local)) == local + unc = slash * 2 + 'server' + slash + 'share' + slash + 'file.json' + assert windows_extended_path(unc) == slash * 2 + '?' + slash + 'UNC' + unc[1:] + assert strip_extended_prefix(windows_extended_path(unc)) == unc + + +def test_sharing_retry_is_bounded_and_does_not_retry_permission_denied(): + from dx_productivity.trial_task_center.path_access import retry_sharing_violation + calls = [] + def operation(): + calls.append(1) + error = PermissionError('sharing violation') + error.winerror = 32 + raise error + with pytest.raises(PermissionError): + retry_sharing_violation(operation, sleep=lambda delay: None) + assert len(calls) == 3 + calls.clear() + def denied(): + calls.append(1) + raise PermissionError('access denied') + with pytest.raises(PermissionError): + retry_sharing_violation(denied, sleep=lambda delay: None) + assert len(calls) == 1 + +def test_discovery_uses_extended_filesystem_access_before_legacy_launch(tmp_path, monkeypatch): + import os + import subprocess + from pathlib import Path + from dx_productivity.trial_task_center.project_discovery import discover_project, DiscoveryRuntime + if os.name != 'nt': + pytest.skip('Windows filesystem boundary') + data = tmp_path / ('nested-' + 'a' * 90) / ('more-' + 'b' * 70) + project = tmp_path / 'board.prj' + project.write_text('project') + script = tmp_path / 'worker.vbs' + script.write_text('script') + real_mkdir = Path.mkdir + def strict_mkdir(path, *args, **kwargs): + if len(str(path)) >= 260 and not str(path).startswith(chr(92) * 2 + '?'): + raise OSError('legacy MAX_PATH filesystem access') + return real_mkdir(path, *args, **kwargs) + monkeypatch.setattr(Path, 'mkdir', strict_mkdir) + reached = [] + def launch(*args): + reached.append(1) + raise subprocess.SubprocessError('stop at launch') + runtime = DiscoveryRuntime(launch, lambda: Path('cscript'), lambda s, r: (str(s), str(r)), + lambda: (), str, lambda *a: (), lambda *a: {}, 5) + with pytest.raises(Exception): + discover_project(project, ('OLD',), data_root=data, script_source=script, runtime=runtime) + assert reached, 'long-path filesystem preparation failed before worker boundary' + +def test_native_short_path_never_passes_extended_prefix_to_wsh(tmp_path): + import os + from dx_productivity.trial_task_center.legacy_paths import _short_path + if os.name != 'nt': + pytest.skip('Windows short-path boundary') + result = _short_path(tmp_path) + if result is None: + pytest.skip('filesystem does not provide short paths') + assert not result.startswith(chr(92) * 2 + '?')