From aaa2219d6b676a480bb1848584452f0eafc676ea Mon Sep 17 00:00:00 2001 From: clawbot <35+clawbot@noreply.example.org> Date: Thu, 19 Nov 2026 13:31:00 +0100 Subject: [PATCH] Take a snapshot's start time from the moment in its ID (closes #482) CreateSnapshotWithName read the clock once for the ID and again for started_at. When the second read fell in the next second, the snapshot shared its started_at with the next run of the same name, and ListRecent, which orders by started_at, could list the two in either order. That made TestBackupWithEmptySourcePathDoesNotPrune fail at random. The start time now comes from the same clock read as the ID, so successive runs of one name have distinct, increasing start times. Model: opus-5-5 --- internal/snapshot/snapshot.go | 13 +++++--- internal/snapshot/snapshot_test.go | 52 ++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 4 deletions(-) diff --git a/internal/snapshot/snapshot.go b/internal/snapshot/snapshot.go index 80c764e..f0de341 100644 --- a/internal/snapshot/snapshot.go +++ b/internal/snapshot/snapshot.go @@ -118,17 +118,22 @@ func ShortHostname(hostname string) string { // hostname_timestamp if name is empty. The timestamp is in whole seconds. // If the local index already has a snapshot with that ID, from a run of the // same name that started in the same second, it waits a second and takes a -// new timestamp. +// new timestamp. The snapshot's start time is the moment in its ID, so a +// later run of one name always has a later start time. func (sm *SnapshotManager) CreateSnapshotWithName( ctx context.Context, hostname, name, version, gitRevision string, ) (string, error) { shortHostname := ShortHostname(hostname) - var snapshotID string + var ( + snapshotID string + startedAt time.Time + ) for { // Build snapshot ID with optional name - timestamp := time.Now().UTC().Format("2006-01-02T15:04:05Z") + startedAt = time.Now().UTC() + timestamp := startedAt.Format("2006-01-02T15:04:05Z") if name != "" { snapshotID = fmt.Sprintf("%s_%s_%s", shortHostname, name, timestamp) @@ -153,7 +158,7 @@ func (sm *SnapshotManager) CreateSnapshotWithName( Hostname: types.Hostname(hostname), VaultikVersion: types.Version(version), VaultikGitRevision: types.GitRevision(gitRevision), - StartedAt: time.Now().UTC(), + StartedAt: startedAt, CompletedAt: nil, // Not completed yet FileCount: 0, ChunkCount: 0, diff --git a/internal/snapshot/snapshot_test.go b/internal/snapshot/snapshot_test.go index b371d72..d2084b5 100644 --- a/internal/snapshot/snapshot_test.go +++ b/internal/snapshot/snapshot_test.go @@ -492,3 +492,55 @@ func TestCreateSnapshotWithNameTwiceBackToBack(t *testing.T) { t.Fatalf("both creates returned snapshot ID %s", first) } } + +// Two creates of one snapshot name back to back list newest first. The +// start time is the moment in the ID, so the two cannot share a start +// time even when the clock crosses a second while the first is created. +// See https://git.eeqj.de/sneak/vaultik/issues/482. +func TestCreateSnapshotWithNameTwiceBackToBackListsNewestFirst(t *testing.T) { + log.Initialize(log.Config{}) + t.Parallel() + + const created = 2 + + ctx := context.Background() + + db, err := database.New(ctx, filepath.Join(t.TempDir(), "index.sqlite")) + if err != nil { + t.Fatalf("failed to create database: %v", err) + } + + defer func() { _ = db.Close() }() + + repos := database.NewRepositories(db) + sm := &SnapshotManager{repos: repos} + + first, err := sm.CreateSnapshotWithName(ctx, "test-host", "data", "v", "g") + if err != nil { + t.Fatalf("first create failed: %v", err) + } + + second, err := sm.CreateSnapshotWithName(ctx, "test-host", "data", "v", "g") + if err != nil { + t.Fatalf("second create failed: %v", err) + } + + snapshots, err := repos.Snapshots.ListRecent(ctx, created) + if err != nil { + t.Fatalf("listing snapshots failed: %v", err) + } + + if len(snapshots) != created { + t.Fatalf("listed %d snapshots, want %d", len(snapshots), created) + } + + if !snapshots[0].StartedAt.After(snapshots[1].StartedAt) { + t.Fatalf("start times %v and %v are not in order", + snapshots[1].StartedAt, snapshots[0].StartedAt) + } + + if snapshots[0].ID.String() != second || snapshots[1].ID.String() != first { + t.Fatalf("listed %s, %s; want %s, %s", + snapshots[0].ID, snapshots[1].ID, second, first) + } +}