rename.

Cleaned up errors / writing of 'wcc' and 'postOpAttr'

Author: willscott

conn.go

@@ -158,16 +158,13 @@ func (c *conn) err(ctx context.Context, w *response, err error) error {
 		return nil
 	}
 
-	var rpcErr RPCError
-	if errors.As(err, &rpcErr) {
-		if writeErr := w.writeHeader(rpcErr.Code()); writeErr != nil {
-			return writeErr
-		}
-
-		body, _ := rpcErr.MarshalBinary()
-		return w.Write(body)
+	rpcErr := w.errorFmt(err)
+	if writeErr := w.writeHeader(rpcErr.Code()); writeErr != nil {
+		return writeErr
 	}
-	return w.writeHeader(ResponseCodeSystemErr)
+
+	body, _ := rpcErr.MarshalBinary()
+	return w.Write(body)
 }
 
 type request struct {
@@ -190,6 +187,7 @@ type response struct {
 	writer    *bytes.Buffer
 	responded bool
 	err       error
+	errorFmt  func(error) RPCError
 	req       *request
 }
 
@@ -321,8 +319,9 @@ func (c *conn) readRequestHeader(ctx context.Context, reader *bufio.Reader) (w *
 	}
 
 	w = &response{
-		conn: c,
-		req:  &req,
+		conn:     c,
+		req:      &req,
+		errorFmt: basicErrorFormatter,
 		// TODO: use a pool for these.
 		writer: bytes.NewBuffer([]byte{}),
 	}

errors.go

@@ -3,6 +3,7 @@ package nfs
 import (
 	"encoding"
 	"encoding/binary"
+	"errors"
 	"fmt"
 )
 
@@ -152,6 +153,17 @@ func (r *ResponseCodeSystemError) MarshalBinary() (data []byte, err error) {
 	return []byte{}, nil
 }
 
+// basicErrorFormatter is the default error handler for response errors.
+// if the error is already formatted, it is directly written. Otherwise,
+// ResponseCodeSystemError is sent to the client.
+func basicErrorFormatter(err error) RPCError {
+	var rpcErr RPCError
+	if errors.As(err, &rpcErr) {
+		return rpcErr
+	}
+	return &ResponseCodeSystemError{}
+}
+
 // NFSStatusError represents an error at the NFS level.
 type NFSStatusError struct {
 	NFSStatus
@@ -174,46 +186,32 @@ func (s *NFSStatusError) MarshalBinary() (data []byte, err error) {
 	return resp[:], nil
 }
 
-// NFSStatusErrorWithOpAttr is an NFS error where a 'post_op_attr' is expected
-type NFSStatusErrorWithOpAttr struct {
-	NFSStatus
-}
-
-// Error is The wrapped error
-func (s *NFSStatusErrorWithOpAttr) Error() string {
-	return s.NFSStatus.String()
-}
-
-// Code for NFS issues are successful RPC responses
-func (s *NFSStatusErrorWithOpAttr) Code() ResponseCode {
-	return ResponseCodeSuccess
+// StatusErrorWithBody is an NFS error with a payload.
+type StatusErrorWithBody struct {
+	NFSStatusError
+	Body []byte
 }
 
-// MarshalBinary - The binary form of the code.
-func (s *NFSStatusErrorWithOpAttr) MarshalBinary() (data []byte, err error) {
-	var resp [8]byte
-	binary.BigEndian.PutUint32(resp[0:4], uint32(s.NFSStatus))
-	return resp[:], nil
+// MarshalBinary provides the wire format of the error response
+func (s *StatusErrorWithBody) MarshalBinary() (data []byte, err error) {
+	head, err := s.NFSStatusError.MarshalBinary()
+	return append(head, s.Body...), err
 }
 
-// NFSStatusErrorWithWccData is an NFS error where a 'wcc_data' is expected
-type NFSStatusErrorWithWccData struct {
-	NFSStatus
-}
-
-// Error is The wrapped error
-func (s *NFSStatusErrorWithWccData) Error() string {
-	return s.NFSStatus.String()
-}
-
-// Code for NFS issues are successful RPC responses
-func (s *NFSStatusErrorWithWccData) Code() ResponseCode {
-	return ResponseCodeSuccess
+// errFormatterWithBody appends a provided body to errors
+func errFormatterWithBody(body []byte) func(err error) RPCError {
+	return func(err error) RPCError {
+		var nfsErr NFSStatusError
+		if errors.As(err, &nfsErr) {
+			return &StatusErrorWithBody{nfsErr, body[:]}
+		}
+		return &ResponseCodeSystemError{}
+	}
 }
 
-// MarshalBinary - The binary form of the code.
-func (s *NFSStatusErrorWithWccData) MarshalBinary() (data []byte, err error) {
-	var resp [12]byte
-	binary.BigEndian.PutUint32(resp[0:4], uint32(s.NFSStatus))
-	return resp[:], nil
-}
+var (
+	opAttrErrorBody       = [4]byte{}
+	opAttrErrorFormatter  = errFormatterWithBody(opAttrErrorBody[:])
+	wccDataErrorBody      = [8]byte{}
+	wccDataErrorFormatter = errFormatterWithBody(wccDataErrorBody[:])
+)

file.go

@@ -84,7 +84,7 @@ func (f FileAttribute) AsCache() *FileCacheAttribute {
 }
 
 // ToFileAttribute creates an NFS fattr3 struct from an OS.FileInfo
-func ToFileAttribute(info os.FileInfo) FileAttribute {
+func ToFileAttribute(info os.FileInfo) *FileAttribute {
 	f := FileAttribute{}
 
 	m := info.Mode()
@@ -122,19 +122,43 @@ func ToFileAttribute(info os.FileInfo) FileAttribute {
 	f.Atime = ToNFSTime(info.ModTime())
 	f.Mtime = f.Atime
 	f.Ctime = f.Atime
-	return f
+	return &f
 }
 
-// WritePostOpAttrs writes the `post_op_attr` representation of a files attributes
-func WritePostOpAttrs(writer io.Writer, fs billy.Filesystem, path []string) {
+// tryStat attempts to create a FileAttribute from a path.
+func tryStat(fs billy.Filesystem, path []string) *FileAttribute {
 	attrs, err := fs.Stat(fs.Join(path...))
 	if err != nil || attrs == nil {
-		log.Printf("err writing attrs for %s: %v", fs.Join(path...), err)
+		log.Printf("err loading attrs for %s: %v", fs.Join(path...), err)
+		return nil
+	}
+	return ToFileAttribute(attrs)
+}
+
+// WriteWcc writes the `wcc_data` representation of an object.
+func WriteWcc(writer io.Writer, pre *FileCacheAttribute, post *FileAttribute) {
+	if pre == nil {
+		_ = xdr.Write(writer, uint32(0))
+	} else {
+		_ = xdr.Write(writer, uint32(1))
+		_ = xdr.Write(writer, *pre)
+	}
+	if post == nil {
 		_ = xdr.Write(writer, uint32(0))
-		return
+	} else {
+		_ = xdr.Write(writer, uint32(1))
+		_ = xdr.Write(writer, *post)
+	}
+}
+
+// WritePostOpAttrs writes the `post_op_attr` representation of a files attributes
+func WritePostOpAttrs(writer io.Writer, post *FileAttribute) {
+	if post == nil {
+		_ = xdr.Write(writer, uint32(0))
+	} else {
+		_ = xdr.Write(writer, uint32(1))
+		_ = xdr.Write(writer, *post)
 	}
-	_ = xdr.Write(writer, uint32(1))
-	_ = xdr.Write(writer, ToFileAttribute(attrs))
 }
 
 // SetFileAttributes represents a command to update some metadata

nfs.go

@@ -21,9 +21,9 @@ func init() {
 	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureMkDir), onMkdir)       // 9
 	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureSymlink), onSymlink)   // 10
 	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureMkNod), onMknod)       // 11
-	// Remove // 12
-	// Rmdir // 13
-	// Rename // 14
+	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureRemove), onRemove)     // 12
+	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureRmDir), onRmDir)       // 13
+	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureRename), onRename)     // 14
 	// Link // 15
 	// ReadDir // 16
 	RegisterMessageHandler(nfsServiceID, uint32(NFSProcedureReadDirPlus), onReadDirPlus) // 17

