sycommon-python-lib 0.2.7a23__tar.gz → 0.2.7a25__tar.gz

{sycommon_python_lib-0.2.7a23 → sycommon_python_lib-0.2.7a25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.7a23
+Version: 0.2.7a25
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.7a23 → sycommon_python_lib-0.2.7a25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.7a23"
+version = "0.2.7a25"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.7a23 → sycommon_python_lib-0.2.7a25}/src/sycommon/agent/sandbox/minio_sync.py

@@ -244,6 +244,99 @@ class MinioSyncService(metaclass=SingletonMeta):
             self.aremove_prefix(f"{uid}/current/large_tool_results/"),
         )
 
+    # ============== tmp 目录 pip 残留清理（MinIO 侧，与沙箱侧对称双删）==============
+
+    def _list_pip_tmp_object_keys(self, user_prefix: str) -> list[str]:
+        """列出某用户 MinIO current/tmp/ 下 pip-* 开头的对象 key。
+
+        沙箱文件会同步到 {user}/current/{相对路径}，pip 残留落 tmp/ → 对应
+        {user}/current/tmp/pip-*。这里只 list，不删（删除在调用方，便于按用户聚合）。
+
+        Args:
+            user_prefix: 形如 "osulcode.xiao/current/" 的 MinIO 前缀
+
+        Returns:
+            匹配 {user_prefix}tmp/pip- 的 object_name 列表。
+        """
+        if not self._client:
+            return []
+        prefix = f"{user_prefix}tmp/pip-"
+        try:
+            return [
+                obj.object_name
+                for obj in self._client.list_objects(self._bucket, prefix=prefix, recursive=True)
+            ]
+        except Exception as e:
+            SYLogger.warning(f"[MinIO] list pip tmp 失败: prefix={prefix}, error={e}")
+            return []
+
+    def cleanup_pip_tmp(self, now_ts: float = None) -> int:
+        """全量清理所有用户 MinIO current/tmp/ 下的 pip-* 残留。
+
+        供「服务启动」全量清理调用，与 sandbox.cleanup_all_pip_tmp_residue_async 配对。
+        递归 list 整个 bucket，按路径段筛 /current/tmp/pip-*（各用户的残留都在
+        {user}/current/tmp/pip-* 下，前缀含动态 user_id，故不能写死前缀，必须全量扫
+        再按路径模式过滤）。同步实现，调用方用 asyncio.to_thread 包装。
+
+        Args:
+            now_ts: 预留（MinIO 侧 mtime 过滤较复杂且收益低，当前全删；沙箱侧已用
+                    mtime 兜底避免误删正在跑的 pip）。
+
+        Returns:
+            实际删除的对象数量。
+        """
+        if not self._client:
+            return 0
+        removed = 0
+        try:
+            # 递归列出整个 bucket，筛出路径含 /current/tmp/pip- 的对象。
+            # 各用户残留 = {user}/current/tmp/pip-*，user_id 动态，故必须全量扫后按
+            # 路径模式过滤，不能写死前缀。
+            keys = [
+                obj.object_name
+                for obj in self._client.list_objects(self._bucket, recursive=True)
+                if "/current/tmp/pip-" in obj.object_name
+            ]
+            for key in keys:
+                if self.remove_object(key):
+                    removed += 1
+        except Exception as e:
+            SYLogger.warning(f"[MinIO] cleanup_pip_tmp 全量清理异常: {e}")
+        return removed
+
+    def cleanup_pip_tmp_for_user(self, user_id: str, now_ts: float = None) -> int:
+        """清理单个用户 MinIO current/tmp/ 下的 pip-* 残留。
+
+        供「对话结束」单用户清理调用，与 sandbox.cleanup_user_pip_tmp_residue_async 配对。
+
+        Args:
+            user_id: 用户ID
+            now_ts: 预留（同 cleanup_pip_tmp，当前全删）
+
+        Returns:
+            实际删除的对象数量。
+        """
+        uid = user_id.lower().replace(" ", "")
+        user_prefix = f"{uid}/current/"
+        keys = self._list_pip_tmp_object_keys(user_prefix)
+        if not keys:
+            return 0
+        removed = 0
+        for key in keys:
+            if self.remove_object(key):
+                removed += 1
+        if removed:
+            SYLogger.info(f"[MinIO] 清理用户 {user_id} tmp pip 残留: removed={removed}")
+        return removed
+
+    async def acleanup_pip_tmp(self, now_ts: float = None) -> int:
+        """异步全量清理所有用户 MinIO tmp pip 残留（to_thread 包装同步实现）。"""
+        return await asyncio.to_thread(self.cleanup_pip_tmp, now_ts)
+
+    async def acleanup_pip_tmp_for_user(self, user_id: str, now_ts: float = None) -> int:
+        """异步清理单个用户 MinIO tmp pip 残留（to_thread 包装同步实现）。"""
+        return await asyncio.to_thread(self.cleanup_pip_tmp_for_user, user_id, now_ts)
+
     # ============== 查找最近副本 ==============
 
     def find_latest_object_key(self, user_id: str, file_path: str) -> Optional[str]:

