package cache import ( "context" "io" "github.com/restic/restic/internal/debug" "github.com/restic/restic/internal/restic" ) // Backend wraps a restic.Backend and adds a cache. type Backend struct { restic.Backend restic.Cache } // ensure cachedBackend implements restic.Backend var _ restic.Backend = &Backend{} // Remove deletes a file from the backend and the cache if it has been cached. func (b *Backend) Remove(ctx context.Context, h restic.Handle) error { debug.Log("cache Remove(%v)", h) err := b.Backend.Remove(ctx, h) if err != nil { return err } return b.Cache.Remove(h) } type teeReader struct { rd io.Reader wr io.Writer err error } func (t *teeReader) Read(p []byte) (n int, err error) { n, err = t.rd.Read(p) if t.err == nil && n > 0 { _, t.err = t.wr.Write(p[:n]) } return n, err } var autoCacheTypes = map[restic.FileType]struct{}{ restic.IndexFile: struct{}{}, restic.SnapshotFile: struct{}{}, } // Save stores a new file is the backend and the cache. func (b *Backend) Save(ctx context.Context, h restic.Handle, rd io.Reader) (err error) { debug.Log("cache Save(%v)", h) if _, ok := autoCacheTypes[h.Type]; !ok { return b.Backend.Save(ctx, h, rd) } wr, err := b.Cache.SaveWriter(h) if err != nil { debug.Log("unable to save object to cache: %v", err) return b.Backend.Save(ctx, h, rd) } tr := &teeReader{rd: rd, wr: wr} err = b.Backend.Save(ctx, h, tr) if err != nil { wr.Close() b.Cache.Remove(h) return err } err = wr.Close() if err != nil { debug.Log("cache writer returned error: %v", err) b.Cache.Remove(h) } return nil } var autoCacheFiles = map[restic.FileType]bool{ restic.IndexFile: true, restic.SnapshotFile: true, } // Load loads a file from the cache or the backend. func (b *Backend) Load(ctx context.Context, h restic.Handle, length int, offset int64) (io.ReadCloser, error) { if b.Cache.Has(h) { debug.Log("Load(%v, %v, %v) from cache", h, length, offset) return b.Cache.Load(h, length, offset) } debug.Log("Load(%v, %v, %v) delegated to backend", h, length, offset) rd, err := b.Backend.Load(ctx, h, length, offset) if err != nil { if b.Backend.IsNotExist(err) { // try to remove from the cache, ignore errors _ = b.Cache.Remove(h) } return nil, err } // only cache complete files if offset != 0 || length != 0 { debug.Log("won't store partial file %v", h) return rd, err } if _, ok := autoCacheFiles[h.Type]; !ok { debug.Log("wrong type for auto store %v", h) return rd, nil } debug.Log("auto-store %v in the cache", h) // cache the file, then return cached copy if err = b.Cache.Save(h, rd); err != nil { return nil, err } if err = rd.Close(); err != nil { // try to remove from the cache, ignore errors _ = b.Cache.Remove(h) return nil, err } // load from the cache and save in the backend return b.Cache.Load(h, 0, 0) } // Stat tests whether the backend has a file. If it does not exist but still // exists in the cache, it is removed from the cache. func (b *Backend) Stat(ctx context.Context, h restic.Handle) (restic.FileInfo, error) { debug.Log("cache Stat(%v)", h) fi, err := b.Backend.Stat(ctx, h) if err != nil { if b.Backend.IsNotExist(err) { // try to remove from the cache, ignore errors _ = b.Cache.Remove(h) } return fi, err } return fi, err } // IsNotExist returns true if the error is caused by a non-existing file. func (b *Backend) IsNotExist(err error) bool { return b.Backend.IsNotExist(err) }