493 lines
16 KiB
Go
493 lines
16 KiB
Go
package cli
|
||
|
||
import (
|
||
"context"
|
||
"database/sql"
|
||
"encoding/hex"
|
||
"fmt"
|
||
"os"
|
||
"path/filepath"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||
)
|
||
|
||
// backupMySQL 将 MySQL 的基础表、数据、例程、触发器和事件导出为可在 MySQL 5.7/8.0 导入的 SQL 文件。
|
||
func backupMySQL(ctx context.Context, cfg config.Config, output string) error {
|
||
resolved, err := resolveMaintenanceDatabase(ctx, cfg.Database, cfg.Paths.Config)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return backupMySQLDatabase(ctx, resolved, output)
|
||
}
|
||
|
||
func backupMySQLDatabase(ctx context.Context, cfg config.DatabaseConfig, output string) error {
|
||
db, err := database.Open(ctx, cfg)
|
||
if err != nil {
|
||
return fmt.Errorf("打开 MySQL 备份连接失败：%w", err)
|
||
}
|
||
defer db.Close()
|
||
|
||
temporaryPath := output + ".tmp"
|
||
file, err := os.OpenFile(temporaryPath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
|
||
if err != nil {
|
||
return fmt.Errorf("创建 MySQL 备份文件失败：%w", err)
|
||
}
|
||
removeTemporary := true
|
||
defer func() {
|
||
_ = file.Close()
|
||
if removeTemporary {
|
||
_ = os.Remove(temporaryPath)
|
||
}
|
||
}()
|
||
// 所有表的数据必须来自同一个可重复读事务，不能按表从连接池独立读取。
|
||
// 元数据变更不属于 MVCC 快照，运维期间仍需禁止外部并发 DDL。
|
||
tx, err := db.DB.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelRepeatableRead, ReadOnly: true})
|
||
if err != nil {
|
||
return fmt.Errorf("创建 MySQL 一致性备份事务失败：%w", err)
|
||
}
|
||
defer tx.Rollback()
|
||
// 客户端取消会关闭连接，但服务端等待元数据锁时未必立即感知断开。
|
||
// 仅限制本次备份会话的单次锁等待；不限制总导出时间，也不修改全局配置。
|
||
if _, err := tx.ExecContext(ctx, "SET SESSION lock_wait_timeout = 5"); err != nil {
|
||
return fmt.Errorf("设置 MySQL 备份元数据锁等待上限失败：%w", err)
|
||
}
|
||
|
||
if _, err := fmt.Fprintf(file, "-- Scert MySQL 数据备份\n-- 生成时间：%s\n\nSET FOREIGN_KEY_CHECKS=0;\n\n", time.Now().UTC().Format(time.RFC3339)); err != nil {
|
||
return fmt.Errorf("写入 MySQL 备份头失败：%w", err)
|
||
}
|
||
if _, err := fmt.Fprint(file, "-- 恢复前须进入维护窗口，停止事件调度并等待工作线程退出；恢复后先核验对象及警告，再由管理员恢复调度。\n\n"); err != nil {
|
||
return err
|
||
}
|
||
|
||
rows, err := tx.QueryContext(ctx, "SELECT TABLE_NAME, ENGINE, TABLE_TYPE FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() ORDER BY TABLE_NAME")
|
||
if err != nil {
|
||
return fmt.Errorf("读取 MySQL 表列表失败：%w", err)
|
||
}
|
||
var tableNames []string
|
||
for rows.Next() {
|
||
var tableName, tableType string
|
||
var engine sql.NullString
|
||
if err := rows.Scan(&tableName, &engine, &tableType); err != nil {
|
||
_ = rows.Close()
|
||
return fmt.Errorf("读取 MySQL 表名失败：%w", err)
|
||
}
|
||
if tableType != "BASE TABLE" || !engine.Valid || !strings.EqualFold(engine.String, "InnoDB") {
|
||
_ = rows.Close()
|
||
return fmt.Errorf("MySQL 一致性备份当前仅支持 InnoDB 基础表，不能静默导出其他对象：%s", tableName)
|
||
}
|
||
tableNames = append(tableNames, tableName)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
_ = rows.Close()
|
||
return fmt.Errorf("遍历 MySQL 表列表失败：%w", err)
|
||
}
|
||
if err := rows.Close(); err != nil {
|
||
return fmt.Errorf("关闭 MySQL 表列表失败：%w", err)
|
||
}
|
||
if err := requireMySQLTriggerVisibility(ctx, tx, tableNames); err != nil {
|
||
return err
|
||
}
|
||
routines, err := listMySQLRoutines(ctx, tx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
events, err := listMySQLEvents(ctx, tx)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
for _, tableName := range tableNames {
|
||
if err := dumpMySQLTable(ctx, tx, file, tableName); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
// 例程先于依赖它的触发器创建；例程定义不执行其中的业务语句。
|
||
if err := dumpMySQLRoutines(ctx, tx, file, routines); err != nil {
|
||
return err
|
||
}
|
||
// 必须先恢复所有基础数据，再创建触发器，避免导入时重放业务副作用。
|
||
if err := dumpMySQLTriggers(ctx, tx, file); err != nil {
|
||
return err
|
||
}
|
||
if _, err := fmt.Fprint(file, "SET FOREIGN_KEY_CHECKS=1;\n"); err != nil {
|
||
return fmt.Errorf("写入 MySQL 备份尾失败：%w", err)
|
||
}
|
||
// 事件必须排在基础数据、例程、触发器和外键恢复之后。
|
||
if err := dumpMySQLEvents(ctx, tx, file, events); err != nil {
|
||
return err
|
||
}
|
||
if err := tx.Commit(); err != nil {
|
||
return fmt.Errorf("结束 MySQL 一致性备份事务失败：%w", err)
|
||
}
|
||
if err := file.Sync(); err != nil {
|
||
return fmt.Errorf("同步 MySQL 备份文件失败：%w", err)
|
||
}
|
||
if err := file.Close(); err != nil {
|
||
return fmt.Errorf("关闭 MySQL 备份文件失败：%w", err)
|
||
}
|
||
if err := os.Chmod(temporaryPath, 0o600); err != nil {
|
||
return fmt.Errorf("设置 MySQL 备份文件权限失败：%w", err)
|
||
}
|
||
if err := ctx.Err(); err != nil {
|
||
return err
|
||
}
|
||
if err := os.Rename(temporaryPath, output); err != nil {
|
||
return fmt.Errorf("保存 MySQL 备份文件失败：%w", err)
|
||
}
|
||
removeTemporary = false
|
||
return nil
|
||
}
|
||
|
||
// createMySQLRestoreBackup 在恢复前保留目标数据库快照，供失败时回滚使用。
|
||
// 快照目录不会在恢复成功后自动删除，便于管理员在需要时继续排查或手动恢复。
|
||
func createMySQLRestoreBackup(ctx context.Context, cfg config.Config, connection config.DatabaseConfig) (string, error) {
|
||
backupRoot := filepath.Clean(strings.TrimSpace(cfg.Paths.Backup))
|
||
if backupRoot == "." || backupRoot == "" {
|
||
return "", fmt.Errorf("MySQL 恢复前备份目录不能为空")
|
||
}
|
||
if err := os.MkdirAll(backupRoot, 0o700); err != nil {
|
||
return "", fmt.Errorf("创建 MySQL 恢复前备份目录失败：%w", err)
|
||
}
|
||
info, err := os.Lstat(backupRoot)
|
||
if err != nil {
|
||
return "", fmt.Errorf("检查 MySQL 恢复前备份目录失败：%w", err)
|
||
}
|
||
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
|
||
return "", fmt.Errorf("MySQL 恢复前备份目录必须是普通目录")
|
||
}
|
||
if err := os.Chmod(backupRoot, 0o700); err != nil {
|
||
return "", fmt.Errorf("设置 MySQL 恢复前备份目录权限失败：%w", err)
|
||
}
|
||
rollbackDirectory, err := os.MkdirTemp(backupRoot, "scert-before-restore-")
|
||
if err != nil {
|
||
return "", fmt.Errorf("创建 MySQL 恢复快照目录失败：%w", err)
|
||
}
|
||
rollbackPath := filepath.Join(rollbackDirectory, "scert.sql")
|
||
if err := backupMySQLDatabase(ctx, connection, rollbackPath); err != nil {
|
||
return "", fmt.Errorf("创建 MySQL 恢复前快照失败：%w", err)
|
||
}
|
||
return rollbackPath, nil
|
||
}
|
||
|
||
func dumpMySQLTable(ctx context.Context, db *sql.Tx, output *os.File, tableName string) error {
|
||
quotedTable := quoteMySQLIdentifier(tableName)
|
||
var name, createSQL string
|
||
if err := db.QueryRowContext(ctx, "SHOW CREATE TABLE "+quotedTable).Scan(&name, &createSQL); err != nil {
|
||
return fmt.Errorf("读取 MySQL 表结构失败（%s）：%w", tableName, err)
|
||
}
|
||
if _, err := fmt.Fprintf(output, "DROP TABLE IF EXISTS %s;\n%s;\n\n", quotedTable, createSQL); err != nil {
|
||
return fmt.Errorf("写入 MySQL 表结构失败（%s）：%w", tableName, err)
|
||
}
|
||
|
||
columns, err := mysqlInsertableColumns(ctx, db, tableName)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// 显式投影可写列：SELECT * 会遗漏不可见列，并错误地包含生成列的计算结果。
|
||
projection := quoteMySQLColumns(columns)
|
||
if len(columns) == 0 {
|
||
// 只有生成列的表仍有行数，使用占位读取并导出空列 INSERT 保留每一行。
|
||
projection = "1"
|
||
}
|
||
rows, err := db.QueryContext(ctx, "SELECT "+projection+" FROM "+quotedTable)
|
||
if err != nil {
|
||
return fmt.Errorf("读取 MySQL 表数据失败（%s）：%w", tableName, err)
|
||
}
|
||
defer rows.Close()
|
||
selectedColumns, err := rows.Columns()
|
||
if err != nil {
|
||
return fmt.Errorf("读取 MySQL 表字段失败（%s）：%w", tableName, err)
|
||
}
|
||
columnTypes, err := rows.ColumnTypes()
|
||
if err != nil {
|
||
return fmt.Errorf("读取 MySQL 表字段类型失败（%s）：%w", tableName, err)
|
||
}
|
||
for rows.Next() {
|
||
values := make([]any, len(selectedColumns))
|
||
pointers := make([]any, len(values))
|
||
for index := range values {
|
||
pointers[index] = &values[index]
|
||
}
|
||
if err := rows.Scan(pointers...); err != nil {
|
||
return fmt.Errorf("读取 MySQL 表行失败（%s）：%w", tableName, err)
|
||
}
|
||
literals := make([]string, len(columns))
|
||
for index := range columns {
|
||
literals[index] = mysqlColumnSQLLiteral(values[index], columnTypes[index].DatabaseTypeName())
|
||
}
|
||
if _, err := fmt.Fprintf(output, "INSERT INTO %s (%s) VALUES (%s);\n", quotedTable, quoteMySQLColumns(columns), strings.Join(literals, ", ")); err != nil {
|
||
return fmt.Errorf("写入 MySQL 表数据失败（%s）：%w", tableName, err)
|
||
}
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return fmt.Errorf("遍历 MySQL 表数据失败（%s）：%w", tableName, err)
|
||
}
|
||
_, err = fmt.Fprintln(output)
|
||
return err
|
||
}
|
||
|
||
func mysqlInsertableColumns(ctx context.Context, db *sql.Tx, tableName string) ([]string, error) {
|
||
rows, err := db.QueryContext(ctx, "SELECT COLUMN_NAME FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND COALESCE(GENERATION_EXPRESSION, '') = '' ORDER BY ORDINAL_POSITION", tableName)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("读取 MySQL 可写字段失败（%s）：%w", tableName, err)
|
||
}
|
||
defer rows.Close()
|
||
var columns []string
|
||
for rows.Next() {
|
||
var name string
|
||
if err := rows.Scan(&name); err != nil {
|
||
return nil, fmt.Errorf("读取 MySQL 可写字段名失败（%s）：%w", tableName, err)
|
||
}
|
||
columns = append(columns, name)
|
||
}
|
||
if err := rows.Err(); err != nil {
|
||
return nil, fmt.Errorf("遍历 MySQL 可写字段失败（%s）：%w", tableName, err)
|
||
}
|
||
return columns, nil
|
||
}
|
||
|
||
func quoteMySQLIdentifier(value string) string {
|
||
return "`" + strings.ReplaceAll(value, "`", "``") + "`"
|
||
}
|
||
|
||
func quoteMySQLColumns(columns []string) string {
|
||
quoted := make([]string, len(columns))
|
||
for index, column := range columns {
|
||
quoted[index] = quoteMySQLIdentifier(column)
|
||
}
|
||
return strings.Join(quoted, ", ")
|
||
}
|
||
|
||
func mysqlColumnSQLLiteral(value any, columnType string) string {
|
||
// 驱动将 DECIMAL 返回为文本字节；十六进制字面量在数值列中会被当作整数。
|
||
// 使用文本字面量保留任意精度，不经浮点转换；真正的二进制列仍按原样导出。
|
||
if columnType == "DECIMAL" {
|
||
switch typed := value.(type) {
|
||
case sql.RawBytes:
|
||
return mysqlStringLiteral(string(typed))
|
||
case []byte:
|
||
return mysqlStringLiteral(string(typed))
|
||
}
|
||
}
|
||
return mysqlSQLLiteral(value)
|
||
}
|
||
|
||
func mysqlSQLLiteral(value any) string {
|
||
switch typed := value.(type) {
|
||
case nil:
|
||
return "NULL"
|
||
case sql.RawBytes:
|
||
return "X'" + hex.EncodeToString(typed) + "'"
|
||
case []byte:
|
||
return "X'" + hex.EncodeToString(typed) + "'"
|
||
case string:
|
||
return mysqlStringLiteral(typed)
|
||
case time.Time:
|
||
return "'" + typed.UTC().Format("2006-01-02 15:04:05.999999") + "'"
|
||
case bool:
|
||
if typed {
|
||
return "1"
|
||
}
|
||
return "0"
|
||
case int64:
|
||
return strconv.FormatInt(typed, 10)
|
||
case uint64:
|
||
return strconv.FormatUint(typed, 10)
|
||
case float64:
|
||
return strconv.FormatFloat(typed, 'g', -1, 64)
|
||
case float32:
|
||
return strconv.FormatFloat(float64(typed), 'g', -1, 32)
|
||
default:
|
||
return mysqlStringLiteral(fmt.Sprint(typed))
|
||
}
|
||
}
|
||
|
||
func mysqlStringLiteral(value string) string {
|
||
var builder strings.Builder
|
||
builder.Grow(len(value) + 2)
|
||
builder.WriteByte('\'')
|
||
for index := 0; index < len(value); index++ {
|
||
switch value[index] {
|
||
case '\\':
|
||
builder.WriteString(`\\`)
|
||
case '\x00':
|
||
builder.WriteString(`\0`)
|
||
case '\n':
|
||
builder.WriteString(`\n`)
|
||
case '\r':
|
||
builder.WriteString(`\r`)
|
||
case '\x1a':
|
||
builder.WriteString(`\Z`)
|
||
case '\'':
|
||
builder.WriteString(`''`)
|
||
default:
|
||
builder.WriteByte(value[index])
|
||
}
|
||
}
|
||
builder.WriteByte('\'')
|
||
return builder.String()
|
||
}
|
||
|
||
// restoreMySQL 执行 Scert 生成的 MySQL SQL 备份。
|
||
func restoreMySQL(ctx context.Context, cfg config.DatabaseConfig, input string) error {
|
||
script, err := os.ReadFile(input)
|
||
if err != nil {
|
||
return fmt.Errorf("读取 MySQL 备份文件失败：%w", err)
|
||
}
|
||
db, err := database.Open(ctx, cfg)
|
||
if err != nil {
|
||
return fmt.Errorf("打开 MySQL 恢复连接失败：%w", err)
|
||
}
|
||
defer db.Close()
|
||
// 会话变量与外键开关必须留在同一条连接上；失败后返回，不切换连接重放。
|
||
connection, err := db.DB.Conn(ctx)
|
||
if err != nil {
|
||
return fmt.Errorf("获取 MySQL 恢复会话失败：%w", err)
|
||
}
|
||
defer connection.Close()
|
||
statements, err := splitMySQLStatements(string(script))
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if err := preflightMySQLEventRestore(ctx, connection, statements); err != nil {
|
||
return err
|
||
}
|
||
for _, statement := range statements {
|
||
if _, err := connection.ExecContext(ctx, statement); err != nil {
|
||
return fmt.Errorf("执行 MySQL 恢复语句失败：%w", err)
|
||
}
|
||
if err := checkMySQLEventRestoreWarnings(ctx, connection, statement); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func splitMySQLStatements(script string) ([]string, error) {
|
||
script = strings.TrimPrefix(script, "\uFEFF")
|
||
var statements []string
|
||
var statement strings.Builder
|
||
delimiter := ";"
|
||
var quote byte
|
||
lineComment := false
|
||
blockComment := false
|
||
executableComment := false
|
||
escaped := false
|
||
flush := func() {
|
||
value := strings.TrimSpace(statement.String())
|
||
if value != "" {
|
||
statements = append(statements, value)
|
||
}
|
||
statement.Reset()
|
||
}
|
||
for index := 0; index < len(script); index++ {
|
||
current := script[index]
|
||
if lineComment {
|
||
if current == '\n' {
|
||
lineComment = false
|
||
statement.WriteByte('\n')
|
||
}
|
||
continue
|
||
}
|
||
if blockComment {
|
||
if current == '*' && index+1 < len(script) && script[index+1] == '/' {
|
||
blockComment = false
|
||
index++
|
||
statement.WriteByte(' ')
|
||
}
|
||
continue
|
||
}
|
||
if executableComment {
|
||
statement.WriteByte(current)
|
||
if current == '*' && index+1 < len(script) && script[index+1] == '/' {
|
||
statement.WriteByte(script[index+1])
|
||
index++
|
||
executableComment = false
|
||
}
|
||
continue
|
||
}
|
||
if quote != 0 {
|
||
statement.WriteByte(current)
|
||
if escaped {
|
||
escaped = false
|
||
continue
|
||
}
|
||
if current == '\\' {
|
||
escaped = true
|
||
continue
|
||
}
|
||
if current == quote {
|
||
if index+1 < len(script) && script[index+1] == quote {
|
||
statement.WriteByte(script[index+1])
|
||
index++
|
||
continue
|
||
}
|
||
quote = 0
|
||
}
|
||
continue
|
||
}
|
||
if (index == 0 || script[index-1] == '\n') && strings.TrimSpace(statement.String()) == "" {
|
||
end := strings.IndexByte(script[index:], '\n')
|
||
if end < 0 {
|
||
end = len(script) - index
|
||
}
|
||
line := strings.TrimSpace(script[index : index+end])
|
||
if len(line) >= len("delimiter") && strings.EqualFold(line[:len("delimiter")], "delimiter") &&
|
||
(len(line) == len("delimiter") || line[len("delimiter")] == ' ' || line[len("delimiter")] == '\t') {
|
||
value := strings.TrimSpace(line[len("delimiter"):])
|
||
if len(value) >= 2 && (value[0] == '\'' || value[0] == '"') && value[len(value)-1] == value[0] {
|
||
value = value[1 : len(value)-1]
|
||
}
|
||
if value == "" || strings.ContainsAny(value, " \t\r\n") || strings.ContainsRune(value, '\\') || strings.ContainsRune(value, '\'') || strings.ContainsRune(value, '"') || strings.ContainsRune(value, '`') {
|
||
return nil, fmt.Errorf("MySQL 备份中的 DELIMITER 指令无效")
|
||
}
|
||
delimiter = value
|
||
statement.Reset()
|
||
index += end
|
||
continue
|
||
}
|
||
}
|
||
if strings.HasPrefix(script[index:], delimiter) {
|
||
flush()
|
||
index += len(delimiter) - 1
|
||
continue
|
||
}
|
||
if current == '\'' || current == '"' || current == '`' {
|
||
quote = current
|
||
statement.WriteByte(current)
|
||
continue
|
||
}
|
||
if current == '#' {
|
||
lineComment = true
|
||
continue
|
||
}
|
||
if current == '-' && index+2 < len(script) && script[index+1] == '-' && (script[index+2] == ' ' || script[index+2] == '\t' || script[index+2] == '\n') {
|
||
lineComment = true
|
||
index++
|
||
continue
|
||
}
|
||
if current == '/' && index+1 < len(script) && script[index+1] == '*' {
|
||
if index+2 < len(script) && (script[index+2] == '!' || script[index+2] == '+') {
|
||
statement.WriteByte(current)
|
||
statement.WriteByte(script[index+1])
|
||
index++
|
||
executableComment = true
|
||
continue
|
||
}
|
||
blockComment = true
|
||
index++
|
||
continue
|
||
}
|
||
statement.WriteByte(current)
|
||
}
|
||
if quote != 0 || blockComment || executableComment {
|
||
return nil, fmt.Errorf("MySQL 备份包含未闭合的字符串、标识符或注释")
|
||
}
|
||
flush()
|
||
return statements, nil
|
||
}
|