Mostly updated flushfs.

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"
-	"golang.org/x/net/context"
 )
 
 // Create a file system whose sole contents are a file named "foo" and a
@@ -86,45 +86,76 @@ func (fs *flushFS) barAttributes() fuseops.InodeAttributes {
 }
 
 // LOCKS_REQUIRED(fs.mu)
-func (fs *flushFS) ServeOps(c *fuse.Connection)
+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.OpenDirOp:
+			fs.openDir(typed)
+
+		case *fuseops.OpenFileOp:
+			fs.openFile(typed)
+
+		case *fuseops.ReadFileOp:
+			fs.readFile(typed)
+
+		default:
+			typed.Respond(fuse.ENOSYS)
+		}
+	}
+}
 
 ////////////////////////////////////////////////////////////////////////
 // Op methods
 ////////////////////////////////////////////////////////////////////////
 
-func (fs *flushFS) Init(
+func (fs *flushFS) init(op *fuseops.InitOp) {
-	ctx context.Context,
+	var err error
-	req *fuse.InitRequest) (
+	defer func() { op.Respond(err) }()
-	resp *fuse.InitResponse, err error) {
+
-	resp = &fuse.InitResponse{}
 	return
 }
 
-func (fs *flushFS) LookUpInode(
+func (fs *flushFS) lookUpInode(op *fuseops.LookUpInodeOp) {
-	ctx context.Context,
+	var err error
-	req *fuse.LookUpInodeRequest) (
+	defer func() { op.Respond(err) }()
-	resp *fuse.LookUpInodeResponse, err error) {
-	resp = &fuse.LookUpInodeResponse{}
 
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
 	// Sanity check.
-	if req.Parent != fuseops.RootInodeID {
+	if op.Parent != fuseops.RootInodeID {
 		err = fuse.ENOENT
 		return
 	}
 
 	// Set up the entry.
-	switch req.Name {
+	switch op.Name {
 	case "foo":
-		resp.Entry = fuse.ChildInodeEntry{
+		op.Entry = fuseops.ChildInodeEntry{
 			Child:      fooID,
 			Attributes: fs.fooAttributes(),
 		}
 
 	case "bar":
-		resp.Entry = fuse.ChildInodeEntry{
+		op.Entry = fuseops.ChildInodeEntry{
 			Child:      barID,
 			Attributes: fs.barAttributes(),
 		}
@@ -137,26 +168,24 @@ func (fs *flushFS) LookUpInode(
 	return
 }
 
-func (fs *flushFS) GetInodeAttributes(
+func (fs *flushFS) getInodeAttributes(op *fuseops.GetInodeAttributesOp) {
-	ctx context.Context,
+	var err error
-	req *fuse.GetInodeAttributesRequest) (
+	defer func() { op.Respond(err) }()
-	resp *fuse.GetInodeAttributesResponse, err error) {
-	resp = &fuse.GetInodeAttributesResponse{}
 
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
-	switch req.Inode {
+	switch op.Inode {
 	case fuseops.RootInodeID:
-		resp.Attributes = fs.rootAttributes()
+		op.Attributes = fs.rootAttributes()
 		return
 
 	case fooID:
-		resp.Attributes = fs.fooAttributes()
+		op.Attributes = fs.fooAttributes()
 		return
 
 	case barID:
-		resp.Attributes = fs.barAttributes()
+		op.Attributes = fs.barAttributes()
 		return
 
 	default:
@@ -165,17 +194,15 @@ func (fs *flushFS) GetInodeAttributes(
 	}
 }
 
-func (fs *flushFS) OpenFile(
+func (fs *flushFS) openFile(op *fuseops.OpenFileOp) {
-	ctx context.Context,
+	var err error
-	req *fuse.OpenFileRequest) (
+	defer func() { op.Respond(err) }()
-	resp *fuse.OpenFileResponse, err error) {
-	resp = &fuse.OpenFileResponse{}
 
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
 	// Sanity check.
-	if req.Inode != fooID {
+	if op.Inode != fooID {
 		err = fuse.ENOSYS
 		return
 	}
@@ -183,59 +210,53 @@ func (fs *flushFS) OpenFile(
 	return
 }
 
-func (fs *flushFS) ReadFile(
+func (fs *flushFS) readFile(op *fuseops.ReadFileOp) {
-	ctx context.Context,
+	var err error
-	req *fuse.ReadFileRequest) (
+	defer func() { op.Respond(err) }()
-	resp *fuse.ReadFileResponse, err error) {
-	resp = &fuse.ReadFileResponse{}
 
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
 	// Ensure the offset is in range.
-	if req.Offset > int64(len(fs.fooContents)) {
+	if op.Offset > int64(len(fs.fooContents)) {
 		return
 	}
 
 	// Read what we can.
-	resp.Data = make([]byte, req.Size)
+	op.Data = make([]byte, op.Size)
-	copy(resp.Data, fs.fooContents[req.Offset:])
+	copy(op.Data, fs.fooContents[op.Offset:])
 
 	return
 }
 
-func (fs *flushFS) WriteFile(
+func (fs *flushFS) writeFile(op *fuseops.WriteFileOp) {
-	ctx context.Context,
+	var err error
-	req *fuse.WriteFileRequest) (
+	defer func() { op.Respond(err) }()
-	resp *fuse.WriteFileResponse, err error) {
-	resp = &fuse.WriteFileResponse{}
 
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
 	// Ensure that the contents slice is long enough.
-	newLen := int(req.Offset) + len(req.Data)
+	newLen := int(op.Offset) + len(op.Data)
 	if len(fs.fooContents) < newLen {
 		padding := make([]byte, newLen-len(fs.fooContents))
 		fs.fooContents = append(fs.fooContents, padding...)
 	}
 
 	// Copy in the data.
-	n := copy(fs.fooContents[req.Offset:], req.Data)
+	n := copy(fs.fooContents[op.Offset:], op.Data)
 
 	// Sanity check.
-	if n != len(req.Data) {
+	if n != len(op.Data) {
 		panic(fmt.Sprintf("Unexpected short copy: %v", n))
 	}
 
 	return
 }
 
-func (fs *flushFS) SyncFile(
+func (fs *flushFS) syncFile(op *fuseops.SyncFileOp) {
-	ctx context.Context,
+	var err error
-	req *fuse.SyncFileRequest) (
+	defer func() { op.Respond(err) }()
-	resp *fuse.SyncFileResponse, err error) {
-	resp = &fuse.SyncFileResponse{}
 
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
@@ -244,11 +265,9 @@ func (fs *flushFS) SyncFile(
 	return
 }
 
-func (fs *flushFS) FlushFile(
+func (fs *flushFS) flushFile(op *fuseops.FlushFileOp) {
-	ctx context.Context,
+	var err error
-	req *fuse.FlushFileRequest) (
+	defer func() { op.Respond(err) }()
-	resp *fuse.FlushFileResponse, err error) {
-	resp = &fuse.FlushFileResponse{}
 
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
@@ -257,17 +276,15 @@ func (fs *flushFS) FlushFile(
 	return
 }
 
-func (fs *flushFS) OpenDir(
+func (fs *flushFS) openDir(op *fuseops.OpenDirOp) {
-	ctx context.Context,
+	var err error
-	req *fuse.OpenDirRequest) (
+	defer func() { op.Respond(err) }()
-	resp *fuse.OpenDirResponse, err error) {
-	resp = &fuse.OpenDirResponse{}
 
 	fs.mu.Lock()
 	defer fs.mu.Unlock()
 
 	// Sanity check.
-	if req.Inode != barID {
+	if op.Inode != barID {
 		err = fuse.ENOSYS
 		return
 	}