init: 初始化 dpb 桃育种系统代码库

前后端 + 后端 FastAPI 全量源码、部署脚本与文档。

backend/app/api/v1/module_monitor/cache/__init__.py

@@ -0,0 +1 @@
+

backend/app/api/v1/module_monitor/cache/controller.py

@@ -0,0 +1,64 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Path, Security
+from fastapi.responses import JSONResponse
+from redis.asyncio.client import Redis
+
+from app.api.v1.module_monitor.cache.schema import CacheInfoSchema, CacheMonitorSchema
+from app.common.response import ResponseSchema, SuccessResponse
+from app.core.dependencies import AuthPermission, redis_getter
+from app.core.router_class import OperationLogRoute
+
+from .service import CacheService
+
+CacheRouter = APIRouter(route_class=OperationLogRoute, prefix="/cache", tags=["缓存监控"])
+
+
+@CacheRouter.get("/info", summary="获取缓存监控信息", response_model=ResponseSchema[CacheMonitorSchema], dependencies=[Security(AuthPermission(["module_monitor:cache:query"]))])
+async def get_monitor_cache_info_controller(
+    redis: Annotated[Redis, Depends(redis_getter)],
+) -> JSONResponse:
+    result = await CacheService.get_monitor_statistical_info(redis=redis)
+    return SuccessResponse(data=result, msg="获取缓存监控信息成功")
+
+
+@CacheRouter.get("/get/names", summary="获取缓存名称列表", response_model=ResponseSchema[list[CacheInfoSchema]], dependencies=[Security(AuthPermission(["module_monitor:cache:query"]))])
+async def get_monitor_cache_name_controller() -> JSONResponse:
+    result = await CacheService.get_monitor_cache_names()
+    return SuccessResponse(data=result, msg="获取缓存名称列表成功")
+
+
+@CacheRouter.get("/get/keys/{cache_name}", summary="获取缓存键名列表", response_model=ResponseSchema[list[CacheInfoSchema]], dependencies=[Security(AuthPermission(["module_monitor:cache:query"]))])
+async def get_monitor_cache_key_controller(cache_name: Annotated[str, Path(description="缓存名称")], redis: Annotated[Redis, Depends(redis_getter)]) -> JSONResponse:
+    result = await CacheService.get_monitor_cache_keys(redis=redis, cache_name=cache_name)
+    return SuccessResponse(data=result, msg=f"获取缓存{cache_name}的键名列表成功")
+
+
+@CacheRouter.get("/get/value/{cache_name}/{cache_key}", summary="获取缓存值", response_model=ResponseSchema[CacheInfoSchema], dependencies=[Security(AuthPermission(["module_monitor:cache:query"]))])
+async def get_monitor_cache_value_controller(
+    cache_name: Annotated[str, Path(description="缓存名称")],
+    cache_key: Annotated[str, Path(description="缓存键名")],
+    redis: Annotated[Redis, Depends(redis_getter)],
+) -> JSONResponse:
+    result = await CacheService.get_monitor_cache_value(redis=redis, cache_name=cache_name, cache_key=cache_key)
+    return SuccessResponse(data=result, msg=f"获取缓存{cache_name}:{cache_key}的值成功")
+
+
+@CacheRouter.delete("/delete/name/{cache_name}", summary="清除指定缓存名称的所有缓存", response_model=ResponseSchema[None], dependencies=[Security(AuthPermission(["module_monitor:cache:delete"]))])
+async def clear_monitor_cache_name_controller(cache_name: Annotated[str, Path(description="缓存名称")], redis: Annotated[Redis, Depends(redis_getter)]) -> JSONResponse:
+    result = await CacheService.clear_monitor_cache_by_name(redis=redis, cache_name=cache_name)
+    return SuccessResponse(msg=f"{cache_name}对应键值清除成功", data=result)
+
+
+@CacheRouter.delete("/delete/key/{cache_key}", summary="清除指定缓存键", response_model=ResponseSchema[None], dependencies=[Security(AuthPermission(["module_monitor:cache:delete"]))])
+async def clear_monitor_cache_key_controller(cache_key: Annotated[str, Path(description="缓存键名")], redis: Annotated[Redis, Depends(redis_getter)]) -> JSONResponse:
+    result = await CacheService.clear_monitor_cache_by_key(redis=redis, cache_key=cache_key)
+    return SuccessResponse(msg=f"{cache_key}清除成功", data=result)
+
+
+@CacheRouter.delete("/clear", summary="清除所有缓存", response_model=ResponseSchema[None], dependencies=[Security(AuthPermission(["module_monitor:cache:delete"]))])
+async def clear_monitor_cache_all_controller(
+    redis: Annotated[Redis, Depends(redis_getter)],
+) -> JSONResponse:
+    result = await CacheService.clear_monitor_cache_all(redis=redis)
+    return SuccessResponse(msg="所有缓存清除成功", data=result)

