Repository Public
1package backup23import (4 "bytes"5 "context"6 "crypto/rand"7 "crypto/sha256"8 "encoding/hex"9 "errors"10 "fmt"11 "io"12 "os"13 "os/exec"14 "path/filepath"15 "sort"16 "strings"17 "time"1819 "github.com/jackc/pgx/v5"20 "github.com/jackc/pgx/v5/pgxpool"2122 "clustr.spboucher.ai/mcc/internal/audit"23 "clustr.spboucher.ai/mcc/internal/ids"24)2526const suffix = ".dump.enc"2728// LoadOrCreateKey reads the 32-byte backup key, creating it (0600) on first use.29func LoadOrCreateKey(path string) (key []byte, created bool, err error) {30 if b, err := os.ReadFile(path); err == nil {31 if len(b) != 32 {32 return nil, false, fmt.Errorf("backup: %s must hold 32 bytes", path)33 }34 return b, false, nil35 } else if !errors.Is(err, os.ErrNotExist) {36 return nil, false, err37 }38 if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {39 return nil, false, err40 }41 key = make([]byte, 32)42 if _, err := rand.Read(key); err != nil {43 return nil, false, err44 }45 f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)46 if err != nil {47 return nil, false, err48 }49 defer f.Close()50 if _, err := f.Write(key); err != nil {51 return nil, false, err52 }53 return key, true, f.Sync()54}5556// pgTool locates a PostgreSQL client binary (Homebrew keeps versioned ones out of PATH).57func pgTool(name string) (string, error) {58 if p, err := exec.LookPath(name); err == nil {59 return p, nil60 }61 for _, dir := range []string{"/opt/homebrew/opt/postgresql@17/bin", "/opt/homebrew/bin", "/usr/local/opt/postgresql@17/bin", "/usr/lib/postgresql/17/bin"} {62 p := filepath.Join(dir, name)63 if st, err := os.Stat(p); err == nil && !st.IsDir() {64 return p, nil65 }66 }67 return "", fmt.Errorf("backup: %s not found", name)68}6970type Result struct {71 Path string72 Size int6473 SHA256 string74 Duration time.Duration75}7677// Create dumps the database (pg_dump custom format) through the encrypter78// into dir. The file appears under its final name only once complete and79// synced; a failed run leaves nothing behind.80func Create(ctx context.Context, dbURL, dir string, key []byte) (*Result, error) {81 pgDump, err := pgTool("pg_dump")82 if err != nil {83 return nil, err84 }85 if err := os.MkdirAll(dir, 0o700); err != nil {86 return nil, err87 }88 start := time.Now()89 final := filepath.Join(dir, "mcc-"+start.UTC().Format("20060102T150405Z")+suffix)90 tmp, err := os.CreateTemp(dir, ".partial-*")91 if err != nil {92 return nil, err93 }94 defer os.Remove(tmp.Name())95 defer tmp.Close()96 if err := tmp.Chmod(0o600); err != nil {97 return nil, err98 }99 hash := sha256.New()100 enc, err := NewEncrypter(io.MultiWriter(tmp, hash), key)101 if err != nil {102 return nil, err103 }104 var stderr bytes.Buffer105 cmd := exec.CommandContext(ctx, pgDump, "--format=custom", "--no-owner", "--no-privileges", "--dbname="+dbURL)106 cmd.Stdout, cmd.Stderr = enc, &stderr107 cmd.Env = append(os.Environ(), "PGCONNECT_TIMEOUT=10")108 if err := cmd.Run(); err != nil {109 return nil, fmt.Errorf("backup: pg_dump: %w: %s", err, firstLine(stderr.String()))110 }111 if err := enc.Close(); err != nil {112 return nil, err113 }114 if err := tmp.Sync(); err != nil {115 return nil, err116 }117 st, err := tmp.Stat()118 if err != nil {119 return nil, err120 }121 if err := os.Rename(tmp.Name(), final); err != nil {122 return nil, err123 }124 if d, err := os.Open(dir); err == nil {125 d.Sync()126 d.Close()127 }128 return &Result{Path: final, Size: st.Size(), SHA256: hex.EncodeToString(hash.Sum(nil)), Duration: time.Since(start)}, nil129}130131// Verify decrypts the whole file (authenticating every chunk) and checks132// that pg_restore can read its table of contents. It returns the number of133// catalogued entries.134func Verify(ctx context.Context, path string, key []byte) (int, error) {135 pgRestore, err := pgTool("pg_restore")136 if err != nil {137 return 0, err138 }139 f, err := os.Open(path)140 if err != nil {141 return 0, err142 }143 defer f.Close()144 dec, err := NewDecrypter(f, key)145 if err != nil {146 return 0, err147 }148 var out, stderr bytes.Buffer149 cmd := exec.CommandContext(ctx, pgRestore, "--list")150 pr, pw := io.Pipe()151 cmd.Stdin, cmd.Stdout, cmd.Stderr = pr, &out, &stderr152 var copyErr error153 go func() {154 _, copyErr = io.Copy(pw, dec)155 pw.CloseWithError(copyErr)156 }()157 runErr := cmd.Run()158 pr.Close()159 if copyErr != nil && !errors.Is(copyErr, io.ErrClosedPipe) {160 return 0, copyErr161 }162 if runErr != nil {163 return 0, fmt.Errorf("backup: pg_restore --list: %w: %s", runErr, firstLine(stderr.String()))164 }165 n := 0166 for _, l := range strings.Split(out.String(), "\n") {167 if l != "" && !strings.HasPrefix(l, ";") {168 n++169 }170 }171 if n == 0 {172 return 0, errors.New("backup: archive has no entries")173 }174 return n, nil175}176177// Restore loads a backup into an EXISTING, EMPTY database. It refuses a178// database that already contains tables: restoring over live data is never179// done implicitly.180func Restore(ctx context.Context, path string, key []byte, targetURL string) error {181 pgRestore, err := pgTool("pg_restore")182 if err != nil {183 return err184 }185 conn, err := pgx.Connect(ctx, targetURL)186 if err != nil {187 return fmt.Errorf("backup: target database: %w", err)188 }189 var tables int190 err = conn.QueryRow(ctx, `select count(*) from information_schema.tables where table_schema='public'`).Scan(&tables)191 conn.Close(ctx)192 if err != nil {193 return err194 }195 if tables > 0 {196 return fmt.Errorf("backup: target database is not empty (%d tables); restore only into a fresh database", tables)197 }198 f, err := os.Open(path)199 if err != nil {200 return err201 }202 defer f.Close()203 dec, err := NewDecrypter(f, key)204 if err != nil {205 return err206 }207 // Decrypt fully to a private temp file first: nothing reaches the database unless the whole backup is authentic.208 tmp, err := os.CreateTemp("", "mcc-restore-*")209 if err != nil {210 return err211 }212 defer os.Remove(tmp.Name())213 defer tmp.Close()214 tmp.Chmod(0o600)215 if _, err := io.Copy(tmp, dec); err != nil {216 return err217 }218 if err := tmp.Sync(); err != nil {219 return err220 }221 var stderr bytes.Buffer222 cmd := exec.CommandContext(ctx, pgRestore, "--no-owner", "--no-privileges", "--exit-on-error", "--single-transaction", "--dbname="+targetURL, tmp.Name())223 cmd.Stderr = &stderr224 if err := cmd.Run(); err != nil {225 return fmt.Errorf("backup: pg_restore: %w: %s", err, firstLine(stderr.String()))226 }227 return nil228}229230// Check holds what a restore test compares between the source and the restored copy.231type Check struct {232 Migrations int233 Users int234 Nodes int235 AuditRows int64236 AuditOK bool237 AuditHead string238}239240// Inspect gathers the comparison facts from a database.241func Inspect(ctx context.Context, url string) (Check, error) {242 var c Check243 pool, err := pgxpool.New(ctx, url)244 if err != nil {245 return c, err246 }247 defer pool.Close()248 if err := pool.QueryRow(ctx, `select (select count(*) from schema_migrations), (select count(*) from users), (select count(*) from nodes)`).249 Scan(&c.Migrations, &c.Users, &c.Nodes); err != nil {250 return c, err251 }252 res, err := audit.Verify(ctx, pool)253 if err != nil {254 return c, err255 }256 c.AuditRows, c.AuditOK, c.AuditHead = res.Entries, res.OK, hex.EncodeToString(res.HeadHash)257 return c, nil258}259260// Prune keeps the newest `keep` backups in dir and deletes the others.261func Prune(dir string, keep int) (removed []string, err error) {262 entries, err := os.ReadDir(dir)263 if err != nil {264 return nil, err265 }266 var names []string267 for _, e := range entries {268 if !e.IsDir() && strings.HasPrefix(e.Name(), "mcc-") && strings.HasSuffix(e.Name(), suffix) {269 names = append(names, e.Name())270 }271 }272 sort.Strings(names) // timestamped names sort chronologically273 for len(names) > keep && keep > 0 {274 if err := os.Remove(filepath.Join(dir, names[0])); err != nil {275 return removed, err276 }277 removed = append(removed, names[0])278 names = names[1:]279 }280 return removed, nil281}282283// Record stores the observed outcome of a backup run in the backups table284// (shown under Storage → Backups). Only what actually happened is recorded.285func Record(ctx context.Context, pool *pgxpool.Pool, name, kind string, res *Result, runErr error, detail string) error {286 now := time.Now().UTC()287 status, size := "ok", int64(0)288 var success *time.Time289 if runErr != nil {290 status, detail = "failed", firstLine(runErr.Error())291 } else {292 success, size = &now, res.Size293 }294 _, err := pool.Exec(ctx, `insert into backups(id, name, kind, last_run_at, last_success_at, last_status, size_bytes, detail, observed_at)295 values ($1,$2,$3,$4,$5,$6,nullif($7,0),$8,$4)296 on conflict (name) do update set kind=excluded.kind, last_run_at=excluded.last_run_at,297 last_success_at=coalesce(excluded.last_success_at, backups.last_success_at), last_status=excluded.last_status,298 size_bytes=coalesce(excluded.size_bytes, backups.size_bytes), detail=excluded.detail, observed_at=excluded.observed_at`,299 ids.New(), name, kind, now, success, status, size, detail)300 return err301}302303func firstLine(s string) string {304 s = strings.TrimSpace(s)305 if i := strings.IndexByte(s, '\n'); i >= 0 {306 s = s[:i]307 }308 if len(s) > 300 {309 s = s[:300]310 }311 return s312}313