From fb33bcf6b1bed45475662cc0394654446c21fb4c Mon Sep 17 00:00:00 2001 From: sneak Date: Mon, 16 Nov 2026 23:12:29 +0000 Subject: [PATCH 1/3] Let snapshot remove accept a remote-only snapshot's remote key (closes #400) snapshot remove hashed its argument into a remote key, so the remote key that snapshot list shows for a remote-only snapshot never matched. A remote key or a leading part of it is now resolved with resolveSnapshotRemoteKey, as snapshot verify and snapshot restore do. Model: opus-5-5 --- README.md | 10 +++++--- internal/cli/snapshot.go | 6 +++-- internal/vaultik/remove_snapshot_test.go | 32 ++++++++++++++++++++++++ internal/vaultik/snapshot.go | 32 ++++++++++++++++++------ 4 files changed, 67 insertions(+), 13 deletions(-) diff --git a/README.md b/README.md index 9879211..d6d7601 100644 --- a/README.md +++ b/README.md @@ -468,10 +468,12 @@ destination store. Blobs are NOT touched — deleting blobs requires reading eve remaining remote manifest (the destination store may hold snapshots this host doesn't know about), which is what `vaultik prune` does. The command prints the `vaultik prune` invocation to run as a follow-up only when it removed the -snapshot's metadata from the destination store, and never under `--json`. An ID -that names no snapshot in the local index or on the destination store is an -error; with `--local-only`, the snapshot must be in the local index. Local row -cleanup (files, chunks, blobs the snapshot was the last referrer for) runs +snapshot's metadata from the destination store, and never under `--json`. It +accepts the same identifiers as `snapshot restore`: a snapshot ID, or a +remote-only snapshot's remote key (or an unambiguous leading part of it). An +identifier that names no snapshot in the local index or on the destination store +is an error; with `--local-only`, the snapshot must be in the local index. Local +row cleanup (files, chunks, blobs the snapshot was the last referrer for) runs automatically. If removing the snapshot's metadata from the destination store fails (for example because the store is unreachable, or the local index holds snapshots and the destination answers that it has no `vaultik-destination.txt`), diff --git a/internal/cli/snapshot.go b/internal/cli/snapshot.go index 5fb5278..04214cd 100644 --- a/internal/cli/snapshot.go +++ b/internal/cli/snapshot.go @@ -331,8 +331,10 @@ know about), which is what 'vaultik prune' does. The command prints the 'vaultik prune' invocation to run as a follow-up only when it removed the snapshot's metadata from the destination store, and never under --json. -An ID that names no snapshot in the local index or on the destination -store is an error. +The snapshot may be named by its ID or, on a host with no local index, +by the remote key that 'snapshot list' prints for a remote-only snapshot +(an unambiguous leading part is enough). An identifier that names no +snapshot in the local index or on the destination store is an error. Use --local-only to skip the remote half (e.g. when you want to forget a snapshot locally without touching the destination store); the snapshot diff --git a/internal/vaultik/remove_snapshot_test.go b/internal/vaultik/remove_snapshot_test.go index ea88183..919f989 100644 --- a/internal/vaultik/remove_snapshot_test.go +++ b/internal/vaultik/remove_snapshot_test.go @@ -472,6 +472,38 @@ func TestRemoveSnapshot_NotInLocalIndex(t *testing.T) { assert.Contains(t, out, "Removed snapshot metadata from remote storage") } +// TestRemoveSnapshot_ByRemoteKey checks that a snapshot only the +// destination store holds can be removed by the remote key that +// `snapshot list` shows for it, or by a leading part of that key. +func TestRemoveSnapshot_ByRemoteKey(t *testing.T) { + log.Initialize(log.Config{}) + t.Parallel() + + remoteKey := snapshot.RemoteSnapshotKey("snapshot-001") + + for name, identifier := range map[string]string{ + "full key": remoteKey, + "leading part": remoteKey[:8], + } { + t.Run(name, func(t *testing.T) { + t.Parallel() + + store := newTestStorer() + addManifest(t, store, "snapshot-001", nil) + + tv := vaultik.NewForTesting(store) + tv.Repositories = newLocalIndex(t) + + result, err := tv.RemoveSnapshot(identifier, + &vaultik.RemoveOptions{Force: true}) + + require.NoError(t, err) + assert.True(t, result.RemoteRemoved) + assert.False(t, store.hasKey(remoteKeyPath("snapshot-001"))) + }) + } +} + // TestRemoveSnapshot_NotInLocalIndexDeleteFails checks that removing a // snapshot only the destination store holds fails when its metadata // cannot be deleted there, under --force and under --json: nothing was diff --git a/internal/vaultik/snapshot.go b/internal/vaultik/snapshot.go index 34c7827..96267df 100644 --- a/internal/vaultik/snapshot.go +++ b/internal/vaultik/snapshot.go @@ -1467,7 +1467,8 @@ func (v *Vaultik) RemoveSnapshot( return result, err } - inLocalIndex, err := v.checkSnapshotExists(snapshotID, opts.LocalOnly) + remoteKey, inLocalIndex, err := v.findSnapshotToRemove( + snapshotID, opts.LocalOnly) if err != nil { return result, err } @@ -1498,7 +1499,7 @@ func (v *Vaultik) RemoveSnapshot( } result.RemoteRemoved, err = v.removeSnapshotRemote( - snapshotID, inLocalIndex, markerErr, opts) + snapshotID, remoteKey, inLocalIndex, markerErr, opts) if err != nil { return result, err } @@ -1530,6 +1531,24 @@ func (v *Vaultik) RemoveSnapshot( return result, nil } +// findSnapshotToRemove returns the remote key of the snapshot that +// identifier names, and whether the local index holds it. A remote key, +// or the leading part of one, names a snapshot only on the destination +// store, so the local index never holds it. +func (v *Vaultik) findSnapshotToRemove( + identifier string, localOnly bool, +) (string, bool, error) { + if isRemoteKeyOrPrefix(identifier) && !localOnly { + remoteKey, err := v.resolveSnapshotRemoteKey(identifier) + + return remoteKey, false, err + } + + inLocalIndex, err := v.checkSnapshotExists(identifier, localOnly) + + return snapshot.RemoteSnapshotKey(identifier), inLocalIndex, err +} + // checkSnapshotExists returns errSnapshotNotFound when the local index // has no row for snapshotID and, unless localOnly is set, the // destination store has no metadata for it either. inLocalIndex reports @@ -1638,8 +1657,8 @@ func (v *Vaultik) confirmRemoveSnapshot(snapshotID string, opts *RemoveOptions) return true } -// removeSnapshotRemote strips the snapshot's metadata from the -// destination store. It returns true only when the delete finished +// removeSnapshotRemote strips the snapshot's metadata, under remoteKey, +// from the destination store. It returns true only when the delete finished // without an error and removed at least one object; under LocalOnly it // does nothing. markerErr is the result of checkDestinationMarker; when // it is set, nothing is deleted and it is the failure. When the snapshot @@ -1651,7 +1670,7 @@ func (v *Vaultik) confirmRemoveSnapshot(snapshotID string, opts *RemoveOptions) // (`vaultik prune` never removes snapshot metadata that has its // manifest). func (v *Vaultik) removeSnapshotRemote( - snapshotID string, inLocalIndex bool, markerErr error, + snapshotID, remoteKey string, inLocalIndex bool, markerErr error, opts *RemoveOptions, ) (bool, error) { if opts.LocalOnly { @@ -1665,8 +1684,7 @@ func (v *Vaultik) removeSnapshotRemote( err := markerErr if err == nil { - deleted, err = v.deleteRemoteSnapshotByKey( - snapshot.RemoteSnapshotKey(snapshotID)) + deleted, err = v.deleteRemoteSnapshotByKey(remoteKey) } if err != nil && !inLocalIndex { -- 2.54.0 From 3af64c829ceaca9fa8cac7d0664e7bc14dc6fa6a Mon Sep 17 00:00:00 2001 From: clawbot <35+clawbot@noreply.example.org> Date: Mon, 16 Nov 2026 23:38:11 +0000 Subject: [PATCH 2/3] Remove a local snapshot fully when named by its remote key snapshot remove treated every remote key as naming a snapshot only on the destination store. Given the remote key of a snapshot the local index holds, it deleted the remote metadata and left the local row. findSnapshotToRemove now returns that snapshot's ID, so it is removed from both. Model: opus-5-5 --- internal/vaultik/remove_snapshot_test.go | 30 ++++++++++++++++++ internal/vaultik/snapshot.go | 39 +++++++++++++++++------- 2 files changed, 58 insertions(+), 11 deletions(-) diff --git a/internal/vaultik/remove_snapshot_test.go b/internal/vaultik/remove_snapshot_test.go index 919f989..df0f202 100644 --- a/internal/vaultik/remove_snapshot_test.go +++ b/internal/vaultik/remove_snapshot_test.go @@ -504,6 +504,36 @@ func TestRemoveSnapshot_ByRemoteKey(t *testing.T) { } } +// TestRemoveSnapshot_ByRemoteKeyInLocalIndex checks that a snapshot the +// local index holds, named by its remote key, is removed from the local +// index as well as from the destination store. +func TestRemoveSnapshot_ByRemoteKeyInLocalIndex(t *testing.T) { + log.Initialize(log.Config{}) + t.Parallel() + + store := newTestStorer() + addManifest(t, store, "snapshot-001", nil) + + // A backup wrote to this destination, so it carries the marker. + require.NoError(t, store.Put(context.Background(), markerFile, + bytes.NewReader(nil))) + + tv := vaultik.NewForTesting(store) + tv.Repositories = newLocalIndex(t, "snapshot-001") + + result, err := tv.RemoveSnapshot(snapshot.RemoteSnapshotKey("snapshot-001"), + &vaultik.RemoveOptions{Force: true}) + + require.NoError(t, err) + assert.True(t, result.RemoteRemoved) + assert.False(t, store.hasKey(remoteKeyPath("snapshot-001"))) + + snap, err := tv.Repositories.Snapshots.GetByID(context.Background(), + "snapshot-001") + require.NoError(t, err) + assert.Nil(t, snap) +} + // TestRemoveSnapshot_NotInLocalIndexDeleteFails checks that removing a // snapshot only the destination store holds fails when its metadata // cannot be deleted there, under --force and under --json: nothing was diff --git a/internal/vaultik/snapshot.go b/internal/vaultik/snapshot.go index 96267df..ae95c93 100644 --- a/internal/vaultik/snapshot.go +++ b/internal/vaultik/snapshot.go @@ -1467,7 +1467,7 @@ func (v *Vaultik) RemoveSnapshot( return result, err } - remoteKey, inLocalIndex, err := v.findSnapshotToRemove( + snapshotID, remoteKey, inLocalIndex, err := v.findSnapshotToRemove( snapshotID, opts.LocalOnly) if err != nil { return result, err @@ -1531,22 +1531,39 @@ func (v *Vaultik) RemoveSnapshot( return result, nil } -// findSnapshotToRemove returns the remote key of the snapshot that -// identifier names, and whether the local index holds it. A remote key, -// or the leading part of one, names a snapshot only on the destination -// store, so the local index never holds it. +// findSnapshotToRemove returns the ID of the snapshot that identifier +// names, its remote key, and whether the local index holds it. A remote +// key, or the leading part of one, is resolved on the destination store; +// when the local index holds the snapshot with that key, its ID is +// returned, so it is removed from both. func (v *Vaultik) findSnapshotToRemove( identifier string, localOnly bool, -) (string, bool, error) { - if isRemoteKeyOrPrefix(identifier) && !localOnly { - remoteKey, err := v.resolveSnapshotRemoteKey(identifier) +) (string, string, bool, error) { + if !isRemoteKeyOrPrefix(identifier) || localOnly { + inLocalIndex, err := v.checkSnapshotExists(identifier, localOnly) - return remoteKey, false, err + return identifier, snapshot.RemoteSnapshotKey(identifier), + inLocalIndex, err } - inLocalIndex, err := v.checkSnapshotExists(identifier, localOnly) + remoteKey, err := v.resolveSnapshotRemoteKey(identifier) + if err != nil { + return "", "", false, err + } - return snapshot.RemoteSnapshotKey(identifier), inLocalIndex, err + localIDs, err := v.localSnapshotIDs() + if err != nil { + return "", "", false, fmt.Errorf( + "looking up snapshot in local index: %w", err) + } + + for _, id := range localIDs { + if snapshot.RemoteSnapshotKey(id) == remoteKey { + return id, remoteKey, true, nil + } + } + + return identifier, remoteKey, false, nil } // checkSnapshotExists returns errSnapshotNotFound when the local index -- 2.54.0 From afcf138c298b1fcbf6999fb5967bbb1412398a82 Mon Sep 17 00:00:00 2001 From: clawbot <35+clawbot@noreply.example.org> Date: Mon, 16 Nov 2026 23:38:12 +0000 Subject: [PATCH 3/3] Correct snapshot remove --help on remote keys The help said a remote key is accepted only on a host with no local index; a remote-only snapshot's key is accepted on any host. Model: opus-5-5 --- internal/cli/snapshot.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/internal/cli/snapshot.go b/internal/cli/snapshot.go index 04214cd..86ac329 100644 --- a/internal/cli/snapshot.go +++ b/internal/cli/snapshot.go @@ -331,10 +331,10 @@ know about), which is what 'vaultik prune' does. The command prints the 'vaultik prune' invocation to run as a follow-up only when it removed the snapshot's metadata from the destination store, and never under --json. -The snapshot may be named by its ID or, on a host with no local index, -by the remote key that 'snapshot list' prints for a remote-only snapshot -(an unambiguous leading part is enough). An identifier that names no -snapshot in the local index or on the destination store is an error. +The snapshot may be named by its ID or by its remote key, which +'snapshot list' prints for a remote-only snapshot. An unambiguous +leading part of the key is enough. An identifier that names no snapshot +in the local index or on the destination store is an error. Use --local-only to skip the remote half (e.g. when you want to forget a snapshot locally without touching the destination store); the snapshot -- 2.54.0