From fe25eff9ae9eb5a289bb0e217a6fdd77becac59b Mon Sep 17 00:00:00 2001 From: sneak Date: Thu, 19 Nov 2026 07:34:49 +0000 Subject: [PATCH] Refuse a relative path on an rclone remote of type local (closes #465) 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 --- README.md | 6 ++- internal/storage/rclone.go | 23 +++++++++++ internal/storage/rclone_test.go | 73 +++++++++++++++++++++++++++++++++ 3 files changed, 101 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index d6d7601..8d9e77e 100644 --- a/README.md +++ b/README.md @@ -602,7 +602,11 @@ only `vaultik-destination.txt` stops such a backup, and only while the local index holds snapshots. **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 shows an object only once its upload has completed, and on the local filesystem diff --git a/internal/storage/rclone.go b/internal/storage/rclone.go index 39413cb..d4d45fc 100644 --- a/internal/storage/rclone.go +++ b/internal/storage/rclone.go @@ -8,6 +8,7 @@ import ( "fmt" "io" "os" + "path/filepath" "strings" "time" @@ -23,6 +24,15 @@ import ( // ErrRemoteNotFound is returned when an rclone remote is not configured. 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. // This allows vaultik to use any of rclone's 70+ supported storage providers. type RcloneStorer struct { @@ -53,6 +63,19 @@ func NewRcloneStorer(ctx context.Context, remote, path string) (*RcloneStorer, e 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 // each object's metadata, which costs one request per object to read. // rclone's use_server_modtime setting makes ModTime the time the diff --git a/internal/storage/rclone_test.go b/internal/storage/rclone_test.go index 32ac7a2..9eaf238 100644 --- a/internal/storage/rclone_test.go +++ b/internal/storage/rclone_test.go @@ -436,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 // 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 -- 2.54.0