clawbot
0cdda43e6c
check / check (push) Waiting to run
The SQLite archive files the database target writes are now managed by internal/archive: file names, rotation, the writer of each target, pruning, renames, the gzipped JSON export, the idle sweep, and the rename lock, which was Handlers.renameMu. The database target stays in internal/delivery and writes through archive.Writers; the engine still closes the writers when it stops, so the stop order is unchanged. The handlers take the rename lock from archive.Archives.RenameLock, and rename and evict through archive.Archives. Exported names drop their Archive prefix in the new package. The tests moved with the code; the two that check a delivery's recorded attempt stay in delivery. Model: opus-5-5
774 lines
20 KiB
Go
774 lines
20 KiB
Go
package archive_test
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
"io/fs"
|
|
"log/slog"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"gorm.io/driver/sqlite"
|
|
"gorm.io/gorm"
|
|
_ "modernc.org/sqlite" // Pure Go SQLite driver.
|
|
"sneak.berlin/go/webhooker/internal/archive"
|
|
"sneak.berlin/go/webhooker/internal/database"
|
|
"sneak.berlin/go/webhooker/internal/gormlog"
|
|
)
|
|
|
|
const (
|
|
// testContentType is the event content type used in tests.
|
|
testContentType = "application/json"
|
|
|
|
// eventQuery is the query string an archived event carries.
|
|
eventQuery = "a=1&b=2"
|
|
)
|
|
|
|
func archiveTestLogger() *slog.Logger {
|
|
return slog.New(slog.NewTextHandler(
|
|
os.Stderr,
|
|
&slog.HandlerOptions{Level: slog.LevelDebug},
|
|
))
|
|
}
|
|
|
|
// openArchiveDBForRead opens an archive file read-only so a
|
|
// test can inspect the rows the writer persisted.
|
|
func openArchiveDBForRead(
|
|
t *testing.T, path string,
|
|
) *gorm.DB {
|
|
t.Helper()
|
|
|
|
sqlDB, err := sql.Open(
|
|
"sqlite",
|
|
fmt.Sprintf("file:%s?mode=ro", path),
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
t.Cleanup(func() { _ = sqlDB.Close() })
|
|
|
|
gdb, err := gorm.Open(
|
|
sqlite.Dialector{Conn: sqlDB},
|
|
&gorm.Config{Logger: gormlog.New(slog.New(slog.DiscardHandler))},
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
return gdb
|
|
}
|
|
|
|
// archiveFileSuffixes returns the archive file itself and the
|
|
// SQLite sidecars that accompany an open database. A test that
|
|
// asserts no archive was created has to check all of them.
|
|
func archiveFileSuffixes() []string {
|
|
return []string{"", "-wal", "-shm"}
|
|
}
|
|
|
|
// removeArchiveFiles simulates an operator moving the archive
|
|
// away by deleting the SQLite file and its sidecar files.
|
|
func removeArchiveFiles(t *testing.T, path string) {
|
|
t.Helper()
|
|
|
|
for _, suffix := range []string{
|
|
"", "-wal", "-shm", "-journal",
|
|
} {
|
|
err := os.Remove(path + suffix)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
t.Fatalf("removing %s%s: %v", path, suffix, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// assertStoredTime asserts that text, a timestamp as SQLite holds it,
|
|
// is in the form GORM stores created_at in: the layout of
|
|
// time.Time.String, with no " m=+…" monotonic clock reading after it.
|
|
func assertStoredTime(t *testing.T, text string) {
|
|
t.Helper()
|
|
|
|
_, err := time.Parse(
|
|
"2006-01-02 15:04:05.999999999 -0700 MST", text,
|
|
)
|
|
assert.NoError(t, err, "stored as %q", text)
|
|
}
|
|
|
|
// newEvent returns an event received now with the given body, as the
|
|
// webhook handler stores it.
|
|
func newEvent(body string) database.Event {
|
|
return database.Event{
|
|
BaseModel: database.BaseModel{
|
|
ID: uuid.New().String(),
|
|
CreatedAt: time.Now(),
|
|
},
|
|
WebhookID: uuid.New().String(),
|
|
EntrypointID: uuid.New().String(),
|
|
Method: http.MethodPost,
|
|
Headers: `{"Content-Type":["application/json"]}`,
|
|
Body: body,
|
|
ContentType: testContentType,
|
|
}
|
|
}
|
|
|
|
// databaseTargetDelivery returns a delivery of event to a database
|
|
// target, as the database target hands it to Writers.Write.
|
|
func databaseTargetDelivery(
|
|
event database.Event, tgt *database.Target,
|
|
) *database.Delivery {
|
|
return &database.Delivery{
|
|
EventID: event.ID,
|
|
TargetID: tgt.ID,
|
|
Event: event,
|
|
Target: database.Target{
|
|
Name: tgt.Name,
|
|
Type: database.TargetTypeDatabase,
|
|
Config: tgt.Config,
|
|
},
|
|
}
|
|
}
|
|
|
|
func TestArchiveWriter_WritesRow(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
path := filepath.Join(t.TempDir(), "archive-wh.db")
|
|
w := archive.NewExportArchiveWriter(
|
|
path, archiveTestLogger(), 0,
|
|
)
|
|
|
|
row := archive.ExportArchivedEvent{
|
|
EventID: "ev-1",
|
|
WebhookID: "wh-1",
|
|
EntrypointID: "ep-1",
|
|
Method: "POST",
|
|
Headers: `{"X":"Y"}`,
|
|
Body: `{"hello":"world"}`,
|
|
ContentType: "application/json",
|
|
}
|
|
|
|
require.NoError(t, w.Write(row, 0))
|
|
assert.FileExists(t, path)
|
|
|
|
var got []archive.ExportArchivedEvent
|
|
|
|
require.NoError(t, w.DB().Find(&got).Error)
|
|
require.Len(t, got, 1)
|
|
assert.Equal(t, "ev-1", got[0].EventID)
|
|
assert.Equal(t, "wh-1", got[0].WebhookID)
|
|
assert.Equal(t, "ep-1", got[0].EntrypointID)
|
|
assert.Equal(t, row.Method, got[0].Method)
|
|
assert.Equal(t, row.ContentType, got[0].ContentType)
|
|
assert.JSONEq(t, `{"hello":"world"}`, got[0].Body)
|
|
assert.False(t, got[0].ArchivedAt.IsZero())
|
|
|
|
var archivedAt string
|
|
|
|
require.NoError(t, w.DB().Raw(
|
|
"SELECT CAST(archived_at AS TEXT) FROM archived_events",
|
|
).Row().Scan(&archivedAt))
|
|
assertStoredTime(t, archivedAt)
|
|
}
|
|
|
|
func TestArchiveWriter_RecreatesAfterRemoval(
|
|
t *testing.T,
|
|
) {
|
|
t.Parallel()
|
|
|
|
path := filepath.Join(t.TempDir(), "archive-wh.db")
|
|
w := archive.NewExportArchiveWriter(
|
|
path, archiveTestLogger(), 0,
|
|
)
|
|
|
|
require.NoError(t, w.Write(
|
|
archive.ExportArchivedEvent{EventID: "a"}, 0,
|
|
))
|
|
assert.FileExists(t, path)
|
|
|
|
// The operator moves the archive away while the handle is
|
|
// still open.
|
|
removeArchiveFiles(t, path)
|
|
require.NoFileExists(t, path)
|
|
|
|
// The next write recreates the file with a fresh schema and
|
|
// only the new row.
|
|
require.NoError(t, w.Write(
|
|
archive.ExportArchivedEvent{EventID: "b"}, 0,
|
|
))
|
|
assert.FileExists(t, path)
|
|
|
|
var got []archive.ExportArchivedEvent
|
|
|
|
require.NoError(t, w.DB().Find(&got).Error)
|
|
require.Len(t, got, 1)
|
|
assert.Equal(t, "b", got[0].EventID)
|
|
}
|
|
|
|
// TestArchiveHandleIsWAL closes the last gap in the durability
|
|
// evidence: the main and per-webhook tiers each assert their journal
|
|
// mode on a live handle, and the archive tier gets its settings from
|
|
// the same code path but nothing checked the running file.
|
|
func TestArchiveHandleIsWAL(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
w := archive.NewExportArchiveWriter(
|
|
filepath.Join(t.TempDir(), "archive-wal.db"),
|
|
archiveTestLogger(), 0,
|
|
)
|
|
|
|
require.NoError(t, w.Open(0))
|
|
|
|
var mode string
|
|
|
|
row := w.DB().Raw("pragma journal_mode").Row()
|
|
require.NoError(t, row.Scan(&mode))
|
|
assert.Equal(t, "wal", strings.ToLower(mode))
|
|
|
|
var busy string
|
|
|
|
row = w.DB().Raw("pragma busy_timeout").Row()
|
|
require.NoError(t, row.Scan(&busy))
|
|
assert.Equal(t, "10000", busy)
|
|
}
|
|
|
|
// TestStatArchive proves Stat finds no file before the first
|
|
// write; after a write still held in the -wal, counts the -wal in the
|
|
// size and takes its later time as the last write; and finds no file
|
|
// again once the file has been moved away.
|
|
func TestStatArchive(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
path := filepath.Join(t.TempDir(), "archive-wh.db")
|
|
|
|
_, err := archive.Stat(path)
|
|
require.ErrorIs(t, err, fs.ErrNotExist)
|
|
|
|
// With the clock stopped, the reopen debounce never passes, so
|
|
// the handle stays open after the write.
|
|
stopped := time.Now()
|
|
w := archive.NewExportArchiveWriter(path, archiveTestLogger(), 0)
|
|
w.SetNow(func() time.Time { return stopped })
|
|
|
|
require.NoError(t, w.Write(archive.ExportArchivedEvent{EventID: "a"}, 0))
|
|
|
|
written := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
|
|
earlier := written.Add(-time.Hour)
|
|
require.NoError(t, os.Chtimes(path, earlier, earlier))
|
|
require.NoError(t, os.Chtimes(path+"-wal", written, written))
|
|
|
|
file, err := os.Stat(path)
|
|
require.NoError(t, err)
|
|
|
|
wal, err := os.Stat(path + "-wal")
|
|
require.NoError(t, err)
|
|
require.Positive(t, wal.Size())
|
|
|
|
got, err := archive.Stat(path)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, 1, got.Files)
|
|
assert.Equal(t, file.Size()+wal.Size(), got.Size)
|
|
assert.True(t, written.Equal(got.Written), got.Written)
|
|
|
|
removeArchiveFiles(t, path)
|
|
|
|
_, err = archive.Stat(path)
|
|
require.ErrorIs(t, err, fs.ErrNotExist)
|
|
}
|
|
|
|
func TestArchiveWriter_ReopenDebounce(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const debounce = 2 * time.Second
|
|
|
|
path := filepath.Join(t.TempDir(), "archive-wh.db")
|
|
w := archive.NewExportArchiveWriter(
|
|
path, archiveTestLogger(), debounce,
|
|
)
|
|
|
|
// The writer measures its reopen debounce on this clock, which
|
|
// only the test moves, so how long the host takes between
|
|
// writes cannot change the result.
|
|
now := time.Now()
|
|
|
|
w.SetNow(func() time.Time { return now })
|
|
|
|
require.NoError(t, w.Write(
|
|
archive.ExportArchivedEvent{EventID: "a"}, 0,
|
|
))
|
|
require.NoError(t, w.Write(
|
|
archive.ExportArchivedEvent{EventID: "b"}, 0,
|
|
))
|
|
|
|
// Two writes inside the debounce window trigger only the
|
|
// initial open — no extra close/reopen.
|
|
assert.Equal(t, 1, w.Reopens())
|
|
|
|
now = now.Add(debounce)
|
|
|
|
require.NoError(t, w.Write(
|
|
archive.ExportArchivedEvent{EventID: "c"}, 0,
|
|
))
|
|
|
|
// A write after the window elapses closes and reopens once.
|
|
assert.Equal(t, 2, w.Reopens())
|
|
}
|
|
|
|
func TestArchiveWriter_ExpiryPrune(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
path := filepath.Join(t.TempDir(), "archive-wh.db")
|
|
w := archive.NewExportArchiveWriter(
|
|
path, archiveTestLogger(), 0,
|
|
)
|
|
|
|
require.NoError(t, w.Open(0))
|
|
|
|
old := archive.ExportArchivedEvent{
|
|
EventID: "old",
|
|
ArchivedAt: time.Now().Add(-2 * time.Hour),
|
|
}
|
|
fresh := archive.ExportArchivedEvent{
|
|
EventID: "fresh",
|
|
ArchivedAt: time.Now(),
|
|
}
|
|
|
|
require.NoError(t, w.DB().Create(&old).Error)
|
|
require.NoError(t, w.DB().Create(&fresh).Error)
|
|
|
|
// Reopening with a one-hour expiry prunes the old row.
|
|
require.NoError(t, w.Reopen(time.Hour))
|
|
|
|
var got []archive.ExportArchivedEvent
|
|
|
|
require.NoError(t, w.DB().Find(&got).Error)
|
|
require.Len(t, got, 1)
|
|
assert.Equal(t, "fresh", got[0].EventID)
|
|
}
|
|
|
|
func TestParseArchiveExpiry(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := []struct {
|
|
name string
|
|
in string
|
|
want time.Duration
|
|
wantErr bool
|
|
}{
|
|
{"empty config", "", 0, false},
|
|
{"explicit never", `{"expiry":"never"}`, 0, false},
|
|
{"empty expiry", `{"expiry":""}`, 0, false},
|
|
{"duration", `{"expiry":"1h"}`, time.Hour, false},
|
|
{"unparseable", `{"expiry":"nonsense"}`, 0, true},
|
|
{"zero duration", `{"expiry":"0s"}`, 0, true},
|
|
{"negative duration", `{"expiry":"-5h"}`, 0, true},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got, err := archive.ParseExpiry(tc.in)
|
|
if tc.wantErr {
|
|
require.Error(t, err)
|
|
|
|
return
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tc.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateArchiveExpiry(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
valid := []string{"", "never", "1h", "720h", "30m"}
|
|
for _, in := range valid {
|
|
require.NoError(t,
|
|
archive.ValidateExpiry(in),
|
|
"expiry %q should be accepted", in,
|
|
)
|
|
}
|
|
|
|
invalid := []string{"nonsense", "7d", "-5h", "0s", "0"}
|
|
for _, in := range invalid {
|
|
require.Error(t,
|
|
archive.ValidateExpiry(in),
|
|
"expiry %q should be rejected", in,
|
|
)
|
|
}
|
|
}
|
|
|
|
// TestArchiveFileName pins the archive file name and the rules
|
|
// that make a webhook or target name safe to put in it.
|
|
func TestArchiveFileName(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
const id = "3f2a1c9e-8d4b-4c1a-9e2f-0a1b2c3d4e5f"
|
|
|
|
cases := []struct {
|
|
name string
|
|
webhook string
|
|
target string
|
|
want string
|
|
}{
|
|
{
|
|
"plain names", "orders", "archive",
|
|
"archive-orders-archive-" + id + ".db",
|
|
},
|
|
{
|
|
"lowercased", "Orders", "Main Archive",
|
|
"archive-orders-main-archive-" + id + ".db",
|
|
},
|
|
{
|
|
"a run of other characters is one dash",
|
|
`a /\..b`, "c__--d",
|
|
"archive-a-b-c-d-" + id + ".db",
|
|
},
|
|
{
|
|
"no dash at either end", " --orders!! ", "(archive)",
|
|
"archive-orders-archive-" + id + ".db",
|
|
},
|
|
{
|
|
"path separators", "../../etc/passwd", "a/b",
|
|
"archive-etc-passwd-a-b-" + id + ".db",
|
|
},
|
|
{
|
|
"letters outside ASCII are dropped",
|
|
"Bestellungen Größe", "café",
|
|
"archive-bestellungen-gr-e-caf-" + id + ".db",
|
|
},
|
|
{
|
|
"nothing left is unnamed", "", "!!!",
|
|
"archive-unnamed-unnamed-" + id + ".db",
|
|
},
|
|
{
|
|
"cut to 40 characters", strings.Repeat("a", 50), "x",
|
|
"archive-" + strings.Repeat("a", 40) + "-x-" + id + ".db",
|
|
},
|
|
{
|
|
"no dash left by the cut",
|
|
strings.Repeat("a", 39) + " b", "x",
|
|
"archive-" + strings.Repeat("a", 39) + "-x-" + id + ".db",
|
|
},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
assert.Equal(
|
|
t, tc.want,
|
|
archive.FileName(tc.webhook, tc.target, id),
|
|
)
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestWrite_EachTargetHasItsOwnArchive proves two
|
|
// database targets of one webhook archive into separate files.
|
|
func TestWrite_EachTargetHasItsOwnArchive(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
env := setupArchiveTest(t)
|
|
first := env.seedDatabaseTarget(t, "")
|
|
second := env.addDatabaseTarget(t, first.WebhookID, "")
|
|
|
|
event := newEvent(`{"n":1}`)
|
|
|
|
for _, tgt := range []*database.Target{first, second} {
|
|
require.NoError(t, env.writers.Write(
|
|
databaseTargetDelivery(event, tgt),
|
|
))
|
|
}
|
|
|
|
require.NotEqual(
|
|
t, env.archivePath(first), env.archivePath(second),
|
|
)
|
|
assert.Equal(
|
|
t, []string{event.ID},
|
|
archivedEventIDs(t, env.archivePath(first)),
|
|
)
|
|
assert.Equal(
|
|
t, []string{event.ID},
|
|
archivedEventIDs(t, env.archivePath(second)),
|
|
)
|
|
}
|
|
|
|
// TestRename_MovesTheFile proves a rename moves the archive, rows
|
|
// and all, and that later writes go to the new name.
|
|
func TestRename_MovesTheFile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
env := setupArchiveTest(t)
|
|
tgt := env.seedDatabaseTarget(t, "")
|
|
oldPath := env.archivePath(tgt)
|
|
|
|
first := newEvent(`{"n":1}`)
|
|
require.NoError(t, env.writers.Write(databaseTargetDelivery(first, tgt)))
|
|
require.FileExists(t, oldPath)
|
|
|
|
require.NoError(
|
|
t, env.writers.Rename(tgt.ID, "Orders", "Long Term"),
|
|
)
|
|
|
|
newPath := filepath.Join(
|
|
env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
|
|
)
|
|
|
|
assert.NoFileExists(t, oldPath)
|
|
assert.Equal(t, []string{first.ID}, archivedEventIDs(t, newPath))
|
|
|
|
second := newEvent(`{"n":2}`)
|
|
require.NoError(t, env.writers.Write(databaseTargetDelivery(second, tgt)))
|
|
|
|
assert.ElementsMatch(
|
|
t, []string{first.ID, second.ID},
|
|
archivedEventIDs(t, newPath),
|
|
)
|
|
assert.NoFileExists(
|
|
t, oldPath, "a write after the rename must use the new name",
|
|
)
|
|
}
|
|
|
|
// TestRename_NeverReplacesAFile plants a file at the new name, once
|
|
// the .db alone, once a lone -wal and once a lone -shm, and proves
|
|
// each time that the rename is refused, the planted file survives,
|
|
// and the archive keeps its name and its rows.
|
|
func TestRename_NeverReplacesAFile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, suffix := range archiveFileSuffixes() {
|
|
t.Run("planted .db"+suffix, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
env := setupArchiveTest(t)
|
|
tgt := env.seedDatabaseTarget(t, "")
|
|
oldPath := env.archivePath(tgt)
|
|
|
|
first := newEvent(`{"n":1}`)
|
|
require.NoError(
|
|
t, env.writers.Write(databaseTargetDelivery(first, tgt)),
|
|
)
|
|
|
|
newPath := filepath.Join(
|
|
env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
|
|
)
|
|
plantedPath := newPath + suffix
|
|
require.NoError(
|
|
t, os.WriteFile(plantedPath, []byte("planted"), 0o600),
|
|
)
|
|
|
|
require.ErrorIs(
|
|
t, env.writers.Rename(tgt.ID, "Orders", "Long Term"),
|
|
archive.ErrNameTaken,
|
|
)
|
|
|
|
//nolint:gosec // reads the file the test planted under t.TempDir()
|
|
planted, err := os.ReadFile(plantedPath)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "planted", string(planted))
|
|
|
|
second := newEvent(`{"n":2}`)
|
|
require.NoError(
|
|
t, env.writers.Write(databaseTargetDelivery(second, tgt)),
|
|
)
|
|
|
|
assert.ElementsMatch(
|
|
t, []string{first.ID, second.ID},
|
|
archivedEventIDs(t, oldPath),
|
|
)
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestRename_BeforeTheNameIsSaved covers the order the handlers
|
|
// use: they rename before they save the new name, so a delivery in
|
|
// between must write under the new name although the main database
|
|
// still has the old one. It also shows that renaming an archive that
|
|
// does not exist yet is not an error.
|
|
func TestRename_BeforeTheNameIsSaved(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
env := setupArchiveTest(t)
|
|
tgt := env.seedDatabaseTarget(t, "")
|
|
|
|
require.NoError(
|
|
t, env.writers.Rename(tgt.ID, "Orders", "Archive"),
|
|
)
|
|
|
|
event := newEvent(`{"n":1}`)
|
|
require.NoError(t, env.writers.Write(databaseTargetDelivery(event, tgt)))
|
|
|
|
assert.FileExists(
|
|
t,
|
|
filepath.Join(
|
|
env.dataDir, "archive-orders-archive-"+tgt.ID+".db",
|
|
),
|
|
)
|
|
assert.NoFileExists(t, env.archivePath(tgt))
|
|
}
|
|
|
|
// TestArchiveWriter_RenameMovesSidecars proves a rename carries
|
|
// the -wal and -shm a crash can leave beside an archive no handle
|
|
// has opened since. SQLite finds them by name, so a -wal left
|
|
// behind would lose the transactions it holds.
|
|
func TestArchiveWriter_RenameMovesSidecars(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
oldPath := filepath.Join(dir, "archive-old.db")
|
|
newPath := filepath.Join(dir, "archive-new.db")
|
|
|
|
for _, suffix := range archiveFileSuffixes() {
|
|
require.NoError(
|
|
t, os.WriteFile(oldPath+suffix, []byte(suffix), 0o600),
|
|
)
|
|
}
|
|
|
|
w := archive.NewExportArchiveWriter(
|
|
oldPath, archiveTestLogger(), 0,
|
|
)
|
|
|
|
require.NoError(t, w.Rename("archive-new.db"))
|
|
|
|
for _, suffix := range archiveFileSuffixes() {
|
|
assert.NoFileExists(t, oldPath+suffix)
|
|
assert.FileExists(t, newPath+suffix)
|
|
}
|
|
|
|
assert.Equal(t, newPath, w.Path())
|
|
}
|
|
|
|
// TestArchiveWriter_RenameMovesBackOnFailure makes the -wal fail to
|
|
// move after the .db has moved, and proves the .db is moved back, so
|
|
// the archive is never split across two names. The new name is 255
|
|
// bytes, the longest a file name may be, so the .db can take it but
|
|
// the -wal, four bytes longer, cannot.
|
|
func TestArchiveWriter_RenameMovesBackOnFailure(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
oldPath := filepath.Join(dir, "archive-old.db")
|
|
newName := strings.Repeat("a", 252) + ".db"
|
|
|
|
for _, suffix := range archiveFileSuffixes() {
|
|
require.NoError(
|
|
t, os.WriteFile(oldPath+suffix, []byte(suffix), 0o600),
|
|
)
|
|
}
|
|
|
|
w := archive.NewExportArchiveWriter(
|
|
oldPath, archiveTestLogger(), 0,
|
|
)
|
|
|
|
require.Error(t, w.Rename(newName))
|
|
|
|
for _, suffix := range archiveFileSuffixes() {
|
|
assert.FileExists(t, oldPath+suffix)
|
|
}
|
|
|
|
assert.NoFileExists(t, filepath.Join(dir, newName))
|
|
assert.Equal(t, oldPath, w.Path())
|
|
}
|
|
|
|
// TestArchiveWriter_RenameMovesBackEveryFile renames a target with a
|
|
// file without a period and a file for a month, and proves that when
|
|
// the month's file fails to move, the file already moved is moved back:
|
|
// both files are under the old name with their rows, and nothing is
|
|
// under the new name. The new name is 251 bytes, so the file without a
|
|
// period, with its -wal and -shm, can take it, but the month's file,
|
|
// eight bytes longer, cannot.
|
|
func TestArchiveWriter_RenameMovesBackEveryFile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
oldPath := filepath.Join(dir, "archive-old.db")
|
|
monthPath := filepath.Join(dir, "archive-old-2026-03.db")
|
|
w := archive.NewExportArchiveWriter(oldPath, archiveTestLogger(), 0)
|
|
|
|
require.NoError(t, w.WritePeriod(
|
|
archive.ExportArchivedEvent{EventID: "in-none"}, 0, "",
|
|
))
|
|
require.NoError(t, w.WritePeriod(
|
|
archive.ExportArchivedEvent{EventID: "in-month"}, 0, "2026-03",
|
|
))
|
|
|
|
require.Error(t, w.Rename(strings.Repeat("a", 248)+".db"))
|
|
|
|
assert.Equal(t, []string{"in-none"}, archivedEventIDs(t, oldPath))
|
|
assert.Equal(t, []string{"in-month"}, archivedEventIDs(t, monthPath))
|
|
|
|
entries, err := os.ReadDir(dir)
|
|
require.NoError(t, err)
|
|
|
|
for _, entry := range entries {
|
|
assert.True(t, strings.HasPrefix(entry.Name(), "archive-old"),
|
|
"%s is not under the old name", entry.Name())
|
|
}
|
|
|
|
assert.Equal(t, oldPath, w.Path())
|
|
}
|
|
|
|
// TestRenameLock_HeldByOneEditAtATime holds the rename lock, as an edit
|
|
// does from loading the stored names until it has saved them. While it
|
|
// is held, the edit's rename and an archive write still finish, since
|
|
// neither takes it, and the event ends up under the new name whichever
|
|
// ran first. A second edit waits for the lock until the first lets go.
|
|
func TestRenameLock_HeldByOneEditAtATime(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
env := setupArchiveTest(t)
|
|
tgt := env.seedDatabaseTarget(t, "")
|
|
event := newEvent(`{"n":1}`)
|
|
|
|
env.writers.RenameLock().Lock()
|
|
|
|
finished := make(chan error, 2)
|
|
|
|
go func() {
|
|
finished <- env.writers.Rename(tgt.ID, "Orders", "Long Term")
|
|
}()
|
|
go func() {
|
|
finished <- env.writers.Write(databaseTargetDelivery(event, tgt))
|
|
}()
|
|
|
|
for range 2 {
|
|
select {
|
|
case err := <-finished:
|
|
require.NoError(t, err)
|
|
case <-time.After(10 * time.Second):
|
|
t.Fatal("a rename or a write waited for the rename lock")
|
|
}
|
|
}
|
|
|
|
newPath := filepath.Join(
|
|
env.dataDir, "archive-orders-long-term-"+tgt.ID+".db",
|
|
)
|
|
assert.Equal(t, []string{event.ID}, archivedEventIDs(t, newPath))
|
|
|
|
secondEdit := make(chan struct{})
|
|
|
|
go func() {
|
|
env.writers.RenameLock().Lock()
|
|
close(secondEdit)
|
|
env.writers.RenameLock().Unlock()
|
|
}()
|
|
|
|
select {
|
|
case <-secondEdit:
|
|
t.Fatal("a second edit took the rename lock while it was held")
|
|
case <-time.After(100 * time.Millisecond):
|
|
}
|
|
|
|
env.writers.RenameLock().Unlock()
|
|
|
|
select {
|
|
case <-secondEdit:
|
|
case <-time.After(10 * time.Second):
|
|
t.Fatal("a second edit did not get the rename lock once released")
|
|
}
|
|
}
|