Compare commits

...
Author SHA1 Message Date
sneak 98a36c6a0c Take a snapshot's start time from the moment in its ID (closes #482)
check / check (push) Waiting to run
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
2026-11-19 12:00:32 +00:00
clawbot 547b9faf36 Add vaultik --version, printing the version command's report (closes #432)
check / check (push) Waiting to run
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
2026-11-19 12:48:51 +01:00
clawbot fbcb1b9fc6 Turn off checkptr for SQLite in the race test run (closes #477)
check / check (push) Waiting to run
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
2026-11-19 12:32:02 +01:00
6 changed files with 113 additions and 10 deletions

No files matched your search

+9 -2
View File
@@ -35,9 +35,16 @@ RUN for attempt in 1 2 3; do \
echo "module download failed: giving up after 3 attempts" >&2; \ echo "module download failed: giving up after 3 attempts" >&2; \
exit 1 exit 1
COPY . . 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 ---"; \ { 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 # Build stage. Nothing is wanted from either phase above; the copies
# are what make BuildKit build them first, so this stage cannot run # are what make BuildKit build them first, so this stage cannot run
+1
View File
@@ -183,6 +183,7 @@ vaultik [--config <path>] remote nuke --force
vaultik [--config <path>] database delete [--force] vaultik [--config <path>] database delete [--force]
vaultik completion <bash|zsh|fish|powershell> vaultik completion <bash|zsh|fish|powershell>
vaultik version vaultik version
vaultik --version
``` ```
### global flags ### global flags
+18 -4
View File
@@ -32,6 +32,8 @@ var rootFlags RootFlags
// It sets up the command structure, global flags, and adds all subcommands. // It sets up the command structure, global flags, and adds all subcommands.
// This is the main entry point for the CLI command hierarchy. // This is the main entry point for the CLI command hierarchy.
func NewRootCommand() *cobra.Command { func NewRootCommand() *cobra.Command {
var showVersion bool
cmd := &cobra.Command{ cmd := &cobra.Command{
Use: "vaultik", Use: "vaultik",
Short: "Secure incremental backup tool with asymmetric encryption", 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 public keys and uploads to S3-compatible storage. No private keys are needed
on the source system.`, on the source system.`,
SilenceUsage: true, SilenceUsage: true,
// Bare 'vaultik' (no subcommand): print help. The banner is // Bare 'vaultik' (no subcommand): print help, or with --version
// printed once at process startup by Entry, before cobra // the report of the version command. The banner is printed once
// parses arguments, so it appears even when cobra rejects // at process startup by Entry, before cobra parses arguments, so
// args (e.g. "requires at least 2 arg(s)") and on --help. // it appears even when cobra rejects args (e.g. "requires at
// least 2 arg(s)") and on --help.
Run: func(cmd *cobra.Command, _ []string) { Run: func(cmd *cobra.Command, _ []string) {
if showVersion {
writeVersion(commandUI(cmd))
return
}
_ = cmd.Help() _ = 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 // Add global flags
cmd.PersistentFlags().StringVar(&rootFlags.ConfigPath, "config", "", cmd.PersistentFlags().StringVar(&rootFlags.ConfigPath, "config", "",
"Path to config file (default: $VAULTIK_CONFIG or platform config dir)") "Path to config file (default: $VAULTIK_CONFIG or platform config dir)")
+24
View File
@@ -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 // TestVersionCommandFlagsDevelopmentBuild is the regression test for
// the thing this command exists to prevent: a build that is not a // 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 // release must say so. The notice used to be gated on the version
+9 -4
View File
@@ -118,17 +118,22 @@ func ShortHostname(hostname string) string {
// hostname_timestamp if name is empty. The timestamp is in whole seconds. // 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 // 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 // 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( func (sm *SnapshotManager) CreateSnapshotWithName(
ctx context.Context, hostname, name, version, gitRevision string, ctx context.Context, hostname, name, version, gitRevision string,
) (string, error) { ) (string, error) {
shortHostname := ShortHostname(hostname) shortHostname := ShortHostname(hostname)
var snapshotID string var (
snapshotID string
startedAt time.Time
)
for { for {
// Build snapshot ID with optional name // 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 != "" { if name != "" {
snapshotID = fmt.Sprintf("%s_%s_%s", shortHostname, name, timestamp) snapshotID = fmt.Sprintf("%s_%s_%s", shortHostname, name, timestamp)
@@ -153,7 +158,7 @@ func (sm *SnapshotManager) CreateSnapshotWithName(
Hostname: types.Hostname(hostname), Hostname: types.Hostname(hostname),
VaultikVersion: types.Version(version), VaultikVersion: types.Version(version),
VaultikGitRevision: types.GitRevision(gitRevision), VaultikGitRevision: types.GitRevision(gitRevision),
StartedAt: time.Now().UTC(), StartedAt: startedAt,
CompletedAt: nil, // Not completed yet CompletedAt: nil, // Not completed yet
FileCount: 0, FileCount: 0,
ChunkCount: 0, ChunkCount: 0,
+52
View File
@@ -492,3 +492,55 @@ func TestCreateSnapshotWithNameTwiceBackToBack(t *testing.T) {
t.Fatalf("both creates returned snapshot ID %s", first) 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)
}
}