优化

src/moldinsight/services/processing_service.py

@@ -3,14 +3,16 @@
 
 import asyncio
 import os
+import shutil
+import tempfile
 import time
-import traceback
 from collections import OrderedDict
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from pathlib import Path
-from typing import Optional, Dict, Any, List
+from typing import Optional, Dict, Any, List, Tuple
 
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from moldinsight.core.stp_parser import STPParser
@@ -19,11 +21,13 @@ from moldinsight.core.mesh_generator import MeshGenerator
 from moldinsight.core.multi_scheme_planner import MultiSchemeMoldPlanner
 from moldinsight.core.cad_exporter import CADExporter
 from moldinsight.services.storage_integration_rustfs import StorageIntegrationService
+from moldinsight.storage.rustfs_storage import rustfs_manager
 from shared.services.redis_task_manager import redis_task_manager
 from moldinsight.services.material_service import MaterialService
 from moldinsight.services.calculation_service import CalculationService
 from moldinsight.services.llm_service import llm_service
 from shared.models.schemas import ProcessingStatus
+from shared.models.database import STPFile
 from shared.database.database import db_manager
 from shared.utils.html_generator import HTMLGenerator
 from shared.utils.logger import get_logger
@@ -71,23 +75,73 @@ class ProcessingService:
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(self._occ_executor, fn, *args)
 
+    async def _materialize_source_file(self, stp_file: STPFile) -> Tuple[Path, Optional[Path]]:
+        """把待处理文件落到本地磁盘，返回 (本地路径, 临时目录或 None)。
+
+        RustFS 为主存储：处理方按 object_key 下载到任务专属临时目录
+        （文件名保留原始名——下游产物命名依赖 Path(file_path).name）。
+        RustFS 不可用或对象缺失时回退 STPFile.file_path 记录的节点本地路径
+        （依赖 compose 共享卷，属过渡方案）；两者皆不可用则抛错置任务失败。
+        """
+        original_name = Path(stp_file.original_filename or "model.stp").name or "model.stp"
+
+        if stp_file.object_key:
+            temp_dir = Path(tempfile.mkdtemp(prefix=f"moldinsight_{stp_file.id}_"))
+            try:
+                data = await rustfs_manager.download_file(
+                    file_type="stp_files", object_key=stp_file.object_key
+                )
+                target = temp_dir / original_name
+                target.write_bytes(data)
+                return target, temp_dir
+            except Exception as exc:
+                shutil.rmtree(temp_dir, ignore_errors=True)
+                logger.warning(
+                    f"RustFS 源文件下载失败 (object_key={stp_file.object_key})，"
+                    f"回退节点本地路径: {exc}"
+                )
+
+        local = Path(stp_file.file_path) if stp_file.file_path else None
+        if local and local.exists():
+            return local, None
+
+        raise RuntimeError(
+            f"源文件不可用：RustFS 对象 {stp_file.object_key!r} 下载失败，"
+            f"且节点本地路径不存在: {stp_file.file_path!r}"
+        )
+
     async def process_file_with_storage(
         self,
         task_id: str,
-        file_path: str,
         stp_file_id: int,
         process_params: Optional[Dict[str, Any]] = None,
     ):
-        """处理文件的后台任务 — 使用独立数据库会话"""
+        """处理文件的后台任务 — 使用独立数据库会话
+
+        分派入参只带 stp_file_id（D6）：源文件由本方法按 PG 元数据中的
+        object_key 从 RustFS 获取，不再依赖分派方传入节点本地路径
+        （API 与 Celery worker 容器文件系统不互通）。
+        """
 
         # 创建独立的数据库会话，避免请求范围会话关闭
         async with db_manager.session() as db_session:
+            temp_dir: Optional[Path] = None
             try:
+                result = await db_session.execute(
+                    select(STPFile).where(STPFile.id == stp_file_id)
+                )
+                stp_file = result.scalar_one_or_none()
+                if not stp_file:
+                    raise RuntimeError(f"STPFile 记录不存在: stp_file_id={stp_file_id}")
+
+                source_path, temp_dir = await self._materialize_source_file(stp_file)
+                file_path = str(source_path)
+
                 logger.info(f"开始处理文件并生成模具型腔: {file_path}")
 
                 from shared.config.settings import settings
 
