forked from TrueCloudLab/restic
This is the first commit that removes the (redundant) Get() method of the backend interface. Get(x, y) is equivalent to GetReader(x, y, 0, 0).
322 lines
6.8 KiB
Go
322 lines
6.8 KiB
Go
package local
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"sync"
|
|
|
|
"github.com/restic/restic/backend"
|
|
)
|
|
|
|
var ErrWrongData = errors.New("wrong data returned by backend, checksum does not match")
|
|
|
|
type Local struct {
|
|
p string
|
|
mu sync.Mutex
|
|
open map[string][]*os.File // Contains open files. Guarded by 'mu'.
|
|
}
|
|
|
|
// Open opens the local backend as specified by config.
|
|
func Open(dir string) (*Local, error) {
|
|
items := []string{
|
|
dir,
|
|
filepath.Join(dir, backend.Paths.Data),
|
|
filepath.Join(dir, backend.Paths.Snapshots),
|
|
filepath.Join(dir, backend.Paths.Index),
|
|
filepath.Join(dir, backend.Paths.Locks),
|
|
filepath.Join(dir, backend.Paths.Keys),
|
|
filepath.Join(dir, backend.Paths.Temp),
|
|
}
|
|
|
|
// test if all necessary dirs are there
|
|
for _, d := range items {
|
|
if _, err := os.Stat(d); err != nil {
|
|
return nil, fmt.Errorf("%s does not exist", d)
|
|
}
|
|
}
|
|
|
|
return &Local{p: dir, open: make(map[string][]*os.File)}, 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(dir string) (*Local, error) {
|
|
dirs := []string{
|
|
dir,
|
|
filepath.Join(dir, backend.Paths.Data),
|
|
filepath.Join(dir, backend.Paths.Snapshots),
|
|
filepath.Join(dir, backend.Paths.Index),
|
|
filepath.Join(dir, backend.Paths.Locks),
|
|
filepath.Join(dir, backend.Paths.Keys),
|
|
filepath.Join(dir, backend.Paths.Temp),
|
|
}
|
|
|
|
// test if config file already exists
|
|
_, err := os.Lstat(filepath.Join(dir, backend.Paths.Config))
|
|
if err == nil {
|
|
return nil, errors.New("config file already exists")
|
|
}
|
|
|
|
// create paths for data, refs and temp
|
|
for _, d := range dirs {
|
|
err := os.MkdirAll(d, backend.Modes.Dir)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// open backend
|
|
return Open(dir)
|
|
}
|
|
|
|
// Location returns this backend's location (the directory name).
|
|
func (b *Local) Location() string {
|
|
return b.p
|
|
}
|
|
|
|
// Return temp directory in correct directory for this backend.
|
|
func (b *Local) tempFile() (*os.File, error) {
|
|
return ioutil.TempFile(filepath.Join(b.p, backend.Paths.Temp), "temp-")
|
|
}
|
|
|
|
type localBlob struct {
|
|
f *os.File
|
|
size uint
|
|
final bool
|
|
basedir string
|
|
}
|
|
|
|
func (lb *localBlob) Write(p []byte) (int, error) {
|
|
if lb.final {
|
|
return 0, errors.New("blob already closed")
|
|
}
|
|
|
|
n, err := lb.f.Write(p)
|
|
lb.size += uint(n)
|
|
return n, err
|
|
}
|
|
|
|
func (lb *localBlob) Size() uint {
|
|
return lb.size
|
|
}
|
|
|
|
func (lb *localBlob) Finalize(t backend.Type, name string) error {
|
|
if lb.final {
|
|
return errors.New("Already finalized")
|
|
}
|
|
|
|
lb.final = true
|
|
|
|
err := lb.f.Close()
|
|
if err != nil {
|
|
return fmt.Errorf("local: file.Close: %v", err)
|
|
}
|
|
|
|
f := filename(lb.basedir, t, name)
|
|
|
|
// create directories if necessary, ignore errors
|
|
if t == backend.Data {
|
|
os.MkdirAll(filepath.Dir(f), backend.Modes.Dir)
|
|
}
|
|
|
|
// test if new path already exists
|
|
if _, err := os.Stat(f); err == nil {
|
|
return fmt.Errorf("Close(): file %v already exists", f)
|
|
}
|
|
|
|
if err := os.Rename(lb.f.Name(), f); err != nil {
|
|
return err
|
|
}
|
|
|
|
// set mode to read-only
|
|
fi, err := os.Stat(f)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return setNewFileMode(f, fi)
|
|
}
|
|
|
|
// Create creates a new Blob. The data is available only after Finalize()
|
|
// has been called on the returned Blob.
|
|
func (b *Local) Create() (backend.Blob, error) {
|
|
// TODO: make sure that tempfile is removed upon error
|
|
|
|
// create tempfile in backend
|
|
file, err := b.tempFile()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
blob := localBlob{
|
|
f: file,
|
|
basedir: b.p,
|
|
}
|
|
|
|
b.mu.Lock()
|
|
open, _ := b.open["blobs"]
|
|
b.open["blobs"] = append(open, file)
|
|
b.mu.Unlock()
|
|
|
|
return &blob, nil
|
|
}
|
|
|
|
// Construct path for given Type and name.
|
|
func filename(base string, t backend.Type, name string) string {
|
|
if t == backend.Config {
|
|
return filepath.Join(base, "config")
|
|
}
|
|
|
|
return filepath.Join(dirname(base, t, name), name)
|
|
}
|
|
|
|
// Construct directory for given Type.
|
|
func dirname(base string, t backend.Type, name string) string {
|
|
var n string
|
|
switch t {
|
|
case backend.Data:
|
|
n = backend.Paths.Data
|
|
if len(name) > 2 {
|
|
n = filepath.Join(n, name[:2])
|
|
}
|
|
case backend.Snapshot:
|
|
n = backend.Paths.Snapshots
|
|
case backend.Index:
|
|
n = backend.Paths.Index
|
|
case backend.Lock:
|
|
n = backend.Paths.Locks
|
|
case backend.Key:
|
|
n = backend.Paths.Keys
|
|
}
|
|
return filepath.Join(base, n)
|
|
}
|
|
|
|
// GetReader returns an io.ReadCloser for the Blob with the given name of
|
|
// type t at offset and length. If length is 0, the reader reads until EOF.
|
|
func (b *Local) GetReader(t backend.Type, name string, offset, length uint) (io.ReadCloser, error) {
|
|
f, err := os.Open(filename(b.p, t, name))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
b.mu.Lock()
|
|
open, _ := b.open[filename(b.p, t, name)]
|
|
b.open[filename(b.p, t, name)] = append(open, f)
|
|
b.mu.Unlock()
|
|
|
|
if offset > 0 {
|
|
_, err = f.Seek(int64(offset), 0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if length == 0 {
|
|
return f, nil
|
|
}
|
|
|
|
return backend.LimitReadCloser(f, int64(length)), nil
|
|
}
|
|
|
|
// Test returns true if a blob of the given type and name exists in the backend.
|
|
func (b *Local) Test(t backend.Type, name string) (bool, error) {
|
|
_, err := os.Stat(filename(b.p, t, name))
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return false, nil
|
|
}
|
|
return false, err
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// Remove removes the blob with the given name and type.
|
|
func (b *Local) Remove(t backend.Type, name string) error {
|
|
// close all open files we may have.
|
|
fn := filename(b.p, t, name)
|
|
b.mu.Lock()
|
|
open, _ := b.open[fn]
|
|
for _, file := range open {
|
|
file.Close()
|
|
}
|
|
b.open[fn] = nil
|
|
b.mu.Unlock()
|
|
|
|
// reset read-only flag
|
|
err := os.Chmod(fn, 0666)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return os.Remove(fn)
|
|
}
|
|
|
|
// List returns a channel that yields all names of blobs of type t. A
|
|
// goroutine is started for this. If the channel done is closed, sending
|
|
// stops.
|
|
func (b *Local) List(t backend.Type, done <-chan struct{}) <-chan string {
|
|
// TODO: use os.Open() and d.Readdirnames() instead of Glob()
|
|
var pattern string
|
|
if t == backend.Data {
|
|
pattern = filepath.Join(dirname(b.p, t, ""), "*", "*")
|
|
} else {
|
|
pattern = filepath.Join(dirname(b.p, t, ""), "*")
|
|
}
|
|
|
|
ch := make(chan string)
|
|
matches, err := filepath.Glob(pattern)
|
|
if err != nil {
|
|
close(ch)
|
|
return ch
|
|
}
|
|
|
|
for i := range matches {
|
|
matches[i] = filepath.Base(matches[i])
|
|
}
|
|
|
|
sort.Strings(matches)
|
|
|
|
go func() {
|
|
defer close(ch)
|
|
for _, m := range matches {
|
|
if m == "" {
|
|
continue
|
|
}
|
|
|
|
select {
|
|
case ch <- m:
|
|
case <-done:
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
return ch
|
|
}
|
|
|
|
// Delete removes the repository and all files.
|
|
func (b *Local) Delete() error {
|
|
b.Close()
|
|
return os.RemoveAll(b.p)
|
|
}
|
|
|
|
// Close closes all open files.
|
|
// They may have been closed already,
|
|
// so we ignore all errors.
|
|
func (b *Local) Close() error {
|
|
b.mu.Lock()
|
|
for _, open := range b.open {
|
|
for _, file := range open {
|
|
file.Close()
|
|
}
|
|
}
|
|
b.open = make(map[string][]*os.File)
|
|
b.mu.Unlock()
|
|
return nil
|
|
}
|