cancan-microstack 0.0.1__py3-none-any.whl

cancan_microstack/services/opsbffsrv/application/db_init_app.py

@@ -0,0 +1,283 @@
+"""数据库初始化应用层 / DB init application layer.
+
+负责数据库初始化和增量构建的业务流程编排。
+Orchestrates database initialization and incremental builds.
+"""
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.pool import NullPool
+
+from linglong_web.utils import logger
+from linglong_web import Rmanager
+from linglong_web import LinglongConfig
+
+from cancan_microstack.services.opsbffsrv.domain.db_init.db_init_domain import DatabaseInitDomain
+from cancan_microstack.public.schemas.opsbffsrv.db_init import (
+    DatabaseInitRequest,
+    DatabaseIncrementalBuildRequest,
+    DatabaseBuildResult,
+    DatabaseStatus,
+    DatabaseInfo,
+)
+
+
+class DatabaseInitApp:
+    """数据库初始化应用服务"""
+
+    def __init__(self):
+        self.domain = DatabaseInitDomain()
+
+    async def initialize_all_databases(self, request: DatabaseInitRequest) -> DatabaseBuildResult:
+        """
+        一键初始化所有数据库（适用于首次部署）
+        
+        Args:
+            request: 初始化请求
+            
+        Returns:
+            构建结果
+        """
+        logger.info(f"Starting database initialization, force={request.force}")
+
+        databases_to_init = request.databases or self.domain.get_all_databases()
+
+        databases_created = []
+        tables_created = []
+        errors = []
+
+        main_engine = None
+        try:
+            # 使用 main 数据库的连接来创建其他数据库
+            # Create a temporary connection to the bootstrap DB (usually 'postgres' or 'main')
+            #
+            # 关键点：这是一次性管理操作，不应持久化连接池，否则多次调用会导致连接数持续上涨。
+            # Key point: this is a one-off admin operation; do NOT keep a long-lived pool here.
+            main_engine = create_async_engine(
+                f"postgresql+asyncpg://{LinglongConfig.PGSQL_USER}:{LinglongConfig.PGSQL_PASSWORD}@{LinglongConfig.PGSQL_HOST}:{LinglongConfig.PGSQL_PORT}/main",
+                poolclass=NullPool,
+                pool_pre_ping=True,
+                isolation_level="AUTOCOMMIT",  # 创建数据库需要在 AUTOCOMMIT 模式 / CREATE DATABASE needs AUTOCOMMIT
+            )
+
+            async with main_engine.connect() as conn:
+                for db_name in databases_to_init:
+                    logger.info(f"Processing database: {db_name}")
+
+                    # 检查数据库是否存在
+                    exists = await self.domain.check_database_exists(db_name, conn)
+
+                    if exists and not request.force:
+                        logger.info(f"Database '{db_name}' already exists, skipping creation")
+                    elif exists and request.force:
+                        # 强制模式：删除并重建
+                        # 注意：DROP DATABASE 必须在 autocommit 模式下执行
+                        logger.warning(f"Force mode: dropping database '{db_name}'")
+                        try:
+                            # 需要退出当前事务，使用 autocommit
+                            await conn.execute(text(f"DROP DATABASE {db_name}"))
+                            logger.info(f"Database '{db_name}' dropped")
+                        except Exception as e:
+                            logger.error(f"Failed to drop database '{db_name}': {e}", exc_info=True)
+                            errors.append({
+                                "database": db_name,
+                                "operation": "drop",
+                                "error": str(e)
+                            })
+                            continue
+
+                    # 创建数据库（如果不存在或已删除）
+                    if not exists or request.force:
+                        if await self.domain.create_database(db_name, conn):
+                            databases_created.append(db_name)
+                            logger.info(f"Database '{db_name}' created")
+                        else:
+                            errors.append({
+                                "database": db_name,
+                                "operation": "create",
+                                "error": "Failed to create database"
+                            })
+                            continue
+
+                    # 需要先注册该数据库的引擎才能继续创建表
+                    # 这里假设已经在配置中预先配置好了
+                    # 如果没有配置，需要动态添加引擎注册
+
+                    # 创建表（增量方式）
+                    created, failed = await self.domain.create_tables_incremental(db_name)
+                    tables_created.extend([f"{db_name}.{table}" for table in created])
+
+                    if failed:
+                        for table in failed:
+                            errors.append({
+                                "database": db_name,
+                                "table": table,
+                                "operation": "create_table",
+                                "error": "Failed to create table"
+                            })
+
+            success = len(errors) == 0
+            message = f"Initialized {len(databases_created)} databases, created {len(tables_created)} tables"
+            if errors:
+                message += f", {len(errors)} errors"
+
+            return DatabaseBuildResult(
+                success=success,
+                message=message,
+                databases_created=databases_created,
+                tables_created=tables_created,
+                errors=errors
+            )
+
+        except Exception as e:
+            logger.error(f"Database initialization failed: {e}", exc_info=True)
+            return DatabaseBuildResult(
+                success=False,
+                message=f"Initialization failed: {str(e)}",
+                databases_created=databases_created,
+                tables_created=tables_created,
+                errors=errors + [{"error": str(e)}]
+            )
+
+        finally:
+            if main_engine is not None:
+                try:
+                    await main_engine.dispose()
+                except Exception as dispose_exc:  # pragma: no cover - defensive cleanup
+                    logger.warning("Failed to dispose main_engine: %s", dispose_exc)
+
+    async def incremental_build(self, request: DatabaseIncrementalBuildRequest) -> DatabaseBuildResult:
+        """
+        增量构建数据库和表
+        - 数据库不存在则创建，存在则跳过
+        - 表不存在则创建，存在则跳过
+        
+        Args:
+            request: 增量构建请求
+            
+        Returns:
+            构建结果
+        """
+        logger.info(f"Starting incremental database build")
+
+        databases_to_build = request.databases or self.domain.get_all_databases()
+
+        databases_created = []
+        tables_created = []
+        errors = []
+
+        try:
+            # 使用 postgres 数据库的连接来创建其他数据库
+            engine = Rmanager.get_pgsql_engine("default")
+            if engine is None:
+                return DatabaseBuildResult(
+                    success=False,
+                    message="Failed to get database connection",
+                    databases_created=[],
+                    tables_created=[],
+                    errors=[{"error": "No default database engine available"}]
+                )
+
+            async with engine.connect() as conn:
+                for db_name in databases_to_build:
+                    logger.info(f"Processing database: {db_name}")
+
+                    # 检查数据库是否存在
+                    exists = await self.domain.check_database_exists(db_name, conn)
+
+                    # 数据库不存在则创建
+                    if not exists:
+                        if await self.domain.create_database(db_name, conn):
+                            databases_created.append(db_name)
+                            logger.info(f"Database '{db_name}' created")
+                        else:
+                            errors.append({
+                                "database": db_name,
+                                "operation": "create",
+                                "error": "Failed to create database"
+                            })
+                            continue
+                    else:
+                        logger.info(f"Database '{db_name}' already exists")
+
+                    # 增量创建表
+                    created, failed = await self.domain.create_tables_incremental(
+                        db_name,
+                        request.tables
+                    )
+                    tables_created.extend([f"{db_name}.{table}" for table in created])
+
+                    if failed:
+                        for table in failed:
+                            errors.append({
+                                "database": db_name,
+                                "table": table,
+                                "operation": "create_table",
+                                "error": "Failed to create table"
+                            })
+
+            success = len(errors) == 0
+            message = f"Built {len(databases_created)} new databases, created {len(tables_created)} tables"
+            if errors:
+                message += f", {len(errors)} errors"
+
+            return DatabaseBuildResult(
+                success=success,
+                message=message,
+                databases_created=databases_created,
+                tables_created=tables_created,
+                errors=errors
+            )
+
+        except Exception as e:
+            logger.error(f"Incremental build failed: {e}", exc_info=True)
+            return DatabaseBuildResult(
+                success=False,
+                message=f"Build failed: {str(e)}",
+                databases_created=databases_created,
+                tables_created=tables_created,
+                errors=errors + [{"error": str(e)}]
+            )
+
+    async def get_database_status(self) -> DatabaseStatus:
+        """
+        获取数据库状态
+        
+        Returns:
+            数据库状态信息
+        """
+        databases = []
+
+        try:
+            engine = Rmanager.get_pgsql_engine("default")
+            if engine is None:
+                return DatabaseStatus(
+                    databases=[],
+                    ddl_path=str(self.domain.ddl_root)
+                )
+
+            async with engine.connect() as conn:
+                for db_name in self.domain.get_all_databases():
+                    exists = await self.domain.check_database_exists(db_name, conn)
+
+                    tables = []
+                    if exists:
+                        tables = list(await self.domain.get_existing_tables(db_name))
+
+                    databases.append(DatabaseInfo(
+                        name=db_name,
+                        exists=exists,
+                        tables=tables
+                    ))
+
+            return DatabaseStatus(
+                databases=databases,
+                ddl_path=str(self.domain.ddl_root)
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to get database status: {e}", exc_info=True)
+            return DatabaseStatus(
+                databases=[],
+                ddl_path=str(self.domain.ddl_root)
+            )

cancan_microstack/services/opsbffsrv/application/logging/__init__.py

@@ -0,0 +1 @@
+"""opsbffsrv logging application package."""

cancan_microstack/services/opsbffsrv/application/logging/log_query_app.py

@@ -0,0 +1,28 @@
+"""应用层：日志查询 / Application layer for log search."""
+from typing import Optional
+
+from linglong_web import LinglongConfig
+from cancan_microstack.public.schemas.logging.log_event import (
+    LogQueryRequest,
+    LogQueryResponse,
+)
+
+from cancan_microstack.services.opsbffsrv.domain.logging.log_query_domain import LogQueryDomain
+from cancan_microstack.services.opsbffsrv.infrastructure.mongo.log_query_repository import LogQueryRepository
+
+
+class LogQueryApp:
+    """调度日志查询流程 / Orchestrates log query workflows."""
+
+    def __init__(self) -> None:
+        self._repository = LogQueryRepository()
+        self._domain = LogQueryDomain(self._repository)
+        # 注意：该模块可能会在 LinglongConfig 初始化前被 import。
+        # Note: This module may be imported before LinglongConfig is initialized.
+        self._max_range_days = int(getattr(LinglongConfig, "LOG_QUERY_MAX_RANGE_DAYS", 7))
+
+    async def search_logs(self, payload: LogQueryRequest) -> LogQueryResponse:
+        return await self._domain.search_logs(payload, self._max_range_days)
+
+
+log_query_app = LogQueryApp()

cancan_microstack/services/opsbffsrv/application/service_config.py

@@ -0,0 +1,158 @@
+"""
+服务配置管理应用层
+Service configuration application layer coordinating persistence and push triggers
+"""
+from typing import Dict
+
+from pydantic import ValidationError
+
+from linglong_web import (
+    HTTPClientConfig,
+    http_client,
+)
+from linglong_web import LinglongConfig
+from linglong_web.utils import logger
+
+from cancan_microstack.services.opsbffsrv.domain.service_config.service_config import ServiceConfigDomain
+from cancan_microstack.public.schemas.opsbffsrv.service_config import (
+    ConfigPushExecutionResult,
+    ConfigPushStatus,
+    ServiceConfigDetail,
+    ServiceConfigEntry,
+    ServiceConfigOperationSummary,
+    ServiceConfigOverview,
+)
+from cancan_microstack.public.schemas.infra.push import PushResult
+
+
+class ServiceConfigApp:
+    def __init__(self):
+        self.service_config_domain = ServiceConfigDomain()
+
+    async def get_service_config(self, service_name: str) -> ServiceConfigDetail:
+        """
+        获取指定服务的配置字典
+        Retrieve configuration entries for a specific service
+        """
+        config_items = await self.service_config_domain.get_service_config(service_name)
+        entries = [
+            ServiceConfigEntry(key=key, value=value)
+            for key, value in sorted(config_items.items())
+        ]
+        return ServiceConfigDetail(service_name=service_name, items=entries)
+
+    async def insert_service_config(self, service_name: str,
+                                    conf_dict: Dict[str, str]) -> ServiceConfigOperationSummary:
+        """
+        插入服务配置并触发推送
+        Insert configuration values and trigger downstream push
+        """
+        await self.service_config_domain.insert_service_config(service_name, conf_dict)
+        push_result = await self._trigger_config_push(service_name)
+        return ServiceConfigOperationSummary(
+            service_name=service_name,
+            message="Config inserted successfully",
+            push_result=push_result,
+        )
+
+    async def update_service_config(self, service_name: str,
+                                    conf_dict: Dict[str, str]) -> ServiceConfigOperationSummary:
+        """
+        更新服务配置并触发推送
+        Update configuration values and trigger downstream push
+        """
+        await self.service_config_domain.update_service_config(service_name, conf_dict)
+        push_result = await self._trigger_config_push(service_name)
+        return ServiceConfigOperationSummary(
+            service_name=service_name,
+            message="Config updated successfully",
+            push_result=push_result,
+        )
+
+    async def get_all_service_configs(self) -> ServiceConfigOverview:
+        """
+        获取全部服务的配置概览
+        Retrieve configuration overview for every registered service
+        """
+        all_configs = await self.service_config_domain.get_all_service_configs()
+        details = [
+            ServiceConfigDetail(
+                service_name=service,
+                items=[
+                    ServiceConfigEntry(key=key, value=value)
+                    for key, value in sorted(config.items())
+                ],
+            )
+            for service, config in sorted(all_configs.items())
+        ]
+        return ServiceConfigOverview(services=details)
+
+    async def delete_service_config(self, service_name: str, conf_key: str) -> ServiceConfigOperationSummary:
+        """
+        删除服务配置项并触发推送
+        Delete configuration entry and trigger downstream push
+        """
+        await self.service_config_domain.delete_service_config(service_name, conf_key)
+        push_result = await self._trigger_config_push(service_name)
+        return ServiceConfigOperationSummary(
+            service_name=service_name,
+            message="Config deleted successfully",
+            push_result=push_result,
+        )
+
+    async def _trigger_config_push(self, service_name: str) -> ConfigPushExecutionResult:
+        """
+        调用 infrasrv 的内部接口触发配置推送
+        Invoke infrasrv internal API to push configuration updates
+        """
+        try:
+            url = f"{LinglongConfig.INFRASRV_HOST}/v1/infrasrv/internal/config/push"
+            logger.info(f"Triggering config push for service: {service_name}")
+
+            resp = await http_client.post(
+                url,
+                params={"service_name": service_name},
+                json={"service_name": service_name},
+                timeout=HTTPClientConfig.INTERNAL_SERVICE_TIMEOUT,
+            )
+
+            if resp and resp.status == 200:
+                data = await resp.json()
+                logger.info(f"Config push triggered successfully for {service_name}")
+                push_data = data.get("data") if isinstance(data, dict) else None
+                push_summary = None
+                if isinstance(push_data, dict):
+                    try:
+                        push_summary = PushResult.model_validate(push_data)
+                    except ValidationError as exc:
+                        logger.warning(
+                            "Failed to parse push result for %s: %s",
+                            service_name,
+                            exc,
+                        )
+                return ConfigPushExecutionResult(
+                    status=ConfigPushStatus.SUCCESS,
+                    summary=push_summary,
+                )
+
+            http_status = resp.status if resp else "None"
+            logger.warning(
+                "Failed to trigger config push for %s: status %s",
+                service_name,
+                http_status,
+            )
+            return ConfigPushExecutionResult(
+                status=ConfigPushStatus.FAILED,
+                error_message=f"HTTP {http_status}",
+            )
+        except Exception as exc:  # noqa: BLE001
+            logger.error(
+                "Error triggering config push for %s: %s",
+                service_name,
+                exc,
+                exc_info=True,
+            )
+            return ConfigPushExecutionResult(
+                status=ConfigPushStatus.ERROR,
+                error_message=str(exc),
+            )

cancan_microstack/services/opsbffsrv/application/service_logs_app.py

@@ -0,0 +1,74 @@
+"""服务行为日志应用层 / Application layer for service action logs."""
+
+from typing import (
+    List,
+    Optional,
+)
+
+from linglong_web.utils import logger
+from cancan_microstack.public.schemas.infra.service_action_log import ServiceActionLog
+from cancan_microstack.public.schemas.opsbffsrv.service_logs import ServiceLogsPayload
+from cancan_microstack.services.opsbffsrv.infrastructure.db.operate.service_action_log_op import (
+    get_service_action_logs,
+)
+
+
+class ServiceLogsApp:
+    """服务日志应用层：直接访问数据库，避免链路依赖 / Fetch logs directly from infra DB."""
+
+    @staticmethod
+    def _build_service_name_variants(service_name: str) -> List[str]:
+        """构建 service_name 及其变体，适配 *.service 命名风格 / Normalize service names."""
+        raw = service_name.strip()
+        if not raw:
+            return []
+        candidates = {raw}
+        suffix = '.service'
+        if raw.endswith(suffix):
+            base = raw[:-len(suffix)]
+            if base:
+                candidates.add(base)
+        else:
+            candidates.add(f"{raw}{suffix}")
+        return sorted(candidates)
+
+    async def get_service_logs(
+            self,
+            service_name: Optional[str] = None,
+            action_type: Optional[str] = None,
+            action_status: Optional[str] = None,
+            limit: int = 100,
+    ) -> ServiceLogsPayload:
+        """
+        查询服务行为日志（直连 DB）
+        Fetch service action logs directly from the infra database.
+        """
+
+        logger.info(
+            "ServiceLogsApp: querying logs - service_name=%s, action_type=%s, action_status=%s, limit=%s",
+            service_name,
+            action_type,
+            action_status,
+            limit,
+        )
+
+        name_variants = self._build_service_name_variants(service_name) if service_name else None
+        if name_variants:
+            logger.info("Normalized service name variants: input=%s, variants=%s", service_name, name_variants)
+
+        logs: List[ServiceActionLog] = await get_service_action_logs(
+            service_name_variants=name_variants,
+            action_type=action_type,
+            action_status=action_status,
+            limit=limit,
+        )
+        logger.info("Fetched %s logs from infra database", len(logs))
+
+        return ServiceLogsPayload(
+            service_name=service_name,
+            action_type=action_type,
+            action_status=action_status,
+            limit=limit,
+            logs=logs,
+            total=len(logs),
+        )

cancan_microstack/services/opsbffsrv/application/service_registry.py

@@ -0,0 +1,36 @@
+"""
+服务注册查询应用层
+为ops前端提供服务实例查询功能
+"""
+from typing import (
+    List,
+)
+
+from cancan_microstack.public.schemas.infra.service_registry import ServiceInstance
+from cancan_microstack.public.schemas.infra.overview import ServiceOverview
+from cancan_microstack.services.opsbffsrv.domain.service_registry.service_registry import ServiceRegistryDomain
+
+
+class ServiceRegistryApp:
+    def __init__(self):
+        self.service_registry_domain = ServiceRegistryDomain()
+
+    async def get_service_instances(self, service_name: str | None = None, only_healthy: bool = True) -> List[ServiceInstance]:
+        """获取服务实例列表"""
+        return await self.service_registry_domain.get_service_instances(service_name, only_healthy)
+
+    async def get_all_instances(self) -> List[ServiceInstance]:
+        """获取所有服务实例"""
+        return await self.service_registry_domain.get_all_instances()
+
+    async def get_instance(self, service_name: str, instance_id: str) -> ServiceInstance | None:
+        """获取指定服务实例"""
+        return await self.service_registry_domain.get_instance(service_name, instance_id)
+
+    async def get_all_service_names(self) -> List[str]:
+        """获取所有服务名称"""
+        return await self.service_registry_domain.get_all_service_names()
+
+    async def get_services_overview(self) -> List[ServiceOverview]:
+        """获取所有服务的概览信息"""
+        return await self.service_registry_domain.get_services_overview()