{sycommon_python_lib-0.2.7a23 → sycommon_python_lib-0.2.7a25}/src/sycommon/middleware/sandbox.py

@@ -83,9 +83,36 @@ def _get_process_lock() -> asyncio.Lock:
 PROCESS_CLEANUP_TTL = 300  # 已完成进程保留时间（秒）
 PROCESS_CLEANUP_INTERVAL = 60  # 清理检查间隔（秒）
 
+# tmp 目录 pip 残留清理配置
+# pip 安装(build/setup 阶段)会在 $TMPDIR 下建一堆临时目录: pip-build-env-*、
+# pip-unpack-*、pip-req-build-*、pip-trampoline-* 等。正常 pip 成功结束会自己清,
+# 但被超时杀掉/中断/异常退出时这些目录就残留下来,越积越多(每个可能几十~几百 MB,
+# 含源码/wheel/build 产物)。沙箱 $TMPDIR = {workspace}/tmp,故残留全堆在这里。
+#
+# 所有 pip 临时目录统一以 "pip-" 开头(pip 源码 temp_dir.py 里 mkdtemp(prefix="pip-...")
+# 的约定),故用一个前缀覆盖全部,且对 pip 未来新增变体自动生效。刻意不用"包含
+# pip/pip3"匹配——会误伤用户在 tmp 里自建的含 pip 字样的正常文件(如 pipeline-data、
+# my-pip-export);也不用裸 "pip" 前缀——会误伤 pipeline-*/pipcache 等。带 "-" 边界
+# 刚好圈住所有 pip 临时目录,又不碰用户文件。
+_PIP_TMP_PREFIXES = ("pip-",)
+# 只清理 N 分钟前的(mtime 兜底):pip 正在跑时这些目录 mtime 持续更新,不会误删。
+_PIP_TMP_MIN_AGE_SECONDS = 10 * 60
+
+# 清理触发方式(用户最终方案):
+#   - 服务启动时清一次(全量,所有用户) -> services lifespan startup 调
+#     cleanup_all_pip_tmp_residue_async()
+#   - 每次对话结束后异步清一次(单用户) -> api/chat + wecom/manager 调
+#     cleanup_user_pip_tmp_residue_async(user_id)
+# 不再用周期 60s 轮询——启动 + 对话结束两个事件已覆盖所有产生时机。
+
 
 async def _cleanup_finished_processes():
-    """异步清理已完成的过期进程"""
+    """周期清理已完成的过期后台进程记录（仅进程记录，不含 pip tmp）。
+
+    注：pip tmp 残留的清理改为「启动 + 对话结束」事件触发
+    (cleanup_all_pip_tmp_residue_async / cleanup_user_pip_tmp_residue_async)，
+    不再在此循环里做。
+    """
     lock = _get_process_lock()
     while True:
         await asyncio.sleep(PROCESS_CLEANUP_INTERVAL)
@@ -100,6 +127,159 @@ async def _cleanup_finished_processes():
                 SYLogger.debug(f"[Sandbox Server] 清理过期进程: {k}")
 
 
