fix: verify server snapshots and recover whole migration sessions (#3)

This commit is contained in:
Mikhail Chusavitin committed 2026-10-26 22:48:07 +03:00
1 parent 3d4101ecc0
commit 8569871a17
29 files changed
+1923 -133

No files matched your search

+185
View File
@@ -0,0 +1,185 @@
package mariadb
import (
"archive/zip"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"time"
"git.mchus.pro/mchus/quoteforge/internal/appstate"
"gorm.io/gorm"
)
type snapshotTable struct {
Name, Create, Entry, Digest string
Columns []string
Rows int64
}
type snapshotManifest struct {
Format int
Schema, Collation string
Tables []snapshotTable
Triggers []snapshotTrigger
}
func freshDB(db *gorm.DB) *gorm.DB { return db.Session(&gorm.Session{NewDB: true}) }
func quoteIdentifier(s string) string { return "`" + strings.ReplaceAll(s, "`", "``") + "`" }
// CreateSnapshot writes a consistent InnoDB snapshot, without external DB tools.
// The caller supplies a dedicated connection and excludes concurrent writers
// for the entire migration session, including any recovery.
func CreateSnapshot(db *gorm.DB, root, label string) (string, error) {
if err := appstate.ValidateBackupLocation(root); err != nil {
return "", err
}
if filepath.Base(label) != label {
return "", fmt.Errorf("invalid snapshot label")
}
if err := os.MkdirAll(root, 0700); err != nil {
return "", fmt.Errorf("create snapshot directory: %w", err)
}
if err := appstate.ValidateBackupLocation(root); err != nil {
return "", err
}
file, err := os.CreateTemp(root, "qfs-mariadb-v1-"+label+"-"+time.Now().UTC().Format("20060102T150405Z")+"-*.zip")
if err != nil {
return "", fmt.Errorf("create snapshot: %w", err)
}
path := file.Name()
archive := zip.NewWriter(file)
err = freshDB(db).Transaction(func(tx *gorm.DB) error {
manifest, err := snapshotInventory(tx)
if err != nil {
return err
}
for i := range manifest.Tables {
table := &manifest.Tables[i]
table.Entry = fmt.Sprintf("tables/%06d.jsonl", i)
out, err := archive.Create(table.Entry)
if err != nil {
return fmt.Errorf("create table entry %s: %w", table.Name, err)
}
if err := snapshotRows(tx, table, out); err != nil {
return err
}
}
out, err := archive.Create("manifest.json")
if err != nil {
return fmt.Errorf("create snapshot manifest: %w", err)
}
if err := json.NewEncoder(out).Encode(manifest); err != nil {
return fmt.Errorf("write snapshot manifest: %w", err)
}
return nil
}, &sql.TxOptions{Isolation: sql.LevelRepeatableRead, ReadOnly: true})
zipErr := archive.Close()
syncErr := file.Sync()
closeErr := file.Close()
for _, candidate := range []error{err, zipErr, syncErr, closeErr} {
if candidate != nil {
return "", fmt.Errorf("write snapshot %s: %w", path, candidate)
}
}
if _, err := readSnapshot(path, nil); err != nil {
return "", err
}
return path, nil
}
func snapshotInventory(db *gorm.DB) (*snapshotManifest, error) {
m := &snapshotManifest{Format: 1}
if err := freshDB(db).Raw("SELECT DATABASE(), @@collation_database").Row().Scan(&m.Schema, &m.Collation); err != nil {
return nil, fmt.Errorf("read snapshot schema: %w", err)
}
var unsupported int64
query := `SELECT
(SELECT COUNT(*) FROM information_schema.TABLES WHERE TABLE_SCHEMA=? AND (TABLE_TYPE<>'BASE TABLE' OR ENGINE<>'InnoDB')) +
(SELECT COUNT(*) FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA=?) +
(SELECT COUNT(*) FROM information_schema.EVENTS WHERE EVENT_SCHEMA=?) +
(SELECT COUNT(*) FROM information_schema.KEY_COLUMN_USAGE WHERE
(TABLE_SCHEMA=? AND REFERENCED_TABLE_SCHEMA<>?) OR (REFERENCED_TABLE_SCHEMA=? AND TABLE_SCHEMA<>?))`
if err := freshDB(db).Raw(query, m.Schema, m.Schema, m.Schema, m.Schema, m.Schema, m.Schema, m.Schema).Scan(&unsupported).Error; err != nil {
return nil, fmt.Errorf("check snapshot support: %w", err)
}
if unsupported != 0 {
return nil, fmt.Errorf("snapshot refused: views, non-InnoDB tables, routines, events or cross-schema foreign keys require supported recovery before migration")
}
var names []string
if err := freshDB(db).Raw("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA=? ORDER BY TABLE_NAME", m.Schema).Scan(&names).Error; err != nil {
return nil, fmt.Errorf("list snapshot tables: %w", err)
}
for _, name := range names {
table := snapshotTable{Name: name}
var ignored string
if err := freshDB(db).Raw("SHOW CREATE TABLE "+quoteIdentifier(name)).Row().Scan(&ignored, &table.Create); err != nil {
return nil, fmt.Errorf("read schema for %s: %w", name, err)
}
if err := freshDB(db).Raw(`SELECT COLUMN_NAME FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=? AND TABLE_NAME=? AND EXTRA NOT LIKE '%VIRTUAL GENERATED%' AND EXTRA NOT LIKE '%STORED GENERATED%' ORDER BY ORDINAL_POSITION`, m.Schema, name).Scan(&table.Columns).Error; err != nil {
return nil, fmt.Errorf("read columns for %s: %w", name, err)
}
if len(table.Columns) == 0 {
return nil, fmt.Errorf("snapshot table %s has no writable columns", name)
}
m.Tables = append(m.Tables, table)
}
if err := readSnapshotTriggers(db, m); err != nil {
return nil, err
}
return m, nil
}
func snapshotRows(db *gorm.DB, table *snapshotTable, out io.Writer) error {
columns := make([]string, len(table.Columns))
for i, col := range table.Columns {
columns[i] = "CAST(" + quoteIdentifier(col) + " AS BINARY)"
}
rows, err := freshDB(db).Raw("SELECT " + strings.Join(columns, ",") + " FROM " + quoteIdentifier(table.Name)).Rows()
if err != nil {
return fmt.Errorf("read snapshot table %s: %w", table.Name, err)
}
defer rows.Close()
var digest [32]byte
encoder := json.NewEncoder(out)
table.Rows = 0
for rows.Next() {
values := make([]sql.RawBytes, len(columns))
args := make([]any, len(columns))
for i := range args {
args[i] = &values[i]
}
if err := rows.Scan(args...); err != nil {
return fmt.Errorf("read row in %s: %w", table.Name, err)
}
if err := encoder.Encode(values); err != nil {
return fmt.Errorf("write row in %s: %w", table.Name, err)
}
addRowDigest(&digest, values)
table.Rows++
}
if err := rows.Err(); err != nil {
return fmt.Errorf("iterate %s: %w", table.Name, err)
}
if err := rows.Close(); err != nil {
return fmt.Errorf("close rows in %s: %w", table.Name, err)
}
table.Digest = hex.EncodeToString(digest[:])
return nil
}
func addRowDigest(sum *[32]byte, row []sql.RawBytes) {
encoded, _ := json.Marshal(row) // Raw bytes and nil always marshal successfully.
hash := sha256.Sum256(encoded)
carry := uint16(0)
for i := len(sum) - 1; i >= 0; i-- {
value := uint16(sum[i]) + uint16(hash[i]) + carry
sum[i], carry = byte(value), value>>8
}
}
+101
View File
@@ -0,0 +1,101 @@
package mariadb
import (
"archive/zip"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"strings"
"git.mchus.pro/mchus/quoteforge/internal/appstate"
)
func readSnapshot(path string, visit func(snapshotTable, []sql.RawBytes) error) (*snapshotManifest, error) {
if err := appstate.ValidateBackupLocation(path); err != nil {
return nil, err
}
archive, err := zip.OpenReader(path)
if err != nil {
return nil, fmt.Errorf("open server snapshot: %w", err)
}
defer archive.Close()
files := map[string]*zip.File{}
for _, f := range archive.File {
if files[f.Name] != nil {
return nil, fmt.Errorf("duplicate snapshot entry")
}
files[f.Name] = f
}
manifestFile := files["manifest.json"]
if manifestFile == nil || manifestFile.UncompressedSize64 > 16<<20 {
return nil, fmt.Errorf("missing or oversized snapshot manifest")
}
in, err := manifestFile.Open()
if err != nil {
return nil, fmt.Errorf("open server manifest: %w", err)
}
data, readErr := io.ReadAll(in)
closeErr := in.Close()
if readErr != nil || closeErr != nil {
return nil, fmt.Errorf("read server manifest: %w", errors.Join(readErr, closeErr))
}
var m snapshotManifest
if err := json.Unmarshal(data, &m); err != nil {
return nil, fmt.Errorf("parse server manifest: %w", err)
}
if m.Format != 1 || m.Schema == "" || len(files) != len(m.Tables)+1 {
return nil, fmt.Errorf("invalid server snapshot manifest")
}
names, entries := map[string]bool{}, map[string]bool{}
for _, table := range m.Tables {
if table.Name == "" || names[table.Name] || entries[table.Entry] || files[table.Entry] == nil || len(table.Columns) == 0 || table.Rows < 0 || !strings.HasPrefix(table.Create, "CREATE TABLE "+quoteIdentifier(table.Name)+" (") {
return nil, fmt.Errorf("invalid snapshot table metadata")
}
names[table.Name], entries[table.Entry] = true, true
if err := readSnapshotTable(files[table.Entry], table, visit); err != nil {
return nil, err
}
}
return &m, nil
}
func readSnapshotTable(file *zip.File, table snapshotTable, visit func(snapshotTable, []sql.RawBytes) error) error {
in, err := file.Open()
if err != nil {
return fmt.Errorf("open snapshot table %s: %w", table.Name, err)
}
defer in.Close()
decoder := json.NewDecoder(in)
var rows int64
var digest [32]byte
for {
var values []sql.RawBytes
err := decoder.Decode(&values)
if err == io.EOF {
break
}
if err != nil {
return fmt.Errorf("read snapshot row in %s: %w", table.Name, err)
}
if len(values) != len(table.Columns) {
return fmt.Errorf("snapshot column count mismatch in %s", table.Name)
}
addRowDigest(&digest, values)
rows++
if visit != nil {
if err := visit(table, values); err != nil {
return err
}
}
}
if err := in.Close(); err != nil {
return fmt.Errorf("close snapshot table %s: %w", table.Name, err)
}
if rows != table.Rows || hex.EncodeToString(digest[:]) != table.Digest {
return fmt.Errorf("snapshot checksum mismatch in %s", table.Name)
}
return nil
}
+118
View File
@@ -0,0 +1,118 @@
package mariadb
import (
"database/sql"
"errors"
"fmt"
"strings"
"gorm.io/gorm"
)
// RestoreSnapshot restores and checks a snapshot on a dedicated connection.
// The same maintenance exclusion as migration is required throughout recovery.
func RestoreSnapshot(db *gorm.DB, path string) error {
m, err := readSnapshot(path, nil)
if err != nil {
return err
}
var schema string
if err := freshDB(db).Raw("SELECT DATABASE()").Scan(&schema).Error; err != nil {
return fmt.Errorf("read restore destination: %w", err)
}
if schema != m.Schema {
return fmt.Errorf("snapshot schema does not match restore destination")
}
if err := restoreSnapshotTables(db, path, m); err != nil {
return err
}
return compareSnapshot(db, m)
}
func restoreSnapshotTables(db *gorm.DB, path string, m *snapshotManifest) (err error) {
current, err := snapshotInventory(db)
if err != nil {
return err
}
var foreignKeys int
var sqlMode string
if err := freshDB(db).Raw("SELECT @@foreign_key_checks, @@sql_mode").Row().Scan(&foreignKeys, &sqlMode); err != nil {
return fmt.Errorf("read restore session policy: %w", err)
}
if err := freshDB(db).Exec("SET FOREIGN_KEY_CHECKS=0").Error; err != nil {
return fmt.Errorf("disable FK checks for restore: %w", err)
}
defer func() {
if restoreErr := freshDB(db).Exec("SET sql_mode=?", sqlMode).Error; restoreErr != nil {
err = errors.Join(err, fmt.Errorf("restore SQL mode: %w", restoreErr))
}
if restoreErr := freshDB(db).Exec("SET FOREIGN_KEY_CHECKS=?", foreignKeys).Error; restoreErr != nil {
err = errors.Join(err, fmt.Errorf("restore FK policy: %w", restoreErr))
}
}()
// Preserve explicit zero auto-increment IDs and legacy zero dates. Exact
// schema/data comparison detects any coercion before the source is changed.
if err := freshDB(db).Exec("SET sql_mode='NO_AUTO_VALUE_ON_ZERO'").Error; err != nil {
return fmt.Errorf("set snapshot insert mode: %w", err)
}
for i := len(current.Tables) - 1; i >= 0; i-- {
if err := freshDB(db).Exec("DROP TABLE " + quoteIdentifier(current.Tables[i].Name)).Error; err != nil {
return fmt.Errorf("drop restore table %s: %w", current.Tables[i].Name, err)
}
}
for _, table := range m.Tables {
if err := freshDB(db).Exec(table.Create).Error; err != nil {
return fmt.Errorf("restore schema for %s: %w", table.Name, err)
}
}
var prefix, rowSQL, tableName string
var args []any
var groups []string
var bytes int
flush := func() error {
if len(groups) == 0 {
return nil
}
// Bind through database/sql: GORM expands a byte slice after '('.
// Direct execution also keeps restored values out of SQL logs.
if _, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, prefix+strings.Join(groups, ","), args...); err != nil {
return fmt.Errorf("restore rows in %s: %w", tableName, err)
}
args, groups, bytes = nil, nil, 0
return nil
}
_, err = readSnapshot(path, func(table snapshotTable, values []sql.RawBytes) error {
if tableName != table.Name {
if err := flush(); err != nil {
return err
}
tableName = table.Name
columns, placeholders := make([]string, len(values)), make([]string, len(values))
for i := range values {
columns[i], placeholders[i] = quoteIdentifier(table.Columns[i]), "?"
}
prefix = "INSERT INTO " + quoteIdentifier(tableName) + " (" + strings.Join(columns, ",") + ") VALUES "
rowSQL = "(" + strings.Join(placeholders, ",") + ")"
}
for _, value := range values {
if value == nil {
args = append(args, nil)
} else {
args = append(args, []byte(value))
bytes += len(value)
}
}
groups = append(groups, rowSQL)
if len(groups) >= 250 || len(args)+len(values) > 60000 || bytes >= 1<<20 {
return flush()
}
return nil
})
if err == nil {
err = flush()
}
if err != nil {
return err
}
return restoreSnapshotTriggers(db, m)
}
+87
View File
@@ -0,0 +1,87 @@
package mariadb
import (
"archive/zip"
"database/sql"
"encoding/hex"
"encoding/json"
"os"
"path/filepath"
"testing"
)
func TestSnapshotRowsAndValidation(t *testing.T) {
row := []sql.RawBytes{[]byte{0, 1, 255}, {}, nil}
var sum [32]byte
addRowDigest(&sum, row)
for _, tt := range []struct {
name string
format int
rows int64
digest string
width int
valid bool
}{
{"valid", 1, 1, hex.EncodeToString(sum[:]), 3, true},
{"bad format", 2, 1, hex.EncodeToString(sum[:]), 3, false},
{"bad count", 1, 2, hex.EncodeToString(sum[:]), 3, false},
{"bad digest", 1, 1, "invalid", 3, false},
{"bad width", 1, 1, hex.EncodeToString(sum[:]), 2, false},
} {
t.Run(tt.name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "backup.zip")
file, err := os.Create(path)
if err != nil {
t.Fatal(err)
}
archive := zip.NewWriter(file)
entry, err := archive.Create("table.jsonl")
if err != nil {
t.Fatal(err)
}
if err := json.NewEncoder(entry).Encode(row); err != nil {
t.Fatal(err)
}
entry, err = archive.Create("manifest.json")
if err != nil {
t.Fatal(err)
}
table := snapshotTable{Name: "example", Create: "CREATE TABLE `example` (id INT)", Entry: "table.jsonl", Columns: []string{"a", "b", "c"}[:tt.width], Rows: tt.rows, Digest: tt.digest}
if err := json.NewEncoder(entry).Encode(snapshotManifest{Format: tt.format, Schema: "example", Tables: []snapshotTable{table}}); err != nil {
t.Fatal(err)
}
if err := archive.Close(); err != nil {
t.Fatal(err)
}
if err := file.Close(); err != nil {
t.Fatal(err)
}
_, err = readSnapshot(path, nil)
if (err == nil) != tt.valid {
t.Fatalf("valid=%v err=%v", tt.valid, err)
}
if !tt.valid {
if err := RestoreSnapshot(nil, path); err == nil {
t.Fatal("invalid archive reached restore without preflight refusal")
}
}
})
}
}
func TestSnapshotDigestPreservesValues(t *testing.T) {
a, b := []sql.RawBytes{[]byte("a")}, []sql.RawBytes{[]byte("b")}
var forward, reverse, null, empty [32]byte
addRowDigest(&forward, a)
addRowDigest(&forward, b)
addRowDigest(&reverse, b)
addRowDigest(&reverse, a)
if forward != reverse {
t.Fatal("digest depends on row order")
}
addRowDigest(&null, []sql.RawBytes{nil})
addRowDigest(&empty, []sql.RawBytes{{}})
if null == empty {
t.Fatal("digest conflates NULL and empty bytes")
}
}
@@ -0,0 +1,43 @@
package mariadb
import (
"fmt"
"regexp"
"strings"
)
// Recovery covers the selected schema, so external trigger effects are refused.
func validateSnapshotTriggerReferences(trigger snapshotTrigger, schema string) error {
body := trigger.Body
quoted := `'(?:''|\\.|[^'\\])*'`
if strings.Contains(trigger.SQLMode, "NO_BACKSLASH_ESCAPES") {
quoted = `'(?:''|[^'])*'`
}
body = regexp.MustCompile(quoted).ReplaceAllString(body, " ")
if !strings.Contains(trigger.SQLMode, "ANSI_QUOTES") {
double := `"(?:""|\\.|[^"\\])*"`
if strings.Contains(trigger.SQLMode, "NO_BACKSLASH_ESCAPES") {
double = `"(?:""|[^"])*"`
}
body = regexp.MustCompile(double).ReplaceAllString(body, " ")
}
if strings.Contains(body, "/*!") || strings.Contains(body, "/*M!") {
return fmt.Errorf("trigger %s has unsupported executable comments", trigger.Name)
}
body = regexp.MustCompile(`(?s)/\*.*?\*/|--[\t ][^\n]*|#[^\n]*`).ReplaceAllString(body, " ")
if regexp.MustCompile(`(?i)\bCALL\s+`).MatchString(body) {
return fmt.Errorf("trigger %s calls a routine outside supported recovery", trigger.Name)
}
identifier := "(?:`(?:``|[^`])+`|\"(?:\"\"|[^\"])+\"|[\\pL_$][\\pL\\pN_$]*)"
for _, pattern := range []string{
"(?i)\\b(?:FROM|JOIN|UPDATE|INTO)\\s+(?:(?:LOW_PRIORITY|HIGH_PRIORITY|DELAYED|IGNORE)\\s+)*(" + identifier + ")\\s*\\.",
"(?i)(" + identifier + ")\\s*\\.\\s*" + identifier + "\\s*\\(",
} {
for _, match := range regexp.MustCompile(pattern).FindAllStringSubmatch(body, -1) {
if !strings.EqualFold(strings.Trim(match[1], "`\""), schema) {
return fmt.Errorf("trigger %s references another schema outside supported recovery", trigger.Name)
}
}
}
return nil
}
@@ -0,0 +1,29 @@
package mariadb
import "testing"
func TestSnapshotTriggerReferences(t *testing.T) {
for _, tt := range []struct {
name, body, mode string
fail bool
}{
{"local", "INSERT INTO audit VALUES (NEW.id, OLD.value)", "", false},
{"local qualified", "UPDATE `example`.`audit` SET id=NEW.id", "", false},
{"alias", "SELECT 1 FROM audit a WHERE a.id=OLD.id", "", false},
{"literal", "INSERT INTO audit VALUES ('example.com', '$.field', 'UPDATE other.audit')", "", false},
{"comment", "/* UPDATE other.audit */ INSERT INTO audit VALUES (NEW.id)", "", false},
{"external write", "UPDATE other.audit SET id=NEW.id", "", true},
{"external insert", "INSERT INTO `other`.`audit` VALUES (NEW.id)", "", true},
{"ANSI external", `UPDATE "other"."audit" SET id=NEW.id`, "ANSI_QUOTES", true},
{"external function", "SET NEW.value=other.example(NEW.value)", "", true},
{"routine", "CALL example.change_rows()", "", true},
{"executable", "/*!50000 UPDATE other.audit SET id=1 */", "", true},
} {
t.Run(tt.name, func(t *testing.T) {
err := validateSnapshotTriggerReferences(snapshotTrigger{Name: "example", Body: tt.body, SQLMode: tt.mode}, "example")
if (err != nil) != tt.fail {
t.Fatalf("error=%v", err)
}
})
}
}
+83
View File
@@ -0,0 +1,83 @@
package mariadb
import (
"errors"
"fmt"
"strings"
"gorm.io/gorm"
)
type snapshotTrigger struct {
Name string `gorm:"column:TRIGGER_NAME"`
Table string `gorm:"column:EVENT_OBJECT_TABLE"`
Event string `gorm:"column:EVENT_MANIPULATION"`
Timing string `gorm:"column:ACTION_TIMING"`
Order int `gorm:"column:ACTION_ORDER"`
Body string `gorm:"column:ACTION_STATEMENT"`
SQLMode string `gorm:"column:SQL_MODE"`
Definer string `gorm:"column:DEFINER"`
Charset string `gorm:"column:CHARACTER_SET_CLIENT"`
Collation string `gorm:"column:COLLATION_CONNECTION"`
DatabaseCollation string `gorm:"column:DATABASE_COLLATION"`
}
func readSnapshotTriggers(db *gorm.DB, m *snapshotManifest) error {
query := `SELECT TRIGGER_NAME, EVENT_OBJECT_TABLE, EVENT_MANIPULATION, ACTION_TIMING,
ACTION_ORDER, ACTION_STATEMENT, SQL_MODE, DEFINER, CHARACTER_SET_CLIENT,
COLLATION_CONNECTION, DATABASE_COLLATION FROM information_schema.TRIGGERS
WHERE TRIGGER_SCHEMA=? ORDER BY EVENT_OBJECT_TABLE, ACTION_TIMING, EVENT_MANIPULATION, ACTION_ORDER`
if err := freshDB(db).Raw(query, m.Schema).Scan(&m.Triggers).Error; err != nil {
return fmt.Errorf("read snapshot triggers: %w", err)
}
for _, trigger := range m.Triggers {
if err := validateSnapshotTriggerReferences(trigger, m.Schema); err != nil {
return err
}
if trigger.DatabaseCollation != m.Collation {
return fmt.Errorf("trigger %s has a legacy database collation; restore support is required before migration", trigger.Name)
}
}
return nil
}
func restoreSnapshotTriggers(db *gorm.DB, m *snapshotManifest) (err error) {
if len(m.Triggers) == 0 {
return nil
}
var mode, charset, collation, schema string
if err := freshDB(db).Raw("SELECT @@sql_mode, @@character_set_client, @@collation_connection, DATABASE()").Row().Scan(&mode, &charset, &collation, &schema); err != nil {
return fmt.Errorf("read trigger restore session: %w", err)
}
defer func() {
for _, reset := range []struct{ sql, value string }{{"SET sql_mode=?", mode}, {"SET character_set_client=?", charset}, {"SET collation_connection=?", collation}} {
if e := freshDB(db).Exec(reset.sql, reset.value).Error; e != nil {
err = errors.Join(err, fmt.Errorf("reset trigger restore session: %w", e))
}
}
}()
for _, trigger := range m.Triggers {
if trigger.Timing != "BEFORE" && trigger.Timing != "AFTER" {
return fmt.Errorf("invalid trigger timing")
}
if trigger.Event != "INSERT" && trigger.Event != "UPDATE" && trigger.Event != "DELETE" {
return fmt.Errorf("invalid trigger event")
}
at := strings.LastIndex(trigger.Definer, "@")
if at < 1 || at == len(trigger.Definer)-1 {
return fmt.Errorf("invalid trigger definer")
}
for _, setting := range []struct{ sql, value string }{{"SET sql_mode=?", trigger.SQLMode}, {"SET character_set_client=?", trigger.Charset}, {"SET collation_connection=?", trigger.Collation}} {
if err := freshDB(db).Exec(setting.sql, setting.value).Error; err != nil {
return fmt.Errorf("set trigger restore session: %w", err)
}
}
// Explicitly bind name and target table to the destination. Trigger bodies
// retain their original SQL; verification performs no DML after creation.
statement := "CREATE DEFINER=" + quoteIdentifier(trigger.Definer[:at]) + "@" + quoteIdentifier(trigger.Definer[at+1:]) + " TRIGGER " + quoteIdentifier(schema) + "." + quoteIdentifier(trigger.Name) + " " + trigger.Timing + " " + trigger.Event + " ON " + quoteIdentifier(schema) + "." + quoteIdentifier(trigger.Table) + " FOR EACH ROW " + trigger.Body
if _, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, statement); err != nil {
return fmt.Errorf("restore trigger %s: %w", trigger.Name, err)
}
}
return nil
}
+79
View File
@@ -0,0 +1,79 @@
package mariadb
import (
"crypto/rand"
"encoding/hex"
"errors"
"fmt"
"io"
"reflect"
"gorm.io/gorm"
)
// CheckSnapshot compares restored schema and all writable row values.
func CheckSnapshot(db *gorm.DB, path string) error {
m, err := readSnapshot(path, nil)
if err != nil {
return err
}
return compareSnapshot(db, m)
}
// VerifySnapshot proves restore readiness in an isolated temporary database.
func VerifySnapshot(db *gorm.DB, path string) (err error) {
m, err := readSnapshot(path, nil)
if err != nil {
return err
}
var random [12]byte
if _, err := rand.Read(random[:]); err != nil {
return fmt.Errorf("name verification schema: %w", err)
}
scratch := "qfs_verify_" + hex.EncodeToString(random[:])
var original string
if err := freshDB(db).Raw("SELECT DATABASE()").Scan(&original).Error; err != nil {
return fmt.Errorf("read original schema: %w", err)
}
if err := freshDB(db).Exec("CREATE DATABASE " + quoteIdentifier(scratch) + " COLLATE " + quoteIdentifier(m.Collation)).Error; err != nil {
return fmt.Errorf("create restore verification schema: %w", err)
}
defer func() {
if e := freshDB(db).Exec("USE " + quoteIdentifier(original)).Error; e != nil {
err = errors.Join(err, fmt.Errorf("return to original schema: %w", e))
}
if e := freshDB(db).Exec("DROP DATABASE " + quoteIdentifier(scratch)).Error; e != nil {
err = errors.Join(err, fmt.Errorf("remove verification schema %s: %w", scratch, e))
}
}()
if err := freshDB(db).Exec("USE " + quoteIdentifier(scratch)).Error; err != nil {
return fmt.Errorf("select verification schema: %w", err)
}
if err := restoreSnapshotTables(db, path, m); err != nil {
return err
}
return compareSnapshot(db, m)
}
func compareSnapshot(db *gorm.DB, m *snapshotManifest) error {
current, err := snapshotInventory(db)
if err != nil {
return err
}
if !reflect.DeepEqual(current.Triggers, m.Triggers) {
return fmt.Errorf("restored trigger metadata mismatch")
}
if len(current.Tables) != len(m.Tables) {
return fmt.Errorf("restored table count mismatch")
}
for i := range m.Tables {
want, got := m.Tables[i], current.Tables[i]
if err := snapshotRows(db, &got, io.Discard); err != nil {
return err
}
if want.Name != got.Name || want.Create != got.Create || want.Rows != got.Rows || want.Digest != got.Digest {
return fmt.Errorf("restored snapshot mismatch in %s (name=%t schema=%t rows=%t digest=%t)", want.Name, want.Name == got.Name, want.Create == got.Create, want.Rows == got.Rows, want.Digest == got.Digest)
}
}
return nil
}