Просмотр исходного кода

feat(vas_task): add pause status guards, lifecycle handling, and optimize starter config

Hu Jiarui 2 месяцев назад
Родитель
Сommit
11dd03fb09

+ 9 - 1
app/main.py

@@ -24,7 +24,15 @@ async def lifespan(app: FastAPI):
     yield
 
 
-app = FastAPI(title=settings.app_name, lifespan=lifespan)
+is_prod = settings.env.upper() == "PROD"
+
+app = FastAPI(
+    title=settings.app_name,
+    lifespan=lifespan,
+    docs_url=None if is_prod else "/docs",
+    redoc_url=None if is_prod else "/redoc",
+    openapi_url=None if is_prod else "/openapi.json",
+)
 
 
 # -----------------------

+ 2 - 2
app/services/order_service.py

@@ -74,7 +74,7 @@ class OrderService:
         task_res = await db.execute(
             select(VasTask).where(
                 VasTask.order_id == order.id,
-                VasTask.status.in_(["pending", "grabbed", "running", "completed"]),
+                VasTask.status.in_(["pending", "grabbed", "running", "pause", "completed"]),
             )
         )
         for task in task_res.scalars().all():
@@ -228,7 +228,7 @@ class OrderService:
         task_res = await db.execute(
             select(VasTask).where(
                 VasTask.order_id == order.id,
-                VasTask.status.in_(["pending", "grabbed", "running", "completed"]),
+                VasTask.status.in_(["pending", "grabbed", "running", "pause", "completed"]),
             )
         )
         for task in task_res.scalars().all():

+ 16 - 0
app/services/vas_task_service.py

@@ -192,6 +192,16 @@ class VasTaskService:
 
         if not rec:
             raise NotFoundError("Task not exist")
+
+        if rec.status in ["completed", "cancelled"]:
+            raise BizLogicError(f"Cannot return a {rec.status} task to queue")
+
+        if rec.order_id:
+            order_stmt = select(VasOrder).where(VasOrder.id == rec.order_id)
+            order_result = await db.execute(order_stmt)
+            order = order_result.scalar_one_or_none()
+            if order and order.status in ["closed", "refunded"]:
+                raise BizLogicError("Cannot return task to queue: associated order is closed")
         
         rec.status = "pending"
         await db.commit()
@@ -207,6 +217,12 @@ class VasTaskService:
 
         if not rec:
             raise NotFoundError("Task not exist")
+
+        if rec.status == "pause":
+            return rec
+
+        if rec.status in ["completed", "cancelled"]:
+            raise BizLogicError(f"Cannot pause a {rec.status} task")
         
         rec.status = "pause"
         await db.commit()

+ 1 - 1
app/services/webhook_service.py

@@ -81,7 +81,7 @@ class WebhookService:
             exists_stmt = select(VasTask).where(
                 VasTask.order_id == order.id,
                 VasTask.routing_key == routing.routing_key,
-                VasTask.status.in_(["pending", "grabbed", "running", "completed"]),
+                VasTask.status.in_(["pending", "grabbed", "running", "pause", "completed"]),
             )
             exists_result = await db.execute(exists_stmt)
             exists = exists_result.scalar_one_or_none()

+ 32 - 30
starter.py

@@ -1,14 +1,13 @@
 #!/usr/bin/env python3
 import os
 import sys
-import subprocess
 
 
 def main():
     """
     启动 FastAPI 应用,根据环境选择不同参数:
     - DEV: 热重载,单进程,仅监听 app 目录
-    - PROD: 多进程,高性能 uvloop + httptools
+    - PROD: 多进程,代理头穿透(获取真实IP),高性能 uvloop + httptools,优雅停机
     """
     
     os.environ.setdefault(
@@ -17,61 +16,64 @@ def main():
     )
     
     env = os.getenv("ENV", "DEV").upper()
-    
-    # env = "DEV"
-
-    host = "0.0.0.0"
-    port = "8888"
+    host = os.getenv("HOST", "0.0.0.0")
+    port = os.getenv("PORT", "8888")
     app_module = "app.main:app"
 
-    # 使用 python -m uvicorn 确保在所有平台(特别是 Windows)上都能正常工作
+    # 使用 sys.executable 确保在所有环境使用当前 Python 解释器
     base_cmd = [
-        sys.executable,  # 使用当前 Python 解释器
+        sys.executable,
         "-m", "uvicorn",
         app_module,
         "--host", host,
         "--port", port,
     ]
 
-    if env == "DEV":
-        print("🚀 启动开发环境(热重载)")
+    if env == "PROD":
+        print("🔥 启动生产环境(多进程 + 代理穿透 + 高性能)")
 
-        base_cmd += [
-            "--reload",
-            "--workers", "1",
-
-            # ⭐ 关键:限制监听范围
-            "--reload-dir", "app",
-            "--reload-exclude", ".git",
-            "--reload-exclude", "venv",
-            "--reload-exclude", "__pycache__",
-        ]
-
-    elif env == "PROD":
-        print("🔥 启动生产环境(多进程 + 高性能)")
+        # 容器/生产环境限制:默认限制最大 4 个 Worker,防止物理宿主机多核导致 DB 连接池耗尽与 OOM
+        # 运维可通过 WORKERS 或 WEB_CONCURRENCY 环境变量自定义
+        default_workers = min(os.cpu_count() or 1, 4)
+        workers = os.getenv("WORKERS") or os.getenv("WEB_CONCURRENCY") or str(default_workers)
 
         base_cmd += [
-            "--workers", str(os.cpu_count() or 1),
+            "--workers", str(workers),
             "--loop", "uvloop",
             "--http", "httptools",
+            "--proxy-headers",             # ⭐ 信任反向代理(Nginx等)头信息
+            "--forwarded-allow-ips", "*",   # ⭐ 允许提取真实客户端 IP
+            "--no-access-log",             # 避免与 main.py 的自定义 access_log 中间件重复打印
         ]
 
     else:
-        print(f"⚠️ 未知环境 {env},使用默认 DEV 配置")
+        if env != "DEV":
+            print(f"⚠️ 未知环境 {env},使用默认 DEV 配置")
+        else:
+            print("🚀 启动开发环境(热重载)")
 
         base_cmd += [
             "--reload",
-            "--workers", "1",
             "--reload-dir", "app",
+            "--reload-exclude", "*__pycache__*",
         ]
 
     print("\n执行命令:")
     print(" ", " ".join(base_cmd))
-    print(f"\nSwagger UI: http://{host}:{port}/docs")
-    print(f"ReDoc UI:   http://{host}:{port}/redoc\n")
+    if env != "PROD":
+        print(f"\nSwagger UI: http://{host}:{port}/docs")
+        print(f"ReDoc UI:   http://{host}:{port}/redoc\n")
+    else:
+        print("\n🔒 生产环境(PROD)已禁用 Docs 与 ReDoc\n")
 
-    subprocess.run(base_cmd)
+    # 在 POSIX 环境下使用 execvp 替换当前进程,使 uvicorn 成为 PID 1 直接接收系统 SIGTERM 信号进行优雅停机
+    if sys.platform == "win32":
+        import subprocess
+        subprocess.run(base_cmd)
+    else:
+        os.execvp(base_cmd[0], base_cmd)
 
 
 if __name__ == "__main__":
     main()
+

+ 211 - 0
tests/test_vas_task_pause_guards.py

@@ -0,0 +1,211 @@
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch
+from datetime import datetime
+
+from app.models.vas_task import VasTask
+from app.models.order import VasOrder
+from app.models.product_routing import VasProductRouting
+from app.schemas.order import VasOrderPatchUserInputs
+from app.core.biz_exception import BizLogicError
+from app.services.order_service import OrderService
+from app.services.webhook_service import WebhookService
+from app.services.vas_task_service import VasTaskService
+
+
+class TestVasTaskPauseGuards(unittest.IsolatedAsyncioTestCase):
+
+    async def test_order_cancel_cancels_paused_task(self):
+        db = AsyncMock()
+        order = VasOrder(
+            id="ORD-001",
+            status="paid",
+            product_id=1,
+            user_inputs={}
+        )
+        paused_task = VasTask(
+            id=10,
+            order_id="ORD-001",
+            routing_key="test.routing",
+            status="pause"
+        )
+
+        order_mock = MagicMock()
+        order_mock.scalar_one_or_none.return_value = order
+
+        tasks_mock = MagicMock()
+        tasks_mock.scalars.return_value.all.return_value = [paused_task]
+
+        db.execute.side_effect = [order_mock, tasks_mock]
+
+        cancelled_order = await OrderService.cancel(db, "ORD-001")
+        self.assertEqual(cancelled_order.status, "closed")
+        self.assertEqual(paused_task.status, "cancelled")
+        db.commit.assert_awaited()
+
+    async def test_order_patch_user_inputs_cancels_paused_task(self):
+        db = AsyncMock()
+        order = VasOrder(
+            id="ORD-002",
+            status="paid",
+            product_id=1,
+            user_inputs={"name": "Old"}
+        )
+        paused_task = VasTask(
+            id=20,
+            order_id="ORD-002",
+            routing_key="test.routing",
+            status="pause"
+        )
+
+        order_mock = MagicMock()
+        order_mock.scalar_one_or_none.return_value = order
+
+        tasks_mock = MagicMock()
+        tasks_mock.scalars.return_value.all.return_value = [paused_task]
+
+        db.execute.side_effect = [order_mock, tasks_mock]
+
+        with patch.object(WebhookService, "_create_task_if_not_exists", new_callable=AsyncMock) as mock_create:
+            payload = VasOrderPatchUserInputs(user_inputs={"name": "New"})
+            patched_order = await OrderService.patch_user_inputs(db, "ORD-002", payload)
+            self.assertEqual(paused_task.status, "cancelled")
+            self.assertEqual(patched_order.user_inputs, {"name": "New"})
+            mock_create.assert_awaited_once_with(db, order)
+
+    async def test_webhook_create_task_skips_if_paused_task_exists(self):
+        db = AsyncMock()
+        order = VasOrder(
+            id="ORD-003",
+            product_id=1,
+            status="paid",
+            user_inputs={"email": "test@example.com"}
+        )
+        routing = VasProductRouting(
+            id=1,
+            product_id=1,
+            routing_key="test.routing",
+            is_active=1,
+            priority=10,
+            script_version="v1"
+        )
+        paused_task = VasTask(
+            id=30,
+            order_id="ORD-003",
+            routing_key="test.routing",
+            status="pause"
+        )
+
+        routings_mock = MagicMock()
+        routings_mock.scalars.return_value.all.return_value = [routing]
+
+        exists_mock = MagicMock()
+        exists_mock.scalar_one_or_none.return_value = paused_task
+
+        db.execute.side_effect = [routings_mock, exists_mock]
+
+        created = await WebhookService._create_task_if_not_exists(db, order)
+        # Should skip creation since paused task exists
+        self.assertEqual(created, [])
+        db.add.assert_not_called()
+
+    async def test_pause_rejects_completed_or_cancelled_task(self):
+        db = AsyncMock()
+
+        completed_task = VasTask(id=1, status="completed", order_id="ORD-01")
+        mock_res1 = MagicMock()
+        mock_res1.scalar_one_or_none.return_value = completed_task
+        db.execute.return_value = mock_res1
+
+        with self.assertRaises(BizLogicError) as ctx1:
+            await VasTaskService.pause(db, 1)
+        self.assertIn("Cannot pause a completed task", str(ctx1.exception))
+
+        cancelled_task = VasTask(id=2, status="cancelled", order_id="ORD-02")
+        mock_res2 = MagicMock()
+        mock_res2.scalar_one_or_none.return_value = cancelled_task
+        db.execute.return_value = mock_res2
+
+        with self.assertRaises(BizLogicError) as ctx2:
+            await VasTaskService.pause(db, 2)
+        self.assertIn("Cannot pause a cancelled task", str(ctx2.exception))
+
+    async def test_pause_idempotent_on_paused_task(self):
+        db = AsyncMock()
+        task = VasTask(id=3, status="pause", order_id="ORD-03")
+        mock_res = MagicMock()
+        mock_res.scalar_one_or_none.return_value = task
+        db.execute.return_value = mock_res
+
+        res = await VasTaskService.pause(db, 3)
+        self.assertEqual(res.status, "pause")
+        db.commit.assert_not_called()
+
+    async def test_pause_valid_task(self):
+        db = AsyncMock()
+        task = VasTask(id=4, status="pending", order_id="ORD-04")
+        mock_res = MagicMock()
+        mock_res.scalar_one_or_none.return_value = task
+        db.execute.return_value = mock_res
+
+        res = await VasTaskService.pause(db, 4)
+        self.assertEqual(res.status, "pause")
+        db.commit.assert_awaited_once()
+
+    async def test_return_to_queue_rejects_completed_or_cancelled(self):
+        db = AsyncMock()
+
+        completed_task = VasTask(id=1, status="completed", order_id="ORD-01")
+        mock_res1 = MagicMock()
+        mock_res1.scalar_one_or_none.return_value = completed_task
+        db.execute.return_value = mock_res1
+
+        with self.assertRaises(BizLogicError) as ctx1:
+            await VasTaskService.return_to_queue(db, 1)
+        self.assertIn("Cannot return a completed task to queue", str(ctx1.exception))
+
+        cancelled_task = VasTask(id=2, status="cancelled", order_id="ORD-02")
+        mock_res2 = MagicMock()
+        mock_res2.scalar_one_or_none.return_value = cancelled_task
+        db.execute.return_value = mock_res2
+
+        with self.assertRaises(BizLogicError) as ctx2:
+            await VasTaskService.return_to_queue(db, 2)
+        self.assertIn("Cannot return a cancelled task to queue", str(ctx2.exception))
+
+    async def test_return_to_queue_rejects_closed_order(self):
+        db = AsyncMock()
+        task = VasTask(id=5, status="pause", order_id="ORD-CLOSED")
+        closed_order = VasOrder(id="ORD-CLOSED", status="closed")
+
+        task_mock = MagicMock()
+        task_mock.scalar_one_or_none.return_value = task
+
+        order_mock = MagicMock()
+        order_mock.scalar_one_or_none.return_value = closed_order
+
+        db.execute.side_effect = [task_mock, order_mock]
+
+        with self.assertRaises(BizLogicError) as ctx:
+            await VasTaskService.return_to_queue(db, 5)
+        self.assertIn("associated order is closed", str(ctx.exception))
+
+    async def test_return_to_queue_success(self):
+        db = AsyncMock()
+        task = VasTask(id=6, status="pause", order_id="ORD-PAID")
+        order = VasOrder(id="ORD-PAID", status="paid")
+
+        task_mock = MagicMock()
+        task_mock.scalar_one_or_none.return_value = task
+
+        order_mock = MagicMock()
+        order_mock.scalar_one_or_none.return_value = order
+
+        db.execute.side_effect = [task_mock, order_mock]
+
+        res = await VasTaskService.return_to_queue(db, 6)
+        self.assertEqual(res.status, "pending")
+        db.commit.assert_awaited_once()
+
+
+if __name__ == "__main__":
+    unittest.main()