fuse: move to top level

fuse/file.go

@@ -0,0 +1,135 @@
+package fuse
+
+import (
+	"sync"
+
+	"github.com/restic/restic"
+	"github.com/restic/restic/backend"
+	"github.com/restic/restic/pack"
+
+	"bazil.org/fuse"
+	"bazil.org/fuse/fs"
+	"golang.org/x/net/context"
+)
+
+// Statically ensure that *file implements the given interface
+var _ = fs.HandleReader(&file{})
+var _ = fs.HandleReleaser(&file{})
+
+// BlobLoader is an abstracted repository with a reduced set of methods used
+// for fuse operations.
+type BlobLoader interface {
+	LookupBlobSize(backend.ID) (uint, error)
+	LoadBlob(pack.BlobType, backend.ID, []byte) ([]byte, error)
+}
+
+type file struct {
+	repo BlobLoader
+	node *restic.Node
+
+	sizes []uint
+	blobs [][]byte
+}
+
+const defaultBlobSize = 128 * 1024
+
+var blobPool = sync.Pool{
+	New: func() interface{} {
+		return make([]byte, defaultBlobSize)
+	},
+}
+
+func newFile(repo BlobLoader, node *restic.Node) (*file, error) {
+	sizes := make([]uint, len(node.Content))
+	for i, id := range node.Content {
+		size, err := repo.LookupBlobSize(id)
+		if err != nil {
+			return nil, err
+		}
+
+		sizes[i] = size
+	}
+
+	return &file{
+		repo:  repo,
+		node:  node,
+		sizes: sizes,
+		blobs: make([][]byte, len(node.Content)),
+	}, nil
+}
+
+func (f *file) Attr(ctx context.Context, a *fuse.Attr) error {
+	a.Inode = f.node.Inode
+	a.Mode = f.node.Mode
+	a.Size = f.node.Size
+	return nil
+}
+
+func (f *file) getBlobAt(i int) (blob []byte, err error) {
+	if f.blobs[i] != nil {
+		return f.blobs[i], nil
+	}
+
+	buf := blobPool.Get().([]byte)
+	buf = buf[:cap(buf)]
+
+	if uint(len(buf)) < f.sizes[i] {
+		if len(buf) > defaultBlobSize {
+			blobPool.Put(buf)
+		}
+		buf = make([]byte, f.sizes[i])
+	}
+
+	blob, err = f.repo.LoadBlob(pack.Data, f.node.Content[i], buf)
+	if err != nil {
+		return nil, err
+	}
+	f.blobs[i] = blob
+
+	return blob, nil
+}
+
+func (f *file) Read(ctx context.Context, req *fuse.ReadRequest, resp *fuse.ReadResponse) error {
+	offset := req.Offset
+
+	// Skip blobs before the offset
+	startContent := 0
+	for offset > int64(f.sizes[startContent]) {
+		offset -= int64(f.sizes[startContent])
+		startContent++
+	}
+
+	dst := resp.Data[0:req.Size]
+	readBytes := 0
+	remainingBytes := req.Size
+	for i := startContent; remainingBytes > 0 && i < len(f.sizes); i++ {
+		blob, err := f.getBlobAt(i)
+		if err != nil {
+			return err
+		}
+
+		if offset > 0 {
+			blob = blob[offset:len(blob)]
+			offset = 0
+		}
+
+		copied := copy(dst, blob)
+		remainingBytes -= copied
+		readBytes += copied
+
+		dst = dst[copied:]
+	}
+	resp.Data = resp.Data[:readBytes]
+
+	return nil
+}
+
+func (f *file) Release(ctx context.Context, req *fuse.ReleaseRequest) error {
+	for i := range f.blobs {
+		if f.blobs[i] != nil {
+			blobPool.Put(f.blobs[i])
+			f.blobs[i] = nil
+		}
+	}
+	return nil
+}