From fbcb1b9fc675f3997cf578e4bd606765379635f1 Mon Sep 17 00:00:00 2001 From: clawbot <35+clawbot@noreply.example.org> Date: Thu, 19 Nov 2026 12:32:02 +0100 Subject: [PATCH 1/3] Turn off checkptr for SQLite in the race test run (closes #477) The internal/vaultik tests timed out under load. Their time goes to SQLite, which serializes on one allocator lock under -race. checkptr, which -race turns on, was about a third of the CPU time in SQLite's translated C code. The test phase now turns it off for modernc.org packages only; the race detector stays on everywhere and our own packages keep checkptr. Model: opus-5-5 --- Dockerfile | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/Dockerfile b/Dockerfile index c60db2c..ea36ab4 100644 --- a/Dockerfile +++ b/Dockerfile @@ -35,9 +35,16 @@ RUN for attempt in 1 2 3; do \ echo "module download failed: giving up after 3 attempts" >&2; \ exit 1 COPY . . -RUN go test -timeout 90s -race -cover ./... || \ +# -race also turns on checkptr, which checks every pointer conversion. In +# the SQLite library's translated C code that is about a third of the test +# CPU time, much of it under one lock all SQLite work shares, and the +# tests that use SQLite time out on a busy host. The gcflags turn it off +# for that library only; our own packages keep it. +RUN go test -timeout 90s -race -gcflags='modernc.org/...=-d=checkptr=0' \ + -cover ./... || \ { echo "--- Rerunning with -v for details ---"; \ - go test -timeout 90s -race -v ./...; exit 1; } + go test -timeout 90s -race -gcflags='modernc.org/...=-d=checkptr=0' \ + -v ./...; exit 1; } # Build stage. Nothing is wanted from either phase above; the copies # are what make BuildKit build them first, so this stage cannot run -- 2.54.0 From 547b9faf362c54e20d132363c50f7fc8c894a190 Mon Sep 17 00:00:00 2001 From: clawbot <35+clawbot@noreply.example.org> Date: Thu, 19 Nov 2026 12:48:51 +0100 Subject: [PATCH 2/3] Add vaultik --version, printing the version command's report (closes #432) The flag is defined on the root command rather than enabled through cobra's Version field: cobra's flag prints a one-line template, not the full report that `vaultik version` prints. Model: opus-5-5 --- README.md | 1 + internal/cli/root.go | 22 ++++++++++++++++++---- internal/cli/version_test.go | 24 ++++++++++++++++++++++++ 3 files changed, 43 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 8d9e77e..769f300 100644 --- a/README.md +++ b/README.md @@ -183,6 +183,7 @@ vaultik [--config ] remote nuke --force vaultik [--config ] database delete [--force] vaultik completion vaultik version +vaultik --version ``` ### global flags diff --git a/internal/cli/root.go b/internal/cli/root.go index ba1fcbc..af74b35 100644 --- a/internal/cli/root.go +++ b/internal/cli/root.go @@ -32,6 +32,8 @@ var rootFlags RootFlags // It sets up the command structure, global flags, and adds all subcommands. // This is the main entry point for the CLI command hierarchy. func NewRootCommand() *cobra.Command { + var showVersion bool + cmd := &cobra.Command{ Use: "vaultik", Short: "Secure incremental backup tool with asymmetric encryption", @@ -39,15 +41,27 @@ func NewRootCommand() *cobra.Command { public keys and uploads to S3-compatible storage. No private keys are needed on the source system.`, SilenceUsage: true, - // Bare 'vaultik' (no subcommand): print help. The banner is - // printed once at process startup by Entry, before cobra - // parses arguments, so it appears even when cobra rejects - // args (e.g. "requires at least 2 arg(s)") and on --help. + // Bare 'vaultik' (no subcommand): print help, or with --version + // the report of the version command. The banner is printed once + // at process startup by Entry, before cobra parses arguments, so + // it appears even when cobra rejects args (e.g. "requires at + // least 2 arg(s)") and on --help. Run: func(cmd *cobra.Command, _ []string) { + if showVersion { + writeVersion(commandUI(cmd)) + + return + } + _ = cmd.Help() }, } + // cobra's own --version prints a template, not the version report, + // so vaultik defines the flag itself. + cmd.Flags().BoolVar(&showVersion, "version", false, + "Print version information (same as 'vaultik version')") + // Add global flags cmd.PersistentFlags().StringVar(&rootFlags.ConfigPath, "config", "", "Path to config file (default: $VAULTIK_CONFIG or platform config dir)") diff --git a/internal/cli/version_test.go b/internal/cli/version_test.go index 3215029..f2107bf 100644 --- a/internal/cli/version_test.go +++ b/internal/cli/version_test.go @@ -86,6 +86,30 @@ func TestVersionCommandReportLines(t *testing.T) { } } +// TestVersionFlagPrintsVersionReport checks that `vaultik --version` +// prints exactly the report of `vaultik version`. +// +//nolint:paralleltest // executes commands that read the global rootFlags +func TestVersionFlagPrintsVersionReport(t *testing.T) { + cmd := cli.NewRootCommand() + + var out bytes.Buffer + + cmd.SetOut(&out) + cmd.SetErr(&out) + cmd.SetArgs([]string{"--version"}) + + err := cmd.Execute() + if err != nil { + t.Fatalf("vaultik --version failed: %v", err) + } + + want := runVersionCommand(t) + if out.String() != want { + t.Errorf("vaultik --version printed:\n%s\nwant:\n%s", out.String(), want) + } +} + // TestVersionCommandFlagsDevelopmentBuild is the regression test for // the thing this command exists to prevent: a build that is not a // release must say so. The notice used to be gated on the version -- 2.54.0 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 3/3] 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) + } +} -- 2.54.0