fix: verify server snapshots and recover whole migration sessions (#3)
This commit is contained in:
1 parent
3d4101ecc0
commit
8569871a17
29 files changed
+1923
-133
No files matched your search
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
Reference in new issue
Block a user