Peach: Local-first video metadata scraper and media manager.
feat(smb): 添加固定共享根的只读传输与请求期限
longmeidao831cabe28803
diff --git a/src/peach/smb_transport.py b/src/peach/smb_transport.pynew file mode 100644index 000000000..8bbbfb9d2--- /dev/null+++ b/src/peach/smb_transport.py@@ -0,0 +1,406 @@+"""固定共享根的只读 SMB 传输;每个实例独占连接、会话及请求期限。"""++from __future__ import annotations++import errno+import io+import math+import ntpath+import threading+import time+import uuid+from dataclasses import dataclass, field+from datetime import datetime, timezone++import smbclient+from smbclient._io import _chunk_size+from smbprotocol.connection import Connection+from smbprotocol.exceptions import (+ NoMoreFiles, NoSuchFile, SMBAuthenticationError, SMBOSError, SMBResponseException,+)+from smbprotocol.file_info import FileAttributes, FileInformationClass+from smbprotocol.header import NtStatus+from smbprotocol.open import (+ CreateDisposition, CreateOptions, FilePipePrinterAccessMask,+ ImpersonationLevel, Open, QueryDirectoryFlags, ShareAccess,+)+from smbprotocol.tree import TreeConnect+++@dataclass(frozen=True)+class SmbConnection:+ host: str+ share: str+ username: str = field(default="", repr=False)+ password: str = field(default="", repr=False)+ port: int = 445+ encrypt: bool = False+ timeout: float = 8++ def __post_init__(self):+ for value in (self.host, self.share):+ if not value or any(c in value for c in "\\/\x00") or value in (".", ".."):+ raise ValueError("SMB 主机和共享名必须是单独的路径分量")+ if not 0 < self.port <= 65535:+ raise ValueError("SMB 端口无效")+ if not math.isfinite(self.timeout) or self.timeout <= 0:+ raise ValueError("SMB 请求期限必须是有限正数")+++@dataclass(frozen=True)+class SmbStat:+ size: int+ mtime: float+ mtime_ns: int+ is_dir: bool+ name: str++ @property+ def st_size(self):+ return self.size++ @property+ def st_mtime(self):+ return self.mtime++ @property+ def st_mtime_ns(self):+ return self.mtime_ns+++@dataclass(frozen=True)+class SmbEntry(SmbStat):+ is_symlink: bool = False+++def _parts(relative: tuple[str, ...] | str) -> tuple[str, ...]:+ if isinstance(relative, str):+ if ntpath.isabs(relative) or ntpath.splitdrive(relative)[0]:+ raise ValueError("SMB 路径必须相对共享根")+ parts = tuple(relative.replace("\\", "/").split("/")) if relative else ()+ elif isinstance(relative, tuple):+ parts = relative+ else:+ raise TypeError("SMB 路径必须是字符串或路径分量元组")+ for part in parts:+ if (not isinstance(part, str) or not part or part in (".", "..")+ or any(c in part for c in "\\/:\x00*?\"<>|")+ or any(ord(c) < 32 for c in part) or part.endswith((" ", "."))):+ raise ValueError("SMB 路径含无效分量")+ return parts+++def _timestamp(value: datetime) -> tuple[float, int]:+ if value.tzinfo is None:+ value = value.replace(tzinfo=timezone.utc)+ delta = value - datetime(1970, 1, 1, tzinfo=timezone.utc)+ ns = ((delta.days * 86400 + delta.seconds) * 1_000_000 + delta.microseconds) * 1000+ return ns / 1_000_000_000, ns+++def _error(exc: Exception) -> OSError:+ if isinstance(exc, SMBAuthenticationError):+ return PermissionError(errno.EACCES, "SMB 身份验证失败")+ if isinstance(exc, SMBResponseException):+ if exc.status in (NtStatus.STATUS_ACCESS_DENIED, NtStatus.STATUS_LOGON_FAILURE,+ NtStatus.STATUS_STOPPED_ON_SYMLINK):+ return PermissionError(errno.EACCES, "SMB 访问被拒绝")+ mapped = SMBOSError(exc.status, "SMB 共享")+ return mapped if mapped.errno else OSError(errno.EIO, "SMB 请求失败")+ if isinstance(exc, OSError):+ return exc+ return OSError(errno.ENETUNREACH, "SMB 连接不可用")+++class _DeadlineConnection(Connection):+ """在库的响应事件上等待绝对期限,关闭自动符号链接解析。"""++ def __init__(self, config: SmbConnection):+ super().__init__(uuid.uuid4(), config.host, config.port)+ self.request_timeout = config.timeout+ self._cancelling = False++ def receive(self, request, wait=True, timeout=None, resolve_symlinks=False):+ budget = self.request_timeout if timeout is None else min(timeout, self.request_timeout)+ deadline = time.monotonic() + budget+ sent_deadline = getattr(request, "_peach_deadline", None)+ if isinstance(sent_deadline, (float, int)):+ deadline = min(deadline, sent_deadline)+ try:+ while True:+ remaining = deadline - time.monotonic()+ if remaining <= 0 or not request.response_event.wait(remaining):+ raise TimeoutError(errno.ETIMEDOUT, "SMB 请求超时")+ with request.response_event_lock:+ self._check_worker_running()+ status = request.response["status"].get_value()+ if status == NtStatus.STATUS_PENDING and wait:+ request.response_event.clear()+ continue+ return super().receive(request, wait=False, timeout=remaining, resolve_symlinks=False)+ except TimeoutError:+ self._cancelling = True+ try:+ request.cancel()+ except Exception:+ pass+ finally:+ self.disconnect(close=False)+ raise++ def send(self, *args, **kwargs):+ deadline = time.monotonic() + self.request_timeout+ self._bound_socket()+ request = super().send(*args, **kwargs)+ request._peach_deadline = deadline+ return request++ def send_compound(self, *args, **kwargs):+ deadline = time.monotonic() + self.request_timeout+ self._bound_socket()+ requests = super().send_compound(*args, **kwargs)+ for request in requests:+ request._peach_deadline = deadline+ return requests++ def _bound_socket(self):+ # 限制发送及取消消息的 socket 等待;响应读取由独立的库接收线程负责。+ if self.transport is not None and self.transport.connected:+ timeout = min(self.request_timeout, .05) if self._cancelling else self.request_timeout+ self.transport._sock.settimeout(timeout)+++class SmbTransport:+ """独占会话的只读传输;close 中止所属句柄,失败请求不自动重连。"""++ def __init__(self, connection: SmbConnection):+ self.connection = connection+ self._cache: dict = {}+ self._conn = None+ self._tree = None+ self._closed = False+ self._lock = threading.RLock()++ def __enter__(self):+ return self++ def __exit__(self, *_):+ self.close()++ def _connect(self):+ with self._lock:+ if self._closed:+ raise OSError(errno.EBADF, "SMB 传输已关闭")+ if self._conn is not None:+ if not self._conn.transport.connected:+ raise OSError(errno.ENETDOWN, "SMB 连接已断开")+ return self._tree+ config = self.connection+ self._conn = conn = _DeadlineConnection(config)+ try:+ conn.connect(timeout=config.timeout)+ self._cache[f"{config.host.lower()}:{config.port}"] = conn+ session = smbclient.register_session(+ config.host, username=config.username or None, password=config.password or None,+ port=config.port, encrypt=config.encrypt, connection_timeout=config.timeout,+ connection_cache=self._cache,+ )+ self._tree = TreeConnect(session, f"\\\\{config.host}\\{config.share}")+ self._tree.connect()+ if self._tree.is_dfs_share:+ raise PermissionError(errno.EACCES, "SMB DFS 共享不允许重解析")+ return self._tree+ except Exception as exc:+ self.close()+ raise _error(exc) from None++ def close(self):+ self._closed = True+ self._cache.clear()+ if self._conn is not None and self._conn.transport is not None:+ # 直接关闭所属 socket,不发需要等待响应的逐句柄注销请求。+ self._conn.disconnect(close=False)++ def _open_fd(self, parts, *, data=False, directory=False):+ tree = self._connect()+ fd = Open(tree, "\\".join(parts))+ access = FilePipePrinterAccessMask.FILE_READ_ATTRIBUTES+ if data:+ access |= FilePipePrinterAccessMask.FILE_READ_DATA+ options = CreateOptions.FILE_OPEN_REPARSE_POINT+ if directory:+ options |= CreateOptions.FILE_DIRECTORY_FILE+ elif data:+ options |= CreateOptions.FILE_NON_DIRECTORY_FILE+ try:+ fd.create(+ ImpersonationLevel.Impersonation, access, FileAttributes.FILE_ATTRIBUTE_NORMAL,+ ShareAccess.FILE_SHARE_READ, CreateDisposition.FILE_OPEN, options,+ )+ if fd.file_attributes & FileAttributes.FILE_ATTRIBUTE_REPARSE_POINT:+ raise PermissionError(errno.EACCES, "SMB 重解析点不可访问")+ return fd+ except Exception as exc:+ if fd.connected:+ self._close_fd(fd)+ error = _error(exc)+ if error.errno not in (errno.ENOENT, errno.EACCES, errno.EPERM, errno.EISDIR, errno.ENOTDIR):+ self.close()+ raise error from None++ def _close_fd(self, fd):+ if self._conn.transport.connected:+ try:+ fd.close()+ except Exception as exc:+ self.close()+ raise _error(exc) from None++ def _check_parents(self, parts):+ # 每个祖先以重解析点自身打开;读共享锁阻止检查期间的替换和删除。+ parents = []+ try:+ for index in range(1, len(parts)):+ parents.append(self._open_fd(parts[:index], directory=True))+ return parents+ except Exception:+ for fd in reversed(parents):+ self._close_fd(fd)+ raise++ def stat(self, relative: tuple[str, ...] | str) -> SmbStat:+ parts = _parts(relative)+ parents = self._check_parents(parts)+ fd = None+ try:+ fd = self._open_fd(parts)+ mtime, ns = _timestamp(fd.last_write_time)+ return SmbStat(fd.end_of_file, mtime, ns,+ bool(fd.file_attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY),+ parts[-1] if parts else self.connection.share)+ finally:+ for item in ([fd] if fd is not None else []) + list(reversed(parents)):+ self._close_fd(item)++ def scandir(self, relative: tuple[str, ...] | str) -> list[SmbEntry]:+ parts = _parts(relative)+ parents = self._check_parents(parts)+ fd = None+ try:+ fd = self._open_fd(parts, data=True, directory=True)+ result = []+ flags = QueryDirectoryFlags.SMB2_RESTART_SCANS+ while True:+ try:+ page = fd.query_directory("*", FileInformationClass.FILE_ID_FULL_DIRECTORY_INFORMATION,+ flags=flags)+ except (NoMoreFiles, NoSuchFile):+ break+ flags = 0+ if not page:+ break+ for entry in page:+ name = entry["file_name"].get_value().decode("utf-16-le")+ if name in (".", ".."):+ continue+ _parts((name,))+ attributes = entry["file_attributes"].get_value()+ mtime, ns = _timestamp(entry["last_write_time"].get_value())+ result.append(SmbEntry(+ entry["end_of_file"].get_value(), mtime, ns,+ bool(attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY), name,+ bool(attributes & FileAttributes.FILE_ATTRIBUTE_REPARSE_POINT),+ ))+ return result+ except Exception as exc:+ raise _error(exc) from None+ finally:+ for item in ([fd] if fd is not None else []) + list(reversed(parents)):+ self._close_fd(item)++ def open(self, relative: tuple[str, ...] | str):+ parts = _parts(relative)+ parents = self._check_parents(parts)+ try:+ return _SmbReader(self, self._open_fd(parts, data=True), parents)+ except Exception:+ for fd in reversed(parents):+ self._close_fd(fd)+ raise+++class _SmbReader:+ def __init__(self, transport, fd, parents):+ self._transport, self._fd, self._parents = transport, fd, parents+ self._offset = 0+ self._lock = threading.Lock()+ self.closed = False++ def __enter__(self):+ self._check()+ return self++ def __exit__(self, *_):+ self.close()++ def _check(self):+ if self.closed:+ raise ValueError("SMB 文件已关闭")+ if self._transport._closed or not self._fd.connection.transport.connected:+ raise OSError(errno.ENETDOWN, "SMB 连接已断开")++ def tell(self):+ self._check()+ return self._offset++ def seek(self, offset, whence=io.SEEK_SET):+ with self._lock:+ self._check()+ if whence not in (io.SEEK_SET, io.SEEK_CUR, io.SEEK_END):+ raise ValueError("SMB seek whence 无效")+ target = (0, self._offset, self._fd.end_of_file)[whence] + offset+ if not isinstance(target, int) or target < 0:+ raise ValueError("SMB seek 位置无效")+ self._offset = target+ return target++ def read(self, size=-1):+ with self._lock:+ self._check()+ remaining = max(0, self._fd.end_of_file - self._offset)+ if size is not None and size >= 0:+ remaining = min(remaining, size)+ result = bytearray()+ try:+ while remaining:+ length, credits = _chunk_size(self._fd.connection, remaining, "read")+ if length <= 0:+ raise OSError(errno.EIO, "SMB 读取没有可用额度")+ message, receive = self._fd.read(self._offset, length, send=False)+ request = self._fd.connection.send(+ message, sid=self._fd.tree_connect.session.session_id,+ tid=self._fd.tree_connect.tree_connect_id, credit_request=credits,+ )+ chunk = receive(request)+ if not chunk or len(chunk) > length:+ raise OSError(errno.EIO, "SMB 文件在声明的结尾之前结束")+ self._offset += len(chunk)+ remaining -= len(chunk)+ result.extend(chunk)+ return bytes(result)+ except Exception as exc:+ self._transport.close()+ raise _error(exc) from None++ def close(self):+ if self.closed:+ return+ self.closed = True+ if not self._lock.acquire(blocking=False):+ self._transport.close()+ return+ try:+ for fd in [self._fd] + list(reversed(self._parents)):+ self._transport._close_fd(fd)+ finally:+ self._lock.release()diff --git a/tests/test_smb_transport.py b/tests/test_smb_transport.pynew file mode 100644index 000000000..08f4275c6--- /dev/null+++ b/tests/test_smb_transport.py@@ -0,0 +1,309 @@+"""SMB 只读传输的隔离行为与请求期限。"""++import errno+import io+import threading+import unittest+from concurrent.futures import ThreadPoolExecutor+from datetime import datetime, timezone+from types import SimpleNamespace+from unittest.mock import Mock, patch++from peach.smb_transport import (+ SmbConnection, SmbTransport, _DeadlineConnection, _SmbReader,+)+from smbprotocol.exceptions import NoMoreFiles, ObjectNameNotFound, AccessDenied, SMBAuthenticationError+from smbprotocol.file_info import FileAttributes+from smbprotocol.header import NtStatus, SMB2HeaderResponse+from smbprotocol.open import (+ CreateDisposition, CreateOptions, Open, ShareAccess, SMB2ReadResponse,+)+++def field(value):+ return SimpleNamespace(get_value=lambda: value)+++class SmbTransportTests(unittest.TestCase):+ def setUp(self):+ self.config = SmbConnection("files.invalid", "media", "reader", "secret", timeout=.1)+ self.conn = Mock()+ self.conn.transport.connected = True+ self.conn.max_read_size = 4+ self.conn.sequence_window = {"high": 20, "low": 0}+ self.conn.send.return_value = object()+ self.conn.disconnect.side_effect = self.disconnect+ self.tree = Mock()+ self.tree.is_dfs_share = False+ self.tree.session.session_id = 1+ self.tree.tree_connect_id = 2+ self.patches = [+ patch("peach.smb_transport._DeadlineConnection", return_value=self.conn),+ patch("peach.smb_transport.smbclient.register_session", return_value=self.tree.session),+ patch("peach.smb_transport.TreeConnect", return_value=self.tree),+ patch("peach.smb_transport.Open", side_effect=self.fd),+ ]+ self.mocks = [p.start() for p in self.patches]+ self.addCleanup(lambda: [p.stop() for p in reversed(self.patches)])+ self.transport = SmbTransport(self.config)+ self.addCleanup(self.transport.close)+ self.fds = []+ self.attrs = {}++ def disconnect(self, **_):+ self.conn.transport.connected = False++ def fd(self, tree, name):+ fd = Mock()+ fd.connection = self.conn+ fd.tree_connect = tree+ fd.file_name = name+ fd.connected = True+ fd.end_of_file = 10+ fd.file_attributes = self.attrs.get(name, 0)+ fd.last_write_time = datetime(2026, 1, 2, 3, 4, 5, 123456, tzinfo=timezone.utc)+ fd.close.side_effect = lambda: setattr(fd, "connected", False)+ fd.read.side_effect = lambda offset, length, send: (object(), lambda _: b"0123456789"[offset:offset+length])+ self.fds.append(fd)+ return fd++ def test_credentials_are_not_in_connection_repr(self):+ self.assertNotIn("reader", repr(self.config))+ self.assertNotIn("secret", repr(self.config))++ def test_invalid_paths_never_connect(self):+ for path in ("../x", "/x", "\\x", "C:x", "x/../y", "x//y", "x:stream", "x/", ("a/b",), ("..",), ("x.",)):+ with self.subTest(path=path), self.assertRaises(ValueError):+ self.transport.open(path)+ self.conn.connect.assert_not_called()++ def test_stat_preserves_size_time_and_read_sharing(self):+ result = self.transport.stat(("folder", "film.mp4"))+ self.assertEqual(result.name, "film.mp4")+ self.assertEqual(result.st_size, 10)+ self.assertEqual(result.mtime_ns % 1_000_000_000, 123456000)+ self.assertEqual(result.st_mtime, result.mtime)+ self.assertFalse(result.is_dir)+ parent, file = self.fds+ self.assertEqual(file.create.call_args.args[3], ShareAccess.FILE_SHARE_READ)+ self.assertEqual(file.create.call_args.args[4], CreateDisposition.FILE_OPEN)+ self.assertTrue(file.create.call_args.args[5] & CreateOptions.FILE_OPEN_REPARSE_POINT)+ parent.close.assert_called_once()+ file.close.assert_called_once()++ def test_parent_reparse_is_rejected_before_child_open(self):+ self.attrs["folder"] = FileAttributes.FILE_ATTRIBUTE_REPARSE_POINT+ with self.assertRaises(PermissionError):+ self.transport.open("folder/film.mp4")+ self.assertEqual(len(self.fds), 1)+ self.fds[0].close.assert_called_once()++ def test_final_reparse_is_rejected(self):+ self.attrs["film.mp4"] = FileAttributes.FILE_ATTRIBUTE_REPARSE_POINT+ with self.assertRaises(PermissionError):+ self.transport.open("film.mp4")++ def test_directory_uses_enumeration_metadata_without_per_entry_open(self):+ def entries(*_):+ def entry(name, attributes=0):+ return {key: field(value) for key, value in {+ "file_name": name.encode("utf-16-le"), "file_attributes": attributes,+ "last_write_time": datetime(2026, 1, 1, tzinfo=timezone.utc), "end_of_file": 12,+ }.items()}+ return [entry("."), entry("movie.mp4"), entry("folder", FileAttributes.FILE_ATTRIBUTE_DIRECTORY),+ entry("link", FileAttributes.FILE_ATTRIBUTE_REPARSE_POINT)]+ original = self.mocks[3].side_effect+ def directory(tree, name):+ fd = original(tree, name)+ fd.query_directory.side_effect = [entries(), NoMoreFiles()]+ return fd+ self.mocks[3].side_effect = directory+ result = self.transport.scandir(())+ self.assertEqual([x.name for x in result], ["movie.mp4", "folder", "link"])+ self.assertEqual(result[0].size, 12)+ self.assertTrue(result[1].is_dir)+ self.assertTrue(result[2].is_symlink)+ self.assertEqual(len(self.fds), 1)+ self.assertEqual(self.fds[0].query_directory.call_count, 2)++ def test_connection_cache_is_private_and_dfs_is_rejected(self):+ self.tree.is_dfs_share = True+ with self.assertRaises(PermissionError):+ self.transport.stat(())+ self.assertTrue(self.transport._closed)+ self.assertEqual(self.transport._cache, {})+ self.conn.disconnect.assert_called_with(close=False)++ def test_missing_and_permission_failures_have_distinct_errno(self):+ for exception, expected in ((ObjectNameNotFound(), errno.ENOENT), (AccessDenied(), errno.EACCES),+ (SMBAuthenticationError("credential error"), errno.EACCES)):+ with self.subTest(expected=expected):+ original = self.fd+ def bad_fd(tree, name):+ fd = original(tree, name)+ fd.create.side_effect = exception+ return fd+ self.mocks[3].side_effect = bad_fd+ with self.assertRaises(OSError) as caught:+ self.transport.stat("missing")+ self.assertEqual(caught.exception.errno, expected)++ def test_seek_short_reads_and_eof(self):+ with self.transport.open("film.mp4") as reader:+ reader._fd.read.side_effect = lambda offset, length, send: (object(), lambda _: b"0123456789"[offset:offset+min(2, length)])+ self.assertEqual(reader.read(5), b"01234")+ self.assertEqual(reader.tell(), 5)+ self.assertEqual(reader.seek(-2, io.SEEK_CUR), 3)+ self.assertEqual(reader.read(2), b"34")+ self.assertEqual(reader.seek(-2, io.SEEK_END), 8)+ self.assertEqual(reader.read(), b"89")+ self.assertEqual(reader.read(), b"")+ self.assertEqual(reader.seek(100), 100)+ self.assertEqual(reader.read(), b"")+ for offset, whence in ((-1, 0), (0, 8)):+ with self.assertRaises(ValueError):+ reader.seek(offset, whence)+ with self.assertRaises(ValueError):+ reader.read()++ def test_independent_handles_keep_offsets_and_parent_locks(self):+ first = self.transport.open("folder/film.mp4")+ second = self.transport.open("folder/film.mp4")+ self.assertIsNot(first._fd, second._fd)+ self.assertEqual(first.read(3), b"012")+ self.assertEqual(second.read(2), b"01")+ first.close()+ self.assertEqual(second.read(2), b"23")+ second.close()+ self.assertTrue(all(not fd.connected for fd in self.fds))++ def test_parallel_handles_read_separate_offsets(self):+ first = self.transport.open("film.mp4")+ second = self.transport.open("film.mp4")+ second.seek(5)+ barrier = threading.Barrier(2, timeout=2)+ def read_fd(offset, length, send):+ def receive(_):+ barrier.wait()+ return b"0123456789"[offset:offset+length]+ return object(), receive+ first._fd.read.side_effect = second._fd.read.side_effect = read_fd+ with ThreadPoolExecutor() as executor:+ a = executor.submit(first.read, 3)+ b = executor.submit(second.read, 3)+ self.assertEqual(a.result(), b"012")+ self.assertEqual(b.result(), b"567")+ self.assertEqual((first.tell(), second.tell()), (3, 8))+ first.close()+ second.close()++ def test_premature_empty_read_is_failure_and_disconnects(self):+ reader = self.transport.open("film.mp4")+ reader._fd.read.side_effect = lambda *args, **kwargs: (object(), lambda _: b"")+ with self.assertRaises(OSError) as caught:+ reader.read(1)+ self.assertEqual(caught.exception.errno, errno.EIO)+ self.assertTrue(self.transport._closed)++ def test_close_during_read_aborts_connection(self):+ reader = self.transport.open("film.mp4")+ reader._lock.acquire()+ reader.close()+ reader._lock.release()+ self.assertTrue(reader.closed)+ self.conn.disconnect.assert_called_with(close=False)++ def test_transport_close_does_not_reconnect(self):+ self.transport.stat(())+ self.transport.close()+ with self.assertRaises(OSError):+ self.transport.stat(())+ self.conn.connect.assert_called_once()+++class SmbDeadlineTests(unittest.TestCase):+ def connection(self):+ conn = _DeadlineConnection(SmbConnection("files.invalid", "media", timeout=.05))+ conn._check_worker_running = Mock()+ conn.disconnect = Mock()+ return conn++ def request(self, status=NtStatus.STATUS_SUCCESS):+ response = SMB2HeaderResponse()+ response["status"] = status+ request = Mock()+ request.message = {"message_id": field(1)}+ request.response = response+ request.response_event = threading.Event()+ request.response_event_lock = threading.Lock()+ return request++ def test_timeout_cancels_and_disconnects_without_background_read(self):+ conn, request = self.connection(), self.request()+ with self.assertRaises(TimeoutError):+ conn.receive(request)+ request.cancel.assert_called_once()+ conn.disconnect.assert_called_once_with(close=False)++ def test_continuous_pending_does_not_extend_deadline(self):+ conn, request = self.connection(), self.request(NtStatus.STATUS_PENDING)+ request.response_event = Mock()+ request.response_event.wait.return_value = True+ with patch("peach.smb_transport.time.monotonic", side_effect=[10, 10.01, 10.03, 10.06]):+ with self.assertRaises(TimeoutError):+ conn.receive(request)+ waits = [call.args[0] for call in request.response_event.wait.call_args_list]+ self.assertLess(waits[1], waits[0])+ request.cancel.assert_called_once()+ conn.disconnect.assert_called_once_with(close=False)++ def test_cancel_failure_still_disconnects(self):+ conn, request = self.connection(), self.request()+ request.cancel.side_effect = OSError("offline")+ with self.assertRaises(TimeoutError):+ conn.receive(request)+ conn.disconnect.assert_called_once_with(close=False)++ def test_receive_uses_deadline_set_before_send(self):+ conn, request = self.connection(), self.request()+ request._peach_deadline = 9+ with patch("peach.smb_transport.time.monotonic", return_value=10):+ with self.assertRaises(TimeoutError):+ conn.receive(request)+ request.cancel.assert_called_once()+ conn.disconnect.assert_called_once_with(close=False)++ def test_response_parser_never_resolves_symlinks(self):+ conn, request = self.connection(), self.request()+ request.response_event.set()+ conn.outstanding_requests[request.message["message_id"].get_value()] = request+ # 复用真实库的接收解析路径,只隔离网络事件与线程状态。+ self.assertIs(conn.receive(request, resolve_symlinks=True), request.response)++ def test_real_open_read_parser_receives_explicit_offset(self):+ conn = Mock()+ conn.transport.connected = True+ conn.max_read_size = 65536+ conn.sequence_window = {"high": 10, "low": 0}+ tree = SimpleNamespace(session=SimpleNamespace(connection=conn, session_id=7, username="reader"),+ tree_connect_id=9, share_name="media")+ fd = Open(tree, "film.mp4")+ fd.end_of_file = 6+ fd.file_id = b"f" * 16+ packet = SMB2ReadResponse()+ packet["buffer"] = b"def"+ response = SMB2HeaderResponse()+ response["data"] = packet.pack()+ conn.receive.return_value = response+ transport = SimpleNamespace(_closed=False, close=Mock())+ reader = _SmbReader(transport, fd, [])+ reader.seek(3)+ self.assertEqual(reader.read(3), b"def")+ message = conn.send.call_args.args[0]+ self.assertEqual(message["offset"].get_value(), 3)+ self.assertEqual(message["length"].get_value(), 3)+ self.assertEqual(reader.tell(), 6)+++if __name__ == "__main__":+ unittest.main()