backend/app/api/v1/module_monitor/cache/schema.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+
+
+class CacheMonitorSchema(BaseModel):
+    """缓存监控信息模型"""
+
+    command_stats: list[dict] = Field(default_factory=list, description="Redis命令统计信息")
+    db_size: int = Field(default=0, description="Redis数据库中的Key总数")
+    info: dict = Field(default_factory=dict, description="Redis服务器信息")
+
+
+class CacheInfoSchema(BaseModel):
+    """缓存对象信息模型"""
+
+    cache_key: str = Field(..., description="缓存键名")
+    cache_name: str = Field(..., description="缓存名称")
+    cache_value: str | None = Field(default=None, description="缓存值")
+    remark: str | None = Field(default=None, description="备注说明")

backend/app/api/v1/module_monitor/cache/service.py

@@ -0,0 +1,67 @@
+from redis.asyncio.client import Redis
+
+from app.common.enums import RedisInitKeyConfig
+from app.core.redis_crud import RedisCURD
+
+from .schema import CacheInfoSchema, CacheMonitorSchema
+
+
+class CacheService:
+    """缓存监控模块服务层"""
+
+    @staticmethod
+    async def get_monitor_statistical_info(redis: Redis) -> CacheMonitorSchema:
+        info = await RedisCURD(redis).info()
+        db_size = await RedisCURD(redis).db_size()
+        command_stats_dict = await RedisCURD(redis).commandstats()
+
+        command_stats = [{"name": key.split("_")[1], "value": str(value.get("calls"))} for key, value in command_stats_dict.items()]
+        return CacheMonitorSchema(command_stats=command_stats, db_size=db_size, info=info)
+
+    @staticmethod
+    async def get_monitor_cache_names() -> list[CacheInfoSchema]:
+        return [
+            CacheInfoSchema(
+                cache_key="",
+                cache_name=key_config.key,
+                cache_value="",
+                remark=key_config.remark,
+            )
+            for key_config in RedisInitKeyConfig
+        ]
+
+    @staticmethod
+    async def get_monitor_cache_keys(redis: Redis, cache_name: str) -> list:
+        cache_keys = await RedisCURD(redis).get_keys(f"{cache_name}*")
+        return [key.split(":", 1)[1] for key in cache_keys if key.startswith(f"{cache_name}:")]
+
+    @staticmethod
+    async def get_monitor_cache_value(redis: Redis, cache_name: str, cache_key: str) -> CacheInfoSchema:
+        cache_value = await RedisCURD(redis).get(f"{cache_name}:{cache_key}")
+        return CacheInfoSchema(
+            cache_key=cache_key,
+            cache_name=cache_name,
+            cache_value=cache_value,
+            remark="",
+        )
+
+    @staticmethod
+    async def clear_monitor_cache_by_name(redis: Redis, cache_name: str) -> bool:
+        cache_keys = await RedisCURD(redis).get_keys(f"{cache_name}*")
+        if cache_keys:
+            await RedisCURD(redis).delete(*cache_keys)
+        return True
+
+    @staticmethod
+    async def clear_monitor_cache_by_key(redis: Redis, cache_key: str) -> bool:
+        cache_keys = await RedisCURD(redis).get_keys(f"*{cache_key}")
+        if cache_keys:
+            await RedisCURD(redis).delete(*cache_keys)
+        return True
+
+    @staticmethod
+    async def clear_monitor_cache_all(redis: Redis) -> bool:
+        cache_keys = await RedisCURD(redis).get_keys()
+        if cache_keys:
+            await RedisCURD(redis).delete(*cache_keys)
+        return True