Skip to content

armgit / peach

Public Imported from GitHub
0

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.py
new file mode 100644
index 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.py
new file mode 100644
index 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()