2015-03-28 11:50:23 +01:00
|
|
|
package local
|
|
|
|
|
|
|
|
import (
|
2017-06-03 17:39:57 +02:00
|
|
|
"context"
|
2020-12-19 12:39:48 +01:00
|
|
|
"hash"
|
2015-03-28 11:50:23 +01:00
|
|
|
"io"
|
|
|
|
"os"
|
|
|
|
"path/filepath"
|
2019-10-09 21:42:15 +02:00
|
|
|
"syscall"
|
2015-03-28 11:50:23 +01:00
|
|
|
|
2017-07-23 14:21:03 +02:00
|
|
|
"github.com/restic/restic/internal/backend"
|
2022-10-15 16:23:39 +02:00
|
|
|
"github.com/restic/restic/internal/backend/layout"
|
2022-06-12 17:45:34 +02:00
|
|
|
"github.com/restic/restic/internal/backend/sema"
|
2017-07-23 14:21:03 +02:00
|
|
|
"github.com/restic/restic/internal/debug"
|
2022-06-12 17:45:34 +02:00
|
|
|
"github.com/restic/restic/internal/errors"
|
2017-07-23 14:21:03 +02:00
|
|
|
"github.com/restic/restic/internal/fs"
|
2022-06-12 17:45:34 +02:00
|
|
|
"github.com/restic/restic/internal/restic"
|
2020-12-16 13:58:02 +01:00
|
|
|
|
|
|
|
"github.com/cenkalti/backoff/v4"
|
2015-03-28 11:50:23 +01:00
|
|
|
)
|
|
|
|
|
2016-01-24 20:23:50 +01:00
|
|
|
// Local is a backend in a local directory.
|
2015-03-28 11:50:23 +01:00
|
|
|
type Local struct {
|
2017-03-25 13:20:03 +01:00
|
|
|
Config
|
2022-06-12 17:45:34 +02:00
|
|
|
sem sema.Semaphore
|
2022-10-15 16:23:39 +02:00
|
|
|
layout.Layout
|
2022-04-26 19:15:09 +02:00
|
|
|
backend.Modes
|
2015-03-28 11:50:23 +01:00
|
|
|
}
|
|
|
|
|
2017-03-26 22:14:00 +02:00
|
|
|
// ensure statically that *Local implements restic.Backend.
|
2016-08-31 22:39:36 +02:00
|
|
|
var _ restic.Backend = &Local{}
|
|
|
|
|
2017-04-02 19:54:11 +02:00
|
|
|
const defaultLayout = "default"
|
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
func open(ctx context.Context, cfg Config) (*Local, error) {
|
2022-10-15 16:23:39 +02:00
|
|
|
l, err := layout.ParseLayout(ctx, &layout.LocalFilesystem{}, cfg.Layout, defaultLayout, cfg.Path)
|
2017-04-02 17:57:28 +02:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2017-03-26 21:53:26 +02:00
|
|
|
}
|
|
|
|
|
2022-06-12 17:45:34 +02:00
|
|
|
sem, err := sema.New(cfg.Connections)
|
2021-08-07 19:50:00 +02:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2022-04-26 19:15:09 +02:00
|
|
|
fi, err := fs.Stat(l.Filename(restic.Handle{Type: restic.ConfigFile}))
|
|
|
|
m := backend.DeriveModesFromFileInfo(fi, err)
|
|
|
|
debug.Log("using (%03O file, %03O dir) permissions", m.File, m.Dir)
|
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
return &Local{
|
|
|
|
Config: cfg,
|
|
|
|
Layout: l,
|
|
|
|
sem: sem,
|
2022-04-26 19:15:09 +02:00
|
|
|
Modes: m,
|
2021-08-07 19:50:00 +02:00
|
|
|
}, 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 11:50:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Create creates all the necessary files and directories for a new local
|
2015-05-04 20:39:45 +02:00
|
|
|
// backend at dir. Afterwards a new config blob should be created.
|
2020-09-19 22:01:32 +02:00
|
|
|
func Create(ctx context.Context, cfg Config) (*Local, error) {
|
2017-04-02 19:54:11 +02:00
|
|
|
debug.Log("create local backend at %v (layout %q)", cfg.Path, cfg.Layout)
|
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
be, err := open(ctx, cfg)
|
2017-04-02 19:54:11 +02:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2015-05-04 20:39:45 +02:00
|
|
|
// test if config file already exists
|
2017-04-02 19:54:11 +02:00
|
|
|
_, err = fs.Lstat(be.Filename(restic.Handle{Type: restic.ConfigFile}))
|
2015-03-28 11:50:23 +01:00
|
|
|
if err == nil {
|
2015-05-03 16:43:27 +02:00
|
|
|
return nil, errors.New("config file already exists")
|
2015-03-28 11:50:23 +01:00
|
|
|
}
|
|
|
|
|
2017-04-19 18:56:01 +02:00
|
|
|
// create paths for data and refs
|
2017-03-26 21:53:26 +02:00
|
|
|
for _, d := range be.Paths() {
|
2022-04-26 19:15:09 +02:00
|
|
|
err := fs.MkdirAll(d, be.Modes.Dir)
|
2015-03-28 11:50:23 +01:00
|
|
|
if err != nil {
|
2021-06-07 19:26:25 +02:00
|
|
|
return nil, errors.WithStack(err)
|
2015-03-28 11:50:23 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-26 21:53:26 +02:00
|
|
|
return be, nil
|
2015-03-28 11:50:23 +01:00
|
|
|
}
|
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
func (b *Local) Connections() uint {
|
|
|
|
return b.Config.Connections
|
|
|
|
}
|
|
|
|
|
2015-03-28 11:50:23 +01:00
|
|
|
// Location returns this backend's location (the directory name).
|
|
|
|
func (b *Local) Location() string {
|
2017-03-25 13:20:03 +01:00
|
|
|
return b.Path
|
2015-03-28 11:50:23 +01:00
|
|
|
}
|
|
|
|
|
2020-12-19 12:39:48 +01:00
|
|
|
// Hasher may return a hash function for calculating a content hash for the backend
|
|
|
|
func (b *Local) Hasher() hash.Hash {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-05-01 20:07:29 +02:00
|
|
|
// HasAtomicReplace returns whether Save() can atomically replace files
|
|
|
|
func (b *Local) HasAtomicReplace() bool {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2017-06-15 13:40:27 +02:00
|
|
|
// IsNotExist returns true if the error is caused by a non existing file.
|
|
|
|
func (b *Local) IsNotExist(err error) bool {
|
2021-06-07 19:26:25 +02:00
|
|
|
return errors.Is(err, os.ErrNotExist)
|
2017-06-15 13:40:27 +02:00
|
|
|
}
|
|
|
|
|
2016-01-26 22:12:53 +01:00
|
|
|
// Save stores data in the backend at the handle.
|
2020-12-16 13:58:02 +01:00
|
|
|
func (b *Local) Save(ctx context.Context, h restic.Handle, rd restic.RewindReader) (err error) {
|
2017-01-22 12:32:20 +01:00
|
|
|
debug.Log("Save %v", h)
|
2016-01-26 22:12:53 +01:00
|
|
|
if err := h.Valid(); err != nil {
|
2020-12-17 12:47:53 +01:00
|
|
|
return backoff.Permanent(err)
|
2016-01-24 16:59:38 +01:00
|
|
|
}
|
|
|
|
|
2020-11-02 10:34:21 +01:00
|
|
|
finalname := b.Filename(h)
|
|
|
|
dir := filepath.Dir(finalname)
|
2016-01-24 16:59:38 +01:00
|
|
|
|
2020-12-16 13:58:02 +01:00
|
|
|
defer func() {
|
2020-12-20 21:12:27 +01:00
|
|
|
// Mark non-retriable errors as such
|
|
|
|
if errors.Is(err, syscall.ENOSPC) || os.IsPermission(err) {
|
2020-12-16 13:58:02 +01:00
|
|
|
err = backoff.Permanent(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
b.sem.GetToken()
|
|
|
|
defer b.sem.ReleaseToken()
|
|
|
|
|
2020-11-02 10:34:21 +01:00
|
|
|
// Create new file with a temporary name.
|
|
|
|
tmpname := filepath.Base(finalname) + "-tmp-"
|
|
|
|
f, err := tempFile(dir, tmpname)
|
2018-01-05 17:51:09 +01:00
|
|
|
|
|
|
|
if b.IsNotExist(err) {
|
|
|
|
debug.Log("error %v: creating dir", err)
|
|
|
|
|
|
|
|
// error is caused by a missing directory, try to create it
|
2022-04-26 19:15:09 +02:00
|
|
|
mkdirErr := fs.MkdirAll(dir, b.Modes.Dir)
|
2018-01-05 17:51:09 +01:00
|
|
|
if mkdirErr != nil {
|
2020-11-02 10:34:21 +01:00
|
|
|
debug.Log("error creating dir %v: %v", dir, mkdirErr)
|
2018-01-05 17:51:09 +01:00
|
|
|
} else {
|
|
|
|
// try again
|
2020-11-02 10:34:21 +01:00
|
|
|
f, err = tempFile(dir, tmpname)
|
2018-01-05 17:51:09 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-26 21:53:26 +02:00
|
|
|
if err != nil {
|
2021-06-07 19:26:25 +02:00
|
|
|
return errors.WithStack(err)
|
2017-03-26 21:53:26 +02:00
|
|
|
}
|
|
|
|
|
2020-11-02 10:34:21 +01:00
|
|
|
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)
|
|
|
|
|
2017-03-26 21:53:26 +02:00
|
|
|
// save data, then sync
|
2020-12-18 23:41:29 +01:00
|
|
|
wbytes, err := io.Copy(f, rd)
|
2017-03-26 21:53:26 +02:00
|
|
|
if err != nil {
|
2021-06-07 19:26:25 +02:00
|
|
|
return errors.WithStack(err)
|
2017-03-26 21:53:26 +02:00
|
|
|
}
|
2020-12-18 23:41:29 +01:00
|
|
|
// sanity check
|
|
|
|
if wbytes != rd.Length() {
|
|
|
|
return errors.Errorf("wrote %d bytes instead of the expected %d bytes", wbytes, rd.Length())
|
|
|
|
}
|
2017-03-26 21:53:26 +02:00
|
|
|
|
2020-11-02 10:34:21 +01:00
|
|
|
// Ignore error if filesystem does not support fsync.
|
2021-07-09 17:11:39 +02:00
|
|
|
err = f.Sync()
|
2022-11-11 14:53:42 +01:00
|
|
|
syncNotSup := err != nil && (errors.Is(err, syscall.ENOTSUP) || isMacENOTTY(err))
|
2021-07-09 17:11:39 +02:00
|
|
|
if err != nil && !syncNotSup {
|
2020-11-02 10:34:21 +01:00
|
|
|
return errors.WithStack(err)
|
2017-03-26 21:53:26 +02:00
|
|
|
}
|
2016-01-24 16:59:38 +01:00
|
|
|
|
2020-11-02 10:34:21 +01: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 {
|
2021-06-07 19:26:25 +02:00
|
|
|
return errors.WithStack(err)
|
2016-01-24 16:59:38 +01:00
|
|
|
}
|
|
|
|
|
2021-07-09 17:11:39 +02:00
|
|
|
// Now sync the directory to commit the Rename.
|
|
|
|
if !syncNotSup {
|
|
|
|
err = fsyncDir(dir)
|
|
|
|
if err != nil {
|
|
|
|
return errors.WithStack(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-06 18:46:19 +02:00
|
|
|
// try to mark file as read-only to avoid accidential modifications
|
2020-10-06 18:28:01 +02:00
|
|
|
// 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
|
2022-04-26 19:15:09 +02:00
|
|
|
err = setFileReadonly(finalname, b.Modes.File)
|
2020-10-06 18:28:01 +02:00
|
|
|
if err != nil && !os.IsPermission(err) {
|
2021-06-07 19:26:25 +02:00
|
|
|
return errors.WithStack(err)
|
2020-10-06 18:28:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2016-01-24 01:15:35 +01:00
|
|
|
}
|
|
|
|
|
2022-12-02 19:36:43 +01:00
|
|
|
var tempFile = os.CreateTemp // Overridden by test.
|
2020-12-16 13:58:02 +01:00
|
|
|
|
2018-01-17 05:59:16 +01:00
|
|
|
// 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 18:11:10 +01:00
|
|
|
debug.Log("Load %v, length %v, offset %v", h, length, offset)
|
2017-01-22 22:01:12 +01:00
|
|
|
if err := h.Valid(); err != nil {
|
2020-12-17 12:47:53 +01:00
|
|
|
return nil, backoff.Permanent(err)
|
2017-01-22 22:01:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if offset < 0 {
|
|
|
|
return nil, errors.New("offset is negative")
|
|
|
|
}
|
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
b.sem.GetToken()
|
2017-03-26 21:53:26 +02:00
|
|
|
f, err := fs.Open(b.Filename(h))
|
2017-01-22 22:01:12 +01:00
|
|
|
if err != nil {
|
2021-08-07 19:50:00 +02:00
|
|
|
b.sem.ReleaseToken()
|
2017-01-22 22:01:12 +01:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if offset > 0 {
|
|
|
|
_, err = f.Seek(offset, 0)
|
|
|
|
if err != nil {
|
2021-08-07 19:50:00 +02:00
|
|
|
b.sem.ReleaseToken()
|
2017-06-03 17:39:57 +02:00
|
|
|
_ = f.Close()
|
2017-01-22 22:01:12 +01:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
r := b.sem.ReleaseTokenOnClose(f, nil)
|
|
|
|
|
2017-01-22 22:01:12 +01:00
|
|
|
if length > 0 {
|
2021-08-07 19:50:00 +02:00
|
|
|
return backend.LimitReadCloser(r, int64(length)), nil
|
2017-01-22 22:01:12 +01:00
|
|
|
}
|
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
return r, nil
|
2017-01-22 22:01:12 +01:00
|
|
|
}
|
|
|
|
|
2016-01-23 23:27:58 +01:00
|
|
|
// Stat returns information about a blob.
|
2017-06-03 17:39:57 +02:00
|
|
|
func (b *Local) Stat(ctx context.Context, h restic.Handle) (restic.FileInfo, error) {
|
2016-09-27 22:35:08 +02:00
|
|
|
debug.Log("Stat %v", h)
|
2016-01-23 23:27:58 +01:00
|
|
|
if err := h.Valid(); err != nil {
|
2020-12-17 12:47:53 +01:00
|
|
|
return restic.FileInfo{}, backoff.Permanent(err)
|
2016-01-23 23:27:58 +01:00
|
|
|
}
|
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
b.sem.GetToken()
|
|
|
|
defer b.sem.ReleaseToken()
|
|
|
|
|
2017-03-26 21:53:26 +02:00
|
|
|
fi, err := fs.Stat(b.Filename(h))
|
2016-01-23 23:27:58 +01:00
|
|
|
if err != nil {
|
2021-06-07 19:26:25 +02:00
|
|
|
return restic.FileInfo{}, errors.WithStack(err)
|
2016-01-23 23:27:58 +01:00
|
|
|
}
|
|
|
|
|
2018-01-20 19:34:38 +01:00
|
|
|
return restic.FileInfo{Size: fi.Size(), Name: h.Name}, nil
|
2016-01-23 23:27:58 +01:00
|
|
|
}
|
|
|
|
|
2015-03-28 11:50:23 +01:00
|
|
|
// Remove removes the blob with the given name and type.
|
2017-06-03 17:39:57 +02:00
|
|
|
func (b *Local) Remove(ctx context.Context, h restic.Handle) error {
|
2017-01-25 17:48:35 +01:00
|
|
|
debug.Log("Remove %v", h)
|
2017-03-26 21:53:26 +02:00
|
|
|
fn := b.Filename(h)
|
2015-08-14 15:30:36 +02:00
|
|
|
|
2021-08-07 19:50:00 +02:00
|
|
|
b.sem.GetToken()
|
|
|
|
defer b.sem.ReleaseToken()
|
|
|
|
|
2015-08-19 22:02:47 +02:00
|
|
|
// reset read-only flag
|
Fix 567 (#570)
* Patch for https://github.com/restic/restic/issues/567
Backup also files on windows with longer pathnames than 255 chars (e.g. from node).
as fd0 says "So, as far as I can see, we need to have custom methods for all functions that accept a path, so that on Windows we can substitute the normal (possibly relative) path used within restic by an (absolute) UNC path, and only then call the underlying functions like os.Stat(), os.Lstat(), os.Open() and so on.
I've already thought about adding a generic abstraction for the file system (so we can mock this easier in tests), and this looks like a good opportunity to build it."
* fixed building tests
* Restructured patches
Add Wrapper for filepath.Walk
* using \\?\ requires absolute pathes to be used.
Now all tests run
* used gofmt on the code
* Restructured Code. No patches dir, integrate the file functions into restic/fs/
There is still an issue, because restic.fs.Open has a different api the os.Open, which returns the result of OpenFile, but takes only a string
* Changed the last os.Open() calls to fs.Open() after extending the File interface
* fixed name-clash of restic.fs and fuse.fs detected by travis
* fixed fmt with gofmt
* c&p failure: removed fixpath() call.
* missing include
* fixed includes in linux variant
* Fix for Linux. Fd() is required on File interface
* done gofmt
2016-08-15 21:59:13 +02:00
|
|
|
err := fs.Chmod(fn, 0666)
|
2020-10-06 18:28:01 +02:00
|
|
|
if err != nil && !os.IsPermission(err) {
|
2021-06-07 19:26:25 +02:00
|
|
|
return errors.WithStack(err)
|
2015-08-19 22:02:47 +02:00
|
|
|
}
|
|
|
|
|
Fix 567 (#570)
* Patch for https://github.com/restic/restic/issues/567
Backup also files on windows with longer pathnames than 255 chars (e.g. from node).
as fd0 says "So, as far as I can see, we need to have custom methods for all functions that accept a path, so that on Windows we can substitute the normal (possibly relative) path used within restic by an (absolute) UNC path, and only then call the underlying functions like os.Stat(), os.Lstat(), os.Open() and so on.
I've already thought about adding a generic abstraction for the file system (so we can mock this easier in tests), and this looks like a good opportunity to build it."
* fixed building tests
* Restructured patches
Add Wrapper for filepath.Walk
* using \\?\ requires absolute pathes to be used.
Now all tests run
* used gofmt on the code
* Restructured Code. No patches dir, integrate the file functions into restic/fs/
There is still an issue, because restic.fs.Open has a different api the os.Open, which returns the result of OpenFile, but takes only a string
* Changed the last os.Open() calls to fs.Open() after extending the File interface
* fixed name-clash of restic.fs and fuse.fs detected by travis
* fixed fmt with gofmt
* c&p failure: removed fixpath() call.
* missing include
* fixed includes in linux variant
* Fix for Linux. Fd() is required on File interface
* done gofmt
2016-08-15 21:59:13 +02:00
|
|
|
return fs.Remove(fn)
|
2015-03-28 11:50:23 +01:00
|
|
|
}
|
|
|
|
|
2018-01-20 19:34:38 +01: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.
|
2020-11-19 16:46:42 +01:00
|
|
|
func (b *Local) List(ctx context.Context, t restic.FileType, fn func(restic.FileInfo) error) (err error) {
|
2016-09-27 22:35:08 +02:00
|
|
|
debug.Log("List %v", t)
|
2015-03-28 11:50:23 +01:00
|
|
|
|
2018-01-20 13:43:07 +01:00
|
|
|
basedir, subdirs := b.Basedir(t)
|
2020-11-19 16:46:42 +01:00
|
|
|
if subdirs {
|
|
|
|
err = visitDirs(ctx, basedir, fn)
|
|
|
|
} else {
|
2021-02-27 00:02:13 +01:00
|
|
|
err = visitFiles(ctx, basedir, fn, false)
|
2020-11-19 16:46:42 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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 19:35:46 +01:00
|
|
|
if err != nil {
|
|
|
|
// ignore subsequent errors
|
|
|
|
_ = d.Close()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = d.Close()
|
2020-11-19 16:46:42 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, f := range sub {
|
2021-02-27 00:02:13 +01:00
|
|
|
err = visitFiles(ctx, filepath.Join(dir, f), fn, true)
|
2018-01-20 13:43:07 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2020-11-19 16:46:42 +01:00
|
|
|
}
|
|
|
|
return ctx.Err()
|
|
|
|
}
|
2015-03-28 11:50:23 +01:00
|
|
|
|
2021-02-27 00:02:13 +01:00
|
|
|
func visitFiles(ctx context.Context, dir string, fn func(restic.FileInfo) error, ignoreNotADirectory bool) error {
|
2020-11-19 16:46:42 +01:00
|
|
|
d, err := fs.Open(dir)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2015-03-28 11:50:23 +01:00
|
|
|
|
2021-02-27 00:02:13 +01:00
|
|
|
if ignoreNotADirectory {
|
|
|
|
fi, err := d.Stat()
|
|
|
|
if err != nil || !fi.IsDir() {
|
2021-11-06 19:44:57 +01:00
|
|
|
// ignore subsequent errors
|
|
|
|
_ = d.Close()
|
2021-02-27 00:02:13 +01:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-19 16:46:42 +01:00
|
|
|
sub, err := d.Readdir(-1)
|
2021-01-30 19:35:46 +01:00
|
|
|
if err != nil {
|
|
|
|
// ignore subsequent errors
|
|
|
|
_ = d.Close()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = d.Close()
|
2020-11-19 16:46:42 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-12-14 19:13:01 +01:00
|
|
|
|
2020-11-19 16:46:42 +01:00
|
|
|
for _, fi := range sub {
|
|
|
|
select {
|
|
|
|
case <-ctx.Done():
|
2018-01-20 19:34:38 +01:00
|
|
|
return ctx.Err()
|
2020-11-19 16:46:42 +01:00
|
|
|
default:
|
2018-01-20 19:34:38 +01:00
|
|
|
}
|
|
|
|
|
2020-11-19 16:46:42 +01:00
|
|
|
err := fn(restic.FileInfo{
|
|
|
|
Name: fi.Name(),
|
|
|
|
Size: fi.Size(),
|
|
|
|
})
|
2018-01-20 13:43:07 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-04-10 21:35:30 +02:00
|
|
|
}
|
2020-11-19 16:46:42 +01:00
|
|
|
return nil
|
2015-03-28 11:50:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Delete removes the repository and all files.
|
2017-10-14 13:38:17 +02:00
|
|
|
func (b *Local) Delete(ctx context.Context) error {
|
2016-09-27 22:35:08 +02:00
|
|
|
debug.Log("Delete()")
|
2017-03-25 13:20:03 +01:00
|
|
|
return fs.RemoveAll(b.Path)
|
2015-08-14 15:30:36 +02:00
|
|
|
}
|
2015-03-28 11:50:23 +01:00
|
|
|
|
2015-08-14 15:30:36 +02:00
|
|
|
// Close closes all open files.
|
|
|
|
func (b *Local) Close() error {
|
2016-09-27 22:35:08 +02:00
|
|
|
debug.Log("Close()")
|
2016-01-26 22:07:51 +01:00
|
|
|
// this does not need to do anything, all open files are closed within the
|
|
|
|
// same function.
|
2015-08-14 15:30:36 +02:00
|
|
|
return nil
|
|
|
|
}
|