172 lines
6.5 KiB
Go
172 lines
6.5 KiB
Go
//go:build pgint
|
|
|
|
package pgint
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"slices"
|
|
"testing"
|
|
"time"
|
|
|
|
"felis.lolicon.best/internal/api"
|
|
"felis.lolicon.best/internal/offsite"
|
|
"felis.lolicon.best/internal/reaper"
|
|
)
|
|
|
|
// TestOffsiteCatalogNewestCopyAndKeptRefs: the two reads behind the off-site
|
|
// copy's snapshot and sweep. NewestOffsite is the latest copy of any row;
|
|
// KeptRefs keeps a present archive past its expiry (the reaper expires it, not
|
|
// the sweep) and a deleted one until its expires_at, and nothing after.
|
|
func TestOffsiteCatalogNewestCopyAndKeptRefs(t *testing.T) {
|
|
ctx := context.Background()
|
|
cat := offsite.PGCatalog{DB: db}
|
|
sfx := suffix(t)
|
|
server := "offsite-" + sfx
|
|
t.Cleanup(func() { db.ExecContext(ctx, `DELETE FROM world_backups WHERE server_name = $1`, server) })
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
// Later than any copy another test records.
|
|
latest := now.Add(1000 * reaper.Day)
|
|
insert := func(id, status string, expires time.Time, offsiteAt any) string {
|
|
t.Helper()
|
|
ref := "/archives/" + id + "-" + sfx + ".tar.gz"
|
|
mustExec(t, `INSERT INTO world_backups (id, server_name, backup_ref, size_bytes, reason, status, created_at, expires_at, offsite_at)
|
|
VALUES ($1, $2, $3, 1, 'manual', $4, $5, $6, $7)`,
|
|
id+"-"+sfx, server, ref, status, now.Add(-reaper.Day), expires, offsiteAt)
|
|
return ref
|
|
}
|
|
presentPast := insert("present-past", "present", now.Add(-time.Minute), nil)
|
|
deletedLive := insert("deleted-live", "deleted", now.Add(reaper.Day), now)
|
|
deletedGone := insert("deleted-gone", "deleted", now.Add(-time.Minute), now)
|
|
expiredGone := insert("expired-gone", "expired", now.Add(-time.Minute), nil)
|
|
insert("newest-copy", "deleted", now.Add(-time.Minute), latest)
|
|
|
|
got, err := cat.NewestOffsite(ctx)
|
|
if err != nil || !got.Equal(latest) {
|
|
t.Fatalf("NewestOffsite = %v, %v; want %v", got, err, latest)
|
|
}
|
|
refs, err := cat.KeptRefs(ctx, now)
|
|
if err != nil {
|
|
t.Fatalf("KeptRefs: %v", err)
|
|
}
|
|
for _, want := range []string{presentPast, deletedLive} {
|
|
if !slices.Contains(refs, want) {
|
|
t.Errorf("KeptRefs lacks %s", want)
|
|
}
|
|
}
|
|
for _, gone := range []string{deletedGone, expiredGone} {
|
|
if slices.Contains(refs, gone) {
|
|
t.Errorf("KeptRefs keeps %s, past its expiry", gone)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestOwnerDeletedBackup: ExpireBackup turns one present backup expired with
|
|
// expires_at pulled to the delete (never pushed later), after which no read
|
|
// finds it, the backup budget drops its bytes, the reaper's retention pass
|
|
// lists it whatever its expires_at, and the off-site sweep drops its copy.
|
|
func TestOwnerDeletedBackup(t *testing.T) {
|
|
ctx := context.Background()
|
|
sfx := suffix(t)
|
|
server := "owner-del-" + sfx
|
|
t.Cleanup(func() { db.ExecContext(ctx, `DELETE FROM world_backups WHERE server_name = $1`, server) })
|
|
now := time.Now().UTC().Truncate(time.Microsecond)
|
|
insert := func(id string, size int64, expires time.Time) (string, string) {
|
|
t.Helper()
|
|
id += "-" + sfx
|
|
ref := "/archives/" + id + ".tar.gz"
|
|
mustExec(t, `INSERT INTO world_backups (id, server_name, backup_ref, size_bytes, reason, status, created_at, expires_at, offsite_at)
|
|
VALUES ($1, $2, $3, $4, 'manual', 'present', $5, $6, $7)`,
|
|
id, server, ref, size, now.Add(-reaper.Day), expires, now.Add(-time.Hour))
|
|
return id, ref
|
|
}
|
|
later := now.Add(90 * reaper.Day)
|
|
del, delRef := insert("del", 700, later)
|
|
keep, keepRef := insert("keep", 11, later)
|
|
past, _ := insert("past", 13, now.Add(-time.Minute))
|
|
row := func(id string) (string, time.Time) {
|
|
t.Helper()
|
|
var status string
|
|
var expires time.Time
|
|
if err := db.QueryRowContext(ctx, `SELECT status, expires_at FROM world_backups WHERE id = $1`, id).Scan(&status, &expires); err != nil {
|
|
t.Fatalf("read %s: %v", id, err)
|
|
}
|
|
return status, expires
|
|
}
|
|
|
|
before, err := repo.BackupStoreBytes(ctx)
|
|
if err != nil {
|
|
t.Fatalf("BackupStoreBytes: %v", err)
|
|
}
|
|
if err := repo.ExpireBackup(ctx, del, now); err != nil {
|
|
t.Fatalf("ExpireBackup: %v", err)
|
|
}
|
|
if s, e := row(del); s != "expired" || !e.Equal(now) {
|
|
t.Fatalf("deleted row = %s expiring %v, want expired expiring %v", s, e, now)
|
|
}
|
|
if s, e := row(keep); s != "present" || !e.Equal(later) {
|
|
t.Fatalf("other row = %s expiring %v, want untouched", s, e)
|
|
}
|
|
if after, err := repo.BackupStoreBytes(ctx); err != nil || after != before-700 {
|
|
t.Fatalf("BackupStoreBytes = %d, %v; want %d", after, err, before-700)
|
|
}
|
|
if _, err := repo.BackupByID(ctx, del); !errors.Is(err, api.ErrNotFound) {
|
|
t.Fatalf("BackupByID(deleted) = %v, want ErrNotFound", err)
|
|
}
|
|
for _, id := range []string{del, "missing-" + sfx} {
|
|
if err := repo.ExpireBackup(ctx, id, now); !errors.Is(err, api.ErrNotFound) {
|
|
t.Fatalf("ExpireBackup(%s) = %v, want ErrNotFound", id, err)
|
|
}
|
|
}
|
|
if err := repo.ExpireBackup(ctx, past, now); err != nil {
|
|
t.Fatalf("ExpireBackup(past): %v", err)
|
|
}
|
|
if s, e := row(past); s != "expired" || !e.Equal(now.Add(-time.Minute)) {
|
|
t.Fatalf("past row = %s expiring %v, want expired keeping %v", s, e, now.Add(-time.Minute))
|
|
}
|
|
|
|
// The reaper takes it even at a time before its expires_at.
|
|
exp, err := reaper.NewPGStore(db).ListExpiredBackups(ctx, now.Add(-reaper.Day))
|
|
if err != nil {
|
|
t.Fatalf("ListExpiredBackups: %v", err)
|
|
}
|
|
var ids []string
|
|
for _, b := range exp {
|
|
ids = append(ids, b.ID)
|
|
}
|
|
if !slices.Contains(ids, del) || slices.Contains(ids, keep) {
|
|
t.Fatalf("ListExpiredBackups = %v, want %s and not %s", ids, del, keep)
|
|
}
|
|
|
|
cat := offsite.PGCatalog{DB: db}
|
|
gone, err := cat.ExpiredRefs(ctx, now.Add(time.Second))
|
|
if err != nil {
|
|
t.Fatalf("ExpiredRefs: %v", err)
|
|
}
|
|
if !slices.Contains(gone, delRef) || slices.Contains(gone, keepRef) {
|
|
t.Fatalf("ExpiredRefs = %v, want %s and not %s", gone, delRef, keepRef)
|
|
}
|
|
kept, err := cat.KeptRefs(ctx, now.Add(time.Second))
|
|
if err != nil {
|
|
t.Fatalf("KeptRefs: %v", err)
|
|
}
|
|
if slices.Contains(kept, delRef) || !slices.Contains(kept, keepRef) {
|
|
t.Fatalf("KeptRefs = %v, want %s and not %s", kept, keepRef, delRef)
|
|
}
|
|
|
|
// The undo troubleshooting.md §10 gives, before the reaper has run: the backup
|
|
// is restorable again and the next sync copies it off site anew.
|
|
mustExec(t, `UPDATE world_backups SET status = 'present', expires_at = now() + interval '30 days', offsite_at = NULL
|
|
WHERE id = '`+del+`' AND status = 'expired'`)
|
|
if b, err := repo.BackupByID(ctx, del); err != nil || b.BackupRef != delRef {
|
|
t.Fatalf("BackupByID after the undo = (%+v, %v), want %s", b, err, delRef)
|
|
}
|
|
pending, err := cat.PendingWorlds(ctx)
|
|
if err != nil {
|
|
t.Fatalf("PendingWorlds: %v", err)
|
|
}
|
|
if !slices.ContainsFunc(pending, func(w offsite.WorldBackup) bool { return w.ID == del }) {
|
|
t.Fatalf("PendingWorlds after the undo lacks %s", del)
|
|
}
|
|
}
|