upload project source code

后端源码/yifan.action-ai.cn/app/api/v1/module_monitor/cache/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+

后端源码/yifan.action-ai.cn/app/api/v1/module_monitor/cache/controller.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+
+from fastapi import APIRouter, Depends
+from fastapi.responses import JSONResponse
+from redis.asyncio.client import Redis
+
+from app.common.response import SuccessResponse
+from app.core.exceptions import CustomException
+from app.core.dependencies import AuthPermission, redis_getter
+from app.core.logger import log
+from app.core.router_class import OperationLogRoute
+
+from .service import CacheService
+
+
+CacheRouter = APIRouter(route_class=OperationLogRoute, prefix="/cache", tags=["缓存监控"])
+
+
+@CacheRouter.get(
+    '/info',
+    dependencies=[Depends(AuthPermission(['module_monitor:cache:query']))],
+    summary="获取缓存监控信息",
+    description="获取缓存监控信息"
+)
+async def get_monitor_cache_info_controller(
+    redis: Redis = Depends(redis_getter)
+) -> JSONResponse:
+    """
+    获取缓存监控统计信息
+    
+    返回:
+    - JSONResponse: 包含缓存监控统计信息的JSON响应
+    """
+    result = await CacheService.get_cache_monitor_statistical_info_service(redis=redis)
+    log.info('获取缓存监控信息成功')
+    return SuccessResponse(data=result, msg='获取缓存监控信息成功')
+
+
+@CacheRouter.get(
+    '/get/names',
+    dependencies=[Depends(AuthPermission(['module_monitor:cache:query']))],
+    summary="获取缓存名称列表",
+    description="获取缓存名称列表"
+)
+async def get_monitor_cache_name_controller() -> JSONResponse:
+    """
+    获取缓存名称列表
+    
+    返回:
+    - JSONResponse: 包含缓存名称列表的JSON响应
+    """
+    result = await CacheService.get_cache_monitor_cache_name_service()
+    log.info('获取缓存名称列表成功')
+    return SuccessResponse(data=result, msg='获取缓存名称列表成功')
+
+
+@CacheRouter.get(
+    '/get/keys/{cache_name}',
+    dependencies=[Depends(AuthPermission(['module_monitor:cache:query']))],
+    summary="获取缓存键名列表",
+    description="获取缓存键名列表"
+)
+async def get_monitor_cache_key_controller(
+    cache_name: str,
+    redis: Redis = Depends(redis_getter)
+    ) -> JSONResponse:
+    """
+    获取指定缓存名称下的键名列表
+    
+    参数:
+    - cache_name (str): 缓存名称
+    
+    返回:
+    - JSONResponse: 包含缓存键名列表的JSON响应
+    """
+    result = await CacheService.get_cache_monitor_cache_key_service(redis=redis, cache_name=cache_name)
+    log.info(f'获取缓存{cache_name}的键名列表成功')
+    return SuccessResponse(data=result, msg=f'获取缓存{cache_name}的键名列表成功')
+
+
+@CacheRouter.get(
+    '/get/value/{cache_name}/{cache_key}',
+    dependencies=[Depends(AuthPermission(['module_monitor:cache:query']))],
+    summary="获取缓存值",
+    description="获取缓存值"
+)
+async def get_monitor_cache_value_controller(
+    cache_name: str, 
+    cache_key: str,
+    redis: Redis = Depends(redis_getter)
+)-> JSONResponse:
+    """
+    获取指定缓存键的值
+    
+    参数:
+    - cache_name (str): 缓存名称
+    - cache_key (str): 缓存键
+    
+    返回:
+    - JSONResponse: 包含缓存值的JSON响应
+    """
+    result = await CacheService.get_cache_monitor_cache_value_service(redis=redis, cache_name=cache_name, cache_key=cache_key)
+    log.info(f'获取缓存{cache_name}:{cache_key}的值成功')
+    return SuccessResponse(data=result, msg=f'获取缓存{cache_name}:{cache_key}的值成功')
+
+
+@CacheRouter.delete(
+    '/delete/name/{cache_name}',
+    dependencies=[Depends(AuthPermission(['module_monitor:cache:delete']))],
+    summary="清除指定缓存名称的所有缓存",
+    description="清除指定缓存名称的所有缓存"
+)
+async def clear_monitor_cache_name_controller(
+    cache_name: str,
+    redis: Redis = Depends(redis_getter)
+) -> JSONResponse:
+    """
+    清除指定缓存名称下的所有缓存
+    
+    参数:
+    - cache_name (str): 缓存名称
+    
+    返回:
+    - JSONResponse: 包含清除结果的JSON响应
+    """
+    result = await CacheService.clear_cache_monitor_cache_name_service(redis=redis, cache_name=cache_name)
+    if not result:
+        raise CustomException(msg='清除缓存失败', data=result)
+    log.info(f'清除缓存{cache_name}成功')
+    return SuccessResponse(msg=f'{cache_name}对应键值清除成功', data=result)
+
+
+@CacheRouter.delete(
+    '/delete/key/{cache_key}',
+    dependencies=[Depends(AuthPermission(['module_monitor:cache:delete']))],
+    summary="清除指定缓存键",
+    description="清除指定缓存键"
+)
+async def clear_monitor_cache_key_controller(
+    cache_key: str,
+    redis: Redis = Depends(redis_getter)
+) -> JSONResponse:
+    """
+    清除指定缓存键
+    
+    参数:
+    - cache_key (str): 缓存键
+    
+    返回:
+    - JSONResponse: 包含清除结果的JSON响应
+    """
+    result = await CacheService.clear_cache_monitor_cache_key_service(redis=redis, cache_key=cache_key)
+    if not result:
+        raise CustomException(msg='清除缓存失败', data=result)
+    log.info(f'清除缓存键{cache_key}成功')
+    return SuccessResponse(msg=f'{cache_key}清除成功', data=result)
+
+
+@CacheRouter.delete(
+    '/delete/all',
+    dependencies=[Depends(AuthPermission(['module_monitor:cache:delete']))],
+    summary="清除所有缓存",
+    description="清除所有缓存"
+)
+async def clear_monitor_cache_all_controller(
+    redis: Redis = Depends(redis_getter)
+) -> JSONResponse:
+    """
+    清除所有缓存
+    
+    返回:
+    - JSONResponse: 包含清除结果的JSON响应
+    """
+    result = await CacheService.clear_cache_monitor_all_service(redis=redis)
+    if not result:
+        raise CustomException(msg='清除缓存失败', data=result)
+    log.info('清除所有缓存成功')
+    return SuccessResponse(msg='所有缓存清除成功', data=result)

后端源码/yifan.action-ai.cn/app/api/v1/module_monitor/cache/schema.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+from typing import Any
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class CacheMonitorSchema(BaseModel):
+    """缓存监控信息模型"""
+    model_config = ConfigDict(from_attributes=True)
+
+    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):
+    """缓存对象信息模型"""
+    model_config = ConfigDict(from_attributes=True)
+
+    cache_key: str = Field(..., description='缓存键名')
+    cache_name: str = Field(..., description='缓存名称')
+    cache_value: Any = Field(default=None, description='缓存值')
+    remark: str | None = Field(default=None, description='备注说明')

后端源码/yifan.action-ai.cn/app/api/v1/module_monitor/cache/service.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+
+from redis.asyncio.client import Redis
+
+from app.common.enums import RedisInitKeyConfig
+from app.core.redis_crud import RedisCURD
+
+from .schema import CacheMonitorSchema, CacheInfoSchema
+
+
+class CacheService:
+    """
+    缓存监控模块服务层
+    """
+
+    @classmethod
+    async def get_cache_monitor_statistical_info_service(cls, redis: Redis)->dict:
+        """
+        获取缓存监控信息。
+        
+        参数:
+        - redis (Redis): Redis 对象。
+        
+        返回:
+        - dict: 缓存监控信息字典。
+        """
+        info = await RedisCURD(redis).info()
+        db_size = await RedisCURD(redis).db_size()
+        command_stats_dict = await RedisCURD(redis).commandstats()
+
+        command_stats = [
+            dict(name=key.split('_')[1], value=str(value.get('calls'))) for key, value in command_stats_dict.items()
+        ]
+        result = CacheMonitorSchema(command_stats=command_stats, db_size=db_size, info=info)
+
+        return result.model_dump()
+
+    @classmethod
+    async def get_cache_monitor_cache_name_service(cls)->list:
+        """
+        获取缓存名称列表信息。
+        
+        返回:
+        - list: 缓存名称列表信息。
+        """
+        name_list = []
+        for key_config in RedisInitKeyConfig:
+            name_list.append(
+                CacheInfoSchema(
+                    cache_key='',
+                    cache_name=key_config.key,
+                    cache_value='',
+                    remark=key_config.remark,
+                ).model_dump()
+            )
+
+        return name_list
+
+    @classmethod
+    async def get_cache_monitor_cache_key_service(cls, redis: Redis, cache_name: str)->list:
+        """
+        获取缓存键名列表信息。
+        
+        参数:
+        - redis (Redis): Redis 对象。
+        - cache_name (str): 缓存名称。
+        
+        返回:
+        - list: 缓存键名列表信息。
+        """
+        cache_keys = await RedisCURD(redis).get_keys(f'{cache_name}*')
+        cache_key_list = [key.split(':', 1)[1] for key in cache_keys if key.startswith(f'{cache_name}:')]
+
+        return cache_key_list
+
+    @classmethod
+    async def get_cache_monitor_cache_value_service(cls, redis: Redis, cache_name: str, cache_key: str)->dict:
+        """
+        获取缓存内容信息。
+        
+        参数:
+        - redis (Redis): Redis 对象。
+        - cache_name (str): 缓存名称。
+        - cache_key (str): 缓存键名。
+        
+        返回:
+        - dict: 缓存内容信息字典。
+        """
+        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='').model_dump()
+
+    @classmethod
+    async def clear_cache_monitor_cache_name_service(cls, redis: Redis, cache_name: str)->bool:
+        """
+        清除指定缓存名称对应的所有键值。
+        
+        参数:
+        - redis (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
+
+    @classmethod
+    async def clear_cache_monitor_cache_key_service(cls, redis: Redis, cache_key: str)->bool:
+        """
+        清除匹配指定键名的所有键值。
+        
+        参数:
+        - redis (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
+
+    @classmethod
+    async def clear_cache_monitor_all_service(cls, redis: Redis)->bool:
+        """
+        清除所有缓存。
+        
+        参数:
+        - redis (Redis): Redis 对象。
+        
+        返回:
+        - bool: 是否清理成功。
+        """
+        cache_keys = await RedisCURD(redis).get_keys()
+        if cache_keys:
+            await RedisCURD(redis).delete(*cache_keys)
+
+        return True
+
+        # 避免清除所有的缓存，而采用上面的方式，只清除本系统内指定的所有缓存
+        # return await RedisCURD(redis).clear()