-                file_size_bytes = Path(file_path).stat().st_size if Path(file_path).exists() else 0
+                file_size_bytes = source_path.stat().st_size
                 file_size_mb = max(file_size_bytes / (1024 * 1024), 1)
                 timeout_seconds = min(
                     max(settings.PROCESSING_TIMEOUT_BASE, int(file_size_mb * settings.PROCESSING_TIMEOUT_PER_MB)),
@@ -111,12 +165,16 @@ class ProcessingService:
             except Exception as e:
                 logger.error(f"模具型腔生成失败: {e}")
 
+                # D9：先丢弃未提交的数据本体，失败状态单独提交，
+                # 避免 failed 更新把半成品 flush 数据一起带上
+                await db_session.rollback()
+
                 await self.storage_service.update_stp_file_status(db_session, stp_file_id, "failed")
                 await self.storage_service.update_task_status(
                     db_session, task_id, "failed", error_message=str(e)
                 )
 
-                # 安全更新 Redis 任务状态
+                # 安全更新 Redis 任务状态（Redis 仅热缓存，写失败不影响 PG 事实）
                 task = await redis_task_manager.get_task(task_id)
                 if task:
                     await redis_task_manager.update_task(task_id, {
@@ -124,6 +182,10 @@ class ProcessingService:
                         "error": str(e),
                         "completed_at": str(datetime.now()),
                     })
+            finally:
+                # 任务专属临时目录必须清理，长期运行不允许残留下载副本
+                if temp_dir:
+                    shutil.rmtree(temp_dir, ignore_errors=True)
 
     async def process_file_core(
         self,
@@ -234,6 +296,10 @@ class ProcessingService:
                 geometry_data.get("analysis_method", "mold_cavity"),
             )
 
+            # 阶段 A 提交（D9）：几何 + 网格原子落库——解析后的确定成果，
+            # 后续型腔失败任务标 failed 时这些数据仍完整保留
+            await db_session.commit()
+
             # 7. 生成HTML可视化
             await self.storage_service.update_task_status(
                 db_session, task_id, "processing", 85, "生成可视化报告"
@@ -325,6 +391,11 @@ class ProcessingService:
                 ),
             )
 
+            # 9.65 阶段 B 提交（D9）：型腔 / HTML / 特征 / 指标 / 摘要 / 验证指标
+            # 作为完整结果包原子落库——置 completed 前必须全部就位，
+            # 期间任一步失败回滚后任务标 failed，不会出现"completed 但数据残缺"
+            await db_session.commit()
+
             # 9.7 FreeCAD 几何验证
             stage_started = time.perf_counter()
             verification_result = await self._step_verify(
@@ -347,11 +418,7 @@ class ProcessingService:
                 )
             stage_timings["generate_llm_report"] = round(time.perf_counter() - stage_started, 3)
 
-            # 10. 完成处理
-            await self.storage_service.update_stp_file_status(db_session, stp_file_id, "completed")
-            await self.storage_service.update_task_status(
-                db_session, task_id, "completed", 100, "模具型腔生成完成"
-            )
+            # 10. 完成处理——先 flush 任务参数，完成状态提交时一并原子落库（D9）
             await self.storage_service.update_task_parameters(
                 db_session,
                 task_id,
@@ -364,6 +431,10 @@ class ProcessingService:
                     **process_params,
                 },
             )
+            await self.storage_service.update_stp_file_status(db_session, stp_file_id, "completed")
+            await self.storage_service.update_task_status(
+                db_session, task_id, "completed", 100, "模具型腔生成完成"
+            )
 
             # 更新任务缓存状态（仅保留轻量摘要，完整数据由PG+RustFS持久化；
             # 完成态视图由 TaskQueryService 从 PG+RustFS 组装，Redis 不再存
@@ -390,6 +461,9 @@ class ProcessingService:
         except Exception as e:
             logger.error(f"模具型腔生成失败: {e}")
 
