kra/internal/initialize/initialize.go

package initialize

import (
	"kra/internal/conf"

	"github.com/gin-gonic/gin"
	"github.com/redis/go-redis/v9"
	"gorm.io/gorm"
)

// Initializer 初始化器
type Initializer struct {
	config        *conf.Bootstrap
	db            *gorm.DB
	dbList        *DBList
	redis         *RedisClient
	redisList     *RedisList
	timerManager  *TimerManager
	pluginManager *PluginManager
	mcpServer     *MCPServer
}

// NewInitializer 创建初始化器
func NewInitializer(config *conf.Bootstrap) *Initializer {
	return &Initializer{
		config: config,
	}
}

// InitDB 初始化主数据库
func (i *Initializer) InitDB() (*gorm.DB, error) {
	dbType := "mysql"
	if i.config.System != nil && i.config.System.DbType != "" {
		dbType = i.config.System.DbType
	}

	db, err := NewDBByType(dbType, i.config)
	if err != nil {
		return nil, err
	}

	i.db = db
	return db, nil
}

// InitDBList 初始化多数据库
func (i *Initializer) InitDBList() (*DBList, error) {
	dbList, err := InitDBList(i.config.DbList)
	if err != nil {
		return nil, err
	}

	// 如果有system数据库，设置为主数据库
	if sysDB := dbList.GetSystem(); sysDB != nil {
		i.db = sysDB
	}

	i.dbList = dbList
	return dbList, nil
}

// InitRedis 初始化主Redis
func (i *Initializer) InitRedis() (*RedisClient, error) {
	if i.config.Redis == nil {
		return nil, nil
	}

	client, err := NewRedisClient(i.config.Redis)
	if err != nil {
		return nil, err
	}

	i.redis = client
	return client, nil
}

// InitRedisList 初始化多Redis
func (i *Initializer) InitRedisList() (*RedisList, error) {
	redisList, err := InitRedisList(i.config.RedisList)
	if err != nil {
		return nil, err
	}

	i.redisList = redisList
	return redisList, nil
}

// InitTimer 初始化定时任务
func (i *Initializer) InitTimer() *TimerManager {
	manager := NewTimerManager(i.db)
	manager.Start()
	i.timerManager = manager
	return manager
}

// InitPlugin 初始化插件管理器
func (i *Initializer) InitPlugin() *PluginManager {
	manager := NewPluginManager(i.db)
	i.pluginManager = manager
	return manager
}

// InitMCP 初始化MCP服务器
func (i *Initializer) InitMCP() *MCPServer {
	server := NewMCPServer(i.config.Mcp)
	i.mcpServer = server
	return server
}

// DB 获取主数据库
func (i *Initializer) DB() *gorm.DB {
	return i.db
}

// DBList 获取数据库列表
func (i *Initializer) DBList() *DBList {
	return i.dbList
}

// Redis 获取主Redis客户端
func (i *Initializer) Redis() redis.UniversalClient {
	if i.redis == nil {
		return nil
	}
	return i.redis.Client()
}

// RedisList 获取Redis列表
func (i *Initializer) RedisList() *RedisList {
	return i.redisList
}

// TimerManager 获取定时任务管理器
func (i *Initializer) TimerManager() *TimerManager {
	return i.timerManager
}

// PluginManager 获取插件管理器
func (i *Initializer) PluginManager() *PluginManager {
	return i.pluginManager
}

// MCPServer 获取MCP服务器
func (i *Initializer) MCPServer() *MCPServer {
	return i.mcpServer
}

// InstallPlugins 安装插件
func (i *Initializer) InstallPlugins(privateGroup *gin.RouterGroup, publicGroup *gin.RouterGroup, engine *gin.Engine) {
	if i.pluginManager != nil {
		i.pluginManager.InstallPlugins(privateGroup, publicGroup, engine)
	}
}

// RegisterMCPRoutes 注册MCP路由
func (i *Initializer) RegisterMCPRoutes(engine *gin.Engine) {
	if i.mcpServer != nil {
		i.mcpServer.RegisterRoutes(engine)
	}
}

// Close 关闭所有资源
func (i *Initializer) Close() error {
	// 关闭定时任务
	if i.timerManager != nil {
		i.timerManager.Stop()
	}

	// 关闭数据库连接
	if i.db != nil {
		sqlDB, err := i.db.DB()
		if err == nil {
			sqlDB.Close()
		}
	}

	// 关闭数据库列表
	if i.dbList != nil {
		i.dbList.Close()
	}

	// 关闭Redis连接
	if i.redis != nil {
		i.redis.Close()
	}

	// 关闭Redis列表
	if i.redisList != nil {
		i.redisList.Close()
	}

	return nil
}