sycommon-python-lib 0.2.7a40__tar.gz → 0.2.7a41__tar.gz

{sycommon_python_lib-0.2.7a40 → sycommon_python_lib-0.2.7a41}/PKG-INFO

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

{sycommon_python_lib-0.2.7a40 → sycommon_python_lib-0.2.7a41}/pyproject.toml

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

{sycommon_python_lib-0.2.7a40 → sycommon_python_lib-0.2.7a41}/src/sycommon/agent/sandbox/http_sandbox_backend.py

@@ -467,11 +467,18 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                         import asyncio
                         loop = asyncio.new_event_loop()
                         try:
-                            restored = loop.run_until_complete(
-                                minio.restore_from_minio(self, self._user_id))
-                            workspace_restored = restored > 0
-                            SYLogger.info(
-                                f"[Sandbox] MinIO 恢复完成: {restored} 个文件")
+                            try:
+                                # 🔑 restore 任何异常（含 MINIO_RESTORE_MAX_BYTES 字节上限提前结束）
+                                # 都绝不阻断故障转移切换——这里吞掉异常只记日志，
+                                # 会话末尾的全量扫描会兜底补齐缺失文件。
+                                restored = loop.run_until_complete(
+                                    minio.restore_from_minio(self, self._user_id))
+                                workspace_restored = restored > 0
+                                SYLogger.info(
+                                    f"[Sandbox] MinIO 恢复完成: {restored} 个文件")
+                            except Exception as re:
+                                SYLogger.warning(
+                                    f"[Sandbox] MinIO 恢复异常(不阻断切换): {re}")
                         finally:
                             # restore_from_minio 复用了共享 backend self，内部经
                             # aupload_files -> _get_async_session() 的 loop 不匹配逻辑，
@@ -494,7 +501,7 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
                             loop.close()
                 except Exception as e:
                     SYLogger.warning(
-                        f"[Sandbox] MinIO 恢复失败: {e}")
+                        f"[Sandbox] MinIO 恢复失败(不阻断切换): {e}")
 
                 if not workspace_restored:
                     SYLogger.info(

{sycommon_python_lib-0.2.7a40 → sycommon_python_lib-0.2.7a41}/src/sycommon/agent/sandbox/minio_sync.py

@@ -35,6 +35,12 @@ _RESTORE_GLOBAL_CAP = 100
 # 全局信号量惰性创建（绑定到首次调用时的 event loop；单 loop 部署下不变）。
 _RESTORE_DOWNLOAD_SEM: "asyncio.Semaphore | None" = None
 
+# restore_from_minio 的单用户总字节上限（OOM 兜底）。
+# 旧实现 gather 所有文件内容进内存后才分批上传，用户 MinIO 里文件多/大时会一次性几 GB 驻留 → OOM。
+# 新实现分批流水线（下 N 个→传 N 个→字节出作用域），同时按 list_objects 的 size 累加，
+# 超过本上限则跳过剩余文件（仅 warning，不报错；会话末尾的全量扫描仍兜底）。
+_MAX_RESTORE_BYTES = int(os.environ.get("MINIO_RESTORE_MAX_BYTES", 4 * 1024 ** 3))
+
 
 def _get_restore_download_sem() -> "asyncio.Semaphore":
     """惰性创建全局下载信号量。"""
@@ -698,9 +704,12 @@ class MinioSyncService(metaclass=SingletonMeta):
 
         try:
             coro = _run()
-            self._background_tasks.add(coro)
-            coro.add_done_callback(self._background_tasks.discard)
-            asyncio.ensure_future(coro)
+            # 🔑 必须先 ensure_future 拿到 Task 再 add_done_callback——裸 coroutine 没有
+            # add_done_callback 方法（旧代码先 coro.add_done_callback 会抛 AttributeError，
+            # 而 except RuntimeError 抓不住，导致有 running loop 时直推静默失败）。
+            task = asyncio.ensure_future(coro)
+            self._background_tasks.add(task)
+            task.add_done_callback(self._background_tasks.discard)
         except RuntimeError:
             # 无运行中的事件循环（极少数调用上下文），退化为后台线程兜底
             import threading
@@ -715,6 +724,66 @@ class MinioSyncService(metaclass=SingletonMeta):
                 target=_bg, name=f"minio-userpush-{user_id}", daemon=True
             ).start()
 