+            # D9：先丢弃未提交的数据本体再置失败（同外层说明）
+            await db_session.rollback()
+
             await self.storage_service.update_stp_file_status(db_session, stp_file_id, "failed")
             await self.storage_service.update_task_status(
                 db_session, task_id, "failed", error_message=str(e)
@@ -471,29 +545,29 @@ class ProcessingService:
 
     async def _step_generate_cavity(
         self, shape, selected_material: dict, is_foam_material: bool, process_params: Dict[str, Any],
-    ) -> Optional[Dict[str, Any]]:
-        """生成多方案分模结果"""
-        plan_result = None
-        try:
-            if shape:
-                loop = asyncio.get_running_loop()
-                plan_result = await loop.run_in_executor(
-                    self._occ_executor,
-                    lambda: self.multi_scheme_planner.generate_plan(
-                        shape=shape,
-                        material=selected_material,
-                        is_foam_material=is_foam_material,
-                        process_params=process_params,
-                    ),
-                )
-                logger.info(
-                    f"多方案分模完成: 生成 {len(plan_result.get('candidate_schemes', []))} 套方案"
-                )
-        except Exception as cavity_err:
-            logger.warning(f"多方案分模失败，使用简化数据: {cavity_err}")
-            traceback.print_exc()
-            plan_result = None
+    ) -> Dict[str, Any]:
+        """生成多方案分模结果。
 
+        D8：型腔是任务的核心产出，生成失败必须让任务 failed——
+        此前异常在此被吞掉置 plan_result=None 继续主流程，最终任务
+        completed，"完成"状态不可信。异常直接向编排层传播。
+        """
+        if not shape:
+            raise RuntimeError("无有效几何 shape，无法生成模具型腔")
+
+        loop = asyncio.get_running_loop()
+        plan_result = await loop.run_in_executor(
+            self._occ_executor,
+            lambda: self.multi_scheme_planner.generate_plan(
+                shape=shape,
+                material=selected_material,
+                is_foam_material=is_foam_material,
+                process_params=process_params,
+            ),
+        )
+        logger.info(
+            f"多方案分模完成: 生成 {len(plan_result.get('candidate_schemes', []))} 套方案"
+        )
         return plan_result
 
     def _cache_export_shapes(self, task_id: str, export_shapes: Dict[str, Dict[str, Any]]):
@@ -727,7 +801,8 @@ class ProcessingService:
         )
 
         session.add(metrics)
-        await session.commit()
+        # D9：flush 不 commit，随结果包（阶段 B）由编排层统一提交
+        await session.flush()
         logger.info(f"分析指标保存成功: {metrics.id}")
 
     async def _save_verification_metrics(self, session: AsyncSession, stp_file_id: int, verification_result: dict):
@@ -759,7 +834,8 @@ class ProcessingService:
             )
             session.add(metrics)
 
-        await session.commit()
+        # D9：flush 不 commit，随结果包（阶段 B）由编排层统一提交
+        await session.flush()
         logger.info(f"验证指标保存成功: stp_file_id={stp_file_id}")
 
 

src/moldinsight/services/storage_integration_rustfs.py

@@ -121,7 +121,8 @@ class StorageIntegrationService:
         )
 
         session.add(stp_file)
-        await session.commit()
+        # D9：仅 flush，与 ProcessingTask 由路由层一并原子提交（避免孤儿文件记录）
+        await session.flush()
         await session.refresh(stp_file)
 
         logger.info(f"STP文件保存成功 RustFS: {stp_file.id}, 批次: {batch_id}")
@@ -134,8 +135,11 @@ class StorageIntegrationService:
         stp_file_id: int,
         task_type: str = "stp_parsing",
         parameters: Optional[Dict[str, Any]] = None,
+        batch_id: Optional[str] = None,
     ) -> ProcessingTask:
-        """创建处理任务记录"""
+        """创建处理任务记录（D9：仅 flush 不 commit，事务由调用方收口——
+        与 STPFile 记录同批提交，避免留下无任务的孤儿文件记录；batch_id 用于批量任务聚合查询）
+        """
         try:
             task = ProcessingTask(
                 task_id=task_id,
@@ -144,15 +148,15 @@ class StorageIntegrationService:
                 status="pending",
                 started_time=datetime.now(),
                 parameters=parameters or {},
+                batch_id=batch_id,
             )
-            
+
             session.add(task)
-            await session.commit()
-            await session.refresh(task)
-            
+            await session.flush()
+
             logger.info(f"处理任务创建成功: {task_id}")
             return task
-            
+
         except Exception as e:
             await session.rollback()
             logger.error(f"创建处理任务失败: {e}")
@@ -167,7 +171,8 @@ class StorageIntegrationService:
         current_step: Optional[str] = None,
         error_message: Optional[str] = None
     ):
-        """更新任务状态"""
+        """更新任务状态（保留即时 commit：进度/状态需跨事务对外可见，
+        处理链路中的各阶段进度依赖它落库——D9 收口仅针对数据本体写方法）"""
         try:
             update_data = {
                 "status": status,
@@ -200,7 +205,7 @@ class StorageIntegrationService:
         task_id: str,
         parameters: Dict[str, Any],
     ):
-        """合并更新任务参数，便于保存阶段耗时等元数据。"""
+        """合并更新任务参数，便于保存阶段耗时等元数据。（D9：flush 不 commit，事务由调用方收口）"""
         try:
             task = await session.execute(
                 select(ProcessingTask).where(ProcessingTask.task_id == task_id)
@@ -212,14 +217,14 @@ class StorageIntegrationService:
             merged = dict(task.parameters or {})
             merged.update(parameters or {})
             task.parameters = merged
-            await session.commit()
+            await session.flush()
         except Exception as e:
             await session.rollback()
             logger.error(f"更新任务参数失败: {e}")
             raise
 
     async def update_stp_file_status(self, session: AsyncSession, stp_file_id: int, status: str):
-        """更新STP文件状态"""
+        """更新STP文件状态（保留即时 commit，理由同 update_task_status）"""
         try:
             await session.execute(
                 update(STPFile)
@@ -280,7 +285,8 @@ class StorageIntegrationService:
         )
 
         session.add(geometry_data)
-        await session.commit()
+        # D9：数据本体仅 flush，与网格等同阶段数据由编排层统一 commit（原子落库）
+        await session.flush()
         await session.refresh(geometry_data)
 
         logger.info(f"几何数据保存成功 RustFS: {geometry_data.id}")
@@ -336,7 +342,8 @@ class StorageIntegrationService:
         )
 
         session.add(mesh_data)
-        await session.commit()
+        # D9：数据本体仅 flush，与几何数据同阶段由编排层统一 commit
+        await session.flush()
         await session.refresh(mesh_data)
 
         logger.info(f"网格数据保存成功 RustFS: {mesh_data.id}")
@@ -417,7 +424,8 @@ class StorageIntegrationService:
         )
 
         session.add(mold_cavity)
-        await session.commit()
+        # D9：数据本体仅 flush，型腔/HTML/特征同属结果包，由编排层统一 commit
+        await session.flush()
         await session.refresh(mold_cavity)
 
         logger.info(f"模具型腔数据保存成功 RustFS: {mold_cavity.id}")
@@ -466,7 +474,8 @@ class StorageIntegrationService:
         )
 
         session.add(html_file)
-        await session.commit()
+        # D9：数据本体仅 flush，型腔/HTML/特征同属结果包，由编排层统一 commit
+        await session.flush()
         await session.refresh(html_file)
 
         logger.info(f"HTML文件保存成功 RustFS: {html_file.id}")
@@ -504,7 +513,8 @@ class StorageIntegrationService:
             )
             session.add(rec_record)
 
-        await session.commit()
+        # D9：数据本体仅 flush，型腔/HTML/特征同属结果包，由编排层统一 commit
+        await session.flush()
         logger.info(f"保存了 {len(features)} 个特征和 {len(recommendations)} 个建议")
 
     async def log_user_activity(self, session: AsyncSession,
@@ -798,7 +808,8 @@ class StorageIntegrationService:
                     .where(STPFile.id == stp_file_id)
                     .values(**update_data)
                 )
-                await session.commit()
+                # D9：flush 不 commit，随结果包由编排层统一提交
+                await session.flush()
                 logger.info(f"STP文件分析摘要更新: ID {stp_file_id}")
                 
         except Exception as e:

src/moldinsight/services/task_dispatcher.py

@@ -28,23 +28,28 @@ _background_tasks: set = set()
 _dispatch_semaphore = asyncio.Semaphore(2)
 
 
-async def _run_with_limit(task_id: str, file_path: str, stp_file_id: int, process_params: dict):
+async def _run_with_limit(task_id: str, stp_file_id: int, process_params: dict):
     async with _dispatch_semaphore:
         from moldinsight.services.processing_service import processing_service
         await processing_service.process_file_with_storage(
-            task_id, file_path, stp_file_id, process_params
+            task_id, stp_file_id, process_params
         )
 
 
-def dispatch_processing(task_id: str, file_path: str, stp_file_id: int, process_params: dict):
-    """调度 STP 处理任务：优先 Celery（进程隔离），否则 API 进程内 asyncio 后台执行。"""
+def dispatch_processing(task_id: str, stp_file_id: int, process_params: dict):
+    """调度 STP 处理任务：优先 Celery（进程隔离），否则 API 进程内 asyncio 后台执行。
+
+    入参只传 stp_file_id（D6）：源文件由处理方按 PG 元数据从 RustFS 获取，
+    不再跨进程传节点本地路径——API 与 Celery worker 容器文件系统不互通，
+    传路径在容器化部署下必然失败。
+    """
     if _use_celery:
-        process_stp_task.delay(task_id, file_path, stp_file_id, process_params)
+        process_stp_task.delay(task_id, stp_file_id, process_params)
         logger.info(f"[DISPATCH] Celery 任务已调度: task_id={task_id}")
         return
 
     task = asyncio.create_task(
-        _run_with_limit(task_id, file_path, stp_file_id, process_params)
+        _run_with_limit(task_id, stp_file_id, process_params)
     )
     _background_tasks.add(task)
     task.add_done_callback(_background_tasks.discard)

src/moldinsight/services/task_query_service.py

@@ -5,6 +5,7 @@ import time
 from collections import OrderedDict
 from typing import Optional, Dict, Any, List, Tuple
 
+from fastapi import HTTPException
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import joinedload
@@ -55,6 +56,30 @@ class TaskQueryService:
         """任务 parameters 被更新后调用（export-mold / cam 等），使缓存视图失效。"""
         cls._view_cache.pop(task_id, None)
 
+    @staticmethod
+    async def ensure_task_access(
+        db_session: AsyncSession, task_id: str, user_id: int
+    ) -> "Tuple[ProcessingTask, STPFile]":
+        """校验任务存在且属于指定用户：不存在 404，他人/无主任务 403（无主不等于公共）。
+
+        task_router（状态查询）与 advanced_router（导出/倒扣检测等）共用，
+        之前只有 advanced_router 有一份私有实现，/api/status 曾因此漏鉴权。
+        """
+        row = await db_session.execute(
+            select(ProcessingTask, STPFile)
+            .join(STPFile, ProcessingTask.stp_file_id == STPFile.id)
+            .where(ProcessingTask.task_id == task_id)
+        )
+        row = row.first()
+        if not row:
+            raise HTTPException(404, "任务不存在")
+
+        _, stp_file = row
+        if getattr(stp_file, "user_id", None) != user_id:
+            raise HTTPException(403, "无权访问该任务")
+
+        return row
+
     @staticmethod
     async def get_task_view(db_session: AsyncSession, task_id: str) -> Optional[Dict[str, Any]]:
         """
@@ -128,9 +153,17 @@ class TaskQueryService:
             cam_preferences = processing_task.parameters.get("cam_preferences", {}) or {}
             task_parameters = dict(processing_task.parameters)
 
+        # 注意：analysis_metrics 键可能存在但值为 None（storage 未上传指标时），
+        # .get(key, {}) 的默认值对 None 不生效，必须用 or {} 兜底
+        analysis_metrics = file_with_data.get("analysis_metrics") or {}
+
         task_view = {
             "task_id": processing_task.task_id,
             "status": processing_task.status,
+            # D7：PG 是单一事实源——Redis 不可用时本视图即前端拿到的完整状态，
+            # 进度字段必须从 PG 补齐（Redis 路径的 task dict 也会带同名字段）
+            "progress": processing_task.progress or 0,
+            "current_step": processing_task.current_step,
             "filename": stp_file.original_filename if stp_file else "",
             "file_path": stp_file.file_path or "",
             "file_size": stp_file.file_size if stp_file else 0,
@@ -154,18 +187,18 @@ class TaskQueryService:
             "export_artifacts": task_parameters.get("export_artifacts"),
             "stage_timings": task_parameters.get("stage_timings", {}),
             "verification": task_parameters.get("verification")
-            or file_with_data.get("analysis_metrics", {}).get("verification_details"),
+            or analysis_metrics.get("verification_details"),
             "llm_report": task_parameters.get("llm_report"),
             "analysis_result": {
                 "geometry_data": geometry_json,
                 "detected_features": features_json,
                 "design_recommendations": recommendations_json,
                 "quality_metrics": {
-                    "volume_utilization": file_with_data.get("analysis_metrics", {}).get("volume_utilization", 0),
-                    "topology_complexity": file_with_data.get("analysis_metrics", {}).get("topology_complexity", 0),
-                    "wall_uniformity": file_with_data.get("analysis_metrics", {}).get("wall_uniformity", 0)
+                    "volume_utilization": analysis_metrics.get("volume_utilization", 0),
+                    "topology_complexity": analysis_metrics.get("topology_complexity", 0),
+                    "wall_uniformity": analysis_metrics.get("wall_uniformity", 0)
                 },
-                "analysis_summary": file_with_data.get("analysis_metrics", {}).get("analysis_summary", "分析完成")
+                "analysis_summary": analysis_metrics.get("analysis_summary", "分析完成")
             } if geometry_json or features_json or recommendations_json else None,
             "error": processing_task.error_message or stp_file.error_message or None,
         }