From 574378e871cd8d83aa40f270482148c0821846ca Mon Sep 17 00:00:00 2001
From: Nick Craig-Wood <nick@craig-wood.com>
Date: Mon, 24 Jun 2024 16:32:09 +0100
Subject: [PATCH] serve nfs: rename types and methods which should be internal

---
 cmd/serve/nfs/handler.go | 74 ++++++++++++++++++++--------------------
 cmd/serve/nfs/nfs.go     |  2 +-
 cmd/serve/nfs/server.go  |  5 +--
 3 files changed, 41 insertions(+), 40 deletions(-)

diff --git a/cmd/serve/nfs/handler.go b/cmd/serve/nfs/handler.go
index 313c83def..c89b0c7cb 100644
--- a/cmd/serve/nfs/handler.go
+++ b/cmd/serve/nfs/handler.go
@@ -15,9 +15,9 @@ import (
 	nfshelper "github.com/willscott/go-nfs/helpers"
 )
 
-// NewBackendAuthHandler creates a handler for the provided filesystem
-func NewBackendAuthHandler(vfs *vfs.VFS, opt *Options) nfs.Handler {
-	handler := &BackendAuthHandler{
+// NewHandler creates a handler for the provided filesystem
+func NewHandler(vfs *vfs.VFS, opt *Options) nfs.Handler {
+	handler := &Handler{
 		vfs: vfs,
 		opt: opt,
 	}
@@ -26,15 +26,15 @@ func NewBackendAuthHandler(vfs *vfs.VFS, opt *Options) nfs.Handler {
 	return handler
 }
 
-// BackendAuthHandler returns a NFS backing that exposes a given file system in response to all mount requests.
-type BackendAuthHandler struct {
+// Handler returns a NFS backing that exposes a given file system in response to all mount requests.
+type Handler struct {
 	vfs   *vfs.VFS
 	opt   *Options
 	cache nfs.Handler
 }
 
 // Mount backs Mount RPC Requests, allowing for access control policies.
-func (h *BackendAuthHandler) Mount(ctx context.Context, conn net.Conn, req nfs.MountRequest) (status nfs.MountStatus, hndl billy.Filesystem, auths []nfs.AuthFlavor) {
+func (h *Handler) Mount(ctx context.Context, conn net.Conn, req nfs.MountRequest) (status nfs.MountStatus, hndl billy.Filesystem, auths []nfs.AuthFlavor) {
 	status = nfs.MountStatusOk
 	hndl = &FS{vfs: h.vfs}
 	auths = []nfs.AuthFlavor{nfs.AuthFlavorNull}
@@ -42,7 +42,7 @@ func (h *BackendAuthHandler) Mount(ctx context.Context, conn net.Conn, req nfs.M
 }
 
 // Change provides an interface for updating file attributes.
-func (h *BackendAuthHandler) Change(fs billy.Filesystem) billy.Change {
+func (h *Handler) Change(fs billy.Filesystem) billy.Change {
 	if c, ok := fs.(billy.Change); ok {
 		return c
 	}
@@ -50,7 +50,7 @@ func (h *BackendAuthHandler) Change(fs billy.Filesystem) billy.Change {
 }
 
 // FSStat provides information about a filesystem.
-func (h *BackendAuthHandler) FSStat(ctx context.Context, f billy.Filesystem, s *nfs.FSStat) error {
+func (h *Handler) FSStat(ctx context.Context, f billy.Filesystem, s *nfs.FSStat) error {
 	total, _, free := h.vfs.Statfs()
 	s.TotalSize = uint64(total)
 	s.FreeSize = uint64(free)
@@ -59,28 +59,28 @@ func (h *BackendAuthHandler) FSStat(ctx context.Context, f billy.Filesystem, s *
 }
 
 // ToHandle handled by CachingHandler
-func (h *BackendAuthHandler) ToHandle(f billy.Filesystem, s []string) []byte {
+func (h *Handler) ToHandle(f billy.Filesystem, s []string) []byte {
 	return h.cache.ToHandle(f, s)
 }
 
 // FromHandle handled by CachingHandler
-func (h *BackendAuthHandler) FromHandle(b []byte) (billy.Filesystem, []string, error) {
+func (h *Handler) FromHandle(b []byte) (billy.Filesystem, []string, error) {
 	return h.cache.FromHandle(b)
 }
 
 // HandleLimit handled by cachingHandler
-func (h *BackendAuthHandler) HandleLimit() int {
+func (h *Handler) HandleLimit() int {
 	return h.opt.HandleLimit
 }
 
 // InvalidateHandle is called on removes or renames
-func (h *BackendAuthHandler) InvalidateHandle(billy.Filesystem, []byte) error {
+func (h *Handler) InvalidateHandle(billy.Filesystem, []byte) error {
 	return nil
 }
 
 func newHandler(vfs *vfs.VFS, opt *Options) nfs.Handler {
-	handler := NewBackendAuthHandler(vfs, opt)
-	nfs.SetLogger(&LogIntercepter{Level: nfs.DebugLevel})
+	handler := NewHandler(vfs, opt)
+	nfs.SetLogger(&logIntercepter{Level: nfs.DebugLevel})
 	return handler
 }
 
@@ -110,20 +110,20 @@ func onUnmount() {
 	}
 }
 
-// LogIntercepter intercepts noisy go-nfs logs and reroutes them to DEBUG
-type LogIntercepter struct {
+// logIntercepter intercepts noisy go-nfs logs and reroutes them to DEBUG
+type logIntercepter struct {
 	Level nfs.LogLevel
 }
 
 // Intercept intercepts go-nfs logs and calls fs.Debugf instead
-func (l *LogIntercepter) Intercept(args ...interface{}) {
+func (l *logIntercepter) Intercept(args ...interface{}) {
 	args = append([]interface{}{"[NFS DEBUG] "}, args...)
 	argsS := fmt.Sprint(args...)
 	fs.Debugf(nil, "%v", argsS)
 }
 
 // Interceptf intercepts go-nfs logs and calls fs.Debugf instead
-func (l *LogIntercepter) Interceptf(format string, args ...interface{}) {
+func (l *logIntercepter) Interceptf(format string, args ...interface{}) {
 	argsS := fmt.Sprint(args...)
 	// bit of a workaround... the real fix is probably https://github.com/willscott/go-nfs/pull/28
 	if strings.Contains(argsS, "mount.Umnt") {
@@ -134,96 +134,96 @@ func (l *LogIntercepter) Interceptf(format string, args ...interface{}) {
 }
 
 // Debug reroutes go-nfs Debug messages to Intercept
-func (l *LogIntercepter) Debug(args ...interface{}) {
+func (l *logIntercepter) Debug(args ...interface{}) {
 	l.Intercept(args...)
 }
 
 // Debugf reroutes go-nfs Debugf messages to Interceptf
-func (l *LogIntercepter) Debugf(format string, args ...interface{}) {
+func (l *logIntercepter) Debugf(format string, args ...interface{}) {
 	l.Interceptf(format, args...)
 }
 
 // Error reroutes go-nfs Error messages to Intercept
-func (l *LogIntercepter) Error(args ...interface{}) {
+func (l *logIntercepter) Error(args ...interface{}) {
 	l.Intercept(args...)
 }
 
 // Errorf reroutes go-nfs Errorf messages to Interceptf
-func (l *LogIntercepter) Errorf(format string, args ...interface{}) {
+func (l *logIntercepter) Errorf(format string, args ...interface{}) {
 	l.Interceptf(format, args...)
 }
 
 // Fatal reroutes go-nfs Fatal messages to Intercept
-func (l *LogIntercepter) Fatal(args ...interface{}) {
+func (l *logIntercepter) Fatal(args ...interface{}) {
 	l.Intercept(args...)
 }
 
 // Fatalf reroutes go-nfs Fatalf messages to Interceptf
-func (l *LogIntercepter) Fatalf(format string, args ...interface{}) {
+func (l *logIntercepter) Fatalf(format string, args ...interface{}) {
 	l.Interceptf(format, args...)
 }
 
 // GetLevel returns the nfs.LogLevel
-func (l *LogIntercepter) GetLevel() nfs.LogLevel {
+func (l *logIntercepter) GetLevel() nfs.LogLevel {
 	return l.Level
 }
 
 // Info reroutes go-nfs Info messages to Intercept
-func (l *LogIntercepter) Info(args ...interface{}) {
+func (l *logIntercepter) Info(args ...interface{}) {
 	l.Intercept(args...)
 }
 
 // Infof reroutes go-nfs Infof messages to Interceptf
-func (l *LogIntercepter) Infof(format string, args ...interface{}) {
+func (l *logIntercepter) Infof(format string, args ...interface{}) {
 	l.Interceptf(format, args...)
 }
 
 // Panic reroutes go-nfs Panic messages to Intercept
-func (l *LogIntercepter) Panic(args ...interface{}) {
+func (l *logIntercepter) Panic(args ...interface{}) {
 	l.Intercept(args...)
 }
 
 // Panicf reroutes go-nfs Panicf messages to Interceptf
-func (l *LogIntercepter) Panicf(format string, args ...interface{}) {
+func (l *logIntercepter) Panicf(format string, args ...interface{}) {
 	l.Interceptf(format, args...)
 }
 
 // ParseLevel parses the nfs.LogLevel
-func (l *LogIntercepter) ParseLevel(level string) (nfs.LogLevel, error) {
+func (l *logIntercepter) ParseLevel(level string) (nfs.LogLevel, error) {
 	return nfs.Log.ParseLevel(level)
 }
 
 // Print reroutes go-nfs Print messages to Intercept
-func (l *LogIntercepter) Print(args ...interface{}) {
+func (l *logIntercepter) Print(args ...interface{}) {
 	l.Intercept(args...)
 }
 
 // Printf reroutes go-nfs Printf messages to Intercept
-func (l *LogIntercepter) Printf(format string, args ...interface{}) {
+func (l *logIntercepter) Printf(format string, args ...interface{}) {
 	l.Interceptf(format, args...)
 }
 
 // SetLevel sets the nfs.LogLevel
-func (l *LogIntercepter) SetLevel(level nfs.LogLevel) {
+func (l *logIntercepter) SetLevel(level nfs.LogLevel) {
 	l.Level = level
 }
 
 // Trace reroutes go-nfs Trace messages to Intercept
-func (l *LogIntercepter) Trace(args ...interface{}) {
+func (l *logIntercepter) Trace(args ...interface{}) {
 	l.Intercept(args...)
 }
 
 // Tracef reroutes go-nfs Tracef messages to Interceptf
-func (l *LogIntercepter) Tracef(format string, args ...interface{}) {
+func (l *logIntercepter) Tracef(format string, args ...interface{}) {
 	l.Interceptf(format, args...)
 }
 
 // Warn reroutes go-nfs Warn messages to Intercept
-func (l *LogIntercepter) Warn(args ...interface{}) {
+func (l *logIntercepter) Warn(args ...interface{}) {
 	l.Intercept(args...)
 }
 
 // Warnf reroutes go-nfs Warnf messages to Interceptf
-func (l *LogIntercepter) Warnf(format string, args ...interface{}) {
+func (l *logIntercepter) Warnf(format string, args ...interface{}) {
 	l.Interceptf(format, args...)
 }
diff --git a/cmd/serve/nfs/nfs.go b/cmd/serve/nfs/nfs.go
index 4deb399a8..d22f57d0e 100644
--- a/cmd/serve/nfs/nfs.go
+++ b/cmd/serve/nfs/nfs.go
@@ -98,7 +98,7 @@ We specify a specific port that we can use in the mount command:
 
 To mount the server under Linux/macOS, use the following command:
     
-    mount -oport=$PORT,mountport=$PORT $HOSTNAME: path/to/mountpoint
+    mount -t nfs -o port=$PORT,mountport=$PORT,tcp $HOSTNAME:/ path/to/mountpoint
 
 Where ` + "`$PORT`" + ` is the same port number we used in the serve nfs command.
 
diff --git a/cmd/serve/nfs/server.go b/cmd/serve/nfs/server.go
index a78793492..626f350cd 100644
--- a/cmd/serve/nfs/server.go
+++ b/cmd/serve/nfs/server.go
@@ -4,6 +4,7 @@ package nfs
 
 import (
 	"context"
+	"fmt"
 	"net"
 
 	nfs "github.com/willscott/go-nfs"
@@ -39,9 +40,9 @@ func NewServer(ctx context.Context, vfs *vfs.VFS, opt *Options) (s *Server, err
 	s.handler = newHandler(vfs, opt)
 	s.listener, err = net.Listen("tcp", s.opt.ListenAddr)
 	if err != nil {
-		fs.Errorf(nil, "NFS server failed to listen: %v\n", err)
+		return nil, fmt.Errorf("failed to open listening socket: %w", err)
 	}
-	return
+	return s, nil
 }
 
 // Addr returns the listening address of the server