nfs_onaccess.go

@@ -28,7 +28,7 @@ func onAccess(ctx context.Context, w *response, userHandle Handler) error {
 	if err := xdr.Write(writer, uint32(NFSStatusOk)); err != nil {
 		return err
 	}
-	WritePostOpAttrs(writer, fs, path)
+	WritePostOpAttrs(writer, tryStat(fs, path))
 
 	if !billy.CapabilityCheck(fs, billy.WriteCapability) {
 		mask = mask & (1 | 2 | 0x20)

nfs_oncommit.go

@@ -10,6 +10,7 @@ import (
 
 // onCommit - note this is a no-op, as we always push writes to the backing store.
 func onCommit(ctx context.Context, w *response, userHandle Handler) error {
+	w.errorFmt = wccDataErrorFormatter
 	handle, err := xdr.ReadOpaque(w.req.Body)
 	if err != nil {
 		// TODO: wrap
@@ -19,10 +20,10 @@ func onCommit(ctx context.Context, w *response, userHandle Handler) error {
 
 	fs, path, err := userHandle.FromHandle(handle)
 	if err != nil {
-		return &NFSStatusErrorWithWccData{NFSStatusStale}
+		return &NFSStatusError{NFSStatusStale}
 	}
 	if !billy.CapabilityCheck(fs, billy.WriteCapability) {
-		return &NFSStatusErrorWithWccData{NFSStatusServerFault}
+		return &NFSStatusError{NFSStatusServerFault}
 	}
 
 	writer := bytes.NewBuffer([]byte{})
@@ -34,7 +35,7 @@ func onCommit(ctx context.Context, w *response, userHandle Handler) error {
 	if err := xdr.Write(writer, uint32(0)); err != nil {
 		return err
 	}
-	WritePostOpAttrs(writer, fs, path)
+	WritePostOpAttrs(writer, tryStat(fs, path))
 	// write the 8 bytes of write verification.
 	if err := xdr.Write(writer, w.Server.ID); err != nil {
 		return err

nfs_oncreate.go

@@ -15,6 +15,7 @@ const (
 )
 
 func onCreate(ctx context.Context, w *response, userHandle Handler) error {
+	w.errorFmt = wccDataErrorFormatter
 	obj := DirOpArg{}
 	err := xdr.Read(w.req.Body, &obj)
 	if err != nil {
@@ -39,52 +40,52 @@ func onCreate(ctx context.Context, w *response, userHandle Handler) error {
 			return err
 		}
 		// TODO: support 'exclusive' mode.
-		return &NFSStatusErrorWithWccData{NFSStatusNotSupp}
+		return &NFSStatusError{NFSStatusNotSupp}
 	} else {
 		// invalid
-		return &NFSStatusErrorWithWccData{NFSStatusNotSupp}
+		return &NFSStatusError{NFSStatusNotSupp}
 	}
 
 	fs, path, err := userHandle.FromHandle(obj.Handle)
 	if err != nil {
-		return &NFSStatusErrorWithWccData{NFSStatusStale}
+		return &NFSStatusError{NFSStatusStale}
 	}
 	if !billy.CapabilityCheck(fs, billy.WriteCapability) {
-		return &NFSStatusErrorWithWccData{NFSStatusROFS}
+		return &NFSStatusError{NFSStatusROFS}
 	}
 
 	if len(string(obj.Filename)) > PathNameMax {
-		return &NFSStatusErrorWithWccData{NFSStatusNameTooLong}
+		return &NFSStatusError{NFSStatusNameTooLong}
 	}
 
 	newFilePath := fs.Join(append(path, string(obj.Filename))...)
 	if s, err := fs.Stat(newFilePath); err == nil {
 		if s.IsDir() {
-			return &NFSStatusErrorWithWccData{NFSStatusExist}
+			return &NFSStatusError{NFSStatusExist}
 		}
 		if how == createModeGuarded {
-			return &NFSStatusErrorWithWccData{NFSStatusExist}
+			return &NFSStatusError{NFSStatusExist}
 		}
 	} else {
 		if s, err := fs.Stat(fs.Join(path...)); err != nil {
-			return &NFSStatusErrorWithWccData{NFSStatusAccess}
+			return &NFSStatusError{NFSStatusAccess}
 		} else if !s.IsDir() {
-			return &NFSStatusErrorWithWccData{NFSStatusNotDir}
+			return &NFSStatusError{NFSStatusNotDir}
 		}
 	}
 
 	file, err := fs.Create(newFilePath)
 	if err != nil {
-		return &NFSStatusErrorWithWccData{NFSStatusAccess}
+		return &NFSStatusError{NFSStatusAccess}
 	}
 	if err := file.Close(); err != nil {
-		return &NFSStatusErrorWithWccData{NFSStatusAccess}
+		return &NFSStatusError{NFSStatusAccess}
 	}
 
 	fp := userHandle.ToHandle(fs, append(path, file.Name()))
 	changer := userHandle.Change(fs)
 	if err := attrs.Apply(changer, fs, newFilePath); err != nil {
-		return &NFSStatusErrorWithWccData{NFSStatusIO}
+		return &NFSStatusError{NFSStatusIO}
 	}
 
 	writer := bytes.NewBuffer([]byte{})
@@ -99,13 +100,13 @@ func onCreate(ctx context.Context, w *response, userHandle Handler) error {
 	if err := xdr.Write(writer, fp); err != nil {
 		return err
 	}
-	WritePostOpAttrs(writer, fs, append(path, file.Name()))
+	WritePostOpAttrs(writer, tryStat(fs, append(path, file.Name())))
 
 	// dir_wcc (we don't include pre_op_attr)
 	if err := xdr.Write(writer, uint32(0)); err != nil {
 		return err
 	}
-	WritePostOpAttrs(writer, fs, path)
+	WritePostOpAttrs(writer, tryStat(fs, path))
 
 	return w.Write(writer.Bytes())
 }

nfs_onfsinfo.go

@@ -34,7 +34,7 @@ func onFSInfo(ctx context.Context, w *response, userHandle Handler) error {
 	if err := xdr.Write(writer, uint32(NFSStatusOk)); err != nil {
 		return err
 	}
-	WritePostOpAttrs(writer, fs, path)
+	WritePostOpAttrs(writer, tryStat(fs, path))
 
 	type fsinfores struct {
 		Rtmax       uint32

nfs_onfsstat.go

@@ -42,7 +42,7 @@ func onFSStat(ctx context.Context, w *response, userHandle Handler) error {
 	if err := xdr.Write(writer, uint32(NFSStatusOk)); err != nil {
 		return err
 	}
-	WritePostOpAttrs(writer, fs, path)
+	WritePostOpAttrs(writer, tryStat(fs, path))
 
 	if err := xdr.Write(writer, defaults); err != nil {
 		return err