Compare commits

..
Author SHA1 Message Date
clawbot d71be0b4c8 Retry a failed blob upload five times, 3 seconds apart (closes #476)
check / check (push) Waiting to run
A blob upload that failed, such as one cut off by a lost connection,
ended the backup at once. It is now tried again from the start of the
blob up to five times, 3 seconds apart, with a warning before each
retry; an interrupt still stops it at once. The panic in the report,
"close of closed channel" from the progress reporter, was already fixed
on next by the commit for issue 253; a test now covers a failing upload
with the progress reporter on.

Model: opus-5-5
2026-11-19 09:28:57 +00:00
sneak 4605eae024 next: integrate accumulated work into main (#203)
check / check (push) Waiting to run
Reviewed-on: #203
2026-11-19 10:27:45 +01:00
clawbot 5b09271751 Report no device number for a zeroed stat (closes #462)
check / check (push) Waiting to run
deviceNumberFromStat returned device 0 and true for a stat whose device
and inode numbers are both zero. afero's unreleased master gives such a
stat for every in-memory file; the pinned v1.15.0 gives none. It now
returns false for it, as its comment says, and a test covers both
in-memory shapes.

Model: opus-5-5
2026-11-19 09:53:18 +01:00
clawbot 9fedcbeb0a Refuse a relative path on an rclone remote of type local (closes #465)
check / check (push) Waiting to run
rclone resolves a relative path on its local backend against the working
directory, so rclone://localfs/srv/backup wrote under whatever directory
vaultik ran from. Opening such a destination now fails with an error that
shows the absolute form, rclone://localfs//srv/backup. Other remotes keep
relative paths, which rclone resolves on the remote. The README says how
to write an absolute rclone path.

Model: opus-5-5
2026-11-19 09:24:16 +01:00
29 changed files with 667 additions and 663 deletions

No files matched your search

+57 -57
View File
@@ -340,29 +340,31 @@ In such a config, an unknown key or a value of the wrong type is refused.
error that explains how to fix it error that explains how to fix it
- `--cron`: Silent on total success; warnings and errors are still printed (for - `--cron`: Silent on total success; warnings and errors are still printed (for
crontab) crontab)
- `--prune`: After backup, drop older snapshots of each backed-up name, then - `--prune`: After backup, drop older snapshots of each backed-up name, remove
delete from the destination store what `prune` deletes there. By default keeps orphaned blobs older than `prune_grace_period` from remote storage, and delete
only the latest snapshot per name; use `--keep-newer-than` for a rolling each directory under `metadata/` that has no `manifest.json.zst` once every
window. When `--skip-errors` skipped a file or directory it could not read or object in it is older than `prune_grace_period` and its snapshot is not in the
list, the prune does not run and every older snapshot is kept, since one of local index, as `prune` does. By default keeps only the latest snapshot per
them may be the only one that holds what was skipped; the command says so and name; use `--keep-newer-than` for a rolling window. When `--skip-errors`
exits non-zero. When the backup found nothing in a configured path, as in the skipped a file or directory it could not read or list, the prune does not run
mount point of a volume that is not mounted, the prune does not run either: and every older snapshot is kept, since one of them may be the only one that
every older snapshot is kept, and the command names the path and exits holds what was skipped; the command says so and exits non-zero. When the
non-zero, on every run until the path holds something again. Take a path that backup found nothing in a configured path, as in the mount point of a volume
is empty on purpose out of the config, or remove the older snapshots by hand that is not mounted, the prune does not run either: every older snapshot is
with `snapshot purge`. When an earlier snapshot of the same name in the local kept, and the command names the path and exits non-zero, on every run until
index found a volume mounted at or below a configured path (a directory on a the path holds something again. Take a path that is empty on purpose out of
different filesystem from its parent, with an entry in it that the backup does the config, or remove the older snapshots by hand with `snapshot purge`. When
not exclude) and this backup does not, the prune does not run either: every an earlier snapshot of the same name in the local index found a volume mounted
older snapshot is kept, and the command names the directory and exits at or below a configured path (a directory on a different filesystem from its
non-zero, on every run until the volume is mounted again. A backup also does parent, with an entry in it that the backup does not exclude) and this backup
not find the volume when it finds no such entry in its directory, as when an does not, the prune does not run either: every older snapshot is kept, and the
automounted volume cannot be mounted, or when that directory is no longer command names the directory and exits non-zero, on every run until the volume
backed up, because it is excluded or its configured path was removed. If any is mounted again. A backup also does not find the volume when it finds no such
of this is on purpose, as for a retired volume, remove the older snapshots by entry in its directory, as when an automounted volume cannot be mounted, or
hand with `snapshot purge`. A file removed during the backup does not stop the when that directory is no longer backed up, because it is excluded or its
prune. configured path was removed. If any of this is on purpose, as for a retired
volume, 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
@@ -518,16 +520,14 @@ deleted. Step (3) also deletes each directory under `metadata/` that has no
`db.zst.age` but before its manifest, once every object in it is older than `db.zst.age` but before its manifest, once every object in it is older than
`prune_grace_period` and its snapshot is not in the local index. An object the `prune_grace_period` and its snapshot is not in the local index. An object the
listing gives no time for keeps its directory, and a directory whose name is not listing gives no time for keeps its directory, and a directory whose name is not
a remote key is left alone. Step (3) also deletes each `.partial` object under a remote key is left alone. Step (3) reads all remote manifests — network cost
`metadata/` and `blobs/` left by a killed upload, once it is older than scales with the number of snapshots. `snapshot create --prune` runs the same
`prune_grace_period`. Step (3) reads all remote manifests — network cost scales cleanup automatically; this is the manual entry point for the same work. If the
with the number of snapshots. `snapshot create --prune` runs the same cleanup
automatically; this is the manual entry point for the same work. If the
destination store cannot be listed, or the local index holds snapshots and the destination store cannot be listed, or the local index holds snapshots and the
destination answers that it has no `vaultik-destination.txt` (an unplugged destination answers that it has no `vaultik-destination.txt` (an unplugged
volume's empty mount point), prune fails and deletes nothing. `snapshot purge` volume's empty mount point), prune fails and deletes nothing. `snapshot purge`
does the same. If a blob, such a directory or such a `.partial` object cannot be does the same. If a blob or such a directory cannot be deleted, the command (and
deleted, the command (and `snapshot create --prune`) exits non-zero. `snapshot create --prune`) exits non-zero.
- `--force`: Skip confirmation prompt - `--force`: Skip confirmation prompt
- `--json`: Output stats as JSON. Also skips the confirmation prompt, as - `--json`: Output stats as JSON. Also skips the confirmation prompt, as
@@ -537,10 +537,7 @@ deleted, the command (and `snapshot create --prune`) exits non-zero.
gives no time for it, is counted in `blobs_too_new` and not in `blobs_found`. gives no time for it, is counted in `blobs_too_new` and not in `blobs_found`.
A directory under `metadata/` with no manifest is counted in A directory under `metadata/` with no manifest is counted in
`metadata_dirs_deleted` once deleted, or in `metadata_dirs_failed` if it `metadata_dirs_deleted` once deleted, or in `metadata_dirs_failed` if it
cannot be. A `.partial` object is counted in `partial_uploads_deleted` once cannot be.
deleted, or in `partial_uploads_failed` if it cannot be. One kept for being
newer than `prune_grace_period`, or of unknown age, is counted in
`partial_uploads_too_new`.
**`info`**: Display system configuration, storage settings, encryption **`info`**: Display system configuration, storage settings, encryption
recipients, and local database statistics. recipients, and local database statistics.
@@ -555,9 +552,7 @@ in `unreadable_manifests` and counts the manifests under skipped names in
`skipped_manifest_count`. An unreadable manifest also leaves its snapshot's blob `skipped_manifest_count`. An unreadable manifest also leaves its snapshot's blob
count and blob size unknown, `null` in `--json`. A file under `blobs/` whose count and blob size unknown, `null` in `--json`. A file under `blobs/` whose
name is not a blob hash is not counted as a blob, since `prune` never deletes name is not a blob hash is not counted as a blob, since `prune` never deletes
it. A leftover `.partial` object under `metadata/` or `blobs/` is not counted as it.
a blob either. Such objects are counted on their own line, and in
`partial_upload_count` and `partial_upload_size` in `--json`.
- `--json`: Output as JSON - `--json`: Output as JSON
@@ -607,7 +602,11 @@ 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`). providers. Requires rclone to be configured separately (`rclone config`). The
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
@@ -616,9 +615,12 @@ with a server-side move (local and sftp among them) are written under a
temporary name ending in `.partial` and moved into place. Rclone remotes without temporary name ending in `.partial` and moved into place. Rclone remotes without
one are written in place: where such a remote shows a file while it is still one are written in place: where such a remote shows a file while it is still
being written, a killed upload can leave a truncated object under its name, being written, a killed upload can leave a truncated object under its name,
which a later backup takes for complete. A backup ignores a leftover `.partial` which a later backup takes for complete. A leftover `.partial` file is ignored
file. `prune` deletes it once it is older than `prune_grace_period`, and and can be deleted.
`remote info` counts it.
A blob upload that fails, such as one cut off by a lost connection, is tried
again up to five times, three seconds apart. Each new try is announced with a
warning. If the last try fails too, the backup stops with the upload's error.
A destination shared between hosts or users, each with its own local index, A destination shared between hosts or users, each with its own local index,
relies on `prune_grace_period` to keep one's prune from deleting the blobs of relies on `prune_grace_period` to keep one's prune from deleting the blobs of
@@ -727,8 +729,6 @@ format does and does not protect.
5. Delete each directory under `metadata/` with no manifest whose objects are 5. Delete each directory under `metadata/` with no manifest whose objects are
all older than `prune_grace_period`, unless its snapshot is in the local all older than `prune_grace_period`, unless its snapshot is in the local
index index
6. Delete each `.partial` object under `metadata/` and `blobs/` older than
`prune_grace_period`
### chunking and deduplication ### chunking and deduplication
@@ -762,20 +762,20 @@ Run `vaultik config init` to generate a fully commented config file; a complete
annotated example also lives in annotated example also lives in
[`configs/config.example.yml`](configs/config.example.yml). Key fields: [`configs/config.example.yml`](configs/config.example.yml). Key fields:
| Field | Default | Description | | Field | Default | Description |
| -------------------- | ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | -------------------- | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `age_recipients` | (required by `snapshot create`) | Age public keys for encryption. Other commands run without one, so a machine that only restores can leave it empty | | `age_recipients` | (required by `snapshot create`) | Age public keys for encryption. Other commands run without one, so a machine that only restores can leave it empty |
| `age_secret_key` | (unset) | Age private key for decryption (`snapshot restore`, `snapshot files`, `snapshot verify --deep`). Setting it in the config file places the private key on the backed-up host, defeating the public-key-only design (see "why" above). Prefer the `VAULTIK_AGE_SECRET_KEY` environment variable, supplied only on the machine you restore from. | | `age_secret_key` | (unset) | Age private key for decryption (`snapshot restore`, `snapshot files`, `snapshot verify --deep`). Setting it in the config file places the private key on the backed-up host, defeating the public-key-only design (see "why" above). Prefer the `VAULTIK_AGE_SECRET_KEY` environment variable, supplied only on the machine you restore from. |
| `snapshots` | (required) | Named snapshot definitions with paths and excludes | | `snapshots` | (required) | Named snapshot definitions with paths and excludes |
| `storage_url` | | Storage backend URL (`s3://`, `file://`, `rclone://`) | | `storage_url` | | Storage backend URL (`s3://`, `file://`, `rclone://`) |
| `s3.*` | | Legacy S3 configuration (endpoint, bucket, credentials) | | `s3.*` | | Legacy S3 configuration (endpoint, bucket, credentials) |
| `exclude` | | Global exclude patterns (applied to all snapshots) | | `exclude` | | Global exclude patterns (applied to all snapshots) |
| `chunk_size` | `10MB` | Average chunk size for content-defined chunking | | `chunk_size` | `10MB` | Average chunk size for content-defined chunking |
| `blob_size_limit` | `10GB` | Maximum blob size before splitting. Must be at least four times `chunk_size` (the largest chunk the chunker can emit), otherwise a single-chunk blob could exceed the limit. A backup needs free temporary space, because each blob is written whole to a temporary file before it is uploaded (up to about `blob_size_limit`; an rclone destination that cannot stream uploads needs about twice that) and the metadata export writes copies of the local index. Temporary files go to `$TMPDIR` (default `/tmp`); with `TMPDIR` unset, SQLite writes one of those copies to `/var/tmp` | | `blob_size_limit` | `10GB` | Maximum blob size before splitting. Must be at least four times `chunk_size` (the largest chunk the chunker can emit), otherwise a single-chunk blob could exceed the limit. A backup needs free temporary space, because each blob is written whole to a temporary file before it is uploaded (up to about `blob_size_limit`; an rclone destination that cannot stream uploads needs about twice that) and the metadata export writes copies of the local index. Temporary files go to `$TMPDIR` (default `/tmp`); with `TMPDIR` unset, SQLite writes one of those copies to `/var/tmp` |
| `compression_level` | `3` | zstd compression level (1-19) | | `compression_level` | `3` | zstd compression level (1-19) |
| `prune_grace_period` | `24h` | How old a blob that no snapshot lists must be before `prune` deletes it, and how old every object in a directory under `metadata/` with no manifest must be before `prune` deletes that directory. `prune` also deletes a `.partial` object left by a killed upload only once it is this old. A backup uploads its blobs and its `db.zst.age` before its manifest, so on a destination shared between hosts or users this must be longer than the longest backup run (see [locking](#locking)). It does not protect a blob a backup reuses from an earlier run that stopped before its manifest: that blob keeps the time of its first upload, so a prune can delete it. A duration such as `36h` or `90m`; `0s` deletes such blobs and directories at once | | `prune_grace_period` | `24h` | How old a blob that no snapshot lists must be before `prune` deletes it, and how old every object in a directory under `metadata/` with no manifest must be before `prune` deletes that directory. A backup uploads its blobs and its `db.zst.age` before its manifest, so on a destination shared between hosts or users this must be longer than the longest backup run (see [locking](#locking)). It does not protect a blob a backup reuses from an earlier run that stopped before its manifest: that blob keeps the time of its first upload, so a prune can delete it. A duration such as `36h` or `90m`; `0s` deletes such blobs and directories at once |
| `hostname` | system hostname | Hostname used in snapshot IDs | | `hostname` | system hostname | Hostname used in snapshot IDs |
| `index_path` | platform data dir | Local SQLite index path | | `index_path` | platform data dir | Local SQLite index path |
--- ---
-2
View File
@@ -333,8 +333,6 @@ compression_level: 5
# How old a blob that no snapshot lists must be before prune deletes it, and # How old a blob that no snapshot lists must be before prune deletes it, and
# how old every object in a directory under metadata/ with no manifest must # how old every object in a directory under metadata/ with no manifest must
# be before prune deletes that directory # be before prune deletes that directory
# prune also deletes a .partial object left by a killed upload only once it is
# this old
# A backup uploads its blobs and its db.zst.age before its manifest, so on a # A backup uploads its blobs and its db.zst.age before its manifest, so on a
# destination shared between hosts or users this must be longer than the # destination shared between hosts or users this must be longer than the
# longest backup run # longest backup run
-3
View File
@@ -314,9 +314,6 @@ The restore process doesn't use the local database. Instead:
- Delete each directory under `metadata/` that has no `manifest.json.zst` - Delete each directory under `metadata/` that has no `manifest.json.zst`
and no local snapshot record, once every object in it is older than and no local snapshot record, once every object in it is older than
`prune_grace_period` `prune_grace_period`
3. **Delete Partial Uploads**
- Delete each `.partial` object under `metadata/` or `blobs/` left by a
killed upload, once it is older than `prune_grace_period`
### 6. Incomplete Snapshot Cleanup ### 6. Incomplete Snapshot Cleanup
+3 -5
View File
@@ -329,8 +329,7 @@ The prune operation is safe because:
1. It keeps every blob listed in any snapshot's manifest and deletes only blobs 1. It keeps every blob listed in any snapshot's manifest and deletes only blobs
that no manifest references. Under `metadata/` it deletes only a directory that no manifest references. Under `metadata/` it deletes only a directory
that has no `manifest.json.zst`, whose name is a remote key, and that no that has no `manifest.json.zst`, whose name is a remote key, and that no
local snapshot record claims. It also deletes the `.partial` objects left by local snapshot record claims
killed uploads, which no backup or restore reads
2. Manifests are unencrypted and can be read without keys 2. Manifests are unencrypted and can be read without keys
3. If any manifest cannot be downloaded or decoded, prune deletes nothing and 3. If any manifest cannot be downloaded or decoded, prune deletes nothing and
exits with an error, rather than treating that snapshot's blobs as exits with an error, rather than treating that snapshot's blobs as
@@ -344,9 +343,8 @@ The prune operation is safe because:
a backup reuses from an earlier run that stopped before its manifest: the a backup reuses from an earlier run that stopped before its manifest: the
backup skips the upload of a blob already on the destination, so that blob backup skips the upload of a blob already on the destination, so that blob
keeps the time of its first upload, and a prune before the backup's manifest keeps the time of its first upload, and a prune before the backup's manifest
is written can delete it; the new snapshot then cannot be restored. Prune is written can delete it; the new snapshot then cannot be restored.
deletes a `.partial` object only once it is older than `prune_grace_period`, `remote nuke` has no such check
so an upload still running keeps its object. `remote nuke` has no such check
## Restoration Requirements ## Restoration Requirements
+3 -5
View File
@@ -269,11 +269,9 @@ storage_url: ""
# How old a blob that no snapshot lists must be before prune deletes it, # How old a blob that no snapshot lists must be before prune deletes it,
# and how old every object in a directory under metadata/ with no manifest # and how old every object in a directory under metadata/ with no manifest
# must be before prune deletes that directory. prune also deletes a # must be before prune deletes that directory. A backup uploads its blobs
# .partial object left by a killed upload only once it is this old. A # and its db.zst.age before its manifest, so on a destination shared
# backup uploads its blobs and its db.zst.age before its manifest, so on # between hosts or users this must be longer than the longest backup run.
# a destination shared between hosts or users this must be longer than
# the longest backup run.
# It does not protect a blob a backup reuses from an earlier run that # It does not protect a blob a backup reuses from an earlier run that
# stopped before its manifest: that blob keeps the time of its first # stopped before its manifest: that blob keeps the time of its first
# upload, so a prune can delete it. # upload, so a prune can delete it.
+4 -6
View File
@@ -13,10 +13,9 @@ func NewPruneCommand() *cobra.Command {
cmd := &cobra.Command{ cmd := &cobra.Command{
Use: "prune", Use: "prune",
Short: "Tidy local database and remote storage", Short: "Tidy local database and remote storage",
Long: `Removes orphaned data from the local index database. From the Long: `Removes orphaned data from the local index database, and
backup destination store it removes unreferenced blobs, directories unreferenced blobs and directories under metadata/ with no manifest
under metadata/ with no manifest, and .partial objects left by killed from the backup destination store.
uploads.
Local cleanup drops incomplete snapshots and any files, chunks, or Local cleanup drops incomplete snapshots and any files, chunks, or
blobs no longer referenced by a completed snapshot. Remote cleanup blobs no longer referenced by a completed snapshot. Remote cleanup
@@ -31,8 +30,7 @@ blob keeps the time of its first upload, so it can be deleted.
Remote cleanup also deletes each directory under metadata/ with no Remote cleanup also deletes each directory under metadata/ with no
manifest, as a backup that stopped before its manifest leaves, once manifest, as a backup that stopped before its manifest leaves, once
all its objects are older than prune_grace_period and its snapshot is all its objects are older than prune_grace_period and its snapshot is
not in the local index. It also deletes each .partial object under not in the local index.
metadata/ or blobs/ once it is older than prune_grace_period.
Snapshot create --prune runs the same cleanup automatically; this Snapshot create --prune runs the same cleanup automatically; this
command is the manual entry point for the same work (e.g. after a command is the manual entry point for the same work (e.g. after a
+1 -2
View File
@@ -75,8 +75,7 @@ func newRemoteInfoCommand() *cobra.Command {
- Size of all snapshot metadata (per snapshot and total) - Size of all snapshot metadata (per snapshot and total)
- Count and total size of all blobs - Count and total size of all blobs
- Count and size of referenced blobs (from all manifests) - Count and size of referenced blobs (from all manifests)
- Count and size of orphaned blobs (not referenced by any manifest) - Count and size of orphaned blobs (not referenced by any manifest)`,
- Count and size of .partial objects left by killed uploads`,
Args: cobra.NoArgs, Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, _ []string) error { RunE: func(cmd *cobra.Command, _ []string) error {
// Use unified config resolution // Use unified config resolution
+7 -5
View File
@@ -138,11 +138,13 @@ on Linux), then /etc/vaultik/config.yml.`,
cmd.Flags().BoolVar(&opts.Cron, "cron", false, cmd.Flags().BoolVar(&opts.Cron, "cron", false,
"Run in cron mode (silent unless warning or error)") "Run in cron mode (silent unless warning or error)")
cmd.Flags().BoolVar(&opts.Prune, "prune", false, cmd.Flags().BoolVar(&opts.Prune, "prune", false,
"After backup, drop older snapshots of the same name, then delete "+ "After backup, drop older snapshots of the same name, remove "+
"from the destination store what prune deletes there (not "+ "orphaned blobs older than prune_grace_period, and delete each "+
"after a backup that skipped unreadable files, found a "+ "directory under metadata/ with no manifest once all its "+
"configured path empty, or did not find a mount point an "+ "objects are older than prune_grace_period and its snapshot is "+
"earlier snapshot found)") "not in the local index (not after a backup that skipped "+
"unreadable files, found a configured path empty, or did not "+
"find a mount point an earlier snapshot found)")
cmd.Flags().StringVar(&opts.KeepNewerThan, "keep-newer-than", "", cmd.Flags().StringVar(&opts.KeepNewerThan, "keep-newer-than", "",
"With --prune: keep snapshots newer than this duration "+ "With --prune: keep snapshots newer than this duration "+
"(e.g. 30d, 4w, 6mo, 1y; m is minutes, mo is months) "+ "(e.g. 30d, 4w, 6mo, 1y; m is minutes, mo is months) "+
+1 -2
View File
@@ -206,8 +206,7 @@ type Config struct {
// directory. A backup writes its manifest only once it has uploaded // directory. A backup writes its manifest only once it has uploaded
// all its blobs and its db.zst.age, so a younger blob or directory may // all its blobs and its db.zst.age, so a younger blob or directory may
// belong to a backup still running, on this host or another sharing // belong to a backup still running, on this host or another sharing
// the destination store. A prune also deletes a `.partial` object left // the destination store.
// by a killed upload only once it is this old.
PruneGracePeriod time.Duration `yaml:"prune_grace_period"` PruneGracePeriod time.Duration `yaml:"prune_grace_period"`
// StorageURL specifies the storage backend using a URL format. // StorageURL specifies the storage backend using a URL format.
+154
View File
@@ -0,0 +1,154 @@
//nolint:testpackage // exercises the unexported uploadBlobIfNeeded
package snapshot
import (
"bytes"
"context"
"io"
"path/filepath"
"testing"
"time"
"github.com/spf13/afero"
"github.com/stretchr/testify/require"
"sneak.berlin/go/vaultik/internal/blob"
"sneak.berlin/go/vaultik/internal/config"
"sneak.berlin/go/vaultik/internal/storage"
"sneak.berlin/go/vaultik/internal/storage/faultstore"
"sneak.berlin/go/vaultik/internal/ui"
)
// retryTestBlobSize is larger than what a failing faultstore Put reads,
// so a new try that did not rewind the blob would store a short object.
const retryTestBlobSize = 4096
// retryTestBlobKey is where the retry tests upload their blob.
const retryTestBlobKey = "blobs/retry"
// uploadRetryTestBlob uploads a retryTestBlobSize blob through store,
// waiting delay between tries, and returns the blob's bytes, the warnings
// the upload printed and its error.
func uploadRetryTestBlob(
ctx context.Context, store storage.Storer, delay time.Duration,
) ([]byte, int, error) {
data := bytes.Repeat([]byte("0123456789abcdef"), retryTestBlobSize/16)
output := ui.NewWithColor(io.Discard, false)
s := &Scanner{storage: store, ui: output, blobUploadRetryDelay: delay}
_, _, err := s.uploadBlobIfNeeded(ctx, retryTestBlobKey, &blob.WithReader{
FinishedBlob: &blob.FinishedBlob{
Hash: "retry",
Compressed: int64(len(data)),
},
Reader: bytes.NewReader(data),
}, time.Now(), &ScanResult{})
return data, output.WarningCount(), err
}
// A blob upload that fails is tried again from the start of the blob,
// and each failure is a warning. See
// https://git.eeqj.de/sneak/vaultik/issues/476.
func TestFailedBlobUploadIsTriedAgain(t *testing.T) {
t.Parallel()
inner, err := storage.NewFileStorer(t.TempDir())
require.NoError(t, err)
puts := 0
store := faultstore.New(inner)
store.OnPut = func(string) faultstore.PutAction {
puts++
if puts <= 2 {
return faultstore.PutFail
}
return faultstore.PutNormal
}
data, warnings, err := uploadRetryTestBlob(context.Background(), store, 0)
require.NoError(t, err)
require.Equal(t, 3, puts)
require.Equal(t, 2, warnings)
rc, err := inner.Get(context.Background(), retryTestBlobKey)
require.NoError(t, err)
defer func() { _ = rc.Close() }()
stored, err := io.ReadAll(rc)
require.NoError(t, err)
require.Equal(t, data, stored)
}
// A blob upload that keeps failing is tried blobUploadRetries more times,
// BlobUploadRetryDelay apart, and then the backup stops with its error.
func TestBlobUploadStopsAfterRetries(t *testing.T) {
t.Parallel()
inner, err := storage.NewFileStorer(t.TempDir())
require.NoError(t, err)
puts := 0
store := faultstore.New(inner)
store.OnPut = func(string) faultstore.PutAction {
puts++
return faultstore.PutFail
}
const delay = 10 * time.Millisecond
start := time.Now()
_, warnings, err := uploadRetryTestBlob(context.Background(), store, delay)
require.ErrorIs(t, err, faultstore.ErrInjectedUpload)
require.Equal(t, 1+blobUploadRetries, puts)
require.Equal(t, blobUploadRetries, warnings)
require.GreaterOrEqual(t, time.Since(start), blobUploadRetries*delay)
}
// An upload stopped by Ctrl-C or SIGTERM is not tried again.
func TestInterruptedBlobUploadIsNotTriedAgain(t *testing.T) {
t.Parallel()
inner, err := storage.NewFileStorer(t.TempDir())
require.NoError(t, err)
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
puts := 0
store := faultstore.New(inner)
store.OnPut = func(string) faultstore.PutAction {
puts++
cancel()
return faultstore.PutFail
}
_, warnings, err := uploadRetryTestBlob(ctx, store, 0)
require.Error(t, err)
require.Equal(t, 1, puts)
require.Zero(t, warnings)
}
// Backups wait BlobUploadRetryDelay before each new try.
func TestBackupScannerWaitsBetweenBlobUploadRetries(t *testing.T) {
t.Parallel()
cfg := &config.Config{
AgeRecipients: []string{testAgeRecipient},
ChunkSize: config.Size(1024 * 1024),
BlobSizeLimit: config.Size(4 * 1024 * 1024),
IndexPath: filepath.Join(t.TempDir(), "index.sqlite"),
}
scanner := provideScannerFactory(cfg, nil, nil)(ScannerParams{
Fs: afero.NewMemMapFs(),
})
require.NotNil(t, scanner)
require.Equal(t, BlobUploadRetryDelay, scanner.blobUploadRetryDelay)
}
+35
View File
@@ -4,8 +4,10 @@ package snapshot
import ( import (
"os" "os"
"path/filepath" "path/filepath"
"syscall"
"testing" "testing"
"github.com/spf13/afero"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
@@ -38,3 +40,36 @@ func TestDeviceNumberFromStat(t *testing.T) {
// /dev is a different filesystem from the temp dir on Linux, macOS and in Docker. // /dev is a different filesystem from the temp dir on Linux, macOS and in Docker.
assert.NotEqual(t, deviceOf(dir), deviceOf("/dev")) assert.NotEqual(t, deviceOf(dir), deviceOf("/dev"))
} }
// fileInfoWithStat is a file's info whose Sys returns stat.
type fileInfoWithStat struct {
os.FileInfo
stat *syscall.Stat_t
}
func (i fileInfoWithStat) Sys() any { return i.stat }
// The in-memory test filesystem has no device numbers. The pinned afero
// gives no stat; its unreleased master gives a stat holding only uid, gid
// and size. See https://git.eeqj.de/sneak/vaultik/issues/462.
func TestDeviceNumberFromStatInMemory(t *testing.T) {
t.Parallel()
fs := afero.NewMemMapFs()
require.NoError(t, afero.WriteFile(fs, "/file.txt", []byte("data"), 0o600))
info, err := fs.Stat("/file.txt")
require.NoError(t, err)
_, ok := deviceNumberFromStat(info)
assert.False(t, ok, "device number read from a file info with no stat")
zeroed := fileInfoWithStat{
FileInfo: info,
stat: &syscall.Stat_t{Uid: 1000, Gid: 1000, Size: 4},
}
_, ok = deviceNumberFromStat(zeroed)
assert.False(t, ok, "device number read from a stat with no device or inode number")
}
+15 -14
View File
@@ -54,20 +54,21 @@ func provideScannerFactory(
} }
return NewScanner(ScannerConfig{ return NewScanner(ScannerConfig{
FS: params.Fs, FS: params.Fs,
ChunkSize: cfg.ChunkSize.Int64(), ChunkSize: cfg.ChunkSize.Int64(),
Repositories: repos, Repositories: repos,
Storage: storer, Storage: storer,
MaxBlobSize: cfg.BlobSizeLimit.Int64(), MaxBlobSize: cfg.BlobSizeLimit.Int64(),
CompressionLevel: cfg.CompressionLevel, CompressionLevel: cfg.CompressionLevel,
AgeRecipients: cfg.AgeRecipients, AgeRecipients: cfg.AgeRecipients,
EnableProgress: params.EnableProgress, EnableProgress: params.EnableProgress,
UI: params.UI, UI: params.UI,
Exclude: excludes, Exclude: excludes,
IndexAndLockFiles: indexAndLockFiles(cfg.IndexPath, pidlock.Dir()), IndexAndLockFiles: indexAndLockFiles(cfg.IndexPath, pidlock.Dir()),
SkipErrors: params.SkipErrors, SkipErrors: params.SkipErrors,
PreviousSnapshotID: params.PreviousSnapshotID, PreviousSnapshotID: params.PreviousSnapshotID,
DeviceNumber: params.DeviceNumber, BlobUploadRetryDelay: BlobUploadRetryDelay,
DeviceNumber: params.DeviceNumber,
}) })
} }
} }
+75 -24
View File
@@ -75,6 +75,8 @@ type Scanner struct {
// skipErrors skips files that cannot be opened or read (logged loudly); // skipErrors skips files that cannot be opened or read (logged loudly);
// packer, database, encryption, and upload errors still abort the run. // packer, database, encryption, and upload errors still abort the run.
skipErrors bool skipErrors bool
// blobUploadRetryDelay is ScannerConfig.BlobUploadRetryDelay.
blobUploadRetryDelay time.Duration
// ui is the user-facing output; never nil (defaults to a discarding writer). // ui is the user-facing output; never nil (defaults to a discarding writer).
ui *ui.Writer ui *ui.Writer
// deviceNumber returns the number of the device that holds a file; // deviceNumber returns the number of the device that holds a file;
@@ -123,8 +125,16 @@ const (
// snapshotAssocBatchSize is how many file IDs are associated with the // snapshotAssocBatchSize is how many file IDs are associated with the
// snapshot per transaction. // snapshot per transaction.
snapshotAssocBatchSize = 1000 snapshotAssocBatchSize = 1000
// blobUploadRetries is how many more times a failed blob upload is
// tried before the backup stops with the error.
blobUploadRetries = 5
) )
// BlobUploadRetryDelay is the wait before each new try of a failed blob
// upload.
const BlobUploadRetryDelay = 3 * time.Second
// ScannerConfig contains configuration for the scanner // ScannerConfig contains configuration for the scanner
type ScannerConfig struct { type ScannerConfig struct {
FS afero.Fs FS afero.Fs
@@ -148,6 +158,10 @@ type ScannerConfig struct {
// PreviousSnapshotID is the most recent completed snapshot of the // PreviousSnapshotID is the most recent completed snapshot of the
// same name, "" for none. // same name, "" for none.
PreviousSnapshotID string PreviousSnapshotID string
// BlobUploadRetryDelay is the wait before each new try of a failed
// blob upload. Backups use snapshot.BlobUploadRetryDelay; tests leave
// it zero to try again at once.
BlobUploadRetryDelay time.Duration
// DeviceNumber returns the number of the device that holds a file, // DeviceNumber returns the number of the device that holds a file,
// and false when there is none to read. nil reads it from the file's // and false when there is none to read. nil reads it from the file's
// stat; tests replace it, since the in-memory test filesystem has none. // stat; tests replace it, since the in-memory test filesystem has none.
@@ -245,23 +259,24 @@ func NewScanner(cfg ScannerConfig) *Scanner {
} }
return &Scanner{ return &Scanner{
fs: cfg.FS, fs: cfg.FS,
chunker: chunker.NewChunker(cfg.ChunkSize), chunker: chunker.NewChunker(cfg.ChunkSize),
packer: packer, packer: packer,
repos: cfg.Repositories, repos: cfg.Repositories,
storage: cfg.Storage, storage: cfg.Storage,
maxBlobSize: cfg.MaxBlobSize, maxBlobSize: cfg.MaxBlobSize,
compressionLevel: cfg.CompressionLevel, compressionLevel: cfg.CompressionLevel,
ageRecipient: strings.Join(cfg.AgeRecipients, ","), ageRecipient: strings.Join(cfg.AgeRecipients, ","),
exclude: cfg.Exclude, exclude: cfg.Exclude,
compiledExclude: compiledExclude, compiledExclude: compiledExclude,
indexAndLockFiles: indexAndLockFiles, indexAndLockFiles: indexAndLockFiles,
progress: progress, progress: progress,
skipErrors: cfg.SkipErrors, skipErrors: cfg.SkipErrors,
previousSnapshotID: cfg.PreviousSnapshotID, previousSnapshotID: cfg.PreviousSnapshotID,
ui: uiw, blobUploadRetryDelay: cfg.BlobUploadRetryDelay,
deviceNumber: deviceNumber, ui: uiw,
pendingChunkHashes: make(map[string]struct{}), deviceNumber: deviceNumber,
pendingChunkHashes: make(map[string]struct{}),
} }
} }
@@ -1438,11 +1453,12 @@ func (s *Scanner) deviceNumberAt(path string) (uint64, bool) {
} }
// deviceNumberFromStat returns the number of the device that holds the // deviceNumberFromStat returns the number of the device that holds the
// file info describes, and false when info carries no stat, as from the // file info describes, and false when info carries no stat from a real
// in-memory test filesystem. // filesystem. The in-memory test filesystem gives either no stat or one
// whose device and inode numbers are both zero, which no real file has.
func deviceNumberFromStat(info os.FileInfo) (uint64, bool) { func deviceNumberFromStat(info os.FileInfo) (uint64, bool) {
stat, ok := info.Sys().(*syscall.Stat_t) stat, ok := info.Sys().(*syscall.Stat_t)
if !ok { if !ok || (stat.Dev == 0 && stat.Ino == 0) {
return 0, false return 0, false
} }
@@ -1875,10 +1891,7 @@ func (s *Scanner) uploadBlobIfNeeded(
s.ui.Hex(finishedBlob.Hash), s.ui.Size(finishedBlob.Compressed), s.ui.Hex(finishedBlob.Hash), s.ui.Size(finishedBlob.Compressed),
s.ui.Path(destination)) s.ui.Path(destination))
progressCallback := s.makeUploadProgressCallback(ctx, finishedBlob, startTime) err = s.putBlob(ctx, blobPath, blobWithReader)
err = s.storage.PutWithProgress(ctx, blobPath, blobWithReader.Reader,
finishedBlob.Compressed, progressCallback)
if err != nil { if err != nil {
// The record is at info level: the returned error ends the backup // The record is at info level: the returned error ends the backup
// and is printed as its ERROR: line. Only an interrupt cancels // and is printed as its ERROR: line. Only an interrupt cancels
@@ -1922,6 +1935,44 @@ func (s *Scanner) uploadBlobIfNeeded(
return finishedBlob.Compressed, false, nil return finishedBlob.Compressed, false, nil
} }
// putBlob uploads the blob to blobPath. After a failed upload it waits
// s.blobUploadRetryDelay and uploads the whole blob again, up to
// blobUploadRetries times, and then returns the last error. An interrupt
// stops it at once.
func (s *Scanner) putBlob(
ctx context.Context, blobPath string, blobWithReader *blob.WithReader,
) error {
finishedBlob := blobWithReader.FinishedBlob
for retries := 0; ; retries++ {
_, err := blobWithReader.Reader.Seek(0, io.SeekStart)
if err != nil {
return fmt.Errorf("rewinding blob for upload: %w", err)
}
progressCallback := s.makeUploadProgressCallback(
ctx, finishedBlob, time.Now().UTC())
err = s.storage.PutWithProgress(ctx, blobPath, blobWithReader.Reader,
finishedBlob.Compressed, progressCallback)
if err == nil || ctx.Err() != nil || retries == blobUploadRetries {
return err
}
log.Info("Blob upload failed, trying again",
"hash", finishedBlob.Hash, "retry", retries+1, "error", err)
s.ui.Warningf("Upload of blob %s failed: %v. Trying again in %s (retry %d of %d).",
s.ui.Hex(finishedBlob.Hash), err,
s.ui.Duration(s.blobUploadRetryDelay), retries+1, blobUploadRetries)
select {
case <-ctx.Done():
return err
case <-time.After(s.blobUploadRetryDelay):
}
}
}
// makeUploadProgressCallback creates a progress callback for blob uploads. // makeUploadProgressCallback creates a progress callback for blob uploads.
// It updates the live progress reporter ~twice/sec for ETAs and prints a // It updates the live progress reporter ~twice/sec for ETAs and prints a
// human-readable status line to s.output at most every 15 seconds. // human-readable status line to s.output at most every 15 seconds.
+3 -5
View File
@@ -200,11 +200,9 @@ func (f *Storer) ListStream(
return f.inner.ListStream(ctx, prefix) return f.inner.ListStream(ctx, prefix)
} }
// ListPartialUploads delegates unchanged. // DeletePartialUploads delegates unchanged.
func (f *Storer) ListPartialUploads( func (f *Storer) DeletePartialUploads(ctx context.Context, prefix string) error {
ctx context.Context, prefix string, return f.inner.DeletePartialUploads(ctx, prefix)
) ([]storage.ObjectInfo, error) {
return f.inner.ListPartialUploads(ctx, prefix)
} }
// Info delegates unchanged. // Info delegates unchanged.
+13 -26
View File
@@ -56,8 +56,8 @@ const storageDirPerm = 0o755
// truncated object at the key a later run would Stat and trust as a complete // truncated object at the key a later run would Stat and trust as a complete
// blob. The rclone backend's upload does the same on remotes with a // blob. The rclone backend's upload does the same on remotes with a
// server-side move. List and ListStream skip these files, so a leftover from // server-side move. List and ListStream skip these files, so a leftover from
// an interrupted write is never listed or trusted as a blob; prune deletes // an interrupted write is never listed or trusted as a blob; it is otherwise
// it once it is older than the prune grace period. // harmless.
const tempSuffix = ".partial" const tempSuffix = ".partial"
// Put stores data at the specified key. // Put stores data at the specified key.
@@ -248,24 +248,22 @@ func (f *FileStorer) ListStream(ctx context.Context, prefix string) <-chan Objec
return ch return ch
} }
// ListPartialUploads returns each file under prefix whose name ends in // DeletePartialUploads removes every file under prefix whose name ends in
// tempSuffix. Like List, it reads through symlinked directories and fails // tempSuffix. Like List, it reads through symlinked directories and fails
// on one whose target is missing. A missing prefix has none. // on one whose target is missing. A missing prefix has none to remove.
func (f *FileStorer) ListPartialUploads( func (f *FileStorer) DeletePartialUploads(ctx context.Context, prefix string) error {
ctx context.Context, prefix string, basePath := f.fullPath(prefix)
) ([]ObjectInfo, error) {
exists, err := f.prefixExists(prefix) exists, err := f.prefixExists(prefix)
if err != nil { if err != nil {
return nil, fmt.Errorf("checking path: %w", err) return fmt.Errorf("checking path: %w", err)
} }
if !exists { if !exists {
return nil, nil return nil
} }
var partial []ObjectInfo err = f.walk(basePath, func(path string, info os.FileInfo, err error) error {
err = f.walk(f.fullPath(prefix), func(path string, info os.FileInfo, err error) error {
if err != nil { if err != nil {
return err return err
} }
@@ -278,24 +276,13 @@ func (f *FileStorer) ListPartialUploads(
return nil return nil
} }
relPath, err := filepath.Rel(f.basePath, path) return f.fs.Remove(path)
if err != nil {
return fmt.Errorf("computing relative path: %w", err)
}
partial = append(partial, ObjectInfo{
Key: strings.ReplaceAll(relPath, string(filepath.Separator), "/"),
Size: info.Size(),
ModTime: info.ModTime(),
})
return nil
}) })
if err != nil { if err != nil {
return nil, fmt.Errorf("walking directory: %w", err) return fmt.Errorf("walking directory: %w", err)
} }
return partial, nil return nil
} }
// Info returns human-readable storage location information. // Info returns human-readable storage location information.
+8 -32
View File
@@ -121,10 +121,9 @@ func TestFileStorer_ListSkipsPartialFiles(t *testing.T) {
} }
} }
// TestFileStorer_ListPartialUploads checks that a leftover temp file is // TestFileStorer_DeletePartialUploads checks that a leftover temp file is
// listed with its size and time, that the object at the real key is not, // removed and the object at the real key is kept.
// and that Delete removes the leftover by the listed key. func TestFileStorer_DeletePartialUploads(t *testing.T) {
func TestFileStorer_ListPartialUploads(t *testing.T) {
t.Parallel() t.Parallel()
base := t.TempDir() base := t.TempDir()
@@ -134,46 +133,23 @@ func TestFileStorer_ListPartialUploads(t *testing.T) {
t.Fatalf("NewFileStorer: %v", err) t.Fatalf("NewFileStorer: %v", err)
} }
checkListPartialUploads(t, f, base)
}
// checkListPartialUploads stores an object and writes a leftover temp
// file next to it in the directory base that s stores into. It checks
// that ListPartialUploads lists only the leftover, with its size and a
// time, and that Delete removes it by the listed key and keeps the
// object.
func checkListPartialUploads(t *testing.T, s storage.Storer, base string) {
t.Helper()
ctx := context.Background() ctx := context.Background()
err := s.Put(ctx, testBlobKey, strings.NewReader("blob-bytes")) err = f.Put(ctx, testBlobKey, strings.NewReader("blob-bytes"))
if err != nil { if err != nil {
t.Fatalf("Put: %v", err) t.Fatalf("Put: %v", err)
} }
leftoverKey := testBlobKey + "-123456.partial" leftover := filepath.Join(base, testBlobKey+"-123456.partial")
leftover := filepath.Join(base, leftoverKey)
err = os.WriteFile(leftover, []byte("half"), 0o600) err = os.WriteFile(leftover, []byte("half"), 0o600)
if err != nil { if err != nil {
t.Fatalf("writing leftover temp file: %v", err) t.Fatalf("writing leftover temp file: %v", err)
} }
partial, err := s.ListPartialUploads(ctx, "blobs/") err = f.DeletePartialUploads(ctx, "blobs/")
if err != nil { if err != nil {
t.Fatalf("ListPartialUploads: %v", err) t.Fatalf("DeletePartialUploads: %v", err)
}
if len(partial) != 1 || partial[0].Key != leftoverKey ||
partial[0].Size != int64(len("half")) || partial[0].ModTime.IsZero() {
t.Fatalf("ListPartialUploads = %+v, want only %s, 4 bytes, "+
"with a time", partial, leftoverKey)
}
err = s.Delete(ctx, partial[0].Key)
if err != nil {
t.Fatalf("Delete: %v", err)
} }
_, err = os.Stat(leftover) _, err = os.Stat(leftover)
@@ -181,7 +157,7 @@ func checkListPartialUploads(t *testing.T, s storage.Storer, base string) {
t.Errorf("leftover temp file was not removed: %v", err) t.Errorf("leftover temp file was not removed: %v", err)
} }
_, err = s.Stat(ctx, testBlobKey) _, err = f.Stat(ctx, testBlobKey)
if err != nil { if err != nil {
t.Errorf("Stat of the real key: %v", err) t.Errorf("Stat of the real key: %v", err)
} }
+18 -13
View File
@@ -239,11 +239,11 @@ func TestFileStorerListFailsOnSymlinkLoop(t *testing.T) {
} }
} }
// TestFileStorerListPartialUploadsThroughSymlinkedDirectory checks that // TestFileStorerDeletePartialUploadsThroughSymlinkedDirectory checks that
// ListPartialUploads, which prune and remote nuke use, lists a leftover // DeletePartialUploads, which remote nuke uses, removes a leftover temp
// temp file behind a symlinked metadata/ or blobs/ directory under its // file behind a symlinked metadata/ or blobs/ directory and keeps the
// key, and leaves out the object at the real key. // object at the real key.
func TestFileStorerListPartialUploadsThroughSymlinkedDirectory(t *testing.T) { func TestFileStorerDeletePartialUploadsThroughSymlinkedDirectory(t *testing.T) {
t.Parallel() t.Parallel()
ctx := context.Background() ctx := context.Background()
@@ -265,24 +265,29 @@ func TestFileStorerListPartialUploadsThroughSymlinkedDirectory(t *testing.T) {
t.Fatalf("Put: %v", err) t.Fatalf("Put: %v", err)
} }
leftoverKey := key + "-123456.partial" leftover := filepath.Join(base, key+"-123456.partial")
err = os.WriteFile(filepath.Join(base, leftoverKey), err = os.WriteFile(leftover, []byte("half"), 0o600)
[]byte("half"), 0o600)
if err != nil { if err != nil {
t.Fatalf("writing leftover temp file: %v", err) t.Fatalf("writing leftover temp file: %v", err)
} }
moveBehindSymlink(t, base, dir) moveBehindSymlink(t, base, dir)
partial, err := s.ListPartialUploads(ctx, dir+"/") err = s.DeletePartialUploads(ctx, dir+"/")
if err != nil { if err != nil {
t.Fatalf("ListPartialUploads: %v", err) t.Fatalf("DeletePartialUploads: %v", err)
} }
if len(partial) != 1 || partial[0].Key != leftoverKey { // leftover runs through the link.
t.Errorf("ListPartialUploads = %+v, want only %s", _, err = os.Stat(leftover)
partial, leftoverKey) if !os.IsNotExist(err) {
t.Errorf("leftover temp file was not removed: %v", err)
}
_, err = s.Stat(ctx, key)
if err != nil {
t.Errorf("Stat of the real key: %v", err)
} }
}) })
} }
+37 -13
View File
@@ -8,6 +8,7 @@ import (
"fmt" "fmt"
"io" "io"
"os" "os"
"path/filepath"
"strings" "strings"
"time" "time"
@@ -23,6 +24,15 @@ 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 {
@@ -53,6 +63,19 @@ 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
@@ -233,28 +256,29 @@ func (r *RcloneStorer) ListStream(
return ch return ch
} }
// ListPartialUploads returns each object under prefix whose name ends in // DeletePartialUploads removes every object under prefix whose name ends
// tempSuffix. // in tempSuffix.
func (r *RcloneStorer) ListPartialUploads( func (r *RcloneStorer) DeletePartialUploads(ctx context.Context, prefix string) error {
ctx context.Context, prefix string, var partial []fs.Object
) ([]ObjectInfo, error) {
var partial []ObjectInfo
err := operations.ListFn(ctx, r.fsys, func(obj fs.Object) { err := operations.ListFn(ctx, r.fsys, func(obj fs.Object) {
key := obj.Remote() key := obj.Remote()
if strings.HasPrefix(key, prefix) && strings.HasSuffix(key, tempSuffix) { if strings.HasPrefix(key, prefix) && strings.HasSuffix(key, tempSuffix) {
partial = append(partial, ObjectInfo{ partial = append(partial, obj)
Key: key,
Size: obj.Size(),
ModTime: obj.ModTime(ctx),
})
} }
}) })
if err != nil { if err != nil {
return nil, fmt.Errorf("listing objects: %w", err) return fmt.Errorf("listing objects: %w", err)
} }
return partial, nil for _, obj := range partial {
err = obj.Remove(ctx)
if err != nil {
return fmt.Errorf("removing object: %w", err)
}
}
return nil
} }
// Info returns human-readable storage location information. // Info returns human-readable storage location information.
+104 -7
View File
@@ -205,21 +205,45 @@ func TestRcloneStorerListSkipsPartialFiles(t *testing.T) {
} }
} }
// TestRcloneStorerListPartialUploads checks that a temporary file left by // TestRcloneStorerDeletePartialUploads checks that a temporary file left
// a killed upload is listed with its size and time, that the object at // by a killed upload is removed and the object at the real key is kept.
// the real key is not, and that Delete removes the leftover by the listed
// key.
// //
//nolint:paralleltest // NewRcloneStorer installs the process-global rclone config //nolint:paralleltest // NewRcloneStorer installs the process-global rclone config
func TestRcloneStorerListPartialUploads(t *testing.T) { func TestRcloneStorerDeletePartialUploads(t *testing.T) {
dir := t.TempDir() dir := t.TempDir()
ctx := context.Background()
s, err := storage.NewRcloneStorer(context.Background(), ":local", dir) s, err := storage.NewRcloneStorer(ctx, ":local", dir)
if err != nil { if err != nil {
t.Fatalf("NewRcloneStorer: %v", err) t.Fatalf("NewRcloneStorer: %v", err)
} }
checkListPartialUploads(t, s, dir) err = s.Put(ctx, testBlobKey, strings.NewReader("blob-bytes"))
if err != nil {
t.Fatalf("Put: %v", err)
}
leftover := filepath.Join(dir, testBlobKey+"-123456.partial")
err = os.WriteFile(leftover, []byte("half"), 0o600)
if err != nil {
t.Fatalf("writing leftover temp file: %v", err)
}
err = s.DeletePartialUploads(ctx, "blobs/")
if err != nil {
t.Fatalf("DeletePartialUploads: %v", err)
}
_, err = os.Stat(leftover)
if !os.IsNotExist(err) {
t.Errorf("leftover temp file was not removed: %v", err)
}
_, err = s.Stat(ctx, testBlobKey)
if err != nil {
t.Errorf("Stat of the real key: %v", err)
}
} }
// newRcloneStorerOnWrappedLocal registers name as rclone's local backend // newRcloneStorerOnWrappedLocal registers name as rclone's local backend
@@ -412,6 +436,79 @@ 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
+4 -6
View File
@@ -100,12 +100,10 @@ func (s *S3Storer) ListStream(ctx context.Context, prefix string) <-chan ObjectI
return ch return ch
} }
// ListPartialUploads finds none: S3 shows an object only once its upload // DeletePartialUploads has nothing to remove: S3 shows an object only once
// has completed, so an upload cut off part-way leaves none. // its upload has completed, so an upload cut off part-way leaves none.
func (s *S3Storer) ListPartialUploads( func (s *S3Storer) DeletePartialUploads(_ context.Context, _ string) error {
_ context.Context, _ string, return nil
) ([]ObjectInfo, error) {
return nil, nil
} }
// Info returns human-readable storage location information. // Info returns human-readable storage location information.
+5 -6
View File
@@ -77,12 +77,11 @@ type Storer interface {
// If an error occurs during listing, the final item will have Err set. // If an error occurs during listing, the final item will have Err set.
ListStream(ctx context.Context, prefix string) <-chan ObjectInfo ListStream(ctx context.Context, prefix string) <-chan ObjectInfo
// ListPartialUploads returns each object under prefix whose name ends // DeletePartialUploads removes every object under prefix that an
// in `.partial`, as a killed upload leaves it, with its key, size and // upload cut off part-way left under a temporary name ending in
// modification time. The file and rclone // `.partial`. The file and rclone backends' List and ListStream skip
// backends' List and ListStream skip such an object; Delete removes // such an object.
// it. DeletePartialUploads(ctx context.Context, prefix string) error
ListPartialUploads(ctx context.Context, prefix string) ([]ObjectInfo, error)
// Info returns human-readable storage location information. // Info returns human-readable storage location information.
Info() Info Info() Info
@@ -258,10 +258,8 @@ func (s *stubLister) List(_ context.Context, _ string) ([]string, error) {
return nil, errStubUnused return nil, errStubUnused
} }
func (s *stubLister) ListPartialUploads( func (s *stubLister) DeletePartialUploads(_ context.Context, _ string) error {
_ context.Context, _ string, return errStubUnused
) ([]storage.ObjectInfo, error) {
return nil, errStubUnused
} }
func (s *stubLister) Info() storage.Info { func (s *stubLister) Info() storage.Info {
+7 -41
View File
@@ -216,11 +216,6 @@ type RemoteInfoResult struct {
OrphanedBlobCount *int `json:"orphaned_blob_count"` OrphanedBlobCount *int `json:"orphaned_blob_count"`
OrphanedBlobSize *int64 `json:"orphaned_blob_size"` OrphanedBlobSize *int64 `json:"orphaned_blob_size"`
// `.partial` objects under metadata/ and blobs/ left by killed
// uploads. The blob figures above leave them out.
PartialUploadCount int `json:"partial_upload_count"`
PartialUploadSize int64 `json:"partial_upload_size"`
// Remote key of each snapshot whose manifest could not be read // Remote key of each snapshot whose manifest could not be read
UnreadableManifests []string `json:"unreadable_manifests,omitempty"` UnreadableManifests []string `json:"unreadable_manifests,omitempty"`
@@ -284,16 +279,6 @@ func (v *Vaultik) RemoteInfo(jsonOutput bool) error {
return err return err
} }
partialUploads, err := v.listPartialUploads()
if err != nil {
return err
}
for _, object := range partialUploads {
result.PartialUploadCount++
result.PartialUploadSize += object.Size
}
log.Info("Remote info complete", log.Info("Remote info complete",
"snapshots", result.TotalMetadataCount, "snapshots", result.TotalMetadataCount,
"total_blobs", result.TotalBlobCount, "total_blobs", result.TotalBlobCount,
@@ -554,12 +539,6 @@ func (v *Vaultik) printRemoteInfoTable(result *RemoteInfoResult) {
"", "", ubytes(result.TotalMetadataSize)) "", "", ubytes(result.TotalMetadataSize))
} }
v.printRemoteBlobStorage(result)
}
// printRemoteBlobStorage renders the blob storage section of the
// human-readable remote info output.
func (v *Vaultik) printRemoteBlobStorage(result *RemoteInfoResult) {
v.stdoutf("\n=== Blob Storage ===\n") v.stdoutf("\n=== Blob Storage ===\n")
v.stdoutf("Total blobs on remote: %s (%s)\n", v.stdoutf("Total blobs on remote: %s (%s)\n",
humanize.Comma(int64(result.TotalBlobCount)), humanize.Comma(int64(result.TotalBlobCount)),
@@ -573,29 +552,16 @@ func (v *Vaultik) printRemoteBlobStorage(result *RemoteInfoResult) {
"(%d manifest(s) could not be read, "+ "(%d manifest(s) could not be read, "+
"%d manifest(s) under a non-conforming name skipped)\n", "%d manifest(s) under a non-conforming name skipped)\n",
len(result.UnreadableManifests), result.SkippedManifestCount) len(result.UnreadableManifests), result.SkippedManifestCount)
} else {
v.stdoutf("Orphaned (unreferenced): %s (%s)\n", return
humanize.Comma(int64(*result.OrphanedBlobCount)),
ubytes(*result.OrphanedBlobSize))
} }
v.stdoutf("Partial uploads: %s (%s)\n", v.stdoutf("Orphaned (unreferenced): %s (%s)\n",
humanize.Comma(int64(result.PartialUploadCount)), humanize.Comma(int64(*result.OrphanedBlobCount)),
ubytes(result.PartialUploadSize)) ubytes(*result.OrphanedBlobSize))
var toRemove []string if *result.OrphanedBlobCount > 0 {
v.stdoutf("\nRun 'vaultik prune' to remove orphaned blobs.\n")
if result.OrphanedBlobCount != nil && *result.OrphanedBlobCount > 0 {
toRemove = append(toRemove, "orphaned blobs")
}
if result.PartialUploadCount > 0 {
toRemove = append(toRemove, "partial uploads")
}
if len(toRemove) > 0 {
v.stdoutf("\nRun 'vaultik prune' to remove %s.\n",
strings.Join(toRemove, " and "))
} }
} }
+4 -6
View File
@@ -155,12 +155,10 @@ func (m *MockStorer) ListStream(
return ch return ch
} }
// ListPartialUploads finds none: Put stores each object under its key at // DeletePartialUploads has nothing to remove: Put stores each object
// once. // under its key at once.
func (m *MockStorer) ListPartialUploads( func (m *MockStorer) DeletePartialUploads(_ context.Context, _ string) error {
_ context.Context, _ string, return nil
) ([]storage.ObjectInfo, error) {
return nil, nil
} }
func (m *MockStorer) Info() storage.Info { func (m *MockStorer) Info() storage.Info {
+45 -212
View File
@@ -31,11 +31,6 @@ var errBlobDeleteFailed = errors.New("blob(s) could not be deleted")
var errMetadataDirDeleteFailed = errors.New( var errMetadataDirDeleteFailed = errors.New(
"metadata director(ies) with no manifest could not be deleted") "metadata director(ies) with no manifest could not be deleted")
// errPartialUploadDeleteFailed reports `.partial` objects prune could not
// delete.
var errPartialUploadDeleteFailed = errors.New(
"partial upload(s) could not be deleted")
// errObjectsLeft reports objects remote nuke still finds on the backup // errObjectsLeft reports objects remote nuke still finds on the backup
// destination store after deleting. // destination store after deleting.
var errObjectsLeft = errors.New( var errObjectsLeft = errors.New(
@@ -143,9 +138,9 @@ func (v *Vaultik) emptyDestinationStore() error {
// that fails is logged and the others still run; that object then // that fails is logged and the others still run; that object then
// shows up in the listing afterwards. // shows up in the listing afterwards.
func (v *Vaultik) deleteEverythingUnder(prefix string) ([]string, error) { func (v *Vaultik) deleteEverythingUnder(prefix string) ([]string, error) {
keys, err := v.listEverythingUnder(prefix) keys, err := v.Storage.List(v.ctx, prefix)
if err != nil { if err != nil {
return nil, err return nil, fmt.Errorf("listing %s: %w", prefix, err)
} }
for _, key := range keys { for _, key := range keys {
@@ -155,47 +150,19 @@ func (v *Vaultik) deleteEverythingUnder(prefix string) ([]string, error) {
} }
} }
return v.listEverythingUnder(prefix) // The file and rclone listings skip `.partial` objects, so the
} // deletes above never reach them.
err = v.Storage.DeletePartialUploads(v.ctx, prefix)
if err != nil {
return nil, fmt.Errorf("deleting partial uploads: %w", err)
}
// listEverythingUnder returns the key of every object under prefix, left, err := v.Storage.List(v.ctx, prefix)
// including the `.partial` objects left by killed uploads, which the file
// and rclone backends' List skips.
func (v *Vaultik) listEverythingUnder(prefix string) ([]string, error) {
keys, err := v.Storage.List(v.ctx, prefix)
if err != nil { if err != nil {
return nil, fmt.Errorf("listing %s: %w", prefix, err) return nil, fmt.Errorf("listing %s: %w", prefix, err)
} }
partialUploads, err := v.Storage.ListPartialUploads(v.ctx, prefix) return left, nil
if err != nil {
return nil, fmt.Errorf("listing partial uploads under %s: %w",
prefix, err)
}
for _, object := range partialUploads {
keys = append(keys, object.Key)
}
return keys, nil
}
// listPartialUploads returns the `.partial` objects under metadata/ and
// blobs/ left by killed uploads.
func (v *Vaultik) listPartialUploads() ([]storage.ObjectInfo, error) {
var partialUploads []storage.ObjectInfo
for _, prefix := range []string{"metadata/", "blobs/"} {
objects, err := v.Storage.ListPartialUploads(v.ctx, prefix)
if err != nil {
return nil, fmt.Errorf("listing partial uploads under %s: %w",
prefix, err)
}
partialUploads = append(partialUploads, objects...)
}
return partialUploads, nil
} }
// PruneBlobsResult contains the result of a blob prune operation // PruneBlobsResult contains the result of a blob prune operation
@@ -215,19 +182,11 @@ type PruneBlobsResult struct {
// not delete. // not delete.
MetadataDirsDeleted int `json:"metadata_dirs_deleted"` MetadataDirsDeleted int `json:"metadata_dirs_deleted"`
MetadataDirsFailed int `json:"metadata_dirs_failed,omitempty"` MetadataDirsFailed int `json:"metadata_dirs_failed,omitempty"`
// PartialUploadsDeleted counts the `.partial` objects prune deleted,
// and PartialUploadsFailed those it could not delete.
// PartialUploadsTooNew counts those kept for being newer than the
// prune grace period, or of unknown age.
PartialUploadsDeleted int `json:"partial_uploads_deleted"`
PartialUploadsFailed int `json:"partial_uploads_failed,omitempty"`
PartialUploadsTooNew int `json:"partial_uploads_too_new"`
} }
// Prune removes orphaned data from the local index database AND, from the // Prune removes orphaned data from the local index database AND, from the
// backup destination store, unreferenced blobs, the directories under // backup destination store, unreferenced blobs and the directories under
// metadata/ with no manifest and the `.partial` objects left by killed // metadata/ with no manifest. This is the single user-facing prune entry
// uploads. This is the single user-facing prune entry
// point — the split between local and remote cleanup is an // point — the split between local and remote cleanup is an
// implementation detail. Calling code should prefer this method over // implementation detail. Calling code should prefer this method over
// PruneDatabase or PruneBlobs individually unless it specifically wants // PruneDatabase or PruneBlobs individually unless it specifically wants
@@ -255,9 +214,8 @@ func (v *Vaultik) Prune(opts *PruneOptions) error {
return v.PruneBlobs(opts) return v.PruneBlobs(opts)
} }
// PruneBlobs removes unreferenced blobs from storage, each directory // PruneBlobs removes unreferenced blobs from storage, and each directory
// under metadata/ that a backup left with no manifest, and each // under metadata/ that a backup left with no manifest.
// `.partial` object left by a killed upload.
func (v *Vaultik) PruneBlobs(opts *PruneOptions) error { func (v *Vaultik) PruneBlobs(opts *PruneOptions) error {
log.Info("Starting prune operation") log.Info("Starting prune operation")
@@ -284,21 +242,14 @@ func (v *Vaultik) PruneBlobs(opts *PruneOptions) error {
return err return err
} }
partialUploads, partialTooNew, err := v.findOldPartialUploads()
if err != nil {
return err
}
result := &PruneBlobsResult{ result := &PruneBlobsResult{
BlobsFound: len(unreferencedBlobs), BlobsFound: len(unreferencedBlobs),
BlobsTooNew: tooNew, BlobsTooNew: tooNew,
PartialUploadsTooNew: partialTooNew,
} }
v.reportTooNew(result, opts) v.reportBlobsTooNew(tooNew, opts)
if len(unreferencedBlobs) == 0 && len(dirsWithoutManifest) == 0 && if len(unreferencedBlobs) == 0 && len(dirsWithoutManifest) == 0 {
len(partialUploads) == 0 {
log.Info("No unreferenced blobs found") log.Info("No unreferenced blobs found")
if opts.JSON { if opts.JSON {
@@ -312,17 +263,15 @@ func (v *Vaultik) PruneBlobs(opts *PruneOptions) error {
log.Info("Found unreferenced blobs", log.Info("Found unreferenced blobs",
"count", len(unreferencedBlobs), "total_size", ubytes(totalSize), "count", len(unreferencedBlobs), "total_size", ubytes(totalSize),
"metadata_dirs_without_manifest", len(dirsWithoutManifest), "metadata_dirs_without_manifest", len(dirsWithoutManifest))
"partial_uploads", len(partialUploads))
if !v.confirmPrune(opts, len(unreferencedBlobs), totalSize, if !v.confirmPrune(opts, len(unreferencedBlobs), totalSize,
dirsWithoutManifest, partialUploads) { dirsWithoutManifest) {
return ErrNotConfirmed return ErrNotConfirmed
} }
v.deleteUnreferencedBlobs(unreferencedBlobs, allBlobs, result) v.deleteUnreferencedBlobs(unreferencedBlobs, allBlobs, result)
v.deleteMetadataDirs(dirsWithoutManifest, result) v.deleteMetadataDirs(dirsWithoutManifest, result)
v.deletePartialUploads(partialUploads, result)
if opts.JSON { if opts.JSON {
err = v.outputPruneBlobsJSON(result) err = v.outputPruneBlobsJSON(result)
@@ -330,16 +279,9 @@ func (v *Vaultik) PruneBlobs(opts *PruneOptions) error {
return err return err
} }
} else { } else {
v.reportPruneDeletions(result, len(dirsWithoutManifest), v.reportPruneDeletions(result, len(dirsWithoutManifest))
len(partialUploads))
} }
return pruneDeleteFailures(result)
}
// pruneDeleteFailures returns an error for each kind of object prune
// could not delete, or nil when every delete succeeded.
func pruneDeleteFailures(result *PruneBlobsResult) error {
var failures []error var failures []error
if result.BlobsFailed > 0 { if result.BlobsFailed > 0 {
@@ -352,41 +294,26 @@ func pruneDeleteFailures(result *PruneBlobsResult) error {
result.MetadataDirsFailed, errMetadataDirDeleteFailed)) result.MetadataDirsFailed, errMetadataDirDeleteFailed))
} }
if result.PartialUploadsFailed > 0 {
failures = append(failures, fmt.Errorf("%d %w",
result.PartialUploadsFailed, errPartialUploadDeleteFailed))
}
return errors.Join(failures...) return errors.Join(failures...)
} }
// confirmPrune states what prune found to delete, unreferenced blobs, // confirmPrune states what prune found to delete, unreferenced blobs and
// directories under metadata/ with no manifest, naming each directory by // directories under metadata/ with no manifest, naming each directory by
// its remote key, and `.partial` objects, and, unless --force is given, // its remote key, and, unless --force is given, asks the operator to
// asks the operator to confirm. Under --json it prints nothing and does // confirm. Under --json it prints nothing and does not ask. It reports
// not ask. It reports whether to go ahead. // whether to go ahead.
func (v *Vaultik) confirmPrune( func (v *Vaultik) confirmPrune(
opts *PruneOptions, blobCount int, blobsSize int64, dirs []string, opts *PruneOptions, blobCount int, blobsSize int64, dirs []string,
partialUploads []storage.ObjectInfo,
) bool { ) bool {
if opts.JSON { if opts.JSON {
return true return true
} }
var partialSize int64
for _, object := range partialUploads {
partialSize += object.Size
}
dirCount := len(dirs) dirCount := len(dirs)
partialCount := len(partialUploads)
blobsFound := fmt.Sprintf("Found %d unreferenced blob(s) totaling %s.", blobsFound := fmt.Sprintf("Found %d unreferenced blob(s) totaling %s.",
blobCount, ubytes(blobsSize)) blobCount, ubytes(blobsSize))
dirsFound := fmt.Sprintf("Found %d metadata director(ies) left by "+ dirsFound := fmt.Sprintf("Found %d metadata director(ies) left by "+
"backups that stopped before their manifest:", dirCount) "backups that stopped before their manifest:", dirCount)
partialFound := fmt.Sprintf("Found %d partial upload(s) totaling %s, "+
"left by uploads cut off part-way.", partialCount, ubytes(partialSize))
if opts.Force { if opts.Force {
if blobCount > 0 { if blobCount > 0 {
@@ -401,10 +328,6 @@ func (v *Vaultik) confirmPrune(
} }
} }
if partialCount > 0 {
v.UI.Infof("%s", partialFound)
}
return true return true
} }
@@ -423,13 +346,16 @@ func (v *Vaultik) confirmPrune(
} }
} }
if partialCount > 0 { switch {
v.stdoutf("%s\n", partialFound) case dirCount == 0:
v.stdoutf("\nDelete %d unreferenced blob(s)? [y/N] ", blobCount)
case blobCount == 0:
v.stdoutf("\nDelete %d metadata director(ies)? [y/N] ", dirCount)
default:
v.stdoutf("\nDelete %d unreferenced blob(s) and %d metadata "+
"director(ies)? [y/N] ", blobCount, dirCount)
} }
v.stdoutf("\nDelete %s? [y/N] ",
pruneTargets(blobCount, dirCount, partialCount))
var confirm string var confirm string
// A failure to read the answer means no confirmation. // A failure to read the answer means no confirmation.
@@ -443,36 +369,9 @@ func (v *Vaultik) confirmPrune(
return true return true
} }
// pruneTargets names what the prune prompt offers to delete, such as // reportPruneDeletions says how many blobs and metadata directories
// "2 unreferenced blob(s) and 1 partial upload(s)", leaving out each kind // prune deleted, naming each kind only when it found some to delete.
// with a count of zero. func (v *Vaultik) reportPruneDeletions(result *PruneBlobsResult, dirCount int) {
func pruneTargets(blobCount, dirCount, partialCount int) string {
var targets []string
if blobCount > 0 {
targets = append(targets,
fmt.Sprintf("%d unreferenced blob(s)", blobCount))
}
if dirCount > 0 {
targets = append(targets,
fmt.Sprintf("%d metadata director(ies)", dirCount))
}
if partialCount > 0 {
targets = append(targets,
fmt.Sprintf("%d partial upload(s)", partialCount))
}
return strings.Join(targets, " and ")
}
// reportPruneDeletions says how many blobs, metadata directories and
// partial uploads prune deleted, naming each kind only when it found some
// to delete.
func (v *Vaultik) reportPruneDeletions(
result *PruneBlobsResult, dirCount, partialCount int,
) {
if result.BlobsFound > 0 { if result.BlobsFound > 0 {
v.UI.Infof("Deleted %d blob(s) totaling %s.", v.UI.Infof("Deleted %d blob(s) totaling %s.",
result.BlobsDeleted, ubytes(result.BytesFreed)) result.BlobsDeleted, ubytes(result.BytesFreed))
@@ -482,11 +381,6 @@ func (v *Vaultik) reportPruneDeletions(
v.UI.Infof("Deleted %d metadata director(ies) with no manifest.", v.UI.Infof("Deleted %d metadata director(ies) with no manifest.",
result.MetadataDirsDeleted) result.MetadataDirsDeleted)
} }
if partialCount > 0 {
v.UI.Infof("Deleted %d partial upload(s).",
result.PartialUploadsDeleted)
}
} }
// listMetadataObjects lists every object under metadata/ on the // listMetadataObjects lists every object under metadata/ on the
@@ -717,79 +611,18 @@ func (v *Vaultik) deleteMetadataDirs(
} }
} }
// reportTooNew says how many unreferenced blobs and partial uploads prune // reportBlobsTooNew says how many unreferenced blobs prune kept for being
// kept for being newer than the grace period or of unknown age. Under // newer than the grace period or of unknown age. Under --json the
// --json the document carries the counts instead. // document carries the count instead.
func (v *Vaultik) reportTooNew(result *PruneBlobsResult, opts *PruneOptions) { func (v *Vaultik) reportBlobsTooNew(tooNew int, opts *PruneOptions) {
if opts.JSON { if tooNew == 0 || opts.JSON {
return return
} }
if result.BlobsTooNew > 0 { v.UI.Infof("Kept %d unreferenced blob(s) newer than "+
v.UI.Infof("Kept %d unreferenced blob(s) newer than "+ "prune_grace_period (%s), or of unknown age: a backup still "+
"prune_grace_period (%s), or of unknown age: a backup still "+ "running may need them.",
"running may need them.", tooNew, v.Config.PruneGracePeriod)
result.BlobsTooNew, v.Config.PruneGracePeriod)
}
if result.PartialUploadsTooNew > 0 {
v.UI.Infof("Kept %d partial upload(s) newer than "+
"prune_grace_period (%s), or of unknown age: an upload may "+
"still be writing them.",
result.PartialUploadsTooNew, v.Config.PruneGracePeriod)
}
}
// findOldPartialUploads returns the `.partial` objects under metadata/
// and blobs/ that are older than the prune grace period. It also returns
// how many it left out for being newer than that, or of unknown age
// because the listing gave no time for them.
func (v *Vaultik) findOldPartialUploads() ([]storage.ObjectInfo, int, error) {
partialUploads, err := v.listPartialUploads()
if err != nil {
return nil, 0, err
}
cutoff := time.Now().UTC().Add(-v.Config.PruneGracePeriod)
var (
old []storage.ObjectInfo
tooNew int
)
for _, object := range partialUploads {
if object.ModTime.IsZero() || object.ModTime.After(cutoff) {
tooNew++
continue
}
old = append(old, object)
}
return old, tooNew, nil
}
// deletePartialUploads deletes the given `.partial` objects and counts
// in the result those deleted and those it could not delete.
func (v *Vaultik) deletePartialUploads(
partialUploads []storage.ObjectInfo, result *PruneBlobsResult,
) {
for _, object := range partialUploads {
err := v.Storage.Delete(v.ctx, object.Key)
if err != nil {
log.Error("Failed to delete partial upload",
"key", object.Key, "error", err)
result.PartialUploadsFailed++
continue
}
log.Info("Deleted partial upload", "key", object.Key)
result.PartialUploadsDeleted++
}
} }
// deleteUnreferencedBlobs deletes the given blobs from storage and // deleteUnreferencedBlobs deletes the given blobs from storage and
@@ -1,157 +0,0 @@
package vaultik_test
import (
"bytes"
"context"
"encoding/json"
"os"
"path/filepath"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"sneak.berlin/go/vaultik/internal/config"
"sneak.berlin/go/vaultik/internal/log"
"sneak.berlin/go/vaultik/internal/storage"
"sneak.berlin/go/vaultik/internal/storage/faultstore"
"sneak.berlin/go/vaultik/internal/ui"
"sneak.berlin/go/vaultik/internal/vaultik"
)
// partialUploadGracePeriod is the prune grace period of the vaultik
// newPartialUploadStore returns.
const partialUploadGracePeriod = time.Hour
// newPartialUploadStore returns a vaultik on a file:// destination
// holding `.partial` files left by killed uploads: one under blobs/
// and one under metadata/ older than the prune grace period, and one
// under blobs/ newer than that. It also returns the buffer the vaultik
// writes its output to, the paths of the old files and the path of the
// new one.
func newPartialUploadStore(
t *testing.T,
) (*vaultik.Vaultik, *bytes.Buffer, []string, string) {
t.Helper()
storeDir := t.TempDir()
store, err := storage.NewFileStorer(storeDir)
require.NoError(t, err)
hash := testBlobHashA
oldFiles := []string{
filepath.Join(storeDir, "blobs", hash[:2], hash[2:4],
hash+"-123456.partial"),
filepath.Join(storeDir, metadataObjectKey(
"testhost_home_2026-01-01T00:00:00Z", "db.zst.age-123456.partial")),
}
newFile := filepath.Join(storeDir, "blobs", hash[:2], hash[2:4],
hash+"-654321.partial")
beforeGracePeriod := time.Now().Add(-partialUploadGracePeriod - time.Minute)
for _, path := range append([]string{newFile}, oldFiles...) {
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o750))
require.NoError(t, os.WriteFile(path, []byte("half an upload"), 0o600))
}
for _, path := range oldFiles {
require.NoError(t, os.Chtimes(path, beforeGracePeriod, beforeGracePeriod))
}
stdout := &bytes.Buffer{}
v := &vaultik.Vaultik{
Config: &config.Config{PruneGracePeriod: partialUploadGracePeriod},
Storage: store,
Stdout: stdout,
UI: ui.NewWithColor(stdout, false),
}
v.SetContext(context.Background())
return v, stdout, oldFiles, newFile
}
// TestPruneDeletesPartialUploadsOlderThanGracePeriod checks that prune
// deletes a `.partial` file under blobs/ or metadata/ left by a killed
// upload once it is older than the grace period, keeps a newer one,
// and counts both in the --json document.
func TestPruneDeletesPartialUploadsOlderThanGracePeriod(t *testing.T) {
log.Initialize(log.Config{})
t.Parallel()
v, stdout, oldFiles, newFile := newPartialUploadStore(t)
require.NoError(t, v.PruneBlobs(&vaultik.PruneOptions{JSON: true}))
for _, path := range oldFiles {
_, err := os.Stat(path)
require.ErrorIs(t, err, os.ErrNotExist, "%s must be deleted", path)
}
_, err := os.Stat(newFile)
require.NoError(t, err, "a partial upload newer than the grace period "+
"must be kept")
var result vaultik.PruneBlobsResult
require.NoError(t, json.Unmarshal(stdout.Bytes(), &result))
assert.Equal(t, 2, result.PartialUploadsDeleted)
assert.Equal(t, 1, result.PartialUploadsTooNew)
}
// TestPruneFailedPartialUploadDeleteReturnsError checks that prune
// returns an error, and counts the failures in the --json document, when
// the `.partial` files it found cannot be deleted.
func TestPruneFailedPartialUploadDeleteReturnsError(t *testing.T) {
log.Initialize(log.Config{})
t.Parallel()
v, stdout, oldFiles, _ := newPartialUploadStore(t)
store := faultstore.New(v.Storage)
store.OnDelete = func(string) bool { return true }
v.Storage = store
err := v.PruneBlobs(&vaultik.PruneOptions{JSON: true})
require.ErrorContains(t, err, "2 partial upload(s) could not be deleted")
for _, path := range oldFiles {
_, statErr := os.Stat(path)
require.NoError(t, statErr, "%s must still exist", path)
}
var result vaultik.PruneBlobsResult
require.NoError(t, json.Unmarshal(stdout.Bytes(), &result),
"stdout must hold the JSON document, got:\n%s", stdout.String())
assert.Equal(t, 2, result.PartialUploadsFailed)
assert.Equal(t, 0, result.PartialUploadsDeleted)
}
// TestRemoteInfoCountsPartialUploads checks that remote info counts
// every `.partial` file under blobs/ and metadata/, whatever its age, and
// advises running prune.
func TestRemoteInfoCountsPartialUploads(t *testing.T) {
log.Initialize(log.Config{})
t.Parallel()
v, stdout, _, _ := newPartialUploadStore(t)
require.NoError(t, v.RemoteInfo(true))
var result vaultik.RemoteInfoResult
require.NoError(t, json.Unmarshal(stdout.Bytes(), &result))
assert.Equal(t, 3, result.PartialUploadCount)
assert.Equal(t, int64(3*len("half an upload")), result.PartialUploadSize)
assert.Equal(t, 0, result.TotalBlobCount)
stdout.Reset()
require.NoError(t, v.RemoteInfo(false))
text := stdout.String()
assert.Contains(t, text, "Partial uploads: 3 (")
assert.Contains(t, text, "Run 'vaultik prune' to remove partial uploads.")
}
+4 -6
View File
@@ -136,12 +136,10 @@ func (s *testStorer) ListStream(
return ch return ch
} }
// ListPartialUploads finds none: Put stores each object under its key at // DeletePartialUploads has nothing to remove: Put stores each object
// once. // under its key at once.
func (s *testStorer) ListPartialUploads( func (s *testStorer) DeletePartialUploads(_ context.Context, _ string) error {
_ context.Context, _ string, return nil
) ([]storage.ObjectInfo, error) {
return nil, nil
} }
func (s *testStorer) Info() storage.Info { func (s *testStorer) Info() storage.Info {
+4 -4
View File
@@ -302,10 +302,10 @@ func (v *Vaultik) snapshotNamesToCreate(requested []string) ([]string, error) {
} }
// runPostBackupPrune drops older snapshots of the given names and removes // runPostBackupPrune drops older snapshots of the given names and removes
// from remote storage the orphan blobs, the directories under metadata/ // from remote storage the orphan blobs and the directories under
// with no manifest and the `.partial` objects, as PruneBlobs does. If // metadata/ with no manifest, as PruneBlobs does. If keepNewerThan is set
// keepNewerThan is set (e.g. "4w"), snapshots newer than that duration are // (e.g. "4w"), snapshots newer than that duration are kept. Otherwise only
// kept. Otherwise only the latest snapshot of each name is kept. // the latest snapshot of each name is kept.
func (v *Vaultik) runPostBackupPrune( func (v *Vaultik) runPostBackupPrune(
snapshotNames []string, keepNewerThan string, snapshotNames []string, keepNewerThan string,
) error { ) error {
@@ -4,6 +4,7 @@ import (
"context" "context"
"maps" "maps"
"path/filepath" "path/filepath"
"strings"
"testing" "testing"
"github.com/spf13/afero" "github.com/spf13/afero"
@@ -12,6 +13,7 @@ import (
"sneak.berlin/go/vaultik/internal/database" "sneak.berlin/go/vaultik/internal/database"
"sneak.berlin/go/vaultik/internal/log" "sneak.berlin/go/vaultik/internal/log"
"sneak.berlin/go/vaultik/internal/storage" "sneak.berlin/go/vaultik/internal/storage"
"sneak.berlin/go/vaultik/internal/storage/faultstore"
"sneak.berlin/go/vaultik/internal/vaultik" "sneak.berlin/go/vaultik/internal/vaultik"
) )
@@ -68,3 +70,55 @@ func TestBackupWithoutCronOfTwoPathSnapshotRestoresBothPaths(t *testing.T) {
assertRestoredTree(t, fs, restoreDir, files) assertRestoredTree(t, fs, restoreDir, files)
} }
// A backup without --cron whose blob uploads keep failing stops with the
// upload's error, and stops the progress reporter once. See
// https://git.eeqj.de/sneak/vaultik/issues/476.
//
//nolint:paralleltest // installs the global logger via log.Initialize
func TestBackupWithoutCronStopsWithBlobUploadError(t *testing.T) {
log.Initialize(log.Config{})
const snapshotName = "data"
fs := afero.NewOsFs()
tempDir := t.TempDir()
firstDir := filepath.Join(tempDir, "first")
secondDir := filepath.Join(tempDir, "second")
dbPath := filepath.Join(tempDir, "index.sqlite")
ctx := context.Background()
writeFaultSourceTree(t, fs, firstDir)
writeFaultSourceTree(t, fs, secondDir)
cfg := faultTestConfig()
cfg.IndexPath = dbPath
cfg.ChunkSize = config.Size(faultChunkSize)
cfg.Snapshots = map[string]config.SnapshotConfig{
snapshotName: {Paths: []string{firstDir, secondDir}},
}
inner, err := storage.NewFileStorer(t.TempDir())
require.NoError(t, err)
store := faultstore.New(inner)
store.OnPut = func(key string) faultstore.PutAction {
if strings.HasPrefix(key, "blobs/") {
return faultstore.PutFail
}
return faultstore.PutNormal
}
db, err := database.New(ctx, dbPath)
require.NoError(t, err)
t.Cleanup(func() { _ = db.Close() })
v := newBackupVaultik(ctx, cfg, store, database.NewRepositories(db), db, fs)
err = v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
Snapshots: []string{snapshotName},
})
require.ErrorIs(t, err, faultstore.ErrInjectedUpload)
}