350 lines
10 KiB
Go
350 lines
10 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)
|
||
}
|
||
}()
|
||
|
||
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)
|
||
}
|
||
|
||
rows, err := db.DB.QueryContext(ctx, "SHOW TABLES")
|
||
if err != nil {
|
||
return fmt.Errorf("读取 MySQL 表列表失败：%w", err)
|
||
}
|
||
var tableNames []string
|
||
for rows.Next() {
|
||
var tableName string
|
||
if err := rows.Scan(&tableName); err != nil {
|
||
_ = rows.Close()
|
||
return fmt.Errorf("读取 MySQL 表名失败：%w", err)
|
||
}
|
||
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)
|
||
}
|
||
|
||
for _, tableName := range tableNames {
|
||
if err := dumpMySQLTable(ctx, db.DB, file, tableName); 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 := 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 := 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.DB, 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)
|
||
}
|
||
|
||
rows, err := db.QueryContext(ctx, "SELECT * FROM "+quotedTable)
|
||
if err != nil {
|
||
return fmt.Errorf("读取 MySQL 表数据失败（%s）：%w", tableName, err)
|
||
}
|
||
defer rows.Close()
|
||
columns, err := rows.Columns()
|
||
if err != nil {
|
||
return fmt.Errorf("读取 MySQL 表字段失败（%s）：%w", tableName, err)
|
||
}
|
||
for rows.Next() {
|
||
values := make([]any, len(columns))
|
||
pointers := make([]any, len(columns))
|
||
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(values))
|
||
for index, value := range values {
|
||
literals[index] = mysqlSQLLiteral(value)
|
||
}
|
||
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 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 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()
|
||
for _, statement := range splitMySQLStatements(string(script)) {
|
||
if _, err := db.DB.ExecContext(ctx, statement); err != nil {
|
||
return fmt.Errorf("执行 MySQL 恢复语句失败：%w", err)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func splitMySQLStatements(script string) []string {
|
||
var statements []string
|
||
var statement strings.Builder
|
||
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 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
|
||
}
|
||
if current == ';' {
|
||
flush()
|
||
continue
|
||
}
|
||
statement.WriteByte(current)
|
||
}
|
||
flush()
|
||
return statements
|
||
}
|