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 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 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) + } +}