+    def push_user_files_from_disk(self, user_id: str, files: list[tuple[str, str]]) -> None:
+        """从磁盘文件 fire-and-forget 直推 MinIO（OOM 友好版本）。
+
+        与 push_user_files_batch 同义，但 files 是 [(相对路径, 本地磁盘绝对路径), ...]，
+        逐文件【读盘上传】，不在内存里同时持有所有附件的 bytes——企微一条消息多张大图场景下，
+        旧 push_user_files_batch 要把所有图 bytes 攒在 list 里直到后台推送结束，内存随附件数线性涨。
+
+        files 里的相对路径规范化（strip ./ 与前导斜杠）与 push_user_files_batch 一致；
+        object_key 复用 make_user_file_key → {user_id}/current/{path}。
+        """
+        if not self.is_available():
+            return
+        # 规范化：(相对路径, 磁盘路径)，去掉空值
+        norm = []
+        for fp, disk in files:
+            if not fp or not disk:
+                continue
+            clean = fp.replace("\\", "/").lstrip("./").lstrip("/")
+            if not clean:
+                continue
+            norm.append((clean, disk))
+        if not norm:
+            return
+
+        def _push_sync():
+            ok = 0
+            for fp, disk in norm:
+                try:
+                    with open(disk, "rb") as f:
+                        content = f.read()
+                    object_key = self.make_user_file_key(user_id, fp)
+                    mt, _ = mimetypes.guess_type(fp)
+                    if self.upload_bytes(
+                        object_key, content,
+                        content_type=mt or "application/octet-stream",
+                    ):
+                        ok += 1
+                    # content 随循环迭代出作用域，下一文件前可被 GC
+                except Exception as e:
+                    SYLogger.warning(f"[MinIO] push_from_disk 单文件失败: {fp}, {e}")
+            SYLogger.info(f"[MinIO] 用户文件已直推(from-disk): user={user_id}, ok={ok}/{len(norm)}")
+
+        async def _run():
+            try:
+                await asyncio.to_thread(_push_sync)
+            except Exception as e:
+                SYLogger.warning(f"[MinIO] 用户文件直推失败(from-disk): user={user_id}, error={e}")
+
+        try:
+            coro = _run()
+            # 🔑 必须先 ensure_future 拿到 Task 再 add_done_callback（裸 coroutine 无该方法）
+            task = asyncio.ensure_future(coro)
+            self._background_tasks.add(task)
+            task.add_done_callback(self._background_tasks.discard)
+        except RuntimeError:
+            import threading
+            threading.Thread(
+                target=_push_sync, name=f"minio-diskpush-{user_id}", daemon=True
+            ).start()
+
     # ============== 反向同步（MinIO → 沙箱） ==============
 
     async def restore_from_minio(self, sandbox_backend, user_id: str) -> int:
@@ -778,15 +847,22 @@ class MinioSyncService(metaclass=SingletonMeta):
 
         SYLogger.info(f"[MinIO] 需恢复 {len(to_restore)} 个文件到沙箱: user={user_id}")
 
-        # 4. 并发恢复：两层限流。
+        # 4. 并发恢复：两层限流 + 分批流水线。
         #   - per_user_sem（每次 restore 新建，本用户独享 5 槽）：单用户恢复够快；
-        #   - global_sem（进程级 15 槽）：多用户同时恢复时全局封顶，防 N×5 路下载
+        #   - global_sem（进程级 100 槽）：多用户同时恢复时全局封顶，防 N×5 路下载
         #     打满线程池、挤占主请求路径的沙箱操作。
