package fuse
import (
"bazil.org/fuse/fs"
)
type FS struct {
backend Backend
}
var _ = fs.FS(&FS{})
func (f *FS) Root() (fs.Node, error) {
n := &Dir{
fs: f,
path: []string{},
}
return n, nil
}
var _ = fs.FSDestroyer(&FS{})
func (f *FS) Destroy() {
f.backend.Close()
}
package fstestutil
import (
"os"
"bazil.org/fuse"
"bazil.org/fuse/fs"
"golang.org/x/net/context"
)
// SimpleFS is a trivial FS that just implements the Root method.
type SimpleFS struct {
Node fs.Node
}
var _ = fs.FS(SimpleFS{})
func (f SimpleFS) Root() (fs.Node, error) {
return f.Node, nil
}
// File can be embedded in a struct to make it look like a file.
type File struct{}
func (f File) Attr(ctx context.Context, a *fuse.Attr) error {
a.Mode = 0666
return nil
}
// Dir can be embedded in a struct to make it look like a directory.
type Dir struct{}
// caller may set cwd, so we can't rely on relative paths
executable, err := filepath.Abs(os.Args[0])
if err != nil {
return nil, err
}
testName = regexp.QuoteMeta(testName)
cmd := exec.Command(executable, "-test.run=^"+testName+"$", "-fuse.internal.childmode")
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd, nil
}
// childMapFS is an FS with one fixed child named "child".
type childMapFS map[string]fs.Node
var _ = fs.FS(childMapFS{})
var _ = fs.Node(childMapFS{})
var _ = fs.NodeStringLookuper(childMapFS{})
func (f childMapFS) Attr() fuse.Attr {
return fuse.Attr{Inode: 1, Mode: os.ModeDir | 0777}
}
func (f childMapFS) Root() (fs.Node, fuse.Error) {
return f, nil
}
func (f childMapFS) Lookup(name string, intr fs.Intr) (fs.Node, fuse.Error) {
child, ok := f[name]
if !ok {
return nil, fuse.ENOENT
"testing"
"bazil.org/fuse"
"bazil.org/fuse/fs"
"bazil.org/fuse/fs/fstestutil"
)
type benchConfig struct {
directIO bool
}
type benchFS struct {
conf *benchConfig
}
var _ = fs.FS(benchFS{})
var _ = fs.FSIniter(benchFS{})
func (benchFS) Init(req *fuse.InitRequest, resp *fuse.InitResponse, intr fs.Intr) fuse.Error {
resp.MaxReadahead = 64 * 1024 * 1024
resp.Flags |= fuse.InitAsyncRead
return nil
}
func (f benchFS) Root() (fs.Node, fuse.Error) {
return benchDir{conf: f.conf}, nil
}
type benchDir struct {
conf *benchConfig
}
"bazil.org/bazil/fs/wire"
"bazil.org/bazil/tokens"
"bazil.org/fuse"
"bazil.org/fuse/fs"
"code.google.com/p/goprotobuf/proto"
"github.com/boltdb/bolt"
)
type Volume struct {
mu sync.Mutex
db *bolt.DB
volID VolumeID
chunkStore chunks.Store
}
var _ = fs.FS(&Volume{})
var _ = fs.FSIniter(&Volume{})
var bucketVolume = []byte(tokens.BucketVolume)
var bucketVolName = []byte(tokens.BucketVolName)
var bucketDir = []byte("dir")
var bucketInode = []byte("inode")
var bucketSnap = []byte("snap")
func (v *Volume) bucket(tx *bolt.Tx) *bolt.Bucket {
b := tx.Bucket(bucketVolume)
b = b.Bucket(v.volID.Bytes())
return b
}
// Open returns a FUSE filesystem instance serving content from the