Use the FileSystem interface in the samples.

samples/cachingfs/caching_fs.go

@@ -16,12 +16,12 @@ package cachingfs
 
 import (
 	"fmt"
-	"io"
 	"os"
 	"time"
 
 	"github.com/jacobsa/fuse"
 	"github.com/jacobsa/fuse/fuseops"
+	"github.com/jacobsa/fuse/fuseutil"
 	"github.com/jacobsa/gcloud/syncutil"
 )
 
@@ -42,7 +42,7 @@ const (
 // requests. It also exposes methods for renumbering inodes and updating mtimes
 // that are useful in testing that these durations are honored.
 type CachingFS interface {
-	fuse.Server
+	fuseutil.FileSystem
 
 	// Return the current inode ID of the file/directory with the given name.
 	FooID() fuseops.InodeID
@@ -99,6 +99,8 @@ const (
 )
 
 type cachingFS struct {
+	fuseutil.NotImplementedFileSystem
+
 	/////////////////////////
 	// Constant data
 	/////////////////////////
@@ -232,53 +234,18 @@ func (fs *cachingFS) SetMtime(mtime time.Time) {
 	fs.mtime = mtime
 }
 
-// LOCKS_EXCLUDED(fs.mu)
-func (fs *cachingFS) ServeOps(c *fuse.Connection) {
-	for {
-		op, err := c.ReadOp()
-		if err == io.EOF {
-			break
-		}
-
-		if err != nil {
-			panic(err)
-		}
-
-		switch typed := op.(type) {
-		case *fuseops.InitOp:
-			fs.init(typed)
-
-		case *fuseops.LookUpInodeOp:
-			fs.lookUpInode(typed)
-
-		case *fuseops.GetInodeAttributesOp:
-			fs.getInodeAttributes(typed)
-
-		case *fuseops.OpenDirOp:
-			fs.openDir(typed)
-
-		case *fuseops.OpenFileOp:
-			fs.openFile(typed)
-
-		default:
-			typed.Respond(fuse.ENOSYS)
-		}
-	}
-}
-
 ////////////////////////////////////////////////////////////////////////
-// Op methods
+// FileSystem methods
 ////////////////////////////////////////////////////////////////////////
 
-func (fs *cachingFS) init(op *fuseops.InitOp) {
-	op.Respond(nil)
+func (fs *cachingFS) Init(
+	op *fuseops.InitOp) (err error) {
+	return
 }
 
 // LOCKS_EXCLUDED(fs.mu)
-func (fs *cachingFS) lookUpInode(op *fuseops.LookUpInodeOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *cachingFS) LookUpInode(
+	op *fuseops.LookUpInodeOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -331,10 +298,8 @@ func (fs *cachingFS) lookUpInode(op *fuseops.LookUpInodeOp) {
 }
 
 // LOCKS_EXCLUDED(fs.mu)
-func (fs *cachingFS) getInodeAttributes(op *fuseops.GetInodeAttributesOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *cachingFS) GetInodeAttributes(
+	op *fuseops.GetInodeAttributesOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -362,16 +327,12 @@ func (fs *cachingFS) getInodeAttributes(op *fuseops.GetInodeAttributesOp) {
 	return
 }
 
-func (fs *cachingFS) openDir(op *fuseops.OpenDirOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *cachingFS) OpenDir(
+	op *fuseops.OpenDirOp) (err error) {
 	return
 }
 
-func (fs *cachingFS) openFile(op *fuseops.OpenFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *cachingFS) OpenFile(
+	op *fuseops.OpenFileOp) (err error) {
 	return
 }

samples/cachingfs/caching_fs_test.go

@@ -23,6 +23,7 @@ import (
 	"time"
 
 	"github.com/googlecloudplatform/gcsfuse/timeutil"
+	"github.com/jacobsa/fuse/fuseutil"
 	"github.com/jacobsa/fuse/samples"
 	"github.com/jacobsa/fuse/samples/cachingfs"
 	. "github.com/jacobsa/oglematchers"
@@ -54,7 +55,7 @@ func (t *cachingFSTest) setUp(
 	t.fs, err = cachingfs.NewCachingFS(lookupEntryTimeout, getattrTimeout)
 	AssertEq(nil, err)
 
-	t.Server = t.fs
+	t.Server = fuseutil.NewFileSystemServer(t.fs)
 
 	// Mount it.
 	t.SampleTest.SetUp(ti)

samples/flushfs/flush_fs.go

@@ -16,12 +16,12 @@ package flushfs
 
 import (
 	"fmt"
-	"io"
 	"os"
 	"sync"
 
 	"github.com/jacobsa/fuse"
 	"github.com/jacobsa/fuse/fuseops"
+	"github.com/jacobsa/fuse/fuseutil"
 )
 
 // Create a file system whose sole contents are a file named "foo" and a
@@ -35,11 +35,12 @@ import (
 func NewFileSystem(
 	reportFlush func(string) error,
 	reportFsync func(string) error) (server fuse.Server, err error) {
-	server = &flushFS{
+	fs := &flushFS{
 		reportFlush: reportFlush,
 		reportFsync: reportFsync,
 	}
 
+	server = fuseutil.NewFileSystemServer(fs)
 	return
 }
 
@@ -49,6 +50,8 @@ const (
 )
 
 type flushFS struct {
+	fuseutil.NotImplementedFileSystem
+
 	reportFlush func(string) error
 	reportFsync func(string) error
 
@@ -85,67 +88,17 @@ func (fs *flushFS) barAttributes() fuseops.InodeAttributes {
 	}
 }
 
-// LOCKS_REQUIRED(fs.mu)
-func (fs *flushFS) ServeOps(c *fuse.Connection) {
-	for {
-		op, err := c.ReadOp()
-		if err == io.EOF {
-			break
-		}
-
-		if err != nil {
-			panic(err)
-		}
-
-		switch typed := op.(type) {
-		case *fuseops.InitOp:
-			fs.init(typed)
-
-		case *fuseops.LookUpInodeOp:
-			fs.lookUpInode(typed)
-
-		case *fuseops.GetInodeAttributesOp:
-			fs.getInodeAttributes(typed)
-
-		case *fuseops.OpenFileOp:
-			fs.openFile(typed)
-
-		case *fuseops.ReadFileOp:
-			fs.readFile(typed)
-
-		case *fuseops.WriteFileOp:
-			fs.writeFile(typed)
-
-		case *fuseops.SyncFileOp:
-			fs.syncFile(typed)
-
-		case *fuseops.FlushFileOp:
-			fs.flushFile(typed)
-
-		case *fuseops.OpenDirOp:
-			fs.openDir(typed)
-
-		default:
-			typed.Respond(fuse.ENOSYS)
-		}
-	}
-}
-
 ////////////////////////////////////////////////////////////////////////
-// Op methods
+// FileSystem methods
 ////////////////////////////////////////////////////////////////////////
 
-func (fs *flushFS) init(op *fuseops.InitOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *flushFS) Init(
+	op *fuseops.InitOp) (err error) {
 	return
 }
 
-func (fs *flushFS) lookUpInode(op *fuseops.LookUpInodeOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *flushFS) LookUpInode(
+	op *fuseops.LookUpInodeOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -177,10 +130,8 @@ func (fs *flushFS) lookUpInode(op *fuseops.LookUpInodeOp) {
 	return
 }
 
-func (fs *flushFS) getInodeAttributes(op *fuseops.GetInodeAttributesOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *flushFS) GetInodeAttributes(
+	op *fuseops.GetInodeAttributesOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -203,10 +154,8 @@ func (fs *flushFS) getInodeAttributes(op *fuseops.GetInodeAttributesOp) {
 	}
 }
 
-func (fs *flushFS) openFile(op *fuseops.OpenFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *flushFS) OpenFile(
+	op *fuseops.OpenFileOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -219,10 +168,8 @@ func (fs *flushFS) openFile(op *fuseops.OpenFileOp) {
 	return
 }
 
-func (fs *flushFS) readFile(op *fuseops.ReadFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *flushFS) ReadFile(
+	op *fuseops.ReadFileOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -238,10 +185,8 @@ func (fs *flushFS) readFile(op *fuseops.ReadFileOp) {
 	return
 }
 
-func (fs *flushFS) writeFile(op *fuseops.WriteFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *flushFS) WriteFile(
+	op *fuseops.WriteFileOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -263,10 +208,8 @@ func (fs *flushFS) writeFile(op *fuseops.WriteFileOp) {
 	return
 }
 
-func (fs *flushFS) syncFile(op *fuseops.SyncFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *flushFS) SyncFile(
+	op *fuseops.SyncFileOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -274,10 +217,8 @@ func (fs *flushFS) syncFile(op *fuseops.SyncFileOp) {
 	return
 }
 
-func (fs *flushFS) flushFile(op *fuseops.FlushFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *flushFS) FlushFile(
+	op *fuseops.FlushFileOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -285,10 +226,8 @@ func (fs *flushFS) flushFile(op *fuseops.FlushFileOp) {
 	return
 }
 
-func (fs *flushFS) openDir(op *fuseops.OpenDirOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *flushFS) OpenDir(
+	op *fuseops.OpenDirOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 

samples/hellofs/hello_fs.go

@@ -33,54 +33,18 @@ import (
 //
 // Each file contains the string "Hello, world!".
 func NewHelloFS(clock timeutil.Clock) (server fuse.Server, err error) {
-	server = &helloFS{
+	fs := &helloFS{
 		Clock: clock,
 	}
 
+	server = fuseutil.NewFileSystemServer(fs)
 	return
 }
 
 type helloFS struct {
-	Clock timeutil.Clock
-}
-
-func (fs *helloFS) ServeOps(c *fuse.Connection) {
-	for {
-		op, err := c.ReadOp()
-		if err == io.EOF {
-			break
-		}
-
-		if err != nil {
-			panic(err)
-		}
-
-		switch typed := op.(type) {
-		case *fuseops.InitOp:
-			fs.init(typed)
-
-		case *fuseops.LookUpInodeOp:
-			fs.lookUpInode(typed)
-
-		case *fuseops.GetInodeAttributesOp:
-			fs.getInodeAttributes(typed)
-
-		case *fuseops.OpenDirOp:
-			fs.openDir(typed)
-
-		case *fuseops.ReadDirOp:
-			fs.readDir(typed)
+	fuseutil.NotImplementedFileSystem
 
-		case *fuseops.OpenFileOp:
-			fs.openFile(typed)
-
-		case *fuseops.ReadFileOp:
-			fs.readFile(typed)
-
-		default:
-			typed.Respond(fuse.ENOSYS)
-		}
-	}
+	Clock timeutil.Clock
 }
 
 const (
@@ -183,14 +147,11 @@ func (fs *helloFS) patchAttributes(
 	attr.Crtime = now
 }
 
-func (fs *helloFS) init(op *fuseops.InitOp) {
-	op.Respond(nil)
+func (fs *helloFS) Init(op *fuseops.InitOp) (err error) {
+	return
 }
 
-func (fs *helloFS) lookUpInode(op *fuseops.LookUpInodeOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *helloFS) LookUpInode(op *fuseops.LookUpInodeOp) (err error) {
 	// Find the info for the parent.
 	parentInfo, ok := gInodeInfo[op.Parent]
 	if !ok {
@@ -214,10 +175,8 @@ func (fs *helloFS) lookUpInode(op *fuseops.LookUpInodeOp) {
 	return
 }
 
-func (fs *helloFS) getInodeAttributes(op *fuseops.GetInodeAttributesOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *helloFS) GetInodeAttributes(
+	op *fuseops.GetInodeAttributesOp) (err error) {
 	// Find the info for this inode.
 	info, ok := gInodeInfo[op.Inode]
 	if !ok {
@@ -234,15 +193,14 @@ func (fs *helloFS) getInodeAttributes(op *fuseops.GetInodeAttributesOp) {
 	return
 }
 
-func (fs *helloFS) openDir(op *fuseops.OpenDirOp) {
+func (fs *helloFS) OpenDir(
+	op *fuseops.OpenDirOp) (err error) {
 	// Allow opening any directory.
-	op.Respond(nil)
+	return
 }
 
-func (fs *helloFS) readDir(op *fuseops.ReadDirOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *helloFS) ReadDir(
+	op *fuseops.ReadDirOp) (err error) {
 	// Find the info for this inode.
 	info, ok := gInodeInfo[op.Inode]
 	if !ok {
@@ -277,15 +235,14 @@ func (fs *helloFS) readDir(op *fuseops.ReadDirOp) {
 	return
 }
 
-func (fs *helloFS) openFile(op *fuseops.OpenFileOp) {
+func (fs *helloFS) OpenFile(
+	op *fuseops.OpenFileOp) (err error) {
 	// Allow opening any file.
-	op.Respond(nil)
+	return
 }
 
-func (fs *helloFS) readFile(op *fuseops.ReadFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *helloFS) ReadFile(
+	op *fuseops.ReadFileOp) (err error) {
 	// Let io.ReaderAt deal with the semantics.
 	reader := strings.NewReader("Hello, world!")
 

samples/memfs/fs.go

@@ -28,6 +28,8 @@ import (
 )
 
 type memFS struct {
+	fuseutil.NotImplementedFileSystem
+
 	/////////////////////////
 	// Dependencies
 	/////////////////////////
@@ -86,70 +88,13 @@ func NewMemFS(
 	// Set up invariant checking.
 	fs.mu = syncutil.NewInvariantMutex(fs.checkInvariants)
 
-	return fs
+	return fuseutil.NewFileSystemServer(fs)
 }
 
 ////////////////////////////////////////////////////////////////////////
 // Helpers
 ////////////////////////////////////////////////////////////////////////
 
-func (fs *memFS) ServeOps(c *fuse.Connection) {
-	for {
-		op, err := c.ReadOp()
-		if err == io.EOF {
-			break
-		}
-
-		if err != nil {
-			panic(err)
-		}
-
-		switch typed := op.(type) {
-		case *fuseops.InitOp:
-			fs.init(typed)
-
-		case *fuseops.LookUpInodeOp:
-			fs.lookUpInode(typed)
-
-		case *fuseops.GetInodeAttributesOp:
-			fs.getInodeAttributes(typed)
-
-		case *fuseops.SetInodeAttributesOp:
-			fs.setInodeAttributes(typed)
-
-		case *fuseops.MkDirOp:
-			fs.mkDir(typed)
-
-		case *fuseops.CreateFileOp:
-			fs.createFile(typed)
-
-		case *fuseops.RmDirOp:
-			fs.rmDir(typed)
-
-		case *fuseops.UnlinkOp:
-			fs.unlink(typed)
-
-		case *fuseops.OpenDirOp:
-			fs.openDir(typed)
-
-		case *fuseops.ReadDirOp:
-			fs.readDir(typed)
-
-		case *fuseops.OpenFileOp:
-			fs.openFile(typed)
-
-		case *fuseops.ReadFileOp:
-			fs.readFile(typed)
-
-		case *fuseops.WriteFileOp:
-			fs.writeFile(typed)
-
-		default:
-			typed.Respond(fuse.ENOSYS)
-		}
-	}
-}
-
 func (fs *memFS) checkInvariants() {
 	// Check reserved inodes.
 	for i := 0; i < fuseops.RootInodeID; i++ {
@@ -251,20 +196,16 @@ func (fs *memFS) deallocateInode(id fuseops.InodeID) {
 }
 
 ////////////////////////////////////////////////////////////////////////
-// Op methods
+// FileSystem methods
 ////////////////////////////////////////////////////////////////////////
 
-func (fs *memFS) init(op *fuseops.InitOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) Init(
+	op *fuseops.InitOp) (err error) {
 	return
 }
 
-func (fs *memFS) lookUpInode(op *fuseops.LookUpInodeOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) LookUpInode(
+	op *fuseops.LookUpInodeOp) (err error) {
 	fs.mu.RLock()
 	defer fs.mu.RUnlock()
 
@@ -295,10 +236,8 @@ func (fs *memFS) lookUpInode(op *fuseops.LookUpInodeOp) {
 	return
 }
 
-func (fs *memFS) getInodeAttributes(op *fuseops.GetInodeAttributesOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) GetInodeAttributes(
+	op *fuseops.GetInodeAttributesOp) (err error) {
 	fs.mu.RLock()
 	defer fs.mu.RUnlock()
 
@@ -316,10 +255,8 @@ func (fs *memFS) getInodeAttributes(op *fuseops.GetInodeAttributesOp) {
 	return
 }
 
-func (fs *memFS) setInodeAttributes(op *fuseops.SetInodeAttributesOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) SetInodeAttributes(
+	op *fuseops.SetInodeAttributesOp) (err error) {
 	fs.mu.RLock()
 	defer fs.mu.RUnlock()
 
@@ -340,10 +277,8 @@ func (fs *memFS) setInodeAttributes(op *fuseops.SetInodeAttributesOp) {
 	return
 }
 
-func (fs *memFS) mkDir(op *fuseops.MkDirOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) MkDir(
+	op *fuseops.MkDirOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -379,10 +314,8 @@ func (fs *memFS) mkDir(op *fuseops.MkDirOp) {
 	return
 }
 
-func (fs *memFS) createFile(op *fuseops.CreateFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) CreateFile(
+	op *fuseops.CreateFileOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -425,10 +358,8 @@ func (fs *memFS) createFile(op *fuseops.CreateFileOp) {
 	return
 }
 
-func (fs *memFS) rmDir(op *fuseops.RmDirOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) RmDir(
+	op *fuseops.RmDirOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -462,10 +393,8 @@ func (fs *memFS) rmDir(op *fuseops.RmDirOp) {
 	return
 }
 
-func (fs *memFS) unlink(op *fuseops.UnlinkOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) Unlink(
+	op *fuseops.UnlinkOp) (err error) {
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
@@ -493,10 +422,8 @@ func (fs *memFS) unlink(op *fuseops.UnlinkOp) {
 	return
 }
 
-func (fs *memFS) openDir(op *fuseops.OpenDirOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) OpenDir(
+	op *fuseops.OpenDirOp) (err error) {
 	fs.mu.RLock()
 	defer fs.mu.RUnlock()
 
@@ -513,10 +440,8 @@ func (fs *memFS) openDir(op *fuseops.OpenDirOp) {
 	return
 }
 
-func (fs *memFS) readDir(op *fuseops.ReadDirOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) ReadDir(
+	op *fuseops.ReadDirOp) (err error) {
 	fs.mu.RLock()
 	defer fs.mu.RUnlock()
 
@@ -534,10 +459,8 @@ func (fs *memFS) readDir(op *fuseops.ReadDirOp) {
 	return
 }
 
-func (fs *memFS) openFile(op *fuseops.OpenFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) OpenFile(
+	op *fuseops.OpenFileOp) (err error) {
 	fs.mu.RLock()
 	defer fs.mu.RUnlock()
 
@@ -554,10 +477,8 @@ func (fs *memFS) openFile(op *fuseops.OpenFileOp) {
 	return
 }
 
-func (fs *memFS) readFile(op *fuseops.ReadFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) ReadFile(
+	op *fuseops.ReadFileOp) (err error) {
 	fs.mu.RLock()
 	defer fs.mu.RUnlock()
 
@@ -578,10 +499,8 @@ func (fs *memFS) readFile(op *fuseops.ReadFileOp) {
 	return
 }
 
-func (fs *memFS) writeFile(op *fuseops.WriteFileOp) {
-	var err error
-	defer func() { op.Respond(err) }()
-
+func (fs *memFS) WriteFile(
+	op *fuseops.WriteFileOp) (err error) {
 	fs.mu.RLock()
 	defer fs.mu.RUnlock()