-        # 下载协程先抢本用户 5 槽、再抢全局 15 槽，故实际并发 = min(本用户待下载, 全局剩余)。
+        # 下载协程先抢本用户 5 槽、再抢全局 100 槽，故实际并发 = min(本用户待下载, 全局剩余)。
+        #
+        # 🔑 OOM 兜底：旧实现 gather 所有文件内容进 downloaded 列表后才上传，用户文件多/大
+        #   一次几 GB 进内存。改为【分批流水线】：下 _RESTORE_PER_USER 个→立即上传→字节出作用域
+        #   →下一批。同时按 list_objects 的 size 累加 total_bytes_seen，超 _MAX_RESTORE_BYTES 跳过剩余。
         restored = 0
         global_sem = _get_restore_download_sem()
         per_user_sem = asyncio.Semaphore(_RESTORE_PER_USER)
 
+        # objects[].size 是 list_objects 返回的字节大小，用它预判总量，避免下完才知道超限
+        obj_size_map = {o.object_name[len(prefix):]: (o.size or 0) for o in objects}
+
         async def _download_one(rel_path: str):
             """下载单个 MinIO 对象到内存，返回 (沙箱绝对路径, 内容) 或 None。"""
             async with per_user_sem, global_sem:
@@ -807,19 +883,37 @@ class MinioSyncService(metaclass=SingletonMeta):
                     SYLogger.warning(f"[MinIO] 下载文件失败: {rel_path}, error: {e}")
                     return None
 
-        # 全量并发下载(受两层 Semaphore 限流)，比按批串行快得多
-        download_results = await asyncio.gather(
-            *[_download_one(rp) for rp in to_restore]
-        )
-        downloaded = [r for r in download_results if r is not None]
-
-        # 上传仍走 batch_upload(服务端并发)，按 5 个一批发(沙箱端点对超大批量可能限流)
-        for i in range(0, len(downloaded), _RESTORE_PER_USER):
-            batch = downloaded[i:i + _RESTORE_PER_USER]
-            if not batch:
+        # 分批流水线：下 N 个 → 传 N 个 → 字节随 downloaded/download_results 出作用域释放
+        total_bytes_seen = 0
+        capped = False
+        batch_size = _RESTORE_PER_USER
+        idx = 0
+        while idx < len(to_restore):
+            batch_paths = to_restore[idx:idx + batch_size]
+            idx += len(batch_paths)
+
+            # 字节上限预判：超限则放弃本批及后续（仅 warning，会话末尾全量扫描兜底）
+            for rp in batch_paths:
+                sz = obj_size_map.get(rp, 0)
+                if sz > 0 and total_bytes_seen + sz > _MAX_RESTORE_BYTES:
+                    remaining = (len(to_restore) - idx) + len(batch_paths)
+                    SYLogger.warning(
+                        f"[MinIO] restore 字节上限触发 ({_MAX_RESTORE_BYTES} bytes)，"
+                        f"跳过剩余约 {remaining} 个文件: user={user_id}")
+                    capped = True
+                    break
+                total_bytes_seen += sz
+            if capped:
+                break
+
+            download_results = await asyncio.gather(
+                *[_download_one(rp) for rp in batch_paths]
+            )
+            downloaded = [r for r in download_results if r is not None]
+            if not downloaded:
                 continue
             try:
-                results = await sandbox_backend.aupload_files(batch)
+                results = await sandbox_backend.aupload_files(downloaded)
                 for r in results:
                     if not r.error:
                         restored += 1
@@ -828,7 +922,13 @@ class MinioSyncService(metaclass=SingletonMeta):
                             f"[MinIO] 上传到沙箱失败: {r.path}, error={r.error}")
             except Exception as e:
                 SYLogger.warning(f"[MinIO] 批量上传到沙箱失败: {e}")
+            # downloaded / download_results 到此出作用域，下一批前可被 GC
 
-        SYLogger.info(
-            f"[MinIO] 恢复完成: user={user_id}, restored={restored}/{len(to_restore)}")
+        if capped:
+            SYLogger.warning(
+                f"[MinIO] 恢复提前结束(字节上限): user={user_id}, "
+                f"restored={restored}/{len(to_restore)}")
+        else:
+            SYLogger.info(
+                f"[MinIO] 恢复完成: user={user_id}, restored={restored}/{len(to_restore)}")
         return restored

{sycommon_python_lib-0.2.7a40 → sycommon_python_lib-0.2.7a41}/src/sycommon_python_lib.egg-info/PKG-INFO

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