restic/src/restic/backend/local/local.go

363 lines
7.8 KiB
Go
Raw Normal View History

2015-03-28 10:50:23 +00:00
package local
import (
"io"
"io/ioutil"
"os"
"path/filepath"
2016-08-31 20:39:36 +00:00
"restic"
2015-03-28 10:50:23 +00:00
2016-09-01 20:17:37 +00:00
"restic/errors"
"restic/backend"
"restic/debug"
"restic/fs"
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 {
p string
2015-03-28 10:50:23 +00:00
}
2016-08-31 20:39:36 +00:00
var _ restic.Backend = &Local{}
2016-01-26 21:09:29 +00:00
func paths(dir string) []string {
return []string{
2015-03-28 10:50:23 +00:00
dir,
filepath.Join(dir, backend.Paths.Data),
filepath.Join(dir, backend.Paths.Snapshots),
2015-04-26 13:48:35 +00:00
filepath.Join(dir, backend.Paths.Index),
2015-03-28 10:50:23 +00:00
filepath.Join(dir, backend.Paths.Locks),
filepath.Join(dir, backend.Paths.Keys),
filepath.Join(dir, backend.Paths.Temp),
}
2016-01-26 21:09:29 +00:00
}
2015-03-28 10:50:23 +00:00
2016-01-26 21:09:29 +00:00
// Open opens the local backend as specified by config.
func Open(dir string) (*Local, error) {
// test if all necessary dirs are there
2016-01-26 21:09:29 +00:00
for _, d := range paths(dir) {
if _, err := fs.Stat(d); err != nil {
2016-08-29 19:54:50 +00:00
return nil, errors.Wrap(err, "Open")
2015-03-28 10:50:23 +00:00
}
}
return &Local{p: dir}, nil
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.
2015-03-28 10:50:23 +00:00
func Create(dir string) (*Local, error) {
2015-05-04 18:39:45 +00:00
// test if config file already exists
_, err := fs.Lstat(filepath.Join(dir, backend.Paths.Config))
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
}
// create paths for data, refs and temp
2016-01-26 21:09:29 +00:00
for _, d := range paths(dir) {
err := fs.MkdirAll(d, backend.Modes.Dir)
2015-03-28 10:50:23 +00:00
if err != nil {
2016-08-29 19:54:50 +00:00
return nil, errors.Wrap(err, "MkdirAll")
2015-03-28 10:50:23 +00:00
}
}
// open backend
return Open(dir)
}
// Location returns this backend's location (the directory name).
func (b *Local) Location() string {
return b.p
}
// Construct path for given Type and name.
2016-08-31 20:39:36 +00:00
func filename(base string, t restic.FileType, name string) string {
if t == restic.ConfigFile {
return filepath.Join(base, "config")
}
2015-03-28 10:50:23 +00:00
return filepath.Join(dirname(base, t, name), name)
}
// Construct directory for given Type.
2016-08-31 20:39:36 +00:00
func dirname(base string, t restic.FileType, name string) string {
2015-03-28 10:50:23 +00:00
var n string
switch t {
2016-08-31 20:39:36 +00:00
case restic.DataFile:
2015-03-28 10:50:23 +00:00
n = backend.Paths.Data
if len(name) > 2 {
n = filepath.Join(n, name[:2])
}
2016-08-31 20:39:36 +00:00
case restic.SnapshotFile:
2015-03-28 10:50:23 +00:00
n = backend.Paths.Snapshots
2016-08-31 20:39:36 +00:00
case restic.IndexFile:
2015-04-26 13:48:35 +00:00
n = backend.Paths.Index
2016-08-31 20:39:36 +00:00
case restic.LockFile:
2015-03-28 10:50:23 +00:00
n = backend.Paths.Locks
2016-08-31 20:39:36 +00:00
case restic.KeyFile:
2015-03-28 10:50:23 +00:00
n = backend.Paths.Keys
}
return filepath.Join(base, n)
}
2016-08-07 12:50:24 +00:00
// Load returns the data stored in the backend for h at the given offset and
// saves it in p. Load has the same semantics as io.ReaderAt, with one
// exception: when off is lower than zero, it is treated as an offset relative
// to the end of the file.
2016-08-31 20:39:36 +00:00
func (b *Local) Load(h restic.Handle, p []byte, off int64) (n int, err error) {
2016-09-27 20:35:08 +00:00
debug.Log("Load %v, length %v at %v", h, len(p), off)
2016-01-23 16:08:03 +00:00
if err := h.Valid(); err != nil {
return 0, err
}
2016-09-01 19:19:30 +00:00
f, err := fs.Open(filename(b.p, h.Type, h.Name))
2016-01-23 13:12:12 +00:00
if err != nil {
2016-08-29 19:54:50 +00:00
return 0, errors.Wrap(err, "Open")
2016-01-23 13:12:12 +00:00
}
defer func() {
e := f.Close()
if err == nil {
2016-08-29 19:54:50 +00:00
err = errors.Wrap(e, "Close")
2016-01-23 13:12:12 +00:00
}
}()
2016-08-07 12:50:24 +00:00
switch {
case off > 0:
2016-01-23 13:12:12 +00:00
_, err = f.Seek(off, 0)
2016-08-07 12:50:24 +00:00
case off < 0:
_, err = f.Seek(off, 2)
}
if err != nil {
2016-08-29 19:54:50 +00:00
return 0, errors.Wrap(err, "Seek")
2016-01-23 13:12:12 +00:00
}
return io.ReadFull(f, p)
}
// writeToTempfile saves p into a tempfile in tempdir.
func writeToTempfile(tempdir string, p []byte) (filename string, err error) {
tmpfile, err := ioutil.TempFile(tempdir, "temp-")
2016-01-24 00:15:35 +00:00
if err != nil {
2016-08-29 19:54:50 +00:00
return "", errors.Wrap(err, "TempFile")
2016-01-24 00:15:35 +00:00
}
2016-01-24 15:59:38 +00:00
n, err := tmpfile.Write(p)
2016-01-24 00:15:35 +00:00
if err != nil {
2016-08-29 19:54:50 +00:00
return "", errors.Wrap(err, "Write")
2016-01-24 00:15:35 +00:00
}
if n != len(p) {
return "", errors.New("not all bytes writen")
2016-01-24 00:15:35 +00:00
}
2016-01-24 15:59:38 +00:00
if err = tmpfile.Sync(); err != nil {
2016-08-29 19:54:50 +00:00
return "", errors.Wrap(err, "Syncn")
2016-01-24 15:59:38 +00:00
}
err = tmpfile.Close()
if err != nil {
2016-08-29 19:54:50 +00:00
return "", errors.Wrap(err, "Close")
}
return tmpfile.Name(), nil
}
// Save stores data in the backend at the handle.
2016-08-31 20:39:36 +00:00
func (b *Local) Save(h restic.Handle, p []byte) (err error) {
2016-09-27 20:35:08 +00:00
debug.Log("Save %v, length %v", h, len(p))
if err := h.Valid(); err != nil {
2016-01-24 15:59:38 +00:00
return err
}
tmpfile, err := writeToTempfile(filepath.Join(b.p, backend.Paths.Temp), p)
2016-09-27 20:35:08 +00:00
debug.Log("saved %v (%d bytes) to %v", h, len(p), tmpfile)
if err != nil {
return err
}
2016-09-01 19:19:30 +00:00
filename := filename(b.p, h.Type, h.Name)
2016-01-24 15:59:38 +00:00
// test if new path already exists
if _, err := fs.Stat(filename); err == nil {
return errors.Errorf("Rename(): file %v already exists", filename)
2016-01-24 15:59:38 +00:00
}
// create directories if necessary, ignore errors
2016-09-01 19:19:30 +00:00
if h.Type == restic.DataFile {
err = fs.MkdirAll(filepath.Dir(filename), backend.Modes.Dir)
if err != nil {
2016-08-29 19:54:50 +00:00
return errors.Wrap(err, "MkdirAll")
}
}
err = fs.Rename(tmpfile, filename)
2016-09-27 20:35:08 +00:00
debug.Log("save %v: rename %v -> %v: %v",
h, filepath.Base(tmpfile), filepath.Base(filename), err)
2016-01-24 15:59:38 +00:00
if err != nil {
2016-08-29 19:54:50 +00:00
return errors.Wrap(err, "Rename")
2016-01-24 15:59:38 +00:00
}
// set mode to read-only
fi, err := fs.Stat(filename)
2016-01-24 15:59:38 +00:00
if err != nil {
2016-08-29 19:54:50 +00:00
return errors.Wrap(err, "Stat")
2016-01-24 15:59:38 +00:00
}
return setNewFileMode(filename, fi)
2016-01-24 00:15:35 +00:00
}
2016-01-23 22:27:58 +00:00
// Stat returns information about a blob.
2016-08-31 20:39:36 +00:00
func (b *Local) Stat(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 {
2016-08-31 20:39:36 +00:00
return restic.FileInfo{}, err
2016-01-23 22:27:58 +00:00
}
2016-09-01 19:19:30 +00:00
fi, err := fs.Stat(filename(b.p, h.Type, h.Name))
2016-01-23 22:27:58 +00:00
if err != nil {
2016-08-31 20:39:36 +00:00
return restic.FileInfo{}, errors.Wrap(err, "Stat")
2016-01-23 22:27:58 +00:00
}
2016-08-31 20:39:36 +00:00
return restic.FileInfo{Size: fi.Size()}, 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.
2016-08-31 20:39:36 +00:00
func (b *Local) Test(t restic.FileType, name string) (bool, error) {
2016-09-27 20:35:08 +00:00
debug.Log("Test %v %v", t, name)
_, err := fs.Stat(filename(b.p, t, name))
2015-03-28 10:50:23 +00:00
if err != nil {
if os.IsNotExist(errors.Cause(err)) {
2015-03-28 10:50:23 +00:00
return false, nil
}
2016-08-29 19:54:50 +00:00
return false, errors.Wrap(err, "Stat")
2015-03-28 10:50:23 +00:00
}
return true, nil
}
// Remove removes the blob with the given name and type.
2016-08-31 20:39:36 +00:00
func (b *Local) Remove(t restic.FileType, name string) error {
2016-09-27 20:35:08 +00:00
debug.Log("Remove %v %v", t, name)
fn := filename(b.p, t, name)
2015-08-19 20:02:47 +00:00
// reset read-only flag
err := fs.Chmod(fn, 0666)
2015-08-19 20:02:47 +00:00
if err != nil {
2016-08-29 19:54:50 +00:00
return errors.Wrap(err, "Chmod")
2015-08-19 20:02:47 +00:00
}
return fs.Remove(fn)
2015-03-28 10:50:23 +00:00
}
func isFile(fi os.FileInfo) bool {
return fi.Mode()&(os.ModeType|os.ModeCharDevice) == 0
}
func readdir(d string) (fileInfos []os.FileInfo, err error) {
f, e := fs.Open(d)
if e != nil {
2016-08-29 19:54:50 +00:00
return nil, errors.Wrap(e, "Open")
}
defer func() {
e := f.Close()
if err == nil {
2016-08-29 19:54:50 +00:00
err = errors.Wrap(e, "Close")
}
}()
return f.Readdir(-1)
}
// listDir returns a list of all files in d.
func listDir(d string) (filenames []string, err error) {
fileInfos, err := readdir(d)
if err != nil {
return nil, err
}
for _, fi := range fileInfos {
if isFile(fi) {
filenames = append(filenames, fi.Name())
}
}
return filenames, nil
}
// listDirs returns a list of all files in directories within d.
func listDirs(dir string) (filenames []string, err error) {
fileInfos, err := readdir(dir)
if err != nil {
return nil, err
}
for _, fi := range fileInfos {
if !fi.IsDir() {
continue
}
files, err := listDir(filepath.Join(dir, fi.Name()))
if err != nil {
continue
}
filenames = append(filenames, files...)
}
return filenames, nil
}
2015-03-28 10:50:23 +00:00
// List returns a channel that yields all names of blobs of type t. A
2015-06-28 07:44:06 +00:00
// goroutine is started for this. If the channel done is closed, sending
2015-03-28 10:50:23 +00:00
// stops.
2016-08-31 20:39:36 +00:00
func (b *Local) List(t restic.FileType, done <-chan struct{}) <-chan string {
2016-09-27 20:35:08 +00:00
debug.Log("List %v", t)
lister := listDir
2016-08-31 20:39:36 +00:00
if t == restic.DataFile {
lister = listDirs
2015-03-28 10:50:23 +00:00
}
ch := make(chan string)
items, err := lister(filepath.Join(dirname(b.p, t, "")))
2015-03-28 10:50:23 +00:00
if err != nil {
close(ch)
return ch
}
go func() {
defer close(ch)
for _, m := range items {
2015-03-28 10:50:23 +00:00
if m == "" {
continue
}
select {
case ch <- m:
case <-done:
return
}
}
}()
return ch
}
// Delete removes the repository and all files.
func (b *Local) Delete() error {
2016-09-27 20:35:08 +00:00
debug.Log("Delete()")
return fs.RemoveAll(b.p)
}
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
}