cancan-microstack 0.0.1__py3-none-any.whl

cancan_microstack/services/opsbffsrv/infrastructure/db/operate/caddy_stats.py

@@ -0,0 +1,343 @@
+"""
+Caddy 统计数据表的数据库操作函数
+"""
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+)
+from datetime import datetime
+from sqlalchemy import select, update, delete, func, and_, or_, desc
+from sqlalchemy.dialects.postgresql import insert
+
+from linglong_web import Rmanager
+from cancan_microstack.public.schemas.caddy import CaddyStats, StatsQuery
+from cancan_microstack.services.opsbffsrv.infrastructure.db.model.caddy_stats_tbl import CaddyStatsTbl
+
+
+async def create_stats(stats: CaddyStats) -> CaddyStats:
+    """
+    创建统计记录
+    
+    Args:
+        stats: 统计对象
+        
+    Returns:
+        创建后的统计对象
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = insert(CaddyStatsTbl).values(
+                **stats.model_dump(exclude={'id', 'created_time', 'update_time'})
+            ).returning(CaddyStatsTbl)
+            row = (await session.execute(stmt)).scalar_one()
+            return CaddyStats.model_validate(row, from_attributes=True)
+
+
+async def upsert_stats(stats: CaddyStats) -> CaddyStats:
+    """
+    插入或更新统计记录（基于唯一约束）
+    
+    Args:
+        stats: 统计对象
+        
+    Returns:
+        创建/更新后的统计对象
+    """
+    from sqlalchemy import select, update, and_, or_
+
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            values = stats.model_dump(exclude={'id', 'created_time', 'update_time'})
+
+            # 处理 dimension_value 为 None 的情况（匹配唯一索引逻辑）
+            dimension_value = values.get('dimension_value') or ''
+
+            # 先尝试查找现有记录
+            stmt = select(CaddyStatsTbl).where(
+                and_(
+                    CaddyStatsTbl.stat_time == values['stat_time'],
+                    CaddyStatsTbl.stat_period == values['stat_period'],
+                    CaddyStatsTbl.dimension_type == values['dimension_type'],
+                    or_(
+                        CaddyStatsTbl.dimension_value == dimension_value,
+                        and_(
+                            CaddyStatsTbl.dimension_value.is_(None),
+                            dimension_value == ''
+                        )
+                    )
+                )
+            )
+            existing_row = (await session.execute(stmt)).scalar_one_or_none()
+
+            if existing_row:
+                # 更新现有记录
+                update_values = {k: v for k, v in values.items()
+                                 if k not in ['stat_time', 'stat_period', 'dimension_type', 'dimension_value']}
+                stmt = update(CaddyStatsTbl).where(
+                    CaddyStatsTbl.id == existing_row.id
+                ).values(**update_values).returning(CaddyStatsTbl)
+                row = (await session.execute(stmt)).scalar_one()
+            else:
+                # 插入新记录
+                if values.get('dimension_value') is None:
+                    values['dimension_value'] = ''
+                stmt = insert(CaddyStatsTbl).values(**values).returning(CaddyStatsTbl)
+                row = (await session.execute(stmt)).scalar_one()
+
+            return CaddyStats.model_validate(row, from_attributes=True)
+
+
+async def get_stats_by_id(stats_id: int) -> Optional[CaddyStats]:
+    """
+    根据 ID 查询统计记录
+    
+    Args:
+        stats_id: 统计记录 ID
+        
+    Returns:
+        统计对象或 None
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = select(CaddyStatsTbl).where(CaddyStatsTbl.id == stats_id)
+            row = (await session.execute(stmt)).scalar_one_or_none()
+            return CaddyStats.model_validate(row, from_attributes=True) if row else None
+
+
+async def query_stats(query: StatsQuery) -> List[CaddyStats]:
+    """
+    根据查询条件查询统计数据
+    
+    Args:
+        query: 查询参数对象
+        
+    Returns:
+        统计数据列表
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = select(CaddyStatsTbl)
+
+            # 构建查询条件
+            conditions = []
+
+            if query.stat_period:
+                conditions.append(CaddyStatsTbl.stat_period == query.stat_period)
+
+            if query.dimension_type:
+                conditions.append(CaddyStatsTbl.dimension_type == query.dimension_type)
+
+            if query.dimension_value:
+                conditions.append(CaddyStatsTbl.dimension_value == query.dimension_value)
+
+            if query.start_time:
+                conditions.append(CaddyStatsTbl.stat_time >= query.start_time)
+
+            if query.end_time:
+                conditions.append(CaddyStatsTbl.stat_time <= query.end_time)
+
+            if conditions:
+                stmt = stmt.where(and_(*conditions))
+
+            # 排序和分页
+            stmt = stmt.order_by(desc(CaddyStatsTbl.stat_time))
+            stmt = stmt.limit(query.limit)
+
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [CaddyStats.model_validate(r, from_attributes=True) for r in rows] if rows else []
+
+
+async def get_global_stats(stat_period: str, start_time: datetime, end_time: datetime) -> List[CaddyStats]:
+    """
+    查询全局统计数据
+    
+    Args:
+        stat_period: 统计周期（minute/hour/day/month）
+        start_time: 开始时间
+        end_time: 结束时间
+        
+    Returns:
+        统计数据列表
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = select(CaddyStatsTbl).where(
+                and_(
+                    CaddyStatsTbl.stat_period == stat_period,
+                    CaddyStatsTbl.dimension_type == 'global',
+                    CaddyStatsTbl.stat_time >= start_time,
+                    CaddyStatsTbl.stat_time <= end_time
+                )
+            ).order_by(CaddyStatsTbl.stat_time)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [CaddyStats.model_validate(r, from_attributes=True) for r in rows] if rows else []
+
+
+async def get_service_stats(upstream_service: str, stat_period: str, start_time: datetime, end_time: datetime) -> List[
+    CaddyStats]:
+    """
+    查询服务级别统计数据
+    
+    Args:
+        upstream_service: 上游服务名称
+        stat_period: 统计周期
+        start_time: 开始时间
+        end_time: 结束时间
+        
+    Returns:
+        统计数据列表
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = select(CaddyStatsTbl).where(
+                and_(
+                    CaddyStatsTbl.stat_period == stat_period,
+                    CaddyStatsTbl.dimension_type == 'service',
+                    CaddyStatsTbl.dimension_value == upstream_service,
+                    CaddyStatsTbl.stat_time >= start_time,
+                    CaddyStatsTbl.stat_time <= end_time
+                )
+            ).order_by(CaddyStatsTbl.stat_time)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [CaddyStats.model_validate(r, from_attributes=True) for r in rows] if rows else []
+
+
+async def get_route_stats(route_name: str, stat_period: str, start_time: datetime, end_time: datetime) -> List[
+    CaddyStats]:
+    """
+    查询路由级别统计数据
+    
+    Args:
+        route_name: 路由名称
+        stat_period: 统计周期
+        start_time: 开始时间
+        end_time: 结束时间
+        
+    Returns:
+        统计数据列表
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = select(CaddyStatsTbl).where(
+                and_(
+                    CaddyStatsTbl.stat_period == stat_period,
+                    CaddyStatsTbl.dimension_type == 'route',
+                    CaddyStatsTbl.dimension_value == route_name,
+                    CaddyStatsTbl.stat_time >= start_time,
+                    CaddyStatsTbl.stat_time <= end_time
+                )
+            ).order_by(CaddyStatsTbl.stat_time)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [CaddyStats.model_validate(r, from_attributes=True) for r in rows] if rows else []
+
+
+async def get_country_stats(stat_period: str, limit: int = 20) -> List[CaddyStats]:
+    """
+    查询国家级别统计数据（Top N）
+    
+    Args:
+        stat_period: 统计周期
+        limit: 返回数量限制
+        
+    Returns:
+        统计数据列表（按请求数降序）
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = select(CaddyStatsTbl).where(
+                and_(
+                    CaddyStatsTbl.stat_period == stat_period,
+                    CaddyStatsTbl.dimension_type == 'country'
+                )
+            ).order_by(desc(CaddyStatsTbl.total_requests)).limit(limit)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [CaddyStats.model_validate(r, from_attributes=True) for r in rows] if rows else []
+
+
+async def get_ip_stats(stat_period: str, limit: int = 20) -> List[CaddyStats]:
+    """
+    查询 IP 级别统计数据（Top N）
+    
+    Args:
+        stat_period: 统计周期
+        limit: 返回数量限制
+        
+    Returns:
+        统计数据列表（按请求数降序）
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = select(CaddyStatsTbl).where(
+                and_(
+                    CaddyStatsTbl.stat_period == stat_period,
+                    CaddyStatsTbl.dimension_type == 'ip'
+                )
+            ).order_by(desc(CaddyStatsTbl.total_requests)).limit(limit)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [CaddyStats.model_validate(r, from_attributes=True) for r in rows] if rows else []
+
+
+async def get_latest_stats(dimension_type: str, dimension_value: Optional[str] = None) -> Optional[CaddyStats]:
+    """
+    获取最新的统计数据
+    
+    Args:
+        dimension_type: 维度类型
+        dimension_value: 维度值
+        
+    Returns:
+        最新的统计对象或 None
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = select(CaddyStatsTbl).where(CaddyStatsTbl.dimension_type == dimension_type)
+
+            if dimension_value:
+                stmt = stmt.where(CaddyStatsTbl.dimension_value == dimension_value)
+
+            stmt = stmt.order_by(desc(CaddyStatsTbl.stat_time)).limit(1)
+            row = (await session.execute(stmt)).scalar_one_or_none()
+            return CaddyStats.model_validate(row, from_attributes=True) if row else None
+
+
+async def delete_old_stats(before_time: datetime) -> int:
+    """
+    删除指定时间之前的统计数据
+    
+    Args:
+        before_time: 删除此时间之前的统计数据
+        
+    Returns:
+        删除的记录数
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = delete(CaddyStatsTbl).where(CaddyStatsTbl.stat_time < before_time)
+            result = await session.execute(stmt)
+            return result.rowcount
+
+
+async def count_stats(filters: Optional[Dict[str, Any]] = None) -> int:
+    """
+    统计记录数量
+    
+    Args:
+        filters: 过滤条件字典
+        
+    Returns:
+        统计记录数量
+    """
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = select(func.count(CaddyStatsTbl.id))
+
+            # 动态添加查询条件
+            if filters:
+                for key, value in filters.items():
+                    if hasattr(CaddyStatsTbl, key) and value is not None:
+                        stmt = stmt.where(getattr(CaddyStatsTbl, key) == value)
+
+            count = (await session.execute(stmt)).scalar_one()
+            return count

cancan_microstack/services/opsbffsrv/infrastructure/db/operate/service_action_log_op.py

@@ -0,0 +1,57 @@
+"""
+服务行为日志表数据库操作
+"""
+from typing import (
+    List,
+    Optional,
+)
+from sqlalchemy import select, desc
+
+from linglong_web import Rmanager
+from cancan_microstack.public.schemas.infra.service_action_log import ServiceActionLog
+from cancan_microstack.services.opsbffsrv.infrastructure.db.model.service_action_log_tbl import ServiceActionLogTbl
+
+
+async def get_service_action_logs(
+        service_name: Optional[str] = None,
+        service_name_variants: Optional[List[str]] = None,
+        action_type: Optional[str] = None,
+        action_status: Optional[str] = None,
+        limit: int = 100
+) -> List[ServiceActionLog]:
+    """
+    查询服务行为日志
+    
+    Args:
+        service_name: 服务名称（可选）
+        action_type: 操作类型（可选）
+        action_status: 操作状态（可选）
+        limit: 返回数量限制
+    
+    Returns:
+        服务行为日志列表
+    """
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceActionLogTbl).where(ServiceActionLogTbl.flag == 0)
+
+            # 动态添加过滤条件
+            candidates: List[str] = []
+            if service_name_variants:
+                candidates = sorted({name for name in service_name_variants if name})
+            elif service_name:
+                candidates = [service_name]
+
+            if candidates:
+                stmt = stmt.where(ServiceActionLogTbl.service_name.in_(candidates))
+            if action_type:
+                stmt = stmt.where(ServiceActionLogTbl.action_type == action_type)
+            if action_status:
+                stmt = stmt.where(ServiceActionLogTbl.action_status == action_status)
+
+            # 按创建时间倒序排列
+            stmt = stmt.order_by(desc(ServiceActionLogTbl.created_time))
+            stmt = stmt.limit(limit)
+
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [ServiceActionLog.model_validate(r, from_attributes=True) for r in rows] if rows else []

cancan_microstack/services/opsbffsrv/infrastructure/db/operate/service_config.py

@@ -0,0 +1,86 @@
+"""
+opsbffsrv 服务配置数据库操作
+与 infrasrv 共用同一套数据库表，但只包含运营管理需要的操作
+"""
+from typing import List
+import itertools
+
+from sqlalchemy.dialects.postgresql import insert
+from sqlalchemy import (
+    select,
+    update,
+    delete,
+    and_,
+)
+
+from linglong_web import Rmanager
+from cancan_microstack.public.schemas.infra.service_config import ServiceConfig
+from cancan_microstack.services.opsbffsrv.infrastructure.db.model.service_config_tbl import ServiceConfigTbl
+
+
+async def insert_service_config(confs: List[ServiceConfig]) -> None:
+    """插入或更新服务配置"""
+    async with Rmanager.pg_session("infra") as session:
+        batched_iter = itertools.batched(confs, 500)
+        for chunk in batched_iter:
+            async with session.begin():
+                stmt = insert(ServiceConfigTbl).values(
+                    [i.model_dump() for i in chunk]
+                )
+                # 冲突时更新字段
+                stmt = stmt.on_conflict_do_update(
+                    index_elements=["service_name", "conf_key"],
+                    set_={
+                        'conf_value': stmt.excluded.conf_value,
+                    }
+                )
+                await session.execute(stmt)
+
+
+async def get_service_config(service_name: str) -> List[ServiceConfig] | None:
+    """获取指定服务的配置"""
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceConfigTbl).where(
+                ServiceConfigTbl.service_name == service_name
+            )
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [ServiceConfig.model_validate(r, from_attributes=True) for r in rows] if rows else None
+
+
+async def update_service_config(confs: List[ServiceConfig]) -> None:
+    """更新服务配置"""
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            for conf in confs:
+                stmt = update(ServiceConfigTbl).where(
+                    and_(
+                        ServiceConfigTbl.service_name == conf.service_name,
+                        ServiceConfigTbl.conf_key == conf.conf_key,
+                    )
+                ).values(
+                    conf_value=conf.conf_value,
+                )
+                await session.execute(stmt)
+
+
+async def get_all_service_configs() -> List[ServiceConfig]:
+    """获取所有服务的配置"""
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceConfigTbl)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [ServiceConfig.model_validate(r, from_attributes=True) for r in rows] if rows else []
+
+
+async def delete_service_config(service_name: str, conf_key: str) -> None:
+    """删除服务配置项"""
+    async with Rmanager.pg_session() as session:
+        async with session.begin():
+            stmt = delete(ServiceConfigTbl).where(
+                and_(
+                    ServiceConfigTbl.service_name == service_name,
+                    ServiceConfigTbl.conf_key == conf_key,
+                )
+            )
+            await session.execute(stmt)

cancan_microstack/services/opsbffsrv/infrastructure/db/operate/service_info_op.py

@@ -0,0 +1,79 @@
+"""
+服务信息表数据库操作
+"""
+from typing import (
+    List,
+    Optional,
+)
+from sqlalchemy import select, delete, func
+from sqlalchemy.dialects.postgresql import insert
+
+from linglong_web import Rmanager
+from cancan_microstack.public.schemas.infra.service_info import ServiceInfo, ServiceInfoCreate
+from cancan_microstack.services.opsbffsrv.infrastructure.db.model.service_info_tbl import ServiceInfoTbl
+
+
+async def get_service_info(service_name: str) -> Optional[ServiceInfo]:
+    """
+    根据服务名获取服务信息
+    
+    Args:
+        service_name: 服务名称
+    
+    Returns:
+        服务信息对象，如果不存在则返回 None
+    """
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInfoTbl).where(
+                ServiceInfoTbl.service_name == service_name,
+                ServiceInfoTbl.flag == 0
+            )
+            row = (await session.execute(stmt)).scalar_one_or_none()
+            return ServiceInfo.model_validate(row, from_attributes=True) if row else None
+
+
+async def get_all_service_info() -> List[ServiceInfo]:
+    """
+    获取所有服务信息
+    
+    Returns:
+        服务信息列表
+    """
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInfoTbl).where(ServiceInfoTbl.flag == 0)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [ServiceInfo.model_validate(r, from_attributes=True) for r in rows] if rows else []
+
+
+async def insert_service_info(data: ServiceInfoCreate) -> ServiceInfo:
+    """
+    插入服务信息（如果已存在则更新）
+    
+    Args:
+        data: 服务信息创建数据
+    
+    Returns:
+        创建或更新的服务信息
+    """
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            values_dict = data.model_dump()
+            stmt = insert(ServiceInfoTbl).values(**values_dict).returning(ServiceInfoTbl)
+            stmt = stmt.on_conflict_do_update(
+                index_elements=['service_name'],
+                set_={
+                    'description': stmt.excluded.description,
+                    'service_type': stmt.excluded.service_type,
+                    'health_check_path': stmt.excluded.health_check_path,
+                    'service_metadata': stmt.excluded.service_metadata,
+                    'expected_status': stmt.excluded.expected_status,
+                    'desired_replicas': stmt.excluded.desired_replicas,
+                    'actual_replicas': stmt.excluded.actual_replicas,
+                    'scale_policy': stmt.excluded.scale_policy,
+                    'last_registered_time': func.current_timestamp(),
+                }
+            )
+            row = (await session.execute(stmt)).scalar_one()
+            return ServiceInfo.model_validate(row, from_attributes=True)

cancan_microstack/services/opsbffsrv/infrastructure/db/operate/service_instance.py

@@ -0,0 +1,58 @@
+"""Read-only service instance queries for opsbff."""
+from typing import (
+    List,
+    Optional,
+)
+
+from sqlalchemy import select, and_
+
+from linglong_web import Rmanager
+from cancan_microstack.public.schemas.infra.service_instance import ServiceInstance
+from cancan_microstack.services.opsbffsrv.infrastructure.db.model.service_instance_tbl import ServiceInstanceTbl
+
+
+async def get_service_instances(
+        service_name: str,
+        status: Optional[str] = None,
+) -> List[ServiceInstance]:
+    """获取指定服务的全部实例 / Fetch all instances for a service."""
+
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInstanceTbl).where(
+                and_(
+                    ServiceInstanceTbl.service_name == service_name,
+                    ServiceInstanceTbl.flag == 0,
+                )
+            )
+            if status:
+                stmt = stmt.where(ServiceInstanceTbl.status == status)
+
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [ServiceInstance.model_validate(r, from_attributes=True) for r in rows]
+
+
+async def get_all_instances() -> List[ServiceInstance]:
+    """读取全部实例数据 / Fetch every instance (ops view)."""
+
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInstanceTbl).where(ServiceInstanceTbl.flag == 0)
+            rows = list((await session.execute(stmt)).scalars().all())
+            return [ServiceInstance.model_validate(r, from_attributes=True) for r in rows]
+
+
+async def get_instance(service_name: str, instance_id: str) -> Optional[ServiceInstance]:
+    """根据服务名+实例ID读取单条记录 / Fetch a single instance."""
+
+    async with Rmanager.pg_session("infra") as session:
+        async with session.begin():
+            stmt = select(ServiceInstanceTbl).where(
+                and_(
+                    ServiceInstanceTbl.service_name == service_name,
+                    ServiceInstanceTbl.instance_id == instance_id,
+                    ServiceInstanceTbl.flag == 0,
+                )
+            )
+            row = (await session.execute(stmt)).scalar_one_or_none()
+            return ServiceInstance.model_validate(row, from_attributes=True) if row else None