+# ============== tmp 目录 pip 残留清理（事件触发：启动 / 对话结束）==============
+
+def _collect_pip_tmp_targets(tmp_dir: str, now_ts: float) -> list[str]:
+    """收集单个用户 tmp/ 下可清理的 pip 残留目录绝对路径（不删除，仅返回清单）。
+
+    筛选规则：名称匹配 _PIP_TMP_PREFIXES 且 mtime 距 now_ts 超过 _PIP_TMP_MIN_AGE_SECONDS。
+    mtime 兜底：pip 正在跑时其临时目录 mtime 持续刷新，不会被误删。
+
+    Args:
+        tmp_dir: 某用户的 tmp 目录绝对路径（如 .../<user>/tmp）
+        now_ts: 当前时间戳（秒），用于 mtime 比较
+
+    Returns:
+        待删目录的绝对路径列表（已通过 mtime 判定）。tmp_dir 不存在时返回 []。
+    """
+    if not os.path.isdir(tmp_dir):
+        return []
+    min_age = _PIP_TMP_MIN_AGE_SECONDS
+    targets = []
+    try:
+        for name in os.listdir(tmp_dir):
+            if not name.startswith(_PIP_TMP_PREFIXES):
+                continue
+            target = os.path.join(tmp_dir, name)
+            try:
+                mtime = os.path.getmtime(target)
+            except OSError:
+                continue  # 已不在或无法 stat，跳过
+            if now_ts - mtime < min_age:
+                continue  # 还"新"，可能在跑，跳过
+            targets.append(target)
+    except OSError:
+        pass
+    return targets
+
+
+def cleanup_user_pip_tmp_residue(user_id: str, now_ts: float = None) -> int:
+    """同步清理单个用户 tmp/ 下的 pip 残留（仅沙箱侧，不碰 MinIO）。
+
+    user_id 经 _sanitize_user_id 归一化后定位到 {WORKSPACE_BASE}/<user>/tmp/。
+    当该用户工作目录不存在时直接返回 0（不报错、不创建、不遍历）。
+
+    Args:
+        user_id: 用户ID
+        now_ts: 当前时间戳；None 则取 datetime.now().timestamp()
+
+    Returns:
+        实际删除的目录数量。
+    """
+    if now_ts is None:
+        now_ts = datetime.now().timestamp()
+    tmp_dir = os.path.join(WORKSPACE_BASE, _sanitize_user_id(user_id), "tmp")
+    if not os.path.isdir(tmp_dir):
+        # 用户工作区不存在 → 不创建、不遍历，直接返回 0
+        return 0
+    removed = 0
+    for target in _collect_pip_tmp_targets(tmp_dir, now_ts):
+        try:
+            shutil.rmtree(target, ignore_errors=True)
+            removed += 1
+        except Exception:
+            pass  # 单个删失败不影响其它
+    return removed
+
+
+def cleanup_all_pip_tmp_residue(now_ts: float = None) -> int:
+    """同步清理所有用户工作区 tmp/ 下的 pip 残留（仅沙箱侧，不碰 MinIO）。
+
+    遍历 {WORKSPACE_BASE} 下每个 <user>/tmp/（不存在的跳过），删除匹配前缀且
+    mtime 超过阈值的 pip 残留目录。供「服务启动」时一次性全量清理。
+
+    Args:
+        now_ts: 当前时间戳；None 则取 datetime.now().timestamp()
+
+    Returns:
+        实际删除的目录数量。
+    """
+    if now_ts is None:
+        now_ts = datetime.now().timestamp()
+    if not os.path.isdir(WORKSPACE_BASE):
+        return 0
+    removed = 0
+    # 逐用户：snapshot listdir，避免遍历时目录被增删导致异常
+    for user_dir in list(os.listdir(WORKSPACE_BASE)):
+        tmp_dir = os.path.join(WORKSPACE_BASE, user_dir, "tmp")
+        # tmp_dir 不存在直接跳过（不创建、不报错）
+        if not os.path.isdir(tmp_dir):
+            continue
+        for target in _collect_pip_tmp_targets(tmp_dir, now_ts):
+            try:
+                shutil.rmtree(target, ignore_errors=True)
+                removed += 1
+            except Exception:
+                pass
+    return removed
+
+
+async def cleanup_all_pip_tmp_residue_async(now_ts: float = None) -> int:
+    """异步全量清理所有用户 tmp pip 残留（沙箱 + MinIO 双删）。
+
+    服务启动时调用。沙箱删除放线程池不阻塞事件循环；MinIO 按用户批量删
+    {user}/current/tmp/pip-* 前缀（沙箱文件已同步上 MinIO，故需双删）。
+    """
+    if now_ts is None:
+        now_ts = datetime.now().timestamp()
+    # 1. 沙箱侧：线程池删除
+    try:
+        removed = await asyncio.to_thread(cleanup_all_pip_tmp_residue, now_ts)
+        if removed:
+            SYLogger.info(f"[Sandbox Server] 清理 tmp pip 残留: {removed} 个目录")
+    except Exception as e:
+        removed = 0
+        SYLogger.warning(f"[Sandbox Server] 清理 tmp pip 残留异常: {e}")
+
+    # 2. MinIO 侧：按用户删 {user}/current/tmp/pip-* 前缀（容错，不可用就跳过）
+    try:
+        from sycommon.agent.sandbox.minio_sync import MinioSyncService
+        service = MinioSyncService()
+        if service.is_available():
+            minio_removed = await service.acleanup_pip_tmp(now_ts=now_ts)
+            if minio_removed:
+                SYLogger.info(f"[Sandbox Server] 清理 MinIO tmp pip 残留: {minio_removed} 个对象")
+    except Exception as e:
+        # MinIO 清理失败不影响沙箱清理结果
+        SYLogger.warning(f"[Sandbox Server] 清理 MinIO tmp pip 残留异常: {e}")
+    return removed
+
+
+async def cleanup_user_pip_tmp_residue_async(user_id: str, now_ts: float = None) -> int:
+    """异步清理单个用户 tmp pip 残留（沙箱 + MinIO 双删）。
+
+    对话结束后调用。沙箱删除放线程池；MinIO 删该用户的 {user}/current/tmp/pip-* 前缀。
+    """
+    if now_ts is None:
+        now_ts = datetime.now().timestamp()
+    # 1. 沙箱侧
+    try:
+        removed = await asyncio.to_thread(cleanup_user_pip_tmp_residue, user_id, now_ts)
+    except Exception as e:
+        removed = 0
+        SYLogger.warning(f"[Sandbox Server] 清理用户 {user_id} tmp pip 残留异常: {e}")
+
+    # 2. MinIO 侧（容错）
+    try:
+        from sycommon.agent.sandbox.minio_sync import MinioSyncService
+        service = MinioSyncService()
+        if service.is_available():
+            await service.acleanup_pip_tmp_for_user(user_id, now_ts=now_ts)
+    except Exception as e:
+        SYLogger.warning(f"[Sandbox Server] 清理用户 {user_id} MinIO tmp pip 残留异常: {e}")
+    return removed
+
+
 # ============== 常量配置 ==============
 
 MAX_OUTPUT_BYTES = 100_000
@@ -1109,7 +1289,8 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
                 try:
                     entries = sorted(os.scandir(dir_path), key=lambda e: (
                         not e.is_dir(follow_symlinks=False), e.name.lower()))
-                except PermissionError:
+                except OSError:
+                    # 枚举期间目录被删除/失联（PermissionError/FileNotFoundError 等）
                     return node
 
                 for entry in entries:
@@ -1127,11 +1308,16 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
                         child = build_tree(abs_path, virtual_path, depth + 1)
                         node.children.append(child)
                     else:
+                        # stat 单独取，跳过枚举期间被删除的瞬时文件（TOCTOU）
+                        try:
+                            st = entry.stat()
+                        except OSError:
+                            continue
                         child = TreeNode(
                             path=virtual_path,
                             name=entry.name,
                             is_dir=False,
-                            size=entry.stat().st_size,
+                            size=st.st_size,
                         )
                         node.children.append(child)
 

{sycommon_python_lib-0.2.7a23 → sycommon_python_lib-0.2.7a25}/src/sycommon/services.py

@@ -333,10 +333,17 @@ class Services(metaclass=SingletonMeta):
 
                 # 5. 启动沙箱后台清理任务（如果沙箱服务启用）
                 if instance._enable_sandbox:
-                    from sycommon.middleware.sandbox import _cleanup_finished_processes
+                    from sycommon.middleware.sandbox import (
+                        _cleanup_finished_processes,
+                        cleanup_all_pip_tmp_residue_async,
+                    )
                     sandbox_cleanup_task = asyncio.create_task(
                         _cleanup_finished_processes())
                     logging.info("沙箱后台清理任务已启动")
+                    # 服务启动即全量清理一次 tmp 目录的 pip 残留（沙箱 + MinIO 双删）。
+                    # fire-and-forget：不阻塞启动，失败只记日志。
+                    asyncio.create_task(cleanup_all_pip_tmp_residue_async())
+                    logging.info("沙箱 tmp pip 残留启动清理任务已触发")
 
                 # 6. 初始化 MCP Server（路由已全部注册，可安全读取 OpenAPI schema）
                 if instance._enable_mcp_server:

{sycommon_python_lib-0.2.7a23 → sycommon_python_lib-0.2.7a25}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.7a23
+Version: 0.2.7a25
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown