123 lines
3.5 KiB
Go
123 lines
3.5 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"embed"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"log"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
)
|
|
|
|
//go:embed migrations/*.sql
|
|
var migrationFS embed.FS
|
|
|
|
// Произвольная константа-ключ advisory lock: параллельные запуски миграций выстраиваются в очередь.
|
|
const migrationLockKey int64 = 7_272_026_002
|
|
|
|
type migration struct{ version, sql, checksum string }
|
|
|
|
func itoa(n int) string { return strconv.Itoa(n) }
|
|
|
|
func loadMigrations() []migration {
|
|
entries, err := migrationFS.ReadDir("migrations")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
var list []migration
|
|
for _, e := range entries {
|
|
if e.IsDir() || !strings.HasSuffix(e.Name(), ".sql") {
|
|
continue
|
|
}
|
|
raw, err := migrationFS.ReadFile("migrations/" + e.Name())
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
sum := sha256.Sum256(raw)
|
|
list = append(list, migration{strings.TrimSuffix(e.Name(), ".sql"), string(raw), hex.EncodeToString(sum[:])})
|
|
}
|
|
sort.Slice(list, func(i, j int) bool { return list[i].version < list[j].version })
|
|
return list
|
|
}
|
|
|
|
func migrationVersions() []string {
|
|
var v []string
|
|
for _, m := range loadMigrations() {
|
|
v = append(v, m.version)
|
|
}
|
|
return v
|
|
}
|
|
|
|
// runMigrations применяет только ещё не применённые версии. Повторный запуск ничего не меняет и не трогает данные:
|
|
// каждая версия записывается в schema_migrations в той же транзакции, что и сама миграция.
|
|
func runMigrations(ctx context.Context, databaseURL string) error {
|
|
var conn *pgx.Conn
|
|
var err error
|
|
deadline := time.Now().Add(60 * time.Second)
|
|
for {
|
|
cctx, cancel := context.WithTimeout(ctx, 5*time.Second)
|
|
conn, err = pgx.Connect(cctx, databaseURL)
|
|
cancel()
|
|
if err == nil {
|
|
break
|
|
}
|
|
if time.Now().After(deadline) || ctx.Err() != nil {
|
|
return fmt.Errorf("database is not reachable: %w", err)
|
|
}
|
|
log.Printf("migrate: waiting for database...")
|
|
time.Sleep(2 * time.Second)
|
|
}
|
|
defer conn.Close(context.Background())
|
|
|
|
if _, err := conn.Exec(ctx, `SELECT pg_advisory_lock($1)`, migrationLockKey); err != nil {
|
|
return err
|
|
}
|
|
defer func() { _, _ = conn.Exec(context.Background(), `SELECT pg_advisory_unlock($1)`, migrationLockKey) }()
|
|
|
|
if _, err := conn.Exec(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (
|
|
version text PRIMARY KEY,
|
|
checksum text NOT NULL,
|
|
applied_at timestamptz NOT NULL DEFAULT now())`); err != nil {
|
|
return err
|
|
}
|
|
applied := 0
|
|
for _, m := range loadMigrations() {
|
|
var have string
|
|
err := conn.QueryRow(ctx, `SELECT checksum FROM schema_migrations WHERE version = $1`, m.version).Scan(&have)
|
|
if err == nil {
|
|
if have != m.checksum {
|
|
return fmt.Errorf("migration %s was changed after being applied (checksum mismatch)", m.version)
|
|
}
|
|
continue
|
|
}
|
|
if err != pgx.ErrNoRows {
|
|
return err
|
|
}
|
|
tx, err := conn.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if _, err := tx.Exec(ctx, m.sql); err != nil {
|
|
_ = tx.Rollback(ctx)
|
|
return fmt.Errorf("migration %s failed: %w", m.version, err)
|
|
}
|
|
if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)`, m.version, m.checksum); err != nil {
|
|
_ = tx.Rollback(ctx)
|
|
return err
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return err
|
|
}
|
|
applied++
|
|
log.Printf("migrate: applied %s", m.version)
|
|
}
|
|
log.Printf("migrate: done, %d new, %d total", applied, len(loadMigrations()))
|
|
return nil
|
|
}
|