mayfly-go/server/internal/db/application/instance.go

package application

import (
	"database/sql"
	"fmt"
	"mayfly-go/internal/db/domain/entity"
	"mayfly-go/internal/db/domain/repository"
	"mayfly-go/pkg/base"
	"mayfly-go/pkg/errorx"
	"mayfly-go/pkg/model"
)

type Instance interface {
	base.App[*entity.Instance]

	// GetPageList 分页获取数据库实例
	GetPageList(condition *entity.InstanceQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error)

	Count(condition *entity.InstanceQuery) int64

	Save(instanceEntity *entity.Instance) error

	// Delete 删除数据库信息
	Delete(id uint64) error

	// GetDatabases 获取数据库实例的所有数据库列表
	GetDatabases(entity *entity.Instance) ([]string, error)
}

func newInstanceApp(instanceRepo repository.Instance) Instance {
	app := new(instanceAppImpl)
	app.Repo = instanceRepo
	return app
}

type instanceAppImpl struct {
	base.AppImpl[*entity.Instance, repository.Instance]
}

// GetPageList 分页获取数据库实例
func (app *instanceAppImpl) GetPageList(condition *entity.InstanceQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error) {
	return app.GetRepo().GetInstanceList(condition, pageParam, toEntity, orderBy...)
}

func (app *instanceAppImpl) Count(condition *entity.InstanceQuery) int64 {
	return app.CountByCond(condition)
}

func (app *instanceAppImpl) Save(instanceEntity *entity.Instance) error {
	// 默认tcp连接
	instanceEntity.Network = instanceEntity.GetNetwork()

	// 测试连接
	if instanceEntity.Password != "" {
		if err := testConnection(instanceEntity); err != nil {
			return errorx.NewBiz("数据库连接失败: %s", err.Error())
		}
	}

	// 查找是否存在该库
	oldInstance := &entity.Instance{Host: instanceEntity.Host, Port: instanceEntity.Port, Username: instanceEntity.Username}
	if instanceEntity.SshTunnelMachineId > 0 {
		oldInstance.SshTunnelMachineId = instanceEntity.SshTunnelMachineId
	}

	err := app.GetBy(oldInstance)
	if instanceEntity.Id == 0 {
		if instanceEntity.Password == "" {
			return errorx.NewBiz("密码不能为空")
		}
		if err == nil {
			return errorx.NewBiz("该数据库实例已存在")
		}
		instanceEntity.PwdEncrypt()
		return app.Insert(instanceEntity)
	}

	// 如果存在该库，则校验修改的库是否为该库
	if err == nil && oldInstance.Id != instanceEntity.Id {
		return errorx.NewBiz("该数据库实例已存在")
	}
	instanceEntity.PwdEncrypt()
	return app.UpdateById(instanceEntity)
}

func (app *instanceAppImpl) Delete(id uint64) error {
	return app.DeleteById(id)
}

// getInstanceConn 获取数据库连接数据库实例
func getInstanceConn(instance *entity.Instance, db string) (*sql.DB, error) {
	var conn *sql.DB
	var err error
	switch instance.Type {
	case entity.DbTypeMysql:
		conn, err = getMysqlDB(instance, db)
	case entity.DbTypePostgres:
		conn, err = getPgsqlDB(instance, db)
	default:
		panic(fmt.Sprintf("invalid database type: %s", instance.Type))
	}

	if err != nil {
		return nil, err
	}
	err = conn.Ping()
	if err != nil {
		conn.Close()
		return nil, err
	}

	return conn, nil
}

func testConnection(d *entity.Instance) error {
	// 不指定数据库名称
	conn, err := getInstanceConn(d, "")
	if err != nil {
		return err
	}
	defer conn.Close()
	return nil
}

func (app *instanceAppImpl) GetDatabases(ed *entity.Instance) ([]string, error) {
	ed.Network = ed.GetNetwork()
	databases := make([]string, 0)
	var dbConn *sql.DB
	metaDb := ed.Type.MetaDbName()
	getDatabasesSql := ed.Type.StmtSelectDbName()

	dbConn, err := getInstanceConn(ed, metaDb)
	if err != nil {
		return nil, errorx.NewBiz("数据库连接失败: %s", err.Error())
	}
	defer dbConn.Close()

	_, res, err := selectDataByDb(dbConn, getDatabasesSql)
	if err != nil {
		return nil, err
	}
	for _, re := range res {
		databases = append(databases, re["dbname"].(string))
	}

	return databases, nil
}