restic/internal/backend/local/local.go

405 lines
9.3 KiB
Go
Raw Normal View History

2015-03-28 10:50:23 +00:00
package local
import (
2017-06-03 15:39:57 +00:00
"context"
"hash"
2015-03-28 10:50:23 +00:00
"io"
"io/ioutil"
2015-03-28 10:50:23 +00:00
"os"
"path/filepath"
"syscall"
2015-03-28 10:50:23 +00:00
2017-07-23 12:21:03 +00:00
"github.com/restic/restic/internal/errors"
2017-07-24 15:42:25 +00:00
"github.com/restic/restic/internal/restic"
2017-07-23 12:21:03 +00:00
"github.com/restic/restic/internal/backend"
"github.com/restic/restic/internal/debug"
"github.com/restic/restic/internal/fs"
"github.com/cenkalti/backoff/v4"
2015-03-28 10:50:23 +00:00
)
2016-01-24 19:23:50 +00:00
// Local is a backend in a local directory.
2015-03-28 10:50:23 +00:00
type Local struct {
2017-03-25 12:20:03 +00:00
Config
sem *backend.Semaphore
backend.Layout
2015-03-28 10:50:23 +00:00
}
2017-03-26 20:14:00 +00:00
// ensure statically that *Local implements restic.Backend.
2016-08-31 20:39:36 +00:00
var _ restic.Backend = &Local{}
2017-04-02 17:54:11 +00:00
const defaultLayout = "default"
func open(ctx context.Context, cfg Config) (*Local, error) {
l, err := backend.ParseLayout(ctx, &backend.LocalFilesystem{}, cfg.Layout, defaultLayout, cfg.Path)
2017-04-02 15:57:28 +00:00
if err != nil {
return nil, err
}
sem, err := backend.NewSemaphore(cfg.Connections)
if err != nil {
return nil, err
}
return &Local{
Config: cfg,
Layout: l,
sem: sem,
}, nil
}
// Open opens the local backend as specified by config.
func Open(ctx context.Context, cfg Config) (*Local, error) {
debug.Log("open local backend at %v (layout %q)", cfg.Path, cfg.Layout)
return open(ctx, cfg)
2015-03-28 10:50:23 +00:00
}
// Create creates all the necessary files and directories for a new local
2015-05-04 18:39:45 +00:00
// backend at dir. Afterwards a new config blob should be created.
func Create(ctx context.Context, cfg Config) (*Local, error) {
2017-04-02 17:54:11 +00:00
debug.Log("create local backend at %v (layout %q)", cfg.Path, cfg.Layout)
be, err := open(ctx, cfg)
2017-04-02 17:54:11 +00:00
if err != nil {
return nil, err
}
2015-05-04 18:39:45 +00:00
// test if config file already exists
2017-04-02 17:54:11 +00:00
_, err = fs.Lstat(be.Filename(restic.Handle{Type: restic.ConfigFile}))
2015-03-28 10:50:23 +00:00
if err == nil {
return nil, errors.New("config file already exists")
2015-03-28 10:50:23 +00:00
}
2017-04-19 16:56:01 +00:00
// create paths for data and refs
for _, d := range be.Paths() {
err := fs.MkdirAll(d, backend.Modes.Dir)
2015-03-28 10:50:23 +00:00
if err != nil {
return nil, errors.WithStack(err)
2015-03-28 10:50:23 +00:00
}
}
return be, nil
2015-03-28 10:50:23 +00:00
}
func (b *Local) Connections() uint {
return b.Config.Connections
}
2015-03-28 10:50:23 +00:00
// Location returns this backend's location (the directory name).
func (b *Local) Location() string {
2017-03-25 12:20:03 +00:00
return b.Path
2015-03-28 10:50:23 +00:00
}
// Hasher may return a hash function for calculating a content hash for the backend
func (b *Local) Hasher() hash.Hash {
return nil
}
2017-06-15 11:40:27 +00:00
// IsNotExist returns true if the error is caused by a non existing file.
func (b *Local) IsNotExist(err error) bool {
return errors.Is(err, os.ErrNotExist)
2017-06-15 11:40:27 +00:00
}
// Save stores data in the backend at the handle.
func (b *Local) Save(ctx context.Context, h restic.Handle, rd restic.RewindReader) (err error) {
debug.Log("Save %v", h)
if err := h.Valid(); err != nil {
2020-12-17 11:47:53 +00:00
return backoff.Permanent(err)
2016-01-24 15:59:38 +00:00
}
finalname := b.Filename(h)
dir := filepath.Dir(finalname)
2016-01-24 15:59:38 +00:00
defer func() {
// Mark non-retriable errors as such
if errors.Is(err, syscall.ENOSPC) || os.IsPermission(err) {
err = backoff.Permanent(err)
}
}()
b.sem.GetToken()
defer b.sem.ReleaseToken()
// Create new file with a temporary name.
tmpname := filepath.Base(finalname) + "-tmp-"
f, err := tempFile(dir, tmpname)
if b.IsNotExist(err) {
debug.Log("error %v: creating dir", err)
// error is caused by a missing directory, try to create it
mkdirErr := fs.MkdirAll(dir, backend.Modes.Dir)
if mkdirErr != nil {
debug.Log("error creating dir %v: %v", dir, mkdirErr)
} else {
// try again
f, err = tempFile(dir, tmpname)
}
}
if err != nil {
return errors.WithStack(err)
}
defer func(f *os.File) {
if err != nil {
_ = f.Close() // Double Close is harmless.
// Remove after Rename is harmless: we embed the final name in the
// temporary's name and no other goroutine will get the same data to
// Save, so the temporary name should never be reused by another
// goroutine.
_ = fs.Remove(f.Name())
}
}(f)
// save data, then sync
wbytes, err := io.Copy(f, rd)
if err != nil {
return errors.WithStack(err)
}
// sanity check
if wbytes != rd.Length() {
return errors.Errorf("wrote %d bytes instead of the expected %d bytes", wbytes, rd.Length())
}
// Ignore error if filesystem does not support fsync.
err = f.Sync()
syncNotSup := errors.Is(err, syscall.ENOTSUP)
if err != nil && !syncNotSup {
return errors.WithStack(err)
}
2016-01-24 15:59:38 +00:00
// Close, then rename. Windows doesn't like the reverse order.
if err = f.Close(); err != nil {
return errors.WithStack(err)
}
if err = os.Rename(f.Name(), finalname); err != nil {
return errors.WithStack(err)
2016-01-24 15:59:38 +00:00
}
// Now sync the directory to commit the Rename.
if !syncNotSup {
err = fsyncDir(dir)
if err != nil {
return errors.WithStack(err)
}
}
// try to mark file as read-only to avoid accidential modifications
// ignore if the operation fails as some filesystems don't allow the chmod call
// e.g. exfat and network file systems with certain mount options
err = setFileReadonly(finalname, backend.Modes.File)
if err != nil && !os.IsPermission(err) {
return errors.WithStack(err)
}
return nil
2016-01-24 00:15:35 +00:00
}
var tempFile = ioutil.TempFile // Overridden by test.
// Load runs fn with a reader that yields the contents of the file at h at the
// given offset.
func (b *Local) Load(ctx context.Context, h restic.Handle, length int, offset int64, fn func(rd io.Reader) error) error {
return backend.DefaultLoad(ctx, h, length, offset, b.openReader, fn)
}
func (b *Local) openReader(ctx context.Context, h restic.Handle, length int, offset int64) (io.ReadCloser, error) {
2017-01-23 17:11:10 +00:00
debug.Log("Load %v, length %v, offset %v", h, length, offset)
2017-01-22 21:01:12 +00:00
if err := h.Valid(); err != nil {
2020-12-17 11:47:53 +00:00
return nil, backoff.Permanent(err)
2017-01-22 21:01:12 +00:00
}
if offset < 0 {
return nil, errors.New("offset is negative")
}
b.sem.GetToken()
f, err := fs.Open(b.Filename(h))
2017-01-22 21:01:12 +00:00
if err != nil {
b.sem.ReleaseToken()
2017-01-22 21:01:12 +00:00
return nil, err
}
if offset > 0 {
_, err = f.Seek(offset, 0)
if err != nil {
b.sem.ReleaseToken()
2017-06-03 15:39:57 +00:00
_ = f.Close()
2017-01-22 21:01:12 +00:00
return nil, err
}
}
r := b.sem.ReleaseTokenOnClose(f, nil)
2017-01-22 21:01:12 +00:00
if length > 0 {
return backend.LimitReadCloser(r, int64(length)), nil
2017-01-22 21:01:12 +00:00
}
return r, nil
2017-01-22 21:01:12 +00:00
}
2016-01-23 22:27:58 +00:00
// Stat returns information about a blob.
2017-06-03 15:39:57 +00:00
func (b *Local) Stat(ctx context.Context, h restic.Handle) (restic.FileInfo, error) {
2016-09-27 20:35:08 +00:00
debug.Log("Stat %v", h)
2016-01-23 22:27:58 +00:00
if err := h.Valid(); err != nil {
2020-12-17 11:47:53 +00:00
return restic.FileInfo{}, backoff.Permanent(err)
2016-01-23 22:27:58 +00:00
}
b.sem.GetToken()
defer b.sem.ReleaseToken()
fi, err := fs.Stat(b.Filename(h))
2016-01-23 22:27:58 +00:00
if err != nil {
return restic.FileInfo{}, errors.WithStack(err)
2016-01-23 22:27:58 +00:00
}
return restic.FileInfo{Size: fi.Size(), Name: h.Name}, nil
2016-01-23 22:27:58 +00:00
}
2015-03-28 10:50:23 +00:00
// Test returns true if a blob of the given type and name exists in the backend.
2017-06-03 15:39:57 +00:00
func (b *Local) Test(ctx context.Context, h restic.Handle) (bool, error) {
debug.Log("Test %v", h)
b.sem.GetToken()
defer b.sem.ReleaseToken()
_, err := fs.Stat(b.Filename(h))
2015-03-28 10:50:23 +00:00
if err != nil {
if b.IsNotExist(err) {
2015-03-28 10:50:23 +00:00
return false, nil
}
return false, errors.WithStack(err)
2015-03-28 10:50:23 +00:00
}
return true, nil
}
// Remove removes the blob with the given name and type.
2017-06-03 15:39:57 +00:00
func (b *Local) Remove(ctx context.Context, h restic.Handle) error {
debug.Log("Remove %v", h)
fn := b.Filename(h)
b.sem.GetToken()
defer b.sem.ReleaseToken()
2015-08-19 20:02:47 +00:00
// reset read-only flag
err := fs.Chmod(fn, 0666)
if err != nil && !os.IsPermission(err) {
return errors.WithStack(err)
2015-08-19 20:02:47 +00:00
}
return fs.Remove(fn)
2015-03-28 10:50:23 +00:00
}
// List runs fn for each file in the backend which has the type t. When an
// error occurs (or fn returns an error), List stops and returns it.
func (b *Local) List(ctx context.Context, t restic.FileType, fn func(restic.FileInfo) error) (err error) {
2016-09-27 20:35:08 +00:00
debug.Log("List %v", t)
2015-03-28 10:50:23 +00:00
basedir, subdirs := b.Basedir(t)
if subdirs {
err = visitDirs(ctx, basedir, fn)
} else {
err = visitFiles(ctx, basedir, fn, false)
}
if b.IsNotExist(err) {
debug.Log("ignoring non-existing directory")
return nil
}
return err
}
// The following two functions are like filepath.Walk, but visit only one or
// two levels of directory structure (including dir itself as the first level).
// Also, visitDirs assumes it sees a directory full of directories, while
// visitFiles wants a directory full or regular files.
func visitDirs(ctx context.Context, dir string, fn func(restic.FileInfo) error) error {
d, err := fs.Open(dir)
if err != nil {
return err
}
sub, err := d.Readdirnames(-1)
2021-01-30 18:35:46 +00:00
if err != nil {
// ignore subsequent errors
_ = d.Close()
return err
}
err = d.Close()
if err != nil {
return err
}
for _, f := range sub {
err = visitFiles(ctx, filepath.Join(dir, f), fn, true)
if err != nil {
return err
}
}
return ctx.Err()
}
2015-03-28 10:50:23 +00:00
func visitFiles(ctx context.Context, dir string, fn func(restic.FileInfo) error, ignoreNotADirectory bool) error {
d, err := fs.Open(dir)
if err != nil {
return err
}
2015-03-28 10:50:23 +00:00
if ignoreNotADirectory {
fi, err := d.Stat()
if err != nil || !fi.IsDir() {
// ignore subsequent errors
_ = d.Close()
return err
}
}
sub, err := d.Readdir(-1)
2021-01-30 18:35:46 +00:00
if err != nil {
// ignore subsequent errors
_ = d.Close()
return err
}
err = d.Close()
if err != nil {
return err
}
for _, fi := range sub {
select {
case <-ctx.Done():
return ctx.Err()
default:
}
err := fn(restic.FileInfo{
Name: fi.Name(),
Size: fi.Size(),
})
if err != nil {
return err
}
}
return nil
2015-03-28 10:50:23 +00:00
}
// Delete removes the repository and all files.
func (b *Local) Delete(ctx context.Context) error {
2016-09-27 20:35:08 +00:00
debug.Log("Delete()")
2017-03-25 12:20:03 +00:00
return fs.RemoveAll(b.Path)
}
2015-03-28 10:50:23 +00:00
// Close closes all open files.
func (b *Local) Close() error {
2016-09-27 20:35:08 +00:00
debug.Log("Close()")
// this does not need to do anything, all open files are closed within the
// same function.
return nil
}