fix: 修复设置系统脱节、队列计数漂移、资源泄露等全量问题

- 统一设置系统：create_scheduler_service 读取 DB 设置覆盖默认值
- 修复 ProxyRepository.update_score 误删所有无效代理的 SQL
- ValidationQueue：修复 Worker 计数漂移与启动恢复任务饿死
- SchedulerService：移除 drain() 阻塞，主循环可正常响应 stop
- TaskService：在调度器周期内自动清理过期任务，防止内存泄漏
- lifespan/conftest：规范关闭顺序，消除 Event loop closed 警告
- Repository：异常日志增加 exc_info，今日新增按 created_at 统计
- ValidatorService：防止 HTTP session 重复关闭，移除 SOCKS 多余 close
- 前端：补全 pluginsStore.isEmpty，ProxyList 最低分数上限改为 100
- 删除 config.py 中冗余的 cors_origins_list property

app/api/common.py

@@ -23,6 +23,7 @@ def format_proxy(proxy) -> dict:
         "port": proxy.port,
         "protocol": proxy.protocol,
         "score": proxy.score,
+        "response_time_ms": proxy.response_time_ms,
         "last_check": proxy.last_check.isoformat() if proxy.last_check else None,
     }
 

app/api/deps.py

@@ -25,21 +25,29 @@ def get_validation_queue(request: Request) -> ValidationQueue:
     return request.app.state.validation_queue
 
 
-def create_scheduler_service() -> SchedulerService:
-    """在应用启动时创建 SchedulerService（非请求上下文）"""
+def create_scheduler_service(db_settings: dict | None = None) -> SchedulerService:
+    """在应用启动时创建 SchedulerService（非请求上下文）
+    
+    db_settings 来自数据库持久化设置，用于覆盖 .env / 默认值。
+    """
+    db_settings = db_settings or {}
     validator = ValidatorService(
-        timeout=app_settings.validator_timeout,
-        connect_timeout=app_settings.validator_connect_timeout,
-        max_concurrency=app_settings.validator_max_concurrency,
+        timeout=db_settings.get("validation_timeout", app_settings.validator_timeout),
+        connect_timeout=db_settings.get("connect_timeout", app_settings.validator_connect_timeout),
+        max_concurrency=db_settings.get("default_concurrency", app_settings.validator_max_concurrency),
     )
     proxy_repo = ProxyRepository()
     queue = ValidationQueue(
         validator=validator,
         proxy_repo=proxy_repo,
-        worker_count=app_settings.validator_max_concurrency,
+        worker_count=db_settings.get("default_concurrency", app_settings.validator_max_concurrency),
         score_valid=app_settings.score_valid,
         score_invalid=app_settings.score_invalid,
         score_min=app_settings.score_min,
         score_max=app_settings.score_max,
     )
-    return SchedulerService(validation_queue=queue, proxy_repo=proxy_repo)
+    svc = SchedulerService(validation_queue=queue, proxy_repo=proxy_repo)
+    svc.interval_minutes = db_settings.get(
+        "validate_interval_minutes", app_settings.validator_timeout
+    )
+    return svc

app/api/lifespan.py

@@ -6,7 +6,7 @@ from app.core.db import init_db, get_db
 from app.core.config import settings as app_settings
 from app.core.log import logger
 from app.api.deps import create_scheduler_service
-from app.repositories.settings_repo import SettingsRepository
+from app.repositories.settings_repo import SettingsRepository, DEFAULT_SETTINGS
 
 settings_repo = SettingsRepository()
 
@@ -17,33 +17,48 @@ async def lifespan(app: FastAPI):
     # 初始化数据库
     await init_db()
 
-    # 创建调度器并挂载到 app.state
-    scheduler_service = create_scheduler_service()
+    # 加载设置并决定是否启动调度器
+    db_settings = DEFAULT_SETTINGS.copy()
+    try:
+        async with get_db() as db:
+            db_settings = await settings_repo.get_all(db)
+    except Exception as e:
+        logger.error(f"Failed to load settings on startup: {e}")
+
+    # 创建调度器并挂载到 app.state（使用 DB 设置覆盖默认值）
+    scheduler_service = create_scheduler_service(db_settings)
     app.state.scheduler_service = scheduler_service
     app.state.validation_queue = scheduler_service.validation_queue
 
-    # 加载设置并决定是否启动调度器
-    try:
-        async with get_db() as db:
-            settings = await settings_repo.get_all(db)
-        scheduler_service.interval_minutes = settings.get(
-            "validate_interval_minutes", app_settings.validator_timeout
-        )
-        if settings.get("auto_validate", True):
+    if db_settings.get("auto_validate", True):
+        try:
             await scheduler_service.start()
-    except Exception as e:
-        logger.error(f"Failed to load settings on startup: {e}")
+        except Exception as e:
+            logger.error(f"Failed to start scheduler on startup: {e}")
 
     logger.info("API server started")
     yield
 
     # 关闭调度器
-    if scheduler_service._validate_task and not scheduler_service._validate_task.done():
-        scheduler_service._validate_task.cancel()
-        try:
-            await scheduler_service._validate_task
-        except asyncio.CancelledError:
-            pass
+    scheduler_service.cancel_validate_task()
     await scheduler_service.stop()
-    await scheduler_service.validation_queue.validator.close()
+
+    # 关闭验证器 HTTP session
+    try:
+        await scheduler_service.validation_queue.validator.close()
+    except Exception:
+        pass
+
+    # 关闭所有插件的 HTTP 客户端
+    from app.core.plugin_system.registry import registry
+    for plugin in registry.list_plugins():
+        if hasattr(plugin, "close"):
+            try:
+                await plugin.close()
+            except Exception:
+                pass
+
+    # 给 aiosqlite / aiohttp 后台线程留出收尾时间
+    await asyncio.sleep(0.1)
+
     logger.info("API server shutdown")

app/api/main.py

@@ -22,7 +22,7 @@ def create_app() -> FastAPI:
     # CORS
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=app_settings.cors_origins_list,
+        allow_origins=app_settings.cors_origins,
         allow_credentials=True,
         allow_methods=["*"],
         allow_headers=["*"],

app/api/routes/__init__.py

@@ -1,9 +1,10 @@
 """路由包"""
 from fastapi import APIRouter
-from app.api.routes import proxies, plugins, scheduler, settings
+from app.api.routes import proxies, plugins, scheduler, settings, tasks
 
 api_router = APIRouter()
 api_router.include_router(proxies.router)
 api_router.include_router(plugins.router)
 api_router.include_router(scheduler.router)
 api_router.include_router(settings.router)
+api_router.include_router(tasks.router)

app/api/routes/plugins.py

@@ -3,6 +3,7 @@ import asyncio
 from fastapi import APIRouter, Depends
 from app.services.plugin_service import PluginService
 from app.services.scheduler_service import SchedulerService
+from app.services.task_service import task_service
 from app.api.deps import get_plugin_service, get_scheduler_service
 from app.api.common import success_response, error_response, format_plugin
 from app.core.log import logger
@@ -12,12 +13,8 @@ router = APIRouter(prefix="/api/plugins", tags=["plugins"])
 
 @router.get("")
 async def list_plugins(service: PluginService = Depends(get_plugin_service)):
-    try:
-        plugins = await service.list_plugins()
-        return success_response("获取插件列表成功", {"plugins": [format_plugin(p) for p in plugins]})
-    except Exception as e:
-        logger.error(f"List plugins failed: {e}")
-        return error_response("获取插件列表失败", 500)
+    plugins = await service.list_plugins()
+    return success_response("获取插件列表成功", {"plugins": [format_plugin(p) for p in plugins]})
 
 
 @router.put("/{plugin_id}/toggle")
@@ -29,18 +26,14 @@ async def toggle_plugin(
     enabled = request.get("enabled")
     if enabled is None:
         return error_response("缺少 enabled 参数", 400)
-    
-    try:
-        success = await service.toggle_plugin(plugin_id, enabled)
-        if not success:
-            return error_response("插件不存在", 404)
-        return success_response(
-            f"插件 {plugin_id} 已{'启用' if enabled else '禁用'}",
-            {"plugin_id": plugin_id, "enabled": enabled},
-        )
-    except Exception as e:
-        logger.error(f"Toggle plugin failed: {e}")
-        return error_response("切换插件状态失败", 500)
+
+    success = await service.toggle_plugin(plugin_id, enabled)
+    if not success:
+        return error_response("插件不存在", 404)
+    return success_response(
+        f"插件 {plugin_id} 已{'启用' if enabled else '禁用'}",
+        {"plugin_id": plugin_id, "enabled": enabled},
+    )
 
 
 @router.get("/{plugin_id}/config")
@@ -48,14 +41,10 @@ async def get_plugin_config(
     plugin_id: str,
     service: PluginService = Depends(get_plugin_service),
 ):
-    try:
-        config = await service.get_plugin_config(plugin_id)
-        if config is None:
-            return error_response("插件不存在", 404)
-        return success_response("获取插件配置成功", {"plugin_id": plugin_id, "config": config})
-    except Exception as e:
-        logger.error(f"Get plugin config failed: {e}")
-        return error_response("获取插件配置失败", 500)
+    config = await service.get_plugin_config(plugin_id)
+    if config is None:
+        return error_response("插件不存在", 404)
+    return success_response("获取插件配置成功", {"plugin_id": plugin_id, "config": config})
 
 
 @router.post("/{plugin_id}/config")
@@ -67,15 +56,11 @@ async def update_plugin_config(
     config = request.get("config", {})
     if not isinstance(config, dict):
         return error_response("config 必须是对象", 400)
-    
-    try:
-        success = await service.update_plugin_config(plugin_id, config)
-        if not success:
-            return error_response("插件不存在或配置无效", 404)
-        return success_response("保存插件配置成功", {"plugin_id": plugin_id, "config": config})
-    except Exception as e:
-        logger.error(f"Update plugin config failed: {e}")
-        return error_response("保存插件配置失败", 500)
+
+    success = await service.update_plugin_config(plugin_id, config)
+    if not success:
+        return error_response("插件不存在或配置无效", 404)
+    return success_response("保存插件配置成功", {"plugin_id": plugin_id, "config": config})
 
 
 @router.post("/{plugin_id}/crawl")
@@ -88,35 +73,51 @@ async def crawl_plugin(
     if not plugin:
         return error_response("插件不存在", 404)
 
-    try:
-        results = await plugin_service.run_plugin(plugin_id)
-        if not results:
-            return success_response(
-                f"插件 {plugin_id} 爬取完成，未获取到代理",
-                {"plugin_id": plugin_id, "proxy_count": 0, "valid_count": 0},
+    task_id = task_service.create_task("crawl_plugin")
+
+    async def _background_crawl():
+        try:
+            task_service.update_task(task_id, status="running")
+            results = await plugin_service.run_plugin(plugin_id)
+            if not results:
+                task_service.update_task(
+                    task_id,
+                    status="completed",
+                    message=f"插件 {plugin_id} 爬取完成，未获取到代理",
+                    data={"plugin_id": plugin_id, "proxy_count": 0, "valid_count": 0},
+                )
+                return
+
+            logger.info(f"Plugin {plugin_id} crawled {len(results)} proxies")
+            scheduler_service.validation_queue.reset_stats()
+            await scheduler_service.validation_queue.submit(results)
+
+            try:
+                await asyncio.wait_for(scheduler_service.validation_queue.drain(), timeout=5.0)
+            except asyncio.TimeoutError:
+                pass
+
+            task_service.update_task(
+                task_id,
+                status="completed",
+                message=f"插件 {plugin_id} 爬取并验证完成",
+                data={
+                    "plugin_id": plugin_id,
+                    "proxy_count": len(results),
+                    "valid_count": scheduler_service.validation_queue.valid_count,
+                    "invalid_count": scheduler_service.validation_queue.invalid_count,
+                },
+            )
+        except Exception as e:
+            logger.error(f"Crawl plugin {plugin_id} failed: {e}")
+            task_service.update_task(
+                task_id, status="failed", message=f"插件爬取失败: {str(e)}"
             )
 
-        logger.info(f"Plugin {plugin_id} crawled {len(results)} proxies")
-        scheduler_service.validation_queue.reset_stats()
-        await scheduler_service.validation_queue.submit(results)
-        
-        try:
-            await asyncio.wait_for(scheduler_service.validation_queue.drain(), timeout=30.0)
-        except asyncio.TimeoutError:
-            pass
-
-        return success_response(
-            f"插件 {plugin_id} 爬取并验证完成",
-            {
-                "plugin_id": plugin_id,
-                "proxy_count": len(results),
-                "valid_count": scheduler_service.validation_queue.valid_count,
-                "invalid_count": scheduler_service.validation_queue.invalid_count,
-            },
-        )
-    except Exception as e:
-        logger.error(f"Crawl plugin {plugin_id} failed: {e}")
-        return error_response(f"插件爬取失败: {str(e)}", 500)
+    asyncio.create_task(_background_crawl())
+    return success_response(
+        "爬取任务已启动", {"task_id": task_id, "plugin_id": plugin_id}
+    )
 
 
 @router.post("/crawl-all")
@@ -124,31 +125,45 @@ async def crawl_all(
     plugin_service: PluginService = Depends(get_plugin_service),
     scheduler_service: SchedulerService = Depends(get_scheduler_service),
 ):
-    try:
-        results = await plugin_service.run_all_plugins()
-        if not results:
-            return success_response(
-                "所有插件爬取完成，未获取到代理",
-                {"total_crawled": 0, "valid_count": 0, "invalid_count": 0},
+    task_id = task_service.create_task("crawl_all")
+
+    async def _background_crawl_all():
+        try:
+            task_service.update_task(task_id, status="running")
+            results = await plugin_service.run_all_plugins()
+            if not results:
+                task_service.update_task(
+                    task_id,
+                    status="completed",
+                    message="所有插件爬取完成，未获取到代理",
+                    data={"total_crawled": 0, "valid_count": 0, "invalid_count": 0},
+                )
+                return
+
+            logger.info(f"All plugins crawled {len(results)} unique proxies")
+            scheduler_service.validation_queue.reset_stats()
+            await scheduler_service.validation_queue.submit(results)
+
+            try:
+                await asyncio.wait_for(scheduler_service.validation_queue.drain(), timeout=5.0)
+            except asyncio.TimeoutError:
+                pass
+
+            task_service.update_task(
+                task_id,
+                status="completed",
+                message="所有插件爬取并验证完成",
+                data={
+                    "total_crawled": len(results),
+                    "valid_count": scheduler_service.validation_queue.valid_count,
+                    "invalid_count": scheduler_service.validation_queue.invalid_count,
+                },
+            )
+        except Exception as e:
+            logger.error(f"Crawl all failed: {e}")
+            task_service.update_task(
+                task_id, status="failed", message=f"批量爬取失败: {str(e)}"
             )
 
-        logger.info(f"All plugins crawled {len(results)} unique proxies")
-        scheduler_service.validation_queue.reset_stats()
-        await scheduler_service.validation_queue.submit(results)
-        
-        try:
-            await asyncio.wait_for(scheduler_service.validation_queue.drain(), timeout=60.0)
-        except asyncio.TimeoutError:
-            pass
-
-        return success_response(
-            "所有插件爬取并验证完成",
-            {
-                "total_crawled": len(results),
-                "valid_count": scheduler_service.validation_queue.valid_count,
-                "invalid_count": scheduler_service.validation_queue.invalid_count,
-            },
-        )
-    except Exception as e:
-        logger.error(f"Crawl all failed: {e}")
-        return error_response(f"批量爬取失败: {str(e)}", 500)
+    asyncio.create_task(_background_crawl_all())
+    return success_response("爬取任务已启动", {"task_id": task_id})

app/api/routes/proxies.py

@@ -6,7 +6,6 @@ from app.services.scheduler_service import SchedulerService
 from app.models.schemas import ProxyListRequest, BatchDeleteRequest
 from app.api.deps import get_proxy_service, get_scheduler_service
 from app.api.common import success_response, error_response, format_proxy
-from app.core.log import logger
 
 router = APIRouter(prefix="/api/proxies", tags=["proxies"])
 
@@ -16,13 +15,9 @@ async def get_stats(
     proxy_service: ProxyService = Depends(get_proxy_service),
     scheduler_service: SchedulerService = Depends(get_scheduler_service),
 ):
-    try:
-        stats = await proxy_service.get_stats()
-        stats["scheduler_running"] = scheduler_service.running
-        return success_response("获取统计信息成功", stats)
-    except Exception as e:
-        logger.error(f"Get stats failed: {e}")
-        return error_response("获取统计信息失败", 500)
+    stats = await proxy_service.get_stats()
+    stats["scheduler_running"] = scheduler_service.running
+    return success_response("获取统计信息成功", stats)
 
 
 @router.post("")
@@ -30,40 +25,32 @@ async def list_proxies(
     request: ProxyListRequest,
     service: ProxyService = Depends(get_proxy_service),
 ):
-    try:
-        proxies, total = await service.list_proxies(
-            page=request.page,
-            page_size=request.page_size,
-            protocol=request.protocol,
-            min_score=request.min_score,
-            max_score=request.max_score,
-            sort_by=request.sort_by,
-            sort_order=request.sort_order,
-        )
-        return success_response(
-            "获取代理列表成功",
-            {
-                "list": [format_proxy(p) for p in proxies],
-                "total": total,
-                "page": request.page,
-                "page_size": request.page_size,
-            },
-        )
-    except Exception as e:
-        logger.error(f"List proxies failed: {e}")
-        return error_response("获取代理列表失败", 500)
+    proxies, total = await service.list_proxies(
+        page=request.page,
+        page_size=request.page_size,
+        protocol=request.protocol,
+        min_score=request.min_score,
+        max_score=request.max_score,
+        sort_by=request.sort_by,
+        sort_order=request.sort_order,
+    )
+    return success_response(
+        "获取代理列表成功",
+        {
+            "list": [format_proxy(p) for p in proxies],
+            "total": total,
+            "page": request.page,
+            "page_size": request.page_size,
+        },
+    )
 
 
 @router.get("/random")
 async def get_random_proxy(service: ProxyService = Depends(get_proxy_service)):
-    try:
-        proxy = await service.get_random_proxy()
-        if not proxy:
-            return error_response("没有找到可用的代理", 404)
-        return success_response("获取随机代理成功", format_proxy(proxy))
-    except Exception as e:
-        logger.error(f"Get random proxy failed: {e}")
-        return error_response("获取随机代理失败", 500)
+    proxy = await service.get_random_proxy()
+    if not proxy:
+        return error_response("没有找到可用的代理", 404)
+    return success_response("获取随机代理成功", format_proxy(proxy))
 
 
 @router.get("/export/{fmt}")
@@ -93,12 +80,8 @@ async def export_proxies(
 
 @router.delete("/{ip}/{port}")
 async def delete_proxy(ip: str, port: int, service: ProxyService = Depends(get_proxy_service)):
-    try:
-        await service.delete_proxy(ip, port)
-        return success_response("删除代理成功")
-    except Exception as e:
-        logger.error(f"Delete proxy failed: {e}")
-        return error_response("删除代理失败", 500)
+    await service.delete_proxy(ip, port)
+    return success_response("删除代理成功")
 
 
 @router.post("/batch-delete")
@@ -106,20 +89,12 @@ async def batch_delete(
     request: BatchDeleteRequest,
     service: ProxyService = Depends(get_proxy_service),
 ):
-    try:
-        proxies = [(item.ip, item.port) for item in request.proxies]
-        deleted = await service.batch_delete(proxies)
-        return success_response(f"批量删除 {deleted} 个代理成功", {"deleted_count": deleted})
-    except Exception as e:
-        logger.error(f"Batch delete failed: {e}")
-        return error_response("批量删除失败", 500)
+    proxies = [(item.ip, item.port) for item in request.proxies]
+    deleted = await service.batch_delete(proxies)
+    return success_response(f"批量删除 {deleted} 个代理成功", {"deleted_count": deleted})
 
 
 @router.delete("/clean-invalid")
 async def clean_invalid(service: ProxyService = Depends(get_proxy_service)):
-    try:
-        count = await service.clean_invalid()
-        return success_response(f"清理了 {count} 个无效代理", {"deleted_count": count})
-    except Exception as e:
-        logger.error(f"Clean invalid failed: {e}")
-        return error_response("清理无效代理失败", 500)
+    count = await service.clean_invalid()
+    return success_response(f"清理了 {count} 个无效代理", {"deleted_count": count})

app/api/routes/scheduler.py

@@ -5,7 +5,6 @@ from app.repositories.settings_repo import SettingsRepository
 from app.core.db import get_db
 from app.api.deps import get_scheduler_service
 from app.api.common import success_response, error_response
-from app.core.log import logger
 
 router = APIRouter(prefix="/api/scheduler", tags=["scheduler"])
 settings_repo = SettingsRepository()
@@ -22,38 +21,26 @@ async def _save_auto_validate_setting(enabled: bool):
 
 @router.post("/start")
 async def start_scheduler(scheduler: SchedulerService = Depends(get_scheduler_service)):
-    try:
-        if scheduler.running:
-            return success_response("验证调度器已在运行", {"running": True})
-        await scheduler.start()
-        await _save_auto_validate_setting(True)
-        return success_response("验证调度器已启动", {"running": True})
-    except Exception as e:
-        logger.error(f"Start scheduler failed: {e}")
-        return error_response(f"启动调度器失败: {str(e)}", 500)
+    if scheduler.running:
+        return success_response("验证调度器已在运行", {"running": True})
+    await scheduler.start()
+    await _save_auto_validate_setting(True)
+    return success_response("验证调度器已启动", {"running": True})
 
 
 @router.post("/stop")
 async def stop_scheduler(scheduler: SchedulerService = Depends(get_scheduler_service)):
-    try:
-        if not scheduler.running:
-            return success_response("验证调度器未运行", {"running": False})
-        await scheduler.stop()
-        await _save_auto_validate_setting(False)
-        return success_response("验证调度器已停止", {"running": False})
-    except Exception as e:
-        logger.error(f"Stop scheduler failed: {e}")
-        return error_response(f"停止调度器失败: {str(e)}", 500)
+    if not scheduler.running:
+        return success_response("验证调度器未运行", {"running": False})
+    await scheduler.stop()
+    await _save_auto_validate_setting(False)
+    return success_response("验证调度器已停止", {"running": False})
 
 
 @router.post("/validate-now")
 async def validate_now(scheduler: SchedulerService = Depends(get_scheduler_service)):
-    try:
-        await scheduler.validate_all_now()
-        return success_response("已开始全量验证", {"started": True})
-    except Exception as e:
-        logger.error(f"Validate now failed: {e}")
-        return error_response(f"启动验证失败: {str(e)}", 500)
+    await scheduler.validate_all_now()
+    return success_response("已开始全量验证", {"started": True})
 
 
 @router.get("/status")

app/api/routes/settings.py

@@ -4,7 +4,6 @@ from app.core.db import get_db
 from app.repositories.settings_repo import SettingsRepository
 from app.models.schemas import SettingsSchema
 from app.api.common import success_response, error_response
-from app.core.log import logger
 
 router = APIRouter(prefix="/api/settings", tags=["settings"])
 settings_repo = SettingsRepository()
@@ -12,23 +11,15 @@ settings_repo = SettingsRepository()
 
 @router.get("")
 async def get_settings():
-    try:
-        async with get_db() as db:
-            settings = await settings_repo.get_all(db)
-        return success_response("获取设置成功", settings)
-    except Exception as e:
-        logger.error(f"Get settings failed: {e}")
-        return error_response("获取设置失败", 500)
+    async with get_db() as db:
+        settings = await settings_repo.get_all(db)
+    return success_response("获取设置成功", settings)
 
 
 @router.post("")
 async def save_settings(request: SettingsSchema):
-    try:
-        async with get_db() as db:
-            success = await settings_repo.save(db, request.model_dump())
-        if not success:
-            return error_response("保存设置失败", 500)
-        return success_response("保存设置成功", request.model_dump())
-    except Exception as e:
-        logger.error(f"Save settings failed: {e}")
-        return error_response(f"保存设置失败: {str(e)}", 500)
+    async with get_db() as db:
+        success = await settings_repo.save(db, request.model_dump())
+    if not success:
+        return error_response("保存设置失败", 500)
+    return success_response("保存设置成功", request.model_dump())

app/api/routes/tasks.py

@@ -0,0 +1,14 @@
+"""异步任务状态路由"""
+from fastapi import APIRouter
+from app.services.task_service import task_service
+from app.api.common import success_response, error_response
+
+router = APIRouter(prefix="/api/tasks", tags=["tasks"])
+
+
+@router.get("/{task_id}")
+async def get_task_status(task_id: str):
+    task = task_service.get_task(task_id)
+    if not task:
+        return error_response("任务不存在", 404)
+    return success_response("获取任务状态成功", task)