Compare commits

..
Author SHA1 Message Date
sneak 28a272903f Split the long README sentences the --prune bullet's edit touched
check / check (push) Waiting to run
The --prune bullet in README.md held sentences of 45 to 75 words that
this branch edits or reflows, and it said the missing-volume case exits
non-zero beside two cases that name their status. Each is now split
into short sentences, and that case says it exits 1.

Model: opus-5-5
2026-11-19 06:49:47 +00:00
sneak 7f3fb97012 Exit 3 when a backup or restore finished but skipped files (closes #439)
check / check (push) In progress
A `snapshot create` or `snapshot restore` that --skip-errors made skip
files now exits 3, the status `restic backup` uses, so a cron job can
tell it from a run that made no backup (1). RunOperation keeps the
operation's error inside errReported so Entry can pick the status.

A run that skipped files and also found a configured path empty, missed
a mount point, or was asked for a path the snapshot lacks still exits 1:
its error wraps only that condition and names the skipped files in text.

The README gains an exit status section.

Model: opus-5-5
2026-11-19 06:38:41 +00:00
11 changed files with 192 additions and 179 deletions

No files matched your search

+37 -26
View File
@@ -196,9 +196,10 @@ vaultik version
that cannot be restored when restoring, instead of aborting. Packing and that cannot be restored when restoring, instead of aborting. Packing and
storage errors while creating a snapshot (which would leave a chunk recorded storage errors while creating a snapshot (which would leave a chunk recorded
but not stored) still abort the run. A run that skipped anything still but not stored) still abort the run. A run that skipped anything still
finishes but exits non-zero: `snapshot create` keeps the snapshot and counts finishes but exits `3` (see [exit status](#exit-status)): `snapshot create`
each file or directory it skipped as failed. A file removed during the backup keeps the snapshot and counts each file or directory it skipped as failed. A
is also counted as failed but does not change the exit status. file removed during the backup is also counted as failed but does not change
the exit status.
### locking ### locking
@@ -271,6 +272,19 @@ Every `--json` command therefore pipes on its own, with no additional flag:
`vaultik snapshot list --json | jq .` and `vaultik prune --json | jq .` both `vaultik snapshot list --json | jq .` and `vaultik prune --json | jq .` both
work as written. work as written.
### exit status
- `0`: the command succeeded.
- `1`: the command failed.
- `3`: `snapshot create` or `snapshot restore` finished, but `--skip-errors`
skipped files it could not read or restore. `restic backup` uses the same
status for this case.
- `130`: Ctrl-C, `SIGINT` or `SIGTERM` stopped the command.
A cron job can page on `1` and only log `3`. A run that skipped files and also
failed in another way exits `1`. For example, a restore that skipped files and
was asked for a path the snapshot does not hold exits `1`.
### environment variables ### environment variables
- `VAULTIK_AGE_SECRET_KEY`: Age private key for decryption (required for - `VAULTIK_AGE_SECRET_KEY`: Age private key for decryption (required for
@@ -347,24 +361,25 @@ In such a config, an unknown key or a value of the wrong type is refused.
local index, as `prune` does. By default keeps only the latest snapshot per local index, as `prune` does. By default keeps only the latest snapshot per
name; use `--keep-newer-than` for a rolling window. When `--skip-errors` name; use `--keep-newer-than` for a rolling window. When `--skip-errors`
skipped a file or directory it could not read or list, the prune does not run skipped a file or directory it could not read or list, the prune does not run
and every older snapshot is kept, since one of them may be the only one that and every older snapshot is kept. One of them may be the only one that holds
holds what was skipped; the command says so and exits non-zero. When the what was skipped. The command says so and exits `3`. The prune does not run
backup found nothing in a configured path, as in the mount point of a volume either when the backup found nothing in a configured path, as in the mount
that is not mounted, the prune does not run either: every older snapshot is point of a volume that is not mounted. Every older snapshot is kept, and the
kept, and the command names the path and exits non-zero, on every run until command names the path and exits `1`, on every run until the path holds
the path holds something again. Take a path that is empty on purpose out of something again. Take a path that is empty on purpose out of the config, or
the config, or remove the older snapshots by hand with `snapshot purge`. When remove the older snapshots by hand with `snapshot purge`. The prune does not
an earlier snapshot of the same name in the local index found a volume mounted run either when this backup does not find a volume that an earlier snapshot of
at or below a configured path (a directory on a different filesystem from its the same name in the local index found. The volume's mount point is a
parent, with an entry in it that the backup does not exclude) and this backup directory at or below a configured path. That directory is on a different
does not, the prune does not run either: every older snapshot is kept, and the filesystem from its parent and holds an entry the backup does not exclude.
command names the directory and exits non-zero, on every run until the volume Every older snapshot is kept, and the command names the directory and exits
is mounted again. A backup also does not find the volume when it finds no such `1`, on every run until the volume is mounted again. A backup also does not
entry in its directory, as when an automounted volume cannot be mounted, or find the volume when it finds no such entry in its directory, as when an
when that directory is no longer backed up, because it is excluded or its automounted volume cannot be mounted. Nor does it find the volume when that
configured path was removed. If any of this is on purpose, as for a retired directory is no longer backed up, because it is excluded or its configured
volume, remove the older snapshots by hand with `snapshot purge`. A file path was removed. If any of this is on purpose, as for a retired volume,
removed during the backup does not stop the prune. remove the older snapshots by hand with `snapshot purge`. A file removed
during the backup does not stop the prune.
- `--keep-newer-than <duration>`: With `--prune`, keep snapshots newer than this - `--keep-newer-than <duration>`: With `--prune`, keep snapshots newer than this
duration instead of only the latest (e.g. `4w`, `30d`, `6mo`, `1y`). Without duration instead of only the latest (e.g. `4w`, `30d`, `6mo`, `1y`). Without
`--prune`, or with a value that is not a valid duration, the command fails `--prune`, or with a value that is not a valid duration, the command fails
@@ -602,11 +617,7 @@ only `vaultik-destination.txt` stops such a backup, and only while the local
index holds snapshots. index holds snapshots.
**Rclone** (`rclone://remote/path`): Uses rclone's 70+ supported cloud **Rclone** (`rclone://remote/path`): Uses rclone's 70+ supported cloud
providers. Requires rclone to be configured separately (`rclone config`). The providers. Requires rclone to be configured separately (`rclone config`).
path after the remote name is relative: rclone resolves it on the remote, for
example against the login directory on sftp. A second slash makes it absolute,
as in `rclone://remote//srv/backup`. A remote of type `local` needs an absolute
path; a relative one is refused.
An upload cut off part-way leaves nothing under the object's name on S3, which An upload cut off part-way leaves nothing under the object's name on S3, which
shows an object only once its upload has completed, and on the local filesystem shows an object only once its upload has completed, and on the local filesystem
+7 -6
View File
@@ -198,7 +198,8 @@ func RunApp(ctx context.Context, app *fx.App) error {
// (or, under `snapshot verify --json`, put in its document). Entry // (or, under `snapshot verify --json`, put in its document). Entry
// turns it into a non-zero exit status without printing anything // turns it into a non-zero exit status without printing anything
// further, so the error line is not doubled. It flows up from // further, so the error line is not doubled. It flows up from
// RunOperation through cobra to Entry. // RunOperation through cobra to Entry, wrapping the operation's error
// so that Entry can choose the exit status from it.
var errReported = errors.New("operation failed") var errReported = errors.New("operation failed")
// errInterrupted marks an operation that SIGINT or SIGTERM stopped // errInterrupted marks an operation that SIGINT or SIGTERM stopped
@@ -232,8 +233,8 @@ func RunOperation(
) error { ) error {
var ( var (
mu sync.Mutex mu sync.Mutex
finished bool // op returned before any interrupt cancelled it finished bool // op returned before any interrupt cancelled it
failed bool // op finished with an error opErr error // what op returned, when it finished
) )
opts.Invokes = append(opts.Invokes, opts.Invokes = append(opts.Invokes,
@@ -258,7 +259,7 @@ func RunOperation(
mu.Lock() mu.Lock()
finished = true finished = true
failed = err != nil opErr = err
mu.Unlock() mu.Unlock()
} }
@@ -303,8 +304,8 @@ func RunOperation(
switch { switch {
case !finished: case !finished:
return errInterrupted return errInterrupted
case failed: case opErr != nil:
return errReported return fmt.Errorf("%w: %w", errReported, opErr)
default: default:
return nil return nil
} }
+16 -2
View File
@@ -9,6 +9,7 @@ import (
"sneak.berlin/go/vaultik/internal/globals" "sneak.berlin/go/vaultik/internal/globals"
"sneak.berlin/go/vaultik/internal/ui" "sneak.berlin/go/vaultik/internal/ui"
"sneak.berlin/go/vaultik/internal/vaultik"
) )
// shortCommitLen is the number of git commit hash characters shown in // shortCommitLen is the number of git commit hash characters shown in
@@ -20,6 +21,13 @@ const shortCommitLen = 12
// shell reports for a command stopped by Ctrl-C. // shell reports for a command stopped by Ctrl-C.
const exitCodeInterrupted = 130 const exitCodeInterrupted = 130
// exitCodeSkippedFiles is the exit status of a `snapshot create` or
// `snapshot restore` that finished but skipped files under
// --skip-errors. It is the status `restic backup` uses for a snapshot
// that could not read some files, so a cron job can tell such a run
// from one that made no backup.
const exitCodeSkippedFiles = 3
// Entry is the main entry point for the CLI application. // Entry is the main entry point for the CLI application.
// It first calls globals.FillUnsetFromBuildInfo, which fills in the // It first calls globals.FillUnsetFromBuildInfo, which fills in the
// version, commit and commit date that the linker flags did not set. // version, commit and commit date that the linker flags did not set.
@@ -30,8 +38,9 @@ const exitCodeInterrupted = 130
// The banner goes to stderr because stdout carries only the output the // The banner goes to stderr because stdout carries only the output the
// user asked for, such as a completion script or a `config get` value. // user asked for, such as a completion script or a `config get` value.
// //
// It returns the process exit code (0 on success, 130 when interrupted, // It returns the process exit code (0 on success, 3 when files were
// 1 on any other error) rather than calling os.Exit, so that main's // skipped, 130 when interrupted, 1 on any other error) rather than
// calling os.Exit, so that main's
// deferred profile writers run before the process ends. See run in // deferred profile writers run before the process ends. See run in
// cmd/vaultik/main.go. // cmd/vaultik/main.go.
func Entry() int { func Entry() int {
@@ -58,6 +67,11 @@ func Entry() int {
return exitCodeInterrupted return exitCodeInterrupted
} }
if errors.Is(err, vaultik.ErrFilesUnreadable) ||
errors.Is(err, vaultik.ErrFilesFailedRestore) {
return exitCodeSkippedFiles
}
return 1 return 1
} }
@@ -0,0 +1,83 @@
package cli //nolint:testpackage // shares runEntry and the hermetic config helpers
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
const flagSkipErrors = "--skip-errors"
// TestEntrySnapshotCreateSkipErrorsExitsNonZeroWhenItSkips backs up,
// under --skip-errors, a source directory that does not exist, which the
// walk skips. The command exits with exitCodeSkippedFiles and reports
// the backup as completed, not as a failed snapshot creation. See
// https://git.eeqj.de/sneak/vaultik/issues/310 and
// https://git.eeqj.de/sneak/vaultik/issues/439.
//
//nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
func TestEntrySnapshotCreateSkipErrorsExitsNonZeroWhenItSkips(t *testing.T) {
// writeBackupConfig would create the source directory.
configPath := writeHermeticPruneConfig(t, false)
code, stdout, stderr := runEntry(t,
flagConfig, configPath, flagSkipErrors, cmdSnapshot, cmdCreate)
assert.Equal(t, exitCodeSkippedFiles, code)
assert.Contains(t, stdout,
"Files: 1 examined, 0 backed up, 0 unchanged, 1 failed.")
assert.NotContains(t, stdout, "Finished successfully.")
assert.Contains(t, stderr,
"Backup completed, but 1 file(s) could not be read")
assert.NotContains(t, stderr, "Snapshot creation failed")
}
// TestEntrySnapshotRestoreSkipErrorsExitStatus backs up, deletes the
// blobs from the destination, and restores under --skip-errors, so every
// file is skipped. A restore that only skipped files exits with
// exitCodeSkippedFiles. One that was also asked for a path the snapshot
// does not hold exits 1. See
// https://git.eeqj.de/sneak/vaultik/issues/439.
//
//nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
func TestEntrySnapshotRestoreSkipErrorsExitStatus(t *testing.T) {
for _, testCase := range []struct {
name string
missingPaths []string
want int
}{
{name: "skipped files only", want: exitCodeSkippedFiles},
{
name: "and a path that matches nothing",
missingPaths: []string{"/no/such/path"},
want: 1,
},
} {
t.Run(testCase.name, func(t *testing.T) {
configPath, storeDir := writeBackupConfigWithPrivateKey(t)
code, _, _ := runEntry(t,
flagConfig, configPath, cmdSnapshot, cmdCreate)
require.Equal(t, 0, code)
require.NoError(t, os.RemoveAll(filepath.Join(storeDir, blobsDir)))
// writeBackupConfig puts the source directory beside the
// config file.
sourceDir := filepath.Join(filepath.Dir(configPath), "source")
args := append([]string{
flagConfig, configPath, flagSkipErrors, cmdSnapshot,
cmdRestore, onlySnapshotID(t, configPath), t.TempDir(),
sourceDir,
}, testCase.missingPaths...)
code, _, stderr := runEntry(t, args...)
assert.Equal(t, testCase.want, code)
assert.Contains(t, stderr, "1 file(s) failed to restore")
})
}
}
@@ -1,30 +0,0 @@
package cli //nolint:testpackage // shares runEntry and the hermetic config helpers
import (
"testing"
"github.com/stretchr/testify/assert"
)
// TestEntrySnapshotCreateSkipErrorsExitsNonZeroWhenItSkips backs up,
// under --skip-errors, a source directory that does not exist, which the
// walk skips. The command exits non-zero and reports the backup as
// completed, not as a failed snapshot creation. See
// https://git.eeqj.de/sneak/vaultik/issues/310.
//
//nolint:paralleltest // replaces os.Args, os.Stdout, os.Stderr and the xdg globals
func TestEntrySnapshotCreateSkipErrorsExitsNonZeroWhenItSkips(t *testing.T) {
// writeBackupConfig would create the source directory.
configPath := writeHermeticPruneConfig(t, false)
code, stdout, stderr := runEntry(t,
flagConfig, configPath, "--skip-errors", cmdSnapshot, cmdCreate)
assert.Equal(t, 1, code)
assert.Contains(t, stdout,
"Files: 1 examined, 0 backed up, 0 unchanged, 1 failed.")
assert.NotContains(t, stdout, "Finished successfully.")
assert.Contains(t, stderr,
"Backup completed, but 1 file(s) could not be read")
assert.NotContains(t, stderr, "Snapshot creation failed")
}
-23
View File
@@ -8,7 +8,6 @@ import (
"fmt" "fmt"
"io" "io"
"os" "os"
"path/filepath"
"strings" "strings"
"time" "time"
@@ -24,15 +23,6 @@ import (
// ErrRemoteNotFound is returned when an rclone remote is not configured. // ErrRemoteNotFound is returned when an rclone remote is not configured.
var ErrRemoteNotFound = errors.New("rclone remote not found in config") var ErrRemoteNotFound = errors.New("rclone remote not found in config")
// ErrRcloneRelativeLocalPath is returned when the path on an rclone remote
// of type local is relative. rclone would resolve it against the working
// directory, so the destination would move with it.
var ErrRcloneRelativeLocalPath = errors.New(
"the path on an rclone remote of type local must be absolute")
// rcloneLocalBackend is the type of rclone's local disk backend.
const rcloneLocalBackend = "local"
// RcloneStorer implements Storer using rclone's filesystem abstraction. // RcloneStorer implements Storer using rclone's filesystem abstraction.
// This allows vaultik to use any of rclone's 70+ supported storage providers. // This allows vaultik to use any of rclone's 70+ supported storage providers.
type RcloneStorer struct { type RcloneStorer struct {
@@ -63,19 +53,6 @@ func NewRcloneStorer(ctx context.Context, remote, path string) (*RcloneStorer, e
rclonePath += path rclonePath += path
} }
// A remote rclone cannot find is reported by fs.NewFs below. Only the
// backend of what fs.ParseRemote returns is needed here.
backend, _, _, _, err := fs.ParseRemote(rclonePath) //nolint:dogsled
if err == nil && backend.Name == rcloneLocalBackend && !filepath.IsAbs(path) {
example := path
if example == "" {
example = "path/to/backup"
}
return nil, fmt.Errorf("%w: use rclone://%s//%s",
ErrRcloneRelativeLocalPath, remote, example)
}
// On S3, Swift and some other remotes rclone keeps a time of its own in // On S3, Swift and some other remotes rclone keeps a time of its own in
// each object's metadata, which costs one request per object to read. // each object's metadata, which costs one request per object to read.
// rclone's use_server_modtime setting makes ModTime the time the // rclone's use_server_modtime setting makes ModTime the time the
-73
View File
@@ -436,79 +436,6 @@ func TestNewRcloneStorerReadsRcloneConfigEnv(t *testing.T) {
} }
} }
// useRcloneConfig points rclone at a config file holding contents for the
// rest of the test.
func useRcloneConfig(t *testing.T, contents string) {
t.Helper()
previous := config.GetConfigPath()
t.Cleanup(func() { _ = config.SetConfigPath(previous) })
confFile := filepath.Join(t.TempDir(), "rclone.conf")
err := os.WriteFile(confFile, []byte(contents), 0o600)
if err != nil {
t.Fatalf("writing rclone config: %v", err)
}
t.Setenv("RCLONE_CONFIG", confFile)
}
// TestNewRcloneStorerRefusesRelativeLocalPath checks that a relative path
// on a remote of type local is refused, with the absolute form in the
// error, and that nothing is created under the working directory. rclone
// would otherwise resolve the path against the working directory.
//
//nolint:paralleltest // changes the working directory and the rclone config
func TestNewRcloneStorerRefusesRelativeLocalPath(t *testing.T) {
useRcloneConfig(t, "[localfs]\ntype = local\n")
workdir := t.TempDir()
t.Chdir(workdir)
for path, wantInError := range map[string]string{
"srv/backup": "rclone://localfs//srv/backup",
"": "rclone://localfs//path/to/backup",
} {
_, err := storage.NewRcloneStorer(context.Background(), "localfs", path)
if !errors.Is(err, storage.ErrRcloneRelativeLocalPath) {
t.Errorf("path %q: error = %v, want ErrRcloneRelativeLocalPath",
path, err)
continue
}
if !strings.Contains(err.Error(), wantInError) {
t.Errorf("path %q: error %q does not show %q",
path, err, wantInError)
}
}
entries, err := os.ReadDir(workdir)
if err != nil {
t.Fatalf("reading working directory: %v", err)
}
if len(entries) != 0 {
t.Errorf("working directory holds %d entries, want none", len(entries))
}
}
// TestNewRcloneStorerKeepsRelativePathOnOtherRemotes checks that a relative
// path is accepted on a remote not of type local, where rclone resolves it
// on the remote itself, as sftp does against the login directory.
//
//nolint:paralleltest // changes the process-global rclone config
func TestNewRcloneStorerKeepsRelativePathOnOtherRemotes(t *testing.T) {
useRcloneConfig(t, "[mem]\ntype = memory\n")
_, err := storage.NewRcloneStorer(context.Background(), "mem", "backups")
if err != nil {
t.Errorf("NewRcloneStorer: %v", err)
}
}
// TestRcloneListStreamOnS3MakesNoRequestPerObject checks that listing an // TestRcloneListStreamOnS3MakesNoRequestPerObject checks that listing an
// rclone S3 remote takes each object's time from the listing itself. By // rclone S3 remote takes each object's time from the listing itself. By
// default rclone reads the time it keeps in each object's metadata, one // default rclone reads the time it keeps in each object's metadata, one
+19 -8
View File
@@ -25,9 +25,13 @@ import (
"sneak.berlin/go/vaultik/internal/types" "sneak.berlin/go/vaultik/internal/types"
) )
// ErrFilesFailedRestore is returned when --skip-errors skipped files the
// restore could not write. Every other file was restored, so the caller
// can report it apart from a failed restore.
var ErrFilesFailedRestore = errors.New("file(s) failed to restore")
// Sentinel errors for restore failures. // Sentinel errors for restore failures.
var ( var (
errFilesFailedRestore = errors.New("file(s) failed to restore")
errPathsNotInSnapshot = errors.New("requested path(s) not in the snapshot") errPathsNotInSnapshot = errors.New("requested path(s) not in the snapshot")
errFilesFailedVerify = errors.New("files failed verification") errFilesFailedVerify = errors.New("files failed verification")
errDecryptionKeyRequired = errors.New( errDecryptionKeyRequired = errors.New(
@@ -201,9 +205,9 @@ func (v *Vaultik) Restore(opts *RestoreOptions) error {
} }
// finishRestore prints the restore summary and the post-restore // finishRestore prints the restore summary and the post-restore
// warnings, runs optional verification, and converts any failed-file // warnings, runs optional verification, and returns the error the
// count into an error. Otherwise it returns unmatchedErr, the error for // restore ends with: one for the files --skip-errors skipped, one for
// the requested paths that matched nothing (nil when there are none). // unmatchedErr, the requested paths that matched nothing, or nil.
func (v *Vaultik) finishRestore( func (v *Vaultik) finishRestore(
repos *database.Repositories, repos *database.Repositories,
files []*database.File, files []*database.File,
@@ -250,11 +254,18 @@ func (v *Vaultik) finishRestore(
} }
} }
if result.FilesFailed > 0 { switch {
return fmt.Errorf("%d %w", result.FilesFailed, errFilesFailedRestore) case result.FilesFailed > 0 && unmatchedErr != nil:
// A requested path that matched nothing outweighs skipped files:
// the error wraps only unmatchedErr, so the command does not exit
// as a restore that only skipped files.
return fmt.Errorf("%w; %d %s",
unmatchedErr, result.FilesFailed, ErrFilesFailedRestore.Error())
case result.FilesFailed > 0:
return fmt.Errorf("%d %w", result.FilesFailed, ErrFilesFailedRestore)
default:
return unmatchedErr
} }
return unmatchedErr
} }
// warnIfOwnershipNotPreserved warns once if some entry restored under // warnIfOwnershipNotPreserved warns once if some entry restored under
+1 -1
View File
@@ -80,7 +80,7 @@ func TestRestoreFreesBlobsNoPendingFileNeeds(t *testing.T) {
TargetDir: restoreDir, TargetDir: restoreDir,
SkipErrors: true, SkipErrors: true,
}) })
require.ErrorIs(t, err, errFilesFailedRestore) require.ErrorIs(t, err, ErrFilesFailedRestore)
requireRestoredFiles(t, fs, restoreDir, originals) requireRestoredFiles(t, fs, restoreDir, originals)
assert.LessOrEqualf(t, peak, 1, assert.LessOrEqualf(t, peak, 1,
+20 -7
View File
@@ -49,8 +49,7 @@ var ErrFilesUnreadable = errors.New("file(s) could not be read")
// prune because the scan found nothing in a configured path of a // prune because the scan found nothing in a configured path of a
// snapshot, as in the mount point of a volume that is not mounted. The // snapshot, as in the mount point of a volume that is not mounted. The
// snapshots are complete and kept, so the caller can report it apart // snapshots are complete and kept, so the caller can report it apart
// from a failed backup. A run that also skipped unreadable files // from a failed backup.
// returns ErrFilesUnreadable instead.
var ErrSourcePathEmpty = errors.New("source path(s) were empty") var ErrSourcePathEmpty = errors.New("source path(s) were empty")
// ErrVolumeNotMounted is returned when --prune skipped the post-backup // ErrVolumeNotMounted is returned when --prune skipped the post-backup
@@ -59,8 +58,8 @@ var ErrSourcePathEmpty = errors.New("source path(s) were empty")
// mounted there is not mounted, the run found no entry in it, or the // mounted there is not mounted, the run found no entry in it, or the
// directory is no longer backed up. The snapshots are complete and // directory is no longer backed up. The snapshots are complete and
// kept, so the caller can report it apart from a failed backup. A run // kept, so the caller can report it apart from a failed backup. A run
// that also skipped unreadable files or found a configured path empty // that also found a configured path empty returns ErrSourcePathEmpty
// returns ErrFilesUnreadable or ErrSourcePathEmpty instead. // instead.
var ErrVolumeNotMounted = errors.New( var ErrVolumeNotMounted = errors.New(
"mount point(s) an earlier snapshot recorded were not found") "mount point(s) an earlier snapshot recorded were not found")
@@ -243,15 +242,29 @@ func (v *Vaultik) skipPostBackupPrune(
if filesUnreadable > 0 { if filesUnreadable > 0 {
v.UI.Warningf("Skipped the post-backup prune because %d file(s) "+ v.UI.Warningf("Skipped the post-backup prune because %d file(s) "+
"could not be read; older snapshots are kept.", filesUnreadable) "could not be read; older snapshots are kept.", filesUnreadable)
}
var err error
switch {
case len(emptyPaths) > 0:
err = fmt.Errorf("%d %w", len(emptyPaths), ErrSourcePathEmpty)
case len(unmountedPaths) > 0:
err = fmt.Errorf("%d %w", len(unmountedPaths), ErrVolumeNotMounted)
default:
return fmt.Errorf("%d %w", filesUnreadable, ErrFilesUnreadable) return fmt.Errorf("%d %w", filesUnreadable, ErrFilesUnreadable)
} }
if len(emptyPaths) > 0 { // An empty path or a missing volume can mean a whole volume is not
return fmt.Errorf("%d %w", len(emptyPaths), ErrSourcePathEmpty) // in the backup, which outweighs skipped files: the error wraps only
// the former, so the command does not exit as a backup that only
// skipped files.
if filesUnreadable > 0 {
return fmt.Errorf("%w; %d %s",
err, filesUnreadable, ErrFilesUnreadable.Error())
} }
return fmt.Errorf("%d %w", len(unmountedPaths), ErrVolumeNotMounted) return err
} }
// finishCreateSnapshot ends a run whose snapshots are all complete and // finishCreateSnapshot ends a run whose snapshots are all complete and
+9 -3
View File
@@ -176,8 +176,11 @@ func TestBackupThroughSymlinkWhoseTargetIsGoneDoesNotPrune(t *testing.T) {
// A backup under --skip-errors --prune that both skipped a file it could // A backup under --skip-errors --prune that both skipped a file it could
// not read and found nothing in a configured path names the empty path // not read and found nothing in a configured path names the empty path
// too when it skips the prune. See // too when it skips the prune. It ends with the empty path's error, which
// https://git.eeqj.de/sneak/vaultik/issues/388. // names the unreadable file too but does not wrap ErrFilesUnreadable, so
// the command does not exit as a backup that only skipped files. See
// https://git.eeqj.de/sneak/vaultik/issues/388 and
// https://git.eeqj.de/sneak/vaultik/issues/439.
func TestBackupWithEmptySourcePathAndUnreadableFileNamesBoth(t *testing.T) { func TestBackupWithEmptySourcePathAndUnreadableFileNamesBoth(t *testing.T) {
log.Initialize(log.Config{}) log.Initialize(log.Config{})
t.Parallel() t.Parallel()
@@ -207,7 +210,10 @@ func TestBackupWithEmptySourcePathAndUnreadableFileNamesBoth(t *testing.T) {
SkipErrors: true, SkipErrors: true,
Snapshots: []string{snapshotName}, Snapshots: []string{snapshotName},
}) })
require.ErrorIs(t, err, vaultik.ErrFilesUnreadable) require.ErrorIs(t, err, vaultik.ErrSourcePathEmpty)
require.NotErrorIs(t, err, vaultik.ErrFilesUnreadable)
require.EqualError(t, err,
"1 source path(s) were empty; 1 file(s) could not be read")
assert.Contains(t, env.out.String(), assert.Contains(t, env.out.String(),
"Skipped the post-backup prune because 1 file(s) could not be read") "Skipped the post-backup prune because 1 file(s) could not be read")
assert.Contains(t, env.out.String(), assert.Contains(t, env.out.String(),