Moves files

internal/backend/local/config.go

@@ -0,0 +1,27 @@
+package local
+
+import (
+	"strings"
+
+	"restic/errors"
+	"restic/options"
+)
+
+// Config holds all information needed to open a local repository.
+type Config struct {
+	Path   string
+	Layout string `option:"layout" help:"use this backend directory layout (default: auto-detect)"`
+}
+
+func init() {
+	options.Register("local", Config{})
+}
+
+// ParseConfig parses a local backend config.
+func ParseConfig(cfg string) (interface{}, error) {
+	if !strings.HasPrefix(cfg, "local:") {
+		return nil, errors.New(`invalid format, prefix "local" not found`)
+	}
+
+	return Config{Path: cfg[6:]}, nil
+}

internal/backend/local/doc.go

@@ -0,0 +1,2 @@
+// Package local implements repository storage in a local directory.
+package local

internal/backend/local/layout_test.go

@@ -0,0 +1,80 @@
+package local
+
+import (
+	"context"
+	"path/filepath"
+	"restic"
+	. "restic/test"
+	"testing"
+)
+
+func TestLayout(t *testing.T) {
+	path, cleanup := TempDir(t)
+	defer cleanup()
+
+	var tests = []struct {
+		filename        string
+		layout          string
+		failureExpected bool
+		datafiles       map[string]bool
+	}{
+		{"repo-layout-default.tar.gz", "", false, map[string]bool{
+			"aa464e9fd598fe4202492ee317ffa728e82fa83a1de1a61996e5bd2d6651646c": false,
+			"fc919a3b421850f6fa66ad22ebcf91e433e79ffef25becf8aef7c7b1eca91683": false,
+			"c089d62788da14f8b7cbf77188305c0874906f0b73d3fce5a8869050e8d0c0e1": false,
+		}},
+		{"repo-layout-s3legacy.tar.gz", "", false, map[string]bool{
+			"fc919a3b421850f6fa66ad22ebcf91e433e79ffef25becf8aef7c7b1eca91683": false,
+			"c089d62788da14f8b7cbf77188305c0874906f0b73d3fce5a8869050e8d0c0e1": false,
+			"aa464e9fd598fe4202492ee317ffa728e82fa83a1de1a61996e5bd2d6651646c": false,
+		}},
+	}
+
+	for _, test := range tests {
+		t.Run(test.filename, func(t *testing.T) {
+			SetupTarTestFixture(t, path, filepath.Join("..", "testdata", test.filename))
+
+			repo := filepath.Join(path, "repo")
+			be, err := Open(Config{
+				Path:   repo,
+				Layout: test.layout,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if be == nil {
+				t.Fatalf("Open() returned nil but no error")
+			}
+
+			datafiles := make(map[string]bool)
+			for id := range be.List(context.TODO(), restic.DataFile) {
+				datafiles[id] = false
+			}
+
+			if len(datafiles) == 0 {
+				t.Errorf("List() returned zero data files")
+			}
+
+			for id := range test.datafiles {
+				if _, ok := datafiles[id]; !ok {
+					t.Errorf("datafile with id %v not found", id)
+				}
+
+				datafiles[id] = true
+			}
+
+			for id, v := range datafiles {
+				if !v {
+					t.Errorf("unexpected id %v found", id)
+				}
+			}
+
+			if err = be.Close(); err != nil {
+				t.Errorf("Close() returned error %v", err)
+			}
+
+			RemoveAll(t, filepath.Join(path, "repo"))
+		})
+	}
+}

internal/backend/local/local.go

@@ -0,0 +1,256 @@
+package local
+
+import (
+	"context"
+	"io"
+	"os"
+	"path/filepath"
+	"restic"
+
+	"restic/errors"
+
+	"restic/backend"
+	"restic/debug"
+	"restic/fs"
+)
+
+// Local is a backend in a local directory.
+type Local struct {
+	Config
+	backend.Layout
+}
+
+// ensure statically that *Local implements restic.Backend.
+var _ restic.Backend = &Local{}
+
+const defaultLayout = "default"
+
+// Open opens the local backend as specified by config.
+func Open(cfg Config) (*Local, error) {
+	debug.Log("open local backend at %v (layout %q)", cfg.Path, cfg.Layout)
+	l, err := backend.ParseLayout(&backend.LocalFilesystem{}, cfg.Layout, defaultLayout, cfg.Path)
+	if err != nil {
+		return nil, err
+	}
+
+	be := &Local{Config: cfg, Layout: l}
+
+	// create paths for data and refs. MkdirAll does nothing if the directory already exists.
+	for _, d := range be.Paths() {
+		err := fs.MkdirAll(d, backend.Modes.Dir)
+		if err != nil {
+			return nil, errors.Wrap(err, "MkdirAll")
+		}
+	}
+
+	return be, nil
+}
+
+// Create creates all the necessary files and directories for a new local
+// backend at dir. Afterwards a new config blob should be created.
+func Create(cfg Config) (*Local, error) {
+	debug.Log("create local backend at %v (layout %q)", cfg.Path, cfg.Layout)
+
+	l, err := backend.ParseLayout(&backend.LocalFilesystem{}, cfg.Layout, defaultLayout, cfg.Path)
+	if err != nil {
+		return nil, err
+	}
+
+	be := &Local{
+		Config: cfg,
+		Layout: l,
+	}
+
+	// test if config file already exists
+	_, err = fs.Lstat(be.Filename(restic.Handle{Type: restic.ConfigFile}))
+	if err == nil {
+		return nil, errors.New("config file already exists")
+	}
+
+	// create paths for data and refs
+	for _, d := range be.Paths() {
+		err := fs.MkdirAll(d, backend.Modes.Dir)
+		if err != nil {
+			return nil, errors.Wrap(err, "MkdirAll")
+		}
+	}
+
+	return be, nil
+}
+
+// Location returns this backend's location (the directory name).
+func (b *Local) Location() string {
+	return b.Path
+}
+
+// IsNotExist returns true if the error is caused by a non existing file.
+func (b *Local) IsNotExist(err error) bool {
+	return os.IsNotExist(errors.Cause(err))
+}
+
+// Save stores data in the backend at the handle.
+func (b *Local) Save(ctx context.Context, h restic.Handle, rd io.Reader) (err error) {
+	debug.Log("Save %v", h)
+	if err := h.Valid(); err != nil {
+		return err
+	}
+
+	filename := b.Filename(h)
+
+	// create new file
+	f, err := fs.OpenFile(filename, os.O_CREATE|os.O_EXCL|os.O_WRONLY, backend.Modes.File)
+	if err != nil {
+		return errors.Wrap(err, "OpenFile")
+	}
+
+	// save data, then sync
+	_, err = io.Copy(f, rd)
+	if err != nil {
+		_ = f.Close()
+		return errors.Wrap(err, "Write")
+	}
+
+	if err = f.Sync(); err != nil {
+		_ = f.Close()
+		return errors.Wrap(err, "Sync")
+	}
+
+	err = f.Close()
+	if err != nil {
+		return errors.Wrap(err, "Close")
+	}
+
+	// set mode to read-only
+	fi, err := fs.Stat(filename)
+	if err != nil {
+		return errors.Wrap(err, "Stat")
+	}
+
+	return setNewFileMode(filename, fi)
+}
+
+// Load returns a reader that yields the contents of the file at h at the
+// given offset. If length is nonzero, only a portion of the file is
+// returned. rd must be closed after use.
+func (b *Local) Load(ctx context.Context, h restic.Handle, length int, offset int64) (io.ReadCloser, error) {
+	debug.Log("Load %v, length %v, offset %v", h, length, offset)
+	if err := h.Valid(); err != nil {
+		return nil, err
+	}
+
+	if offset < 0 {
+		return nil, errors.New("offset is negative")
+	}
+
+	f, err := fs.Open(b.Filename(h))
+	if err != nil {
+		return nil, err
+	}
+
+	if offset > 0 {
+		_, err = f.Seek(offset, 0)
+		if err != nil {
+			_ = f.Close()
+			return nil, err
+		}
+	}
+
+	if length > 0 {
+		return backend.LimitReadCloser(f, int64(length)), nil
+	}
+
+	return f, nil
+}
+
+// Stat returns information about a blob.
+func (b *Local) Stat(ctx context.Context, h restic.Handle) (restic.FileInfo, error) {
+	debug.Log("Stat %v", h)
+	if err := h.Valid(); err != nil {
+		return restic.FileInfo{}, err
+	}
+
+	fi, err := fs.Stat(b.Filename(h))
+	if err != nil {
+		return restic.FileInfo{}, errors.Wrap(err, "Stat")
+	}
+
+	return restic.FileInfo{Size: fi.Size()}, nil
+}
+
+// Test returns true if a blob of the given type and name exists in the backend.
+func (b *Local) Test(ctx context.Context, h restic.Handle) (bool, error) {
+	debug.Log("Test %v", h)
+	_, err := fs.Stat(b.Filename(h))
+	if err != nil {
+		if os.IsNotExist(errors.Cause(err)) {
+			return false, nil
+		}
+		return false, errors.Wrap(err, "Stat")
+	}
+
+	return true, nil
+}
+
+// Remove removes the blob with the given name and type.
+func (b *Local) Remove(ctx context.Context, h restic.Handle) error {
+	debug.Log("Remove %v", h)
+	fn := b.Filename(h)
+
+	// reset read-only flag
+	err := fs.Chmod(fn, 0666)
+	if err != nil {
+		return errors.Wrap(err, "Chmod")
+	}
+
+	return fs.Remove(fn)
+}
+
+func isFile(fi os.FileInfo) bool {
+	return fi.Mode()&(os.ModeType|os.ModeCharDevice) == 0
+}
+
+// List returns a channel that yields all names of blobs of type t. A
+// goroutine is started for this.
+func (b *Local) List(ctx context.Context, t restic.FileType) <-chan string {
+	debug.Log("List %v", t)
+
+	ch := make(chan string)
+
+	go func() {
+		defer close(ch)
+
+		fs.Walk(b.Basedir(t), func(path string, fi os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+
+			if !isFile(fi) {
+				return err
+			}
+
+			select {
+			case ch <- filepath.Base(path):
+			case <-ctx.Done():
+				return err
+			}
+
+			return err
+		})
+	}()
+
+	return ch
+}
+
+// Delete removes the repository and all files.
+func (b *Local) Delete() error {
+	debug.Log("Delete()")
+	return fs.RemoveAll(b.Path)
+}
+
+// Close closes all open files.
+func (b *Local) Close() error {
+	debug.Log("Close()")
+	// this does not need to do anything, all open files are closed within the
+	// same function.
+	return nil
+}

internal/backend/local/local_test.go

@@ -0,0 +1,61 @@
+package local_test
+
+import (
+	"io/ioutil"
+	"restic"
+	"testing"
+
+	"restic/backend/local"
+	"restic/backend/test"
+	. "restic/test"
+)
+
+func newTestSuite(t testing.TB) *test.Suite {
+	return &test.Suite{
+		// NewConfig returns a config for a new temporary backend that will be used in tests.
+		NewConfig: func() (interface{}, error) {
+			dir, err := ioutil.TempDir(TestTempDir, "restic-test-local-")
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			t.Logf("create new backend at %v", dir)
+
+			cfg := local.Config{
+				Path: dir,
+			}
+			return cfg, nil
+		},
+
+		// CreateFn is a function that creates a temporary repository for the tests.
+		Create: func(config interface{}) (restic.Backend, error) {
+			cfg := config.(local.Config)
+			return local.Create(cfg)
+		},
+
+		// OpenFn is a function that opens a previously created temporary repository.
+		Open: func(config interface{}) (restic.Backend, error) {
+			cfg := config.(local.Config)
+			return local.Open(cfg)
+		},
+
+		// CleanupFn removes data created during the tests.
+		Cleanup: func(config interface{}) error {
+			cfg := config.(local.Config)
+			if !TestCleanupTempDirs {
+				t.Logf("leaving test backend dir at %v", cfg.Path)
+			}
+
+			RemoveAll(t, cfg.Path)
+			return nil
+		},
+	}
+}
+
+func TestBackend(t *testing.T) {
+	newTestSuite(t).RunTests(t)
+}
+
+func BenchmarkBackend(t *testing.B) {
+	newTestSuite(t).RunBenchmarks(t)
+}

internal/backend/local/local_unix.go

@@ -0,0 +1,13 @@
+// +build !windows
+
+package local
+
+import (
+	"os"
+	"restic/fs"
+)
+
+// set file to readonly
+func setNewFileMode(f string, fi os.FileInfo) error {
+	return fs.Chmod(f, fi.Mode()&os.FileMode(^uint32(0222)))
+}

internal/backend/local/local_windows.go

@@ -0,0 +1,12 @@
+package local
+
+import (
+	"os"
+)
+
+// We don't modify read-only on windows,
+// since it will make us unable to delete the file,
+// and this isn't common practice on this platform.
+func setNewFileMode(f string, fi os.FileInfo) error {
+	return nil
+}