From 8807902c47896cc7f4790d2e578a2243a89bde08 Mon Sep 17 00:00:00 2001 From: Jon Crussell Date: Mon, 11 Jun 2018 17:42:47 -0700 Subject: [PATCH 1/9] filesystem: new API to create FileServer NewServer with callbacks based on functional options for friendly APIs. Replaces NewUFS. Add .Debug() to return a Debug-enabled version of the FileServer. Remove -root and -debug flags, use functional options instead. Most likely will conflict with #32. --- filesystem/filesystem.go | 73 +++++++++++++++++++++++++++------------- 1 file changed, 49 insertions(+), 24 deletions(-) diff --git a/filesystem/filesystem.go b/filesystem/filesystem.go index bb11357..7a30baa 100644 --- a/filesystem/filesystem.go +++ b/filesystem/filesystem.go @@ -6,7 +6,6 @@ package ufs import ( "bytes" - "flag" "fmt" "io" "log" @@ -38,12 +37,11 @@ type FileServer struct { // mu guards below mu sync.Mutex files map[protocol.FID]*file + + trace protocol.Tracer } -var ( - debug = flag.Int("debug", 0, "print debug messages") - root = flag.String("root", "/", "Set the root for all attaches") -) +type ServerOpt func(*FileServer) error func stat(s string) (*protocol.Dir, protocol.QID, error) { var q protocol.QID @@ -59,6 +57,52 @@ func stat(s string) (*protocol.Dir, protocol.QID, error) { return d, q, nil } +func NewServer(opts ...ServerOpt) (*FileServer, error) { + s := &FileServer{ + mu: &sync.Mutex{}, + Files: make(map[protocol.FID]*File), + } + + for _, opt := range opts { + if err := opt(s); err != nil { + return nil, err + } + } + + return s, nil +} + +func Root(root string) ServerOpt { + return func(s *FileServer) error { + s.rootPath = root + return nil + } +} + +func IOunit(size protocol.MaxSize) ServerOpt { + return func(s *FileServer) error { + s.IOunit = size + return nil + } +} + +func Trace(tracer protocol.Tracer) ServerOpt { + return func(s *FileServer) error { + s.trace = tracer + return nil + } +} + +func (s *FileServer) logf(format string, args ...interface{}) { + if s.trace != nil { + s.trace(format, args...) + } +} + +func (s *FileServer) Debug() protocol.NineServer { + return &debugFileServer{s} +} + func (e *FileServer) Rversion(msize protocol.MaxSize, version string) (protocol.MaxSize, string, error) { if version != "9P2000" { return 0, "", fmt.Errorf("%v not supported; only 9P2000", version) @@ -441,22 +485,3 @@ func (e *FileServer) Rwrite(fid protocol.FID, o protocol.Offset, b []byte) (prot n, err := f.file.WriteAt(b, int64(o)) return protocol.Count(n), err } - -type ServerOpt func(*protocol.Server) error - -func NewUFS(opts ...protocol.ServerOpt) (*protocol.Server, error) { - f := &FileServer{} - f.files = make(map[protocol.FID]*file) - f.rootPath = *root // for now. - // any opts for the ufs layer can be added here too ... - var d protocol.NineServer = f - if *debug != 0 { - d = &debugFileServer{f} - } - s, err := protocol.NewServer(d, opts...) - if err != nil { - return nil, err - } - f.IOunit = 8192 - return s, nil -} From cab800e4008a51fa8fd38cd5f97dbd63dbb1f2a7 Mon Sep 17 00:00:00 2001 From: Jon Crussell Date: Mon, 11 Jun 2018 17:58:01 -0700 Subject: [PATCH 2/9] ufs: fix command Based on NewServer rather than NewUFS. --- cmd/ufs/ufs.go | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/cmd/ufs/ufs.go b/cmd/ufs/ufs.go index d1e023e..909774a 100644 --- a/cmd/ufs/ufs.go +++ b/cmd/ufs/ufs.go @@ -16,6 +16,8 @@ import ( var ( ntype = flag.String("ntype", "tcp4", "Default network type") naddr = flag.String("addr", ":5640", "Network address") + root = flag.String("root", "/", "filesystem root") + debug = flag.Bool("debug", false, "enable debug messages") ) func main() { @@ -26,8 +28,24 @@ func main() { log.Fatalf("Listen failed: %v", err) } - s, err := ufs.NewUFS(func(s *protocol.Server) error { - s.Trace = nil // log.Printf + fs, err := ufs.NewServer(ufs.Root(*root), func(fs *ufs.FileServer) error { + if *debug { + return ufs.Trace(log.Printf)(fs) + } + + return nil + }) + + var ninefs protocol.NineServer = fs + if *debug { + ninefs = fs.Debug() + } + + s, err := protocol.NewServer(ninefs, func(s *protocol.Server) error { + if *debug { + s.Trace = log.Printf + } + return nil }) From 54ad6d4ed40d73e8bc510bbe9831c68ef67b2e6f Mon Sep 17 00:00:00 2001 From: Jon Crussell Date: Mon, 11 Jun 2018 17:58:32 -0700 Subject: [PATCH 3/9] filesystem: fix tests Use NewServer rather than NewUFS. --- filesystem/filesystem_test.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/filesystem/filesystem_test.go b/filesystem/filesystem_test.go index f1771cb..68bed25 100644 --- a/filesystem/filesystem_test.go +++ b/filesystem/filesystem_test.go @@ -18,7 +18,7 @@ func print(f string, args ...interface{}) { } func TestNew(t *testing.T) { - n, err := NewUFS() + n, err := NewServer() if err != nil { t.Fatal(err) } @@ -79,7 +79,11 @@ func TestMount(t *testing.T) { } t.Logf("Client is %v", c.String()) - n, err := NewUFS(func(s *protocol.Server) error { + fs, err := NewServer() + if err != nil { + t.Fatal(err) + } + n, err := protocol.NewServer(fs, func(s *protocol.Server) error { s.Trace = print //t.Logf return nil }) From 0a705936780d5867947cd4e759dd888c5cbb86d7 Mon Sep 17 00:00:00 2001 From: Jon Crussell Date: Tue, 12 Jun 2018 14:45:41 -0700 Subject: [PATCH 4/9] various: create debug package Add debug.Server which wraps a NineServer and logs before and after calling functions for the underlying server. Add Trace option to protocol.Server. Makes #34 obsolete --- cmd/ufs/ufs.go | 43 ++++---- debug/debug.go | 180 ++++++++++++++++++++++++++++++++++ filesystem/debug.go | 152 ---------------------------- filesystem/filesystem.go | 4 - filesystem/filesystem_test.go | 5 +- protocol/server.go | 15 ++- 6 files changed, 213 insertions(+), 186 deletions(-) create mode 100644 debug/debug.go delete mode 100644 filesystem/debug.go diff --git a/cmd/ufs/ufs.go b/cmd/ufs/ufs.go index 909774a..c09fd24 100644 --- a/cmd/ufs/ufs.go +++ b/cmd/ufs/ufs.go @@ -9,6 +9,7 @@ import ( "log" "net" + "github.com/Harvey-OS/ninep/debug" "github.com/Harvey-OS/ninep/filesystem" "github.com/Harvey-OS/ninep/protocol" ) @@ -17,39 +18,37 @@ var ( ntype = flag.String("ntype", "tcp4", "Default network type") naddr = flag.String("addr", ":5640", "Network address") root = flag.String("root", "/", "filesystem root") - debug = flag.Bool("debug", false, "enable debug messages") + trace = flag.Bool("trace", false, "enable debug messages") ) +func checkErr(format string, err error) { + if err != nil { + log.Fatalf(format, err) + } +} + func main() { flag.Parse() - ln, err := net.Listen(*ntype, *naddr) - if err != nil { - log.Fatalf("Listen failed: %v", err) + var tracer protocol.Tracer + if *trace { + tracer = log.Printf } - fs, err := ufs.NewServer(ufs.Root(*root), func(fs *ufs.FileServer) error { - if *debug { - return ufs.Trace(log.Printf)(fs) - } + ln, err := net.Listen(*ntype, *naddr) + checkErr("Listen failed: %v", err) - return nil - }) + fs, err := ufs.NewServer(ufs.Root(*root), ufs.Trace(tracer)) + checkErr("ufs.NewServer failed: %v", err) var ninefs protocol.NineServer = fs - if *debug { - ninefs = fs.Debug() + if *trace { + ninefs, err = debug.NewServer(ninefs, debug.Trace(tracer)) + checkErr("debug.NewServer failed: %v", err) } - s, err := protocol.NewServer(ninefs, func(s *protocol.Server) error { - if *debug { - s.Trace = log.Printf - } + s, err := protocol.NewServer(ninefs, protocol.Trace(tracer)) + checkErr("protocol.NewServer failed: %v", err) - return nil - }) - - if err := s.Serve(ln); err != nil { - log.Fatal(err) - } + checkErr("Serve failed: %v", s.Serve(ln)) } diff --git a/debug/debug.go b/debug/debug.go new file mode 100644 index 0000000..829cda0 --- /dev/null +++ b/debug/debug.go @@ -0,0 +1,180 @@ +// Copyright 2009 The Ninep Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package debug + +import ( + "bytes" + + "github.com/Harvey-OS/ninep/protocol" +) + +type Server struct { + protocol.NineServer + + trace protocol.Tracer +} + +type ServerOpt func(*Server) error + +func NewServer(s protocol.NineServer, opts ...ServerOpt) (*Server, error) { + s2 := &Server{NineServer: s} + + for _, opt := range opts { + if err := opt(s2); err != nil { + return nil, err + } + } + + return s2, nil +} + +func Trace(tracer protocol.Tracer) ServerOpt { + return func(s *Server) error { + s.trace = tracer + return nil + } +} + +func (s *Server) logf(format string, args ...interface{}) { + if s.trace != nil { + s.trace(format, args...) + } +} + +func (s *Server) Rversion(msize protocol.MaxSize, version string) (protocol.MaxSize, string, error) { + s.logf(">>> Tversion %v %v\n", msize, version) + msize, version, err := s.NineServer.Rversion(msize, version) + if err == nil { + s.logf("<<< Rversion %v %v\n", msize, version) + } else { + s.logf("<<< Error %v\n", err) + } + return msize, version, err +} + +func (s *Server) Rattach(fid protocol.FID, afid protocol.FID, uname string, aname string) (protocol.QID, error) { + s.logf(">>> Tattach fid %v, afid %v, uname %v, aname %v\n", fid, afid, + uname, aname) + qid, err := s.NineServer.Rattach(fid, afid, uname, aname) + if err == nil { + s.logf("<<< Rattach %v\n", qid) + } else { + s.logf("<<< Error %v\n", err) + } + return qid, err +} + +func (s *Server) Rflush(o protocol.Tag) error { + s.logf(">>> Tflush tag %v\n", o) + err := s.NineServer.Rflush(o) + if err == nil { + s.logf("<<< Rflush\n") + } else { + s.logf("<<< Error %v\n", err) + } + return err +} + +func (s *Server) Rwalk(fid protocol.FID, newfid protocol.FID, paths []string) ([]protocol.QID, error) { + s.logf(">>> Twalk fid %v, newfid %v, paths %v\n", fid, newfid, paths) + qid, err := s.NineServer.Rwalk(fid, newfid, paths) + if err == nil { + s.logf("<<< Rwalk %v\n", qid) + } else { + s.logf("<<< Error %v\n", err) + } + return qid, err +} + +func (s *Server) Ropen(fid protocol.FID, mode protocol.Mode) (protocol.QID, protocol.MaxSize, error) { + s.logf(">>> Topen fid %v, mode %v\n", fid, mode) + qid, iounit, err := s.NineServer.Ropen(fid, mode) + if err == nil { + s.logf("<<< Ropen %v %v\n", qid, iounit) + } else { + s.logf("<<< Error %v\n", err) + } + return qid, iounit, err +} + +func (s *Server) Rcreate(fid protocol.FID, name string, perm protocol.Perm, mode protocol.Mode) (protocol.QID, protocol.MaxSize, error) { + s.logf(">>> Tcreate fid %v, name %v, perm %v, mode %v\n", fid, name, + perm, mode) + qid, iounit, err := s.NineServer.Rcreate(fid, name, perm, mode) + if err == nil { + s.logf("<<< Rcreate %v %v\n", qid, iounit) + } else { + s.logf("<<< Error %v\n", err) + } + return qid, iounit, err +} + +func (s *Server) Rclunk(fid protocol.FID) error { + s.logf(">>> Tclunk fid %v\n", fid) + err := s.NineServer.Rclunk(fid) + if err == nil { + s.logf("<<< Rclunk\n") + } else { + s.logf("<<< Error %v\n", err) + } + return err +} + +func (s *Server) Rstat(fid protocol.FID) ([]byte, error) { + s.logf(">>> Tstat fid %v\n", fid) + b, err := s.NineServer.Rstat(fid) + if err == nil { + dir, _ := protocol.Unmarshaldir(bytes.NewBuffer(b)) + s.logf("<<< Rstat %v\n", dir) + } else { + s.logf("<<< Error %v\n", err) + } + return b, err +} + +func (s *Server) Rwstat(fid protocol.FID, b []byte) error { + dir, _ := protocol.Unmarshaldir(bytes.NewBuffer(b)) + s.logf(">>> Twstat fid %v, %v\n", fid, dir) + err := s.NineServer.Rwstat(fid, b) + if err == nil { + s.logf("<<< Rwstat\n") + } else { + s.logf("<<< Error %v\n", err) + } + return err +} + +func (s *Server) Rremove(fid protocol.FID) error { + s.logf(">>> Tremove fid %v\n", fid) + err := s.NineServer.Rremove(fid) + if err == nil { + s.logf("<<< Rremove\n") + } else { + s.logf("<<< Error %v\n", err) + } + return err +} + +func (s *Server) Rread(fid protocol.FID, o protocol.Offset, c protocol.Count) ([]byte, error) { + s.logf(">>> Tread fid %v, off %v, count %v\n", fid, o, c) + b, err := s.NineServer.Rread(fid, o, c) + if err == nil { + s.logf("<<< Rread %v\n", len(b)) + } else { + s.logf("<<< Error %v\n", err) + } + return b, err +} + +func (s *Server) Rwrite(fid protocol.FID, o protocol.Offset, b []byte) (protocol.Count, error) { + s.logf(">>> Twrite fid %v, off %v, count %v\n", fid, o, len(b)) + c, err := s.NineServer.Rwrite(fid, o, b) + if err == nil { + s.logf("<<< Rwrite %v\n", c) + } else { + s.logf("<<< Error %v\n", err) + } + return c, err +} diff --git a/filesystem/debug.go b/filesystem/debug.go deleted file mode 100644 index 11f1ee4..0000000 --- a/filesystem/debug.go +++ /dev/null @@ -1,152 +0,0 @@ -// Copyright 2009 The Ninep Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package ufs - -import ( - "bytes" - "log" - - "github.com/Harvey-OS/ninep/protocol" -) - -type debugFileServer struct { - *FileServer -} - -func (e *debugFileServer) Rversion(msize protocol.MaxSize, version string) (protocol.MaxSize, string, error) { - log.Printf(">>> Tversion %v %v\n", msize, version) - msize, version, err := e.FileServer.Rversion(msize, version) - if err == nil { - log.Printf("<<< Rversion %v %v\n", msize, version) - } else { - log.Printf("<<< Error %v\n", err) - } - return msize, version, err -} - -func (e *debugFileServer) Rattach(fid protocol.FID, afid protocol.FID, uname string, aname string) (protocol.QID, error) { - log.Printf(">>> Tattach fid %v, afid %v, uname %v, aname %v\n", fid, afid, - uname, aname) - qid, err := e.FileServer.Rattach(fid, afid, uname, aname) - if err == nil { - log.Printf("<<< Rattach %v\n", qid) - } else { - log.Printf("<<< Error %v\n", err) - } - return qid, err -} - -func (e *debugFileServer) Rflush(o protocol.Tag) error { - log.Printf(">>> Tflush tag %v\n", o) - err := e.FileServer.Rflush(o) - if err == nil { - log.Printf("<<< Rflush\n") - } else { - log.Printf("<<< Error %v\n", err) - } - return err -} - -func (e *debugFileServer) Rwalk(fid protocol.FID, newfid protocol.FID, paths []string) ([]protocol.QID, error) { - log.Printf(">>> Twalk fid %v, newfid %v, paths %v\n", fid, newfid, paths) - qid, err := e.FileServer.Rwalk(fid, newfid, paths) - if err == nil { - log.Printf("<<< Rwalk %v\n", qid) - } else { - log.Printf("<<< Error %v\n", err) - } - return qid, err -} - -func (e *debugFileServer) Ropen(fid protocol.FID, mode protocol.Mode) (protocol.QID, protocol.MaxSize, error) { - log.Printf(">>> Topen fid %v, mode %v\n", fid, mode) - qid, iounit, err := e.FileServer.Ropen(fid, mode) - if err == nil { - log.Printf("<<< Ropen %v %v\n", qid, iounit) - } else { - log.Printf("<<< Error %v\n", err) - } - return qid, iounit, err -} - -func (e *debugFileServer) Rcreate(fid protocol.FID, name string, perm protocol.Perm, mode protocol.Mode) (protocol.QID, protocol.MaxSize, error) { - log.Printf(">>> Tcreate fid %v, name %v, perm %v, mode %v\n", fid, name, - perm, mode) - qid, iounit, err := e.FileServer.Rcreate(fid, name, perm, mode) - if err == nil { - log.Printf("<<< Rcreate %v %v\n", qid, iounit) - } else { - log.Printf("<<< Error %v\n", err) - } - return qid, iounit, err -} - -func (e *debugFileServer) Rclunk(fid protocol.FID) error { - log.Printf(">>> Tclunk fid %v\n", fid) - err := e.FileServer.Rclunk(fid) - if err == nil { - log.Printf("<<< Rclunk\n") - } else { - log.Printf("<<< Error %v\n", err) - } - return err -} - -func (e *debugFileServer) Rstat(fid protocol.FID) ([]byte, error) { - log.Printf(">>> Tstat fid %v\n", fid) - b, err := e.FileServer.Rstat(fid) - if err == nil { - dir, _ := protocol.Unmarshaldir(bytes.NewBuffer(b)) - log.Printf("<<< Rstat %v\n", dir) - } else { - log.Printf("<<< Error %v\n", err) - } - return b, err -} - -func (e *debugFileServer) Rwstat(fid protocol.FID, b []byte) error { - dir, _ := protocol.Unmarshaldir(bytes.NewBuffer(b)) - log.Printf(">>> Twstat fid %v, %v\n", fid, dir) - err := e.FileServer.Rwstat(fid, b) - if err == nil { - log.Printf("<<< Rwstat\n") - } else { - log.Printf("<<< Error %v\n", err) - } - return err -} - -func (e *debugFileServer) Rremove(fid protocol.FID) error { - log.Printf(">>> Tremove fid %v\n", fid) - err := e.FileServer.Rremove(fid) - if err == nil { - log.Printf("<<< Rremove\n") - } else { - log.Printf("<<< Error %v\n", err) - } - return err -} - -func (e *debugFileServer) Rread(fid protocol.FID, o protocol.Offset, c protocol.Count) ([]byte, error) { - log.Printf(">>> Tread fid %v, off %v, count %v\n", fid, o, c) - b, err := e.FileServer.Rread(fid, o, c) - if err == nil { - log.Printf("<<< Rread %v\n", len(b)) - } else { - log.Printf("<<< Error %v\n", err) - } - return b, err -} - -func (e *debugFileServer) Rwrite(fid protocol.FID, o protocol.Offset, b []byte) (protocol.Count, error) { - log.Printf(">>> Twrite fid %v, off %v, count %v\n", fid, o, len(b)) - c, err := e.FileServer.Rwrite(fid, o, b) - if err == nil { - log.Printf("<<< Rwrite %v\n", c) - } else { - log.Printf("<<< Error %v\n", err) - } - return c, err -} diff --git a/filesystem/filesystem.go b/filesystem/filesystem.go index 7a30baa..2d05ea2 100644 --- a/filesystem/filesystem.go +++ b/filesystem/filesystem.go @@ -99,10 +99,6 @@ func (s *FileServer) logf(format string, args ...interface{}) { } } -func (s *FileServer) Debug() protocol.NineServer { - return &debugFileServer{s} -} - func (e *FileServer) Rversion(msize protocol.MaxSize, version string) (protocol.MaxSize, string, error) { if version != "9P2000" { return 0, "", fmt.Errorf("%v not supported; only 9P2000", version) diff --git a/filesystem/filesystem_test.go b/filesystem/filesystem_test.go index 68bed25..b7b46f2 100644 --- a/filesystem/filesystem_test.go +++ b/filesystem/filesystem_test.go @@ -83,10 +83,7 @@ func TestMount(t *testing.T) { if err != nil { t.Fatal(err) } - n, err := protocol.NewServer(fs, func(s *protocol.Server) error { - s.Trace = print //t.Logf - return nil - }) + n, err := protocol.NewServer(fs, protocol.Trace(print)) if err != nil { t.Fatal(err) } diff --git a/protocol/server.go b/protocol/server.go index 04037e7..18c42fd 100644 --- a/protocol/server.go +++ b/protocol/server.go @@ -27,8 +27,8 @@ type Server struct { // TCP address to listen on, default is DefaultAddr Addr string - // Trace function for logging - Trace Tracer + // trace function for logging + trace Tracer // mu guards below mu sync.Mutex @@ -65,6 +65,13 @@ func NewServer(ns NineServer, opts ...ServerOpt) (*Server, error) { return s, nil } +func Trace(tracer Tracer) ServerOpt { + return func(s *Server) error { + s.trace = tracer + return nil + } +} + func (s *Server) newConn(rwc net.Conn) *conn { c := &conn{ server: s, @@ -179,8 +186,8 @@ func (s *Server) String() string { } func (s *Server) logf(format string, args ...interface{}) { - if s.Trace != nil { - s.Trace(format, args...) + if s.trace != nil { + s.trace(format, args...) } } From e8dc951faaa17e0072e8986ea8c5aa8e92dbf5f4 Mon Sep 17 00:00:00 2001 From: Jon Crussell Date: Tue, 12 Jun 2018 14:57:39 -0700 Subject: [PATCH 5/9] filesystem: fix compilation errors Sloppy merge, should have tested build afterwards. --- filesystem/filesystem.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/filesystem/filesystem.go b/filesystem/filesystem.go index 2d05ea2..d7c0cb5 100644 --- a/filesystem/filesystem.go +++ b/filesystem/filesystem.go @@ -59,8 +59,7 @@ func stat(s string) (*protocol.Dir, protocol.QID, error) { func NewServer(opts ...ServerOpt) (*FileServer, error) { s := &FileServer{ - mu: &sync.Mutex{}, - Files: make(map[protocol.FID]*File), + files: make(map[protocol.FID]*file), } for _, opt := range opts { From 37584d1af25d5fa6cf46db698c2a93ab2a7aca84 Mon Sep 17 00:00:00 2001 From: Jon Crussell Date: Tue, 12 Jun 2018 15:00:33 -0700 Subject: [PATCH 6/9] protocol: fix tests Server.Trace was replaced by Trace option. --- protocol/protocol_test.go | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/protocol/protocol_test.go b/protocol/protocol_test.go index a16b810..2ada3de 100644 --- a/protocol/protocol_test.go +++ b/protocol/protocol_test.go @@ -330,10 +330,7 @@ func TestTManyRPCs(t *testing.T) { t.Logf("Client is %v", c.String()) e := newEcho() - s, err := NewServer(e, func(s *Server) error { - s.Trace = print - return nil - }) + s, err := NewServer(e, Trace(print)) if err != nil { t.Fatalf("NewServer: want nil, got %v", err) } @@ -368,12 +365,7 @@ func TestTMessages(t *testing.T) { t.Logf("Client is %v", c.String()) e := newEcho() - s, err := NewServer(e, func(s *Server) error { - s.Trace = print // t.Logf - s.NS = e - return nil - }) - + s, err := NewServer(e, Trace(print)) if err != nil { t.Fatalf("NewServer: want nil, got %v", err) } From 214246c8c7e1fe7209e22d8313e834f833ce391f Mon Sep 17 00:00:00 2001 From: Jon Crussell Date: Wed, 13 Jun 2018 14:41:37 -0700 Subject: [PATCH 7/9] various: tweak trace Set trace for the various servers to no-op log by default. Users can then change the trace function using the Trace option. --- debug/debug.go | 88 +++++++++++++++++++++------------------- filesystem/filesystem.go | 12 +++--- protocol/server.go | 26 +++++++----- 3 files changed, 68 insertions(+), 58 deletions(-) diff --git a/debug/debug.go b/debug/debug.go index 829cda0..f8b82ed 100644 --- a/debug/debug.go +++ b/debug/debug.go @@ -6,6 +6,7 @@ package debug import ( "bytes" + "errors" "github.com/Harvey-OS/ninep/protocol" ) @@ -19,7 +20,10 @@ type Server struct { type ServerOpt func(*Server) error func NewServer(s protocol.NineServer, opts ...ServerOpt) (*Server, error) { - s2 := &Server{NineServer: s} + s2 := &Server{ + NineServer: s, + trace: nologf, + } for _, opt := range opts { if err := opt(s2); err != nil { @@ -32,149 +36,149 @@ func NewServer(s protocol.NineServer, opts ...ServerOpt) (*Server, error) { func Trace(tracer protocol.Tracer) ServerOpt { return func(s *Server) error { + if tracer == nil { + return errors.New("tracer cannot be nil") + } s.trace = tracer return nil } } -func (s *Server) logf(format string, args ...interface{}) { - if s.trace != nil { - s.trace(format, args...) - } -} +// nologf does nothing and is the default trace function +func nologf(format string, args ...interface{}) {} func (s *Server) Rversion(msize protocol.MaxSize, version string) (protocol.MaxSize, string, error) { - s.logf(">>> Tversion %v %v\n", msize, version) + s.trace(">>> Tversion %v %v\n", msize, version) msize, version, err := s.NineServer.Rversion(msize, version) if err == nil { - s.logf("<<< Rversion %v %v\n", msize, version) + s.trace("<<< Rversion %v %v\n", msize, version) } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return msize, version, err } func (s *Server) Rattach(fid protocol.FID, afid protocol.FID, uname string, aname string) (protocol.QID, error) { - s.logf(">>> Tattach fid %v, afid %v, uname %v, aname %v\n", fid, afid, + s.trace(">>> Tattach fid %v, afid %v, uname %v, aname %v\n", fid, afid, uname, aname) qid, err := s.NineServer.Rattach(fid, afid, uname, aname) if err == nil { - s.logf("<<< Rattach %v\n", qid) + s.trace("<<< Rattach %v\n", qid) } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return qid, err } func (s *Server) Rflush(o protocol.Tag) error { - s.logf(">>> Tflush tag %v\n", o) + s.trace(">>> Tflush tag %v\n", o) err := s.NineServer.Rflush(o) if err == nil { - s.logf("<<< Rflush\n") + s.trace("<<< Rflush\n") } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return err } func (s *Server) Rwalk(fid protocol.FID, newfid protocol.FID, paths []string) ([]protocol.QID, error) { - s.logf(">>> Twalk fid %v, newfid %v, paths %v\n", fid, newfid, paths) + s.trace(">>> Twalk fid %v, newfid %v, paths %v\n", fid, newfid, paths) qid, err := s.NineServer.Rwalk(fid, newfid, paths) if err == nil { - s.logf("<<< Rwalk %v\n", qid) + s.trace("<<< Rwalk %v\n", qid) } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return qid, err } func (s *Server) Ropen(fid protocol.FID, mode protocol.Mode) (protocol.QID, protocol.MaxSize, error) { - s.logf(">>> Topen fid %v, mode %v\n", fid, mode) + s.trace(">>> Topen fid %v, mode %v\n", fid, mode) qid, iounit, err := s.NineServer.Ropen(fid, mode) if err == nil { - s.logf("<<< Ropen %v %v\n", qid, iounit) + s.trace("<<< Ropen %v %v\n", qid, iounit) } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return qid, iounit, err } func (s *Server) Rcreate(fid protocol.FID, name string, perm protocol.Perm, mode protocol.Mode) (protocol.QID, protocol.MaxSize, error) { - s.logf(">>> Tcreate fid %v, name %v, perm %v, mode %v\n", fid, name, + s.trace(">>> Tcreate fid %v, name %v, perm %v, mode %v\n", fid, name, perm, mode) qid, iounit, err := s.NineServer.Rcreate(fid, name, perm, mode) if err == nil { - s.logf("<<< Rcreate %v %v\n", qid, iounit) + s.trace("<<< Rcreate %v %v\n", qid, iounit) } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return qid, iounit, err } func (s *Server) Rclunk(fid protocol.FID) error { - s.logf(">>> Tclunk fid %v\n", fid) + s.trace(">>> Tclunk fid %v\n", fid) err := s.NineServer.Rclunk(fid) if err == nil { - s.logf("<<< Rclunk\n") + s.trace("<<< Rclunk\n") } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return err } func (s *Server) Rstat(fid protocol.FID) ([]byte, error) { - s.logf(">>> Tstat fid %v\n", fid) + s.trace(">>> Tstat fid %v\n", fid) b, err := s.NineServer.Rstat(fid) if err == nil { dir, _ := protocol.Unmarshaldir(bytes.NewBuffer(b)) - s.logf("<<< Rstat %v\n", dir) + s.trace("<<< Rstat %v\n", dir) } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return b, err } func (s *Server) Rwstat(fid protocol.FID, b []byte) error { dir, _ := protocol.Unmarshaldir(bytes.NewBuffer(b)) - s.logf(">>> Twstat fid %v, %v\n", fid, dir) + s.trace(">>> Twstat fid %v, %v\n", fid, dir) err := s.NineServer.Rwstat(fid, b) if err == nil { - s.logf("<<< Rwstat\n") + s.trace("<<< Rwstat\n") } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return err } func (s *Server) Rremove(fid protocol.FID) error { - s.logf(">>> Tremove fid %v\n", fid) + s.trace(">>> Tremove fid %v\n", fid) err := s.NineServer.Rremove(fid) if err == nil { - s.logf("<<< Rremove\n") + s.trace("<<< Rremove\n") } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return err } func (s *Server) Rread(fid protocol.FID, o protocol.Offset, c protocol.Count) ([]byte, error) { - s.logf(">>> Tread fid %v, off %v, count %v\n", fid, o, c) + s.trace(">>> Tread fid %v, off %v, count %v\n", fid, o, c) b, err := s.NineServer.Rread(fid, o, c) if err == nil { - s.logf("<<< Rread %v\n", len(b)) + s.trace("<<< Rread %v\n", len(b)) } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return b, err } func (s *Server) Rwrite(fid protocol.FID, o protocol.Offset, b []byte) (protocol.Count, error) { - s.logf(">>> Twrite fid %v, off %v, count %v\n", fid, o, len(b)) + s.trace(">>> Twrite fid %v, off %v, count %v\n", fid, o, len(b)) c, err := s.NineServer.Rwrite(fid, o, b) if err == nil { - s.logf("<<< Rwrite %v\n", c) + s.trace("<<< Rwrite %v\n", c) } else { - s.logf("<<< Error %v\n", err) + s.trace("<<< Error %v\n", err) } return c, err } diff --git a/filesystem/filesystem.go b/filesystem/filesystem.go index d7c0cb5..49031ee 100644 --- a/filesystem/filesystem.go +++ b/filesystem/filesystem.go @@ -6,6 +6,7 @@ package ufs import ( "bytes" + "errors" "fmt" "io" "log" @@ -60,6 +61,7 @@ func stat(s string) (*protocol.Dir, protocol.QID, error) { func NewServer(opts ...ServerOpt) (*FileServer, error) { s := &FileServer{ files: make(map[protocol.FID]*file), + trace: nologf, } for _, opt := range opts { @@ -87,16 +89,16 @@ func IOunit(size protocol.MaxSize) ServerOpt { func Trace(tracer protocol.Tracer) ServerOpt { return func(s *FileServer) error { + if tracer == nil { + return errors.New("tracer cannot be nil") + } s.trace = tracer return nil } } -func (s *FileServer) logf(format string, args ...interface{}) { - if s.trace != nil { - s.trace(format, args...) - } -} +// nologf does nothing and is the default trace function +func nologf(format string, args ...interface{}) {} func (e *FileServer) Rversion(msize protocol.MaxSize, version string) (protocol.MaxSize, string, error) { if version != "9P2000" { diff --git a/protocol/server.go b/protocol/server.go index 18c42fd..3a3ae7d 100644 --- a/protocol/server.go +++ b/protocol/server.go @@ -8,6 +8,7 @@ package protocol import ( "bytes" + "errors" "fmt" "io" "net" @@ -54,9 +55,12 @@ type conn struct { } func NewServer(ns NineServer, opts ...ServerOpt) (*Server, error) { - s := &Server{} - s.NS = ns - s.D = Dispatch + s := &Server{ + NS: ns, + D: Dispatch, + trace: nologf, + } + for _, o := range opts { if err := o(s); err != nil { return nil, err @@ -67,11 +71,17 @@ func NewServer(ns NineServer, opts ...ServerOpt) (*Server, error) { func Trace(tracer Tracer) ServerOpt { return func(s *Server) error { + if tracer == nil { + return errors.New("tracer cannot be nil") + } s.trace = tracer return nil } } +// nologf does nothing and is the default trace function +func nologf(format string, args ...interface{}) {} + func (s *Server) newConn(rwc net.Conn) *conn { c := &conn{ server: s, @@ -148,7 +158,7 @@ func (s *Server) Serve(ln net.Listener) error { if max := 1 * time.Second; tempDelay > max { tempDelay = max } - s.logf("ufs: Accept error: %v; retrying in %v", err, tempDelay) + s.trace("ufs: Accept error: %v; retrying in %v", err, tempDelay) time.Sleep(tempDelay) continue } @@ -185,19 +195,13 @@ func (s *Server) String() string { return "" } -func (s *Server) logf(format string, args ...interface{}) { - if s.trace != nil { - s.trace(format, args...) - } -} - func (c *conn) String() string { return fmt.Sprintf("Dead %v %d replies pending", c.dead, len(c.replies)) } func (c *conn) logf(format string, args ...interface{}) { // prepend some info about the conn - c.server.logf("[%v] "+format, append([]interface{}{c.remoteAddr}, args...)...) + c.server.trace("[%v] "+format, append([]interface{}{c.remoteAddr}, args...)...) } func (c *conn) serve() { From 1afc65ec40f5dd21a327486e64ff1428bcab128d Mon Sep 17 00:00:00 2001 From: Jon Crussell Date: Thu, 14 Jun 2018 09:37:38 -0700 Subject: [PATCH 8/9] ufs: fix bug with default tracer Should not be nil otherwise the *.Trace will return an error. --- cmd/ufs/ufs.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/ufs/ufs.go b/cmd/ufs/ufs.go index c09fd24..d86b0db 100644 --- a/cmd/ufs/ufs.go +++ b/cmd/ufs/ufs.go @@ -30,7 +30,7 @@ func checkErr(format string, err error) { func main() { flag.Parse() - var tracer protocol.Tracer + tracer := func(format string, args ...interface{}) {} if *trace { tracer = log.Printf } From 35ad2879c0a351783e807c89f139dd9a1aed52c4 Mon Sep 17 00:00:00 2001 From: Jon Crussell Date: Tue, 19 Jun 2018 10:57:24 -0700 Subject: [PATCH 9/9] filesystem: fix windows build Forgot to s/File/file. --- filesystem/filesystem_windows.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/filesystem/filesystem_windows.go b/filesystem/filesystem_windows.go index 7a5ef70..70cc388 100644 --- a/filesystem/filesystem_windows.go +++ b/filesystem/filesystem_windows.go @@ -13,13 +13,13 @@ import "os" // resetDir closes the underlying file and reopens it so it can be read again. // This is because Windows doesn't seem to support calling Seek on a directory // handle. -func resetDir(f *File) error { +func resetDir(f *file) error { f2, err := os.OpenFile(f.fullName, os.O_RDONLY, 0) if err != nil { return err } - f.File.Close() - f.File = f2 + f.file.Close() + f.file = f2 return nil }