From 0ace25c11739cd7d46f350ca542c69ef21947b5f Mon Sep 17 00:00:00 2001 From: Dane Everitt Date: Sun, 7 Apr 2019 14:45:23 -0700 Subject: [PATCH] Add support for listing a directory's contents --- go.mod | 2 +- http.go | 21 ++++++++- server/filesystem.go | 91 ++++++++++++++++++++++++++++++++++-- server/filesystem_darwin.go | 13 ++++++ server/filesystem_linux.go | 13 ++++++ server/filesystem_windows.go | 12 +++++ 6 files changed, 146 insertions(+), 6 deletions(-) create mode 100644 server/filesystem_darwin.go create mode 100644 server/filesystem_linux.go create mode 100644 server/filesystem_windows.go diff --git a/go.mod b/go.mod index 21e5edc..53ddcc1 100644 --- a/go.mod +++ b/go.mod @@ -12,7 +12,7 @@ require ( github.com/docker/docker v0.0.0-20180422163414-57142e89befe github.com/docker/go-connections v0.4.0 github.com/docker/go-units v0.3.3 // indirect - github.com/gabriel-vasile/mimetype v0.1.4 // indirect + github.com/gabriel-vasile/mimetype v0.1.4 github.com/gogo/protobuf v1.0.0 // indirect github.com/google/go-cmp v0.2.0 // indirect github.com/gotestyourself/gotestyourself v2.2.0+incompatible // indirect diff --git a/http.go b/http.go index f6a4298..dd7b542 100644 --- a/http.go +++ b/http.go @@ -232,6 +232,24 @@ func (rt *Router) routeServerFileRead(w http.ResponseWriter, r *http.Request, ps bufio.NewReader(f).WriteTo(w) } +// Lists the contents of a directory. +func (rt *Router) routeServerFileList(w http.ResponseWriter, r *http.Request, ps httprouter.Params) { + s := rt.Servers.Get(ps.ByName("server")) + + stats, err := s.Filesystem().ListDirectory(ps.ByName("path")) + if os.IsNotExist(err) { + http.NotFound(w, r) + return + } else if err != nil { + zap.S().Errorw("failed to list contents of directory", zap.String("server", s.Uuid), zap.String("path", ps.ByName("path")), zap.Error(err)) + + http.Error(w, "failed to list directory", http.StatusInternalServerError) + return + } + + json.NewEncoder(w).Encode(stats) +} + // Configures the router and all of the associated routes. func (rt *Router) ConfigureRouter() *httprouter.Router { router := httprouter.New() @@ -240,7 +258,8 @@ func (rt *Router) ConfigureRouter() *httprouter.Router { router.GET("/api/servers", rt.AuthenticateToken("i:servers", rt.routeAllServers)) router.GET("/api/servers/:server", rt.AuthenticateToken("s:view", rt.AuthenticateServer(rt.routeServer))) router.GET("/api/servers/:server/logs", rt.AuthenticateToken("s:logs", rt.AuthenticateServer(rt.routeServerLogs))) - router.GET("/api/servers/:server/files/*path", rt.AuthenticateToken("s:files", rt.AuthenticateServer(rt.routeServerFileRead))) + router.GET("/api/servers/:server/files/read/*path", rt.AuthenticateToken("s:files", rt.AuthenticateServer(rt.routeServerFileRead))) + router.GET("/api/servers/:server/files/list/*path", rt.AuthenticateToken("s:files", rt.AuthenticateServer(rt.routeServerFileList))) router.POST("/api/servers/:server/power", rt.AuthenticateToken("s:power", rt.AuthenticateServer(rt.routeServerPower))) diff --git a/server/filesystem.go b/server/filesystem.go index 1d76e2c..35f7c4e 100644 --- a/server/filesystem.go +++ b/server/filesystem.go @@ -2,6 +2,7 @@ package server import ( "bytes" + "encoding/json" "errors" "github.com/gabriel-vasile/mimetype" "go.uber.org/zap" @@ -9,6 +10,7 @@ import ( "io/ioutil" "os" "path/filepath" + "sort" "strings" "sync" "time" @@ -122,7 +124,7 @@ func (fs *Filesystem) HasSpaceAvailable() bool { if size, err := fs.DirectorySize("/"); err != nil { zap.S().Warnw("failed to determine directory size", zap.String("server", fs.Server.Uuid), zap.Error(err)) } else { - fs.Server.Cache().Set("disk_used", size, time.Minute * 5) + fs.Server.Cache().Set("disk_used", size, time.Minute*5) } } @@ -202,10 +204,34 @@ func (fs *Filesystem) DeleteFile(p string) error { // Defines the stat struct object. type Stat struct { - Info *os.FileInfo + Info os.FileInfo Mimetype string } +func (s *Stat) MarshalJSON() ([]byte, error) { + return json.Marshal(struct { + Name string + Created string + Modified string + Mode string + Size int64 + Directory bool + File bool + Symlink bool + Mime string + }{ + Name: s.Info.Name(), + Created: s.CTime().String(), + Modified: s.Info.ModTime().String(), + Mode: s.Info.Mode().String(), + Size: s.Info.Size(), + Directory: s.Info.IsDir(), + File: !s.Info.IsDir(), + Symlink: s.Info.Mode().Perm()&os.ModeSymlink != 0, + Mime: s.Mimetype, + }) +} + // Stats a file or folder and returns the base stat object from go along with the // MIME data that can be used for editing files. func (fs *Filesystem) Stat(p string) (*Stat, error) { @@ -228,9 +254,66 @@ func (fs *Filesystem) Stat(p string) (*Stat, error) { } st := &Stat{ - Info: &s, + Info: s, Mimetype: m, } return st, nil -} \ No newline at end of file +} + +// Lists the contents of a given directory and returns stat information about each +// file and folder within it. +func (fs *Filesystem) ListDirectory(p string) ([]*Stat, error) { + cleaned, err := fs.SafePath(p) + if err != nil { + return nil, err + } + + files, err := ioutil.ReadDir(cleaned) + if err != nil { + return nil, err + } + + var out []*Stat + var wg sync.WaitGroup + + // Iterate over all of the files and directories returned and perform an async process + // to get the mime-type for them all. + for _, file := range files { + wg.Add(1) + + go func(f os.FileInfo) { + defer wg.Done() + + var m = "inode/directory" + if !f.IsDir() { + m, _, _ = mimetype.DetectFile(filepath.Join(cleaned, f.Name())) + } + + out = append(out, &Stat{ + Info: f, + Mimetype: m, + }) + }(file) + } + + wg.Wait() + + // Sort the output alphabetically to begin with since we've run the output + // through an asynchronous process and the order is gonna be very random. + sort.SliceStable(out, func(i, j int) bool { + if out[i].Info.Name() == out[j].Info.Name() || out[i].Info.Name() < out[j].Info.Name() { + return true + } + + return false + }) + + // Then, sort it so that directories are listed first in the output. Everything + // will continue to be alphabetized at this point. + sort.SliceStable(out, func(i, j int) bool { + return out[i].Info.IsDir() + }) + + return out, nil +} diff --git a/server/filesystem_darwin.go b/server/filesystem_darwin.go new file mode 100644 index 0000000..5fbf5d1 --- /dev/null +++ b/server/filesystem_darwin.go @@ -0,0 +1,13 @@ +package server + +import ( + "syscall" + "time" +) + +// Returns the time that the file/folder was created. +func (s *Stat) CTime() time.Time { + st := s.Info.Sys().(*syscall.Stat_t) + + return time.Unix(int64(st.Ctimespec.Sec), int64(st.Ctimespec.Nsec)) +} \ No newline at end of file diff --git a/server/filesystem_linux.go b/server/filesystem_linux.go new file mode 100644 index 0000000..b9d0ff9 --- /dev/null +++ b/server/filesystem_linux.go @@ -0,0 +1,13 @@ +package server + +import ( + "syscall" + "time" +) + +// Returns the time that the file/folder was created. +func (s *Stat) CTime() time.Time { + st := s.Info.Sys().(*syscall.Stat_t) + + return time.Unix(int64(st.Ctim.Sec), int64(st.Ctim.Nsec)) +} \ No newline at end of file diff --git a/server/filesystem_windows.go b/server/filesystem_windows.go new file mode 100644 index 0000000..930f92a --- /dev/null +++ b/server/filesystem_windows.go @@ -0,0 +1,12 @@ +package server + +import ( + "time" +) + +// On linux systems this will return the time that the file was created. +// However, I have no idea how to do this on windows, so we're skipping it +// for right now. +func (s *Stat) CTime() time.Time { + return s.Info.ModTime() +} \ No newline at end of file