From b1426826ccb279fa04607d337c4dc1a299457f26 Mon Sep 17 00:00:00 2001 From: Matthieu Rakotojaona Date: Sun, 19 Jul 2015 14:28:11 +0200 Subject: [PATCH] Extract fuse structs --- cmd/restic/cmd_mount.go | 282 +--------------------------------------- cmd/restic/fuse/dir.go | 100 ++++++++++++++ cmd/restic/fuse/file.go | 98 ++++++++++++++ 3 files changed, 204 insertions(+), 276 deletions(-) create mode 100644 cmd/restic/fuse/dir.go create mode 100644 cmd/restic/fuse/file.go diff --git a/cmd/restic/cmd_mount.go b/cmd/restic/cmd_mount.go index 033c98850..d06274d00 100644 --- a/cmd/restic/cmd_mount.go +++ b/cmd/restic/cmd_mount.go @@ -3,21 +3,12 @@ package main import ( - "encoding/binary" "fmt" "os" - "sync" - "time" - "golang.org/x/net/context" + "github.com/restic/restic/cmd/restic/fuse" - "github.com/restic/restic" - "github.com/restic/restic/backend" - "github.com/restic/restic/crypto" - "github.com/restic/restic/pack" - "github.com/restic/restic/repository" - - "bazil.org/fuse" + systemFuse "bazil.org/fuse" "bazil.org/fuse/fs" ) @@ -66,20 +57,17 @@ func (cmd CmdMount) Execute(args []string) error { return err } } - c, err := fuse.Mount( + c, err := systemFuse.Mount( mountpoint, - fuse.ReadOnly(), - fuse.FSName("restic"), + systemFuse.ReadOnly(), + systemFuse.FSName("restic"), ) if err != nil { return err } root := fs.Tree{} - root.Add("snapshots", &snapshots{ - repo: repo, - knownSnapshots: make(map[string]snapshotWithId), - }) + root.Add("snapshots", fuse.NewSnapshotsDir(repo)) cmd.global.Printf("Now serving %s at %s\n", repo.Backend().Location(), mountpoint) cmd.global.Printf("Don't forget to umount after quitting!\n") @@ -94,261 +82,3 @@ func (cmd CmdMount) Execute(args []string) error { <-c.Ready return c.MountError } - -type snapshotWithId struct { - *restic.Snapshot - backend.ID -} - -// These lines statically ensure that a *snapshots implement the given -// interfaces; a misplaced refactoring of the implementation that breaks -// the interface will be catched by the compiler -var _ = fs.HandleReadDirAller(&snapshots{}) -var _ = fs.NodeStringLookuper(&snapshots{}) - -type snapshots struct { - repo *repository.Repository - - // knownSnapshots maps snapshot timestamp to the snapshot - sync.RWMutex - knownSnapshots map[string]snapshotWithId -} - -func (sn *snapshots) Attr(ctx context.Context, attr *fuse.Attr) error { - attr.Inode = 0 - attr.Mode = os.ModeDir | 0555 - return nil -} - -func (sn *snapshots) updateCache(ctx context.Context) error { - sn.Lock() - defer sn.Unlock() - - for id := range sn.repo.List(backend.Snapshot, ctx.Done()) { - snapshot, err := restic.LoadSnapshot(sn.repo, id) - if err != nil { - return err - } - sn.knownSnapshots[snapshot.Time.Format(time.RFC3339)] = snapshotWithId{snapshot, id} - } - return nil -} -func (sn *snapshots) get(name string) (snapshot snapshotWithId, ok bool) { - sn.Lock() - snapshot, ok = sn.knownSnapshots[name] - sn.Unlock() - return snapshot, ok -} - -func (sn *snapshots) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) { - err := sn.updateCache(ctx) - if err != nil { - return nil, err - } - - sn.RLock() - defer sn.RUnlock() - - ret := make([]fuse.Dirent, 0) - for _, snapshot := range sn.knownSnapshots { - ret = append(ret, fuse.Dirent{ - Inode: binary.BigEndian.Uint64(snapshot.ID[:8]), - Type: fuse.DT_Dir, - Name: snapshot.Time.Format(time.RFC3339), - }) - } - - return ret, nil -} - -func (sn *snapshots) Lookup(ctx context.Context, name string) (fs.Node, error) { - snapshot, ok := sn.get(name) - - if !ok { - // We don't know about it, update the cache - err := sn.updateCache(ctx) - if err != nil { - return nil, err - } - snapshot, ok = sn.get(name) - if !ok { - // We still don't know about it, this time it really doesn't exist - return nil, fuse.ENOENT - } - } - - return newDirFromSnapshot(sn.repo, snapshot) -} - -// Statically ensure that *dir implement those interface -var _ = fs.HandleReadDirAller(&dir{}) -var _ = fs.NodeStringLookuper(&dir{}) - -type dir struct { - repo *repository.Repository - children map[string]*restic.Node - inode uint64 -} - -func newDir(repo *repository.Repository, node *restic.Node) (*dir, error) { - tree, err := restic.LoadTree(repo, node.Subtree) - if err != nil { - return nil, err - } - children := make(map[string]*restic.Node) - for _, child := range tree.Nodes { - children[child.Name] = child - } - - return &dir{ - repo: repo, - children: children, - inode: node.Inode, - }, nil -} - -func newDirFromSnapshot(repo *repository.Repository, snapshot snapshotWithId) (*dir, error) { - tree, err := restic.LoadTree(repo, snapshot.Tree) - if err != nil { - return nil, err - } - children := make(map[string]*restic.Node) - for _, node := range tree.Nodes { - children[node.Name] = node - } - - return &dir{ - repo: repo, - children: children, - inode: binary.BigEndian.Uint64(snapshot.ID), - }, nil -} - -func (d *dir) Attr(ctx context.Context, a *fuse.Attr) error { - a.Inode = d.inode - a.Mode = os.ModeDir | 0555 - return nil -} - -func (d *dir) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) { - ret := make([]fuse.Dirent, 0, len(d.children)) - - for _, node := range d.children { - var typ fuse.DirentType - switch { - case node.Mode.IsDir(): - typ = fuse.DT_Dir - case node.Mode.IsRegular(): - typ = fuse.DT_File - } - - ret = append(ret, fuse.Dirent{ - Inode: node.Inode, - Type: typ, - Name: node.Name, - }) - } - - return ret, nil -} - -func (d *dir) Lookup(ctx context.Context, name string) (fs.Node, error) { - child, ok := d.children[name] - if !ok { - return nil, fuse.ENOENT - } - switch { - case child.Mode.IsDir(): - return newDir(d.repo, child) - case child.Mode.IsRegular(): - return newFile(d.repo, child) - default: - return nil, fuse.ENOENT - } -} - -// Statically ensure that *file implements the given interface -var _ = fs.HandleReader(&file{}) - -type file struct { - repo *repository.Repository - node *restic.Node - - sizes []uint32 - blobs [][]byte -} - -func newFile(repo *repository.Repository, node *restic.Node) (*file, error) { - sizes := make([]uint32, len(node.Content)) - for i, blobId := range node.Content { - _, _, _, length, err := repo.Index().Lookup(blobId) - if err != nil { - return nil, err - } - sizes[i] = uint32(length) - crypto.Extension - } - - 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 { - blob = f.blobs[i] - } else { - blob, err = f.repo.LoadBlob(pack.Data, f.node.Content[i]) - 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 { - off := req.Offset - - // Skip blobs before the offset - startContent := 0 - for off > int64(f.sizes[startContent]) { - off -= int64(f.sizes[startContent]) - startContent++ - } - - content := make([]byte, req.Size) - allContent := content - for i := startContent; i < len(f.sizes); i++ { - blob, err := f.getBlobAt(i) - if err != nil { - return err - } - - blob = blob[off:] - off = 0 - - var copied int - if len(blob) > len(content) { - copied = copy(content[0:], blob[:len(content)]) - } else { - copied = copy(content[0:], blob) - } - content = content[copied:] - if len(content) == 0 { - break - } - } - resp.Data = allContent - return nil -} diff --git a/cmd/restic/fuse/dir.go b/cmd/restic/fuse/dir.go new file mode 100644 index 000000000..ef9ad9a73 --- /dev/null +++ b/cmd/restic/fuse/dir.go @@ -0,0 +1,100 @@ +package fuse + +import ( + "encoding/binary" + "os" + + "bazil.org/fuse" + "bazil.org/fuse/fs" + "golang.org/x/net/context" + + "github.com/restic/restic" + "github.com/restic/restic/repository" +) + +// Statically ensure that *dir implement those interface +var _ = fs.HandleReadDirAller(&dir{}) +var _ = fs.NodeStringLookuper(&dir{}) + +type dir struct { + repo *repository.Repository + children map[string]*restic.Node + inode uint64 +} + +func newDir(repo *repository.Repository, node *restic.Node) (*dir, error) { + tree, err := restic.LoadTree(repo, node.Subtree) + if err != nil { + return nil, err + } + children := make(map[string]*restic.Node) + for _, child := range tree.Nodes { + children[child.Name] = child + } + + return &dir{ + repo: repo, + children: children, + inode: node.Inode, + }, nil +} + +func newDirFromSnapshot(repo *repository.Repository, snapshot SnapshotWithId) (*dir, error) { + tree, err := restic.LoadTree(repo, snapshot.Tree) + if err != nil { + return nil, err + } + children := make(map[string]*restic.Node) + for _, node := range tree.Nodes { + children[node.Name] = node + } + + return &dir{ + repo: repo, + children: children, + inode: binary.BigEndian.Uint64(snapshot.ID), + }, nil +} + +func (d *dir) Attr(ctx context.Context, a *fuse.Attr) error { + a.Inode = d.inode + a.Mode = os.ModeDir | 0555 + return nil +} + +func (d *dir) ReadDirAll(ctx context.Context) ([]fuse.Dirent, error) { + ret := make([]fuse.Dirent, 0, len(d.children)) + + for _, node := range d.children { + var typ fuse.DirentType + switch { + case node.Mode.IsDir(): + typ = fuse.DT_Dir + case node.Mode.IsRegular(): + typ = fuse.DT_File + } + + ret = append(ret, fuse.Dirent{ + Inode: node.Inode, + Type: typ, + Name: node.Name, + }) + } + + return ret, nil +} + +func (d *dir) Lookup(ctx context.Context, name string) (fs.Node, error) { + child, ok := d.children[name] + if !ok { + return nil, fuse.ENOENT + } + switch { + case child.Mode.IsDir(): + return newDir(d.repo, child) + case child.Mode.IsRegular(): + return newFile(d.repo, child) + default: + return nil, fuse.ENOENT + } +} diff --git a/cmd/restic/fuse/file.go b/cmd/restic/fuse/file.go new file mode 100644 index 000000000..ff28ebf85 --- /dev/null +++ b/cmd/restic/fuse/file.go @@ -0,0 +1,98 @@ +package fuse + +import ( + "github.com/restic/restic" + "github.com/restic/restic/crypto" + "github.com/restic/restic/pack" + "github.com/restic/restic/repository" + + "bazil.org/fuse" + "bazil.org/fuse/fs" + "golang.org/x/net/context" +) + +// Statically ensure that *file implements the given interface +var _ = fs.HandleReader(&file{}) + +type file struct { + repo *repository.Repository + node *restic.Node + + sizes []uint32 + blobs [][]byte +} + +func newFile(repo *repository.Repository, node *restic.Node) (*file, error) { + sizes := make([]uint32, len(node.Content)) + for i, blobId := range node.Content { + _, _, _, length, err := repo.Index().Lookup(blobId) + if err != nil { + return nil, err + } + sizes[i] = uint32(length) - crypto.Extension + } + + 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 { + blob = f.blobs[i] + } else { + blob, err = f.repo.LoadBlob(pack.Data, f.node.Content[i]) + 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 { + off := req.Offset + + // Skip blobs before the offset + startContent := 0 + for off > int64(f.sizes[startContent]) { + off -= int64(f.sizes[startContent]) + startContent++ + } + + content := make([]byte, req.Size) + allContent := content + for i := startContent; i < len(f.sizes); i++ { + blob, err := f.getBlobAt(i) + if err != nil { + return err + } + + blob = blob[off:] + off = 0 + + var copied int + if len(blob) > len(content) { + copied = copy(content[0:], blob[:len(content)]) + } else { + copied = copy(content[0:], blob) + } + content = content[copied:] + if len(content) == 0 { + break + } + } + resp.Data = allContent + return nil +}