ADD: option to sort items in listing page

Author: Jack Tang

internal/server/server.go

@@ -37,6 +37,7 @@ Options:
   --store-size BYTE               Size of space allowed for storage [default: 0]
   --timeout TIMEOUT               Read timeout for connections in milliseconds.  A zero value means that reads will not timeout [default: 30*1000]
   --behind-proxy                  Respect X-Forwarded-* and similar headers which may be set by proxies [default: false]
+	--inc 													Sort filename in increasingly alphabetical order in listing page [default: false]
 `
 
 type ServerConf struct {
@@ -51,6 +52,7 @@ type ServerConf struct {
 	FilesEndpoint   string `docopt:"--files-endpoint"`
 	Timeout         int64  `docopt:"--timeout"`
 	IsBehindProxy   bool   `docopt:"--behind-proxy"`
+	Inc             bool   `docopt:"--inc"`
 }
 
 var stdout = log.New(os.Stdout, "[tusd] ", log.Ldate|log.Ltime)
@@ -75,6 +77,7 @@ func Server() {
 	conf.FilesEndpoint, _ = arguments.String("--files-endpoint")
 	conf.Timeout = util.GetInt64(arguments, "--timeout")
 	conf.IsBehindProxy, _ = arguments.Bool("--behind-proxy")
+	conf.Inc, _ = arguments.Bool("--inc")
 	fmt.Println(conf)
 
 	storeCompoesr := tusd.NewStoreComposer()
@@ -231,9 +234,15 @@ td {
 		}
 
 		// sort file by name
-		sort.Slice(rows, func(i, j int) bool {
-			return rows[i].Filename < rows[j].Filename
-		})
+		if conf.Inc {
+			sort.Slice(rows, func(i, j int) bool {
+				return rows[i].Filename < rows[j].Filename
+			})
+		} else {
+			sort.Slice(rows, func(i, j int) bool {
+				return rows[i].Filename > rows[j].Filename
+			})
+		}
 
 		data := struct {
 			Rows []Row

internal/util/conn.go

@@ -1,60 +1,60 @@
 package util
 
 import (
-  "net"
-  "time"
+	"net"
+	"time"
 )
 
 // Conn wraps a net.Conn, and sets a deadline for every read
 // and write operation.
 type Conn struct {
-  net.Conn
-  ReadTimeout  time.Duration
-  WriteTimeout time.Duration
-
-  // closeRecorded will be true if the connection has been closed and the
-  // corresponding prometheus counter has been decremented. It will be used to
-  // avoid duplicated modifications to this metric.
-  closeRecorded bool
+	net.Conn
+	ReadTimeout  time.Duration
+	WriteTimeout time.Duration
+
+	// closeRecorded will be true if the connection has been closed and the
+	// corresponding prometheus counter has been decremented. It will be used to
+	// avoid duplicated modifications to this metric.
+	closeRecorded bool
 }
 
 func (c *Conn) Read(b []byte) (int, error) {
-  var err error
-  if c.ReadTimeout > 0 {
-    err = c.Conn.SetReadDeadline(time.Now().Add(c.ReadTimeout))
-  } else {
-    err = c.Conn.SetReadDeadline(time.Time{})
-  }
-
-  if err != nil {
-    return 0, err
-  }
-
-  return c.Conn.Read(b)
+	var err error
+	if c.ReadTimeout > 0 {
+		err = c.Conn.SetReadDeadline(time.Now().Add(c.ReadTimeout))
+	} else {
+		err = c.Conn.SetReadDeadline(time.Time{})
+	}
+
+	if err != nil {
+		return 0, err
+	}
+
+	return c.Conn.Read(b)
 }
 
 func (c *Conn) Write(b []byte) (int, error) {
-  var err error
-  if c.WriteTimeout > 0 {
-    err = c.Conn.SetWriteDeadline(time.Now().Add(c.WriteTimeout))
-  } else {
-    err = c.Conn.SetWriteDeadline(time.Time{})
-  }
-
-  if err != nil {
-    return 0, err
-  }
-
-  return c.Conn.Write(b)
+	var err error
+	if c.WriteTimeout > 0 {
+		err = c.Conn.SetWriteDeadline(time.Now().Add(c.WriteTimeout))
+	} else {
+		err = c.Conn.SetWriteDeadline(time.Time{})
+	}
+
+	if err != nil {
+		return 0, err
+	}
+
+	return c.Conn.Write(b)
 }
 
 func (c *Conn) Close() error {
-  // Only decremented the prometheus counter if the Close function has not been
-  // invoked before to avoid duplicated modifications.
-  if !c.closeRecorded {
-    c.closeRecorded = true
-    //MetricsOpenConnections.Dec()
-  }
-
-  return c.Conn.Close()
+	// Only decremented the prometheus counter if the Close function has not been
+	// invoked before to avoid duplicated modifications.
+	if !c.closeRecorded {
+		c.closeRecorded = true
+		//MetricsOpenConnections.Dec()
+	}
+
+	return c.Conn.Close()
 }

internal/util/docopt.go

@@ -1,28 +1,28 @@
 package util
 
 import (
-  "github.com/docopt/docopt-go"
-  "strconv"
+	"github.com/docopt/docopt-go"
+	"strconv"
 )
 
 func GetInt64(arg docopt.Opts, key string) int64 {
-  s, _ := arg.String(key)
-  i, _ := strconv.ParseInt(s, 10, 64)
-  return i
+	s, _ := arg.String(key)
+	i, _ := strconv.ParseInt(s, 10, 64)
+	return i
 }
 
 func GetBool(arg docopt.Opts, key string) bool {
-  v, _ := arg[key]
-  if b, ok := v.(bool); ok {
-    return b
-  }
-  return false
+	v, _ := arg[key]
+	if b, ok := v.(bool); ok {
+		return b
+	}
+	return false
 }
 
 func GetString(arg docopt.Opts, key string) string {
-  v, _ := arg[key]
-  if s, ok := v.(string); ok {
-    return s
-  }
-  return ""
+	v, _ := arg[key]
+	if s, ok := v.(string); ok {
+		return s
+	}
+	return ""
 }

internal/util/listener.go

@@ -1,86 +1,85 @@
 package util
 
 import (
-  "errors"
-  "net"
-  "os"
-  "time"
+	"errors"
+	"net"
+	"os"
+	"time"
 )
 
 // Listener wraps a net.Listener, and gives a place to store the timeout
 // parameters. On Accept, it will wrap the net.Conn with our own Conn for us.
 // Original implementation taken from https://gist.github.com/jbardin/9663312
 // Thanks! <3
 type Listener struct {
-  net.Listener
-  ReadTimeout  time.Duration
-  WriteTimeout time.Duration
+	net.Listener
+	ReadTimeout  time.Duration
+	WriteTimeout time.Duration
 }
 
 func NewListener(addr string, readTimeout, writeTimeout time.Duration) (net.Listener, error) {
-  l, err := net.Listen("tcp", addr)
-  if err != nil {
-    return nil, err
-  }
+	l, err := net.Listen("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
 
-  tl := &Listener{
-    Listener:     l,
-    ReadTimeout:  readTimeout,
-    WriteTimeout: writeTimeout,
-  }
-  return tl, nil
+	tl := &Listener{
+		Listener:     l,
+		ReadTimeout:  readTimeout,
+		WriteTimeout: writeTimeout,
+	}
+	return tl, nil
 }
 
 // Binds to a UNIX socket. If the file already exists, try to remove it before
 // binding again. This logic is borrowed from Gunicorn
 // (see https://github.com/benoitc/gunicorn/blob/a8963ef1a5a76f3df75ce477b55fe0297e3b617d/gunicorn/sock.py#L106)
 func NewUnixListener(path string, readTimeout, writeTimeout time.Duration) (net.Listener, error) {
-  stat, err := os.Stat(path)
+	stat, err := os.Stat(path)
 
-  if err != nil {
-    if !os.IsNotExist(err) {
-      return nil, err
-    }
-  } else {
-    if stat.Mode()&os.ModeSocket != 0 {
-      err = os.Remove(path)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			return nil, err
+		}
+	} else {
+		if stat.Mode()&os.ModeSocket != 0 {
+			err = os.Remove(path)
 
-      if err != nil {
-        return nil, err
-      }
-    } else {
-      return nil, errors.New("specified path is not a socket")
-    }
-  }
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			return nil, errors.New("specified path is not a socket")
+		}
+	}
 
-  l, err := net.Listen("unix", path)
+	l, err := net.Listen("unix", path)
 
-  if err != nil {
-    return nil, err
-  }
+	if err != nil {
+		return nil, err
+	}
 
-  tl := &Listener{
-    Listener:     l,
-    ReadTimeout:  readTimeout,
-    WriteTimeout: writeTimeout,
-  }
+	tl := &Listener{
+		Listener:     l,
+		ReadTimeout:  readTimeout,
+		WriteTimeout: writeTimeout,
+	}
 
-  return tl, nil
+	return tl, nil
 }
 
 func (l *Listener) Accept() (net.Conn, error) {
-  c, err := l.Listener.Accept()
-  if err != nil {
-    return nil, err
-  }
+	c, err := l.Listener.Accept()
+	if err != nil {
+		return nil, err
+	}
 
-  //go MetricsOpenConnections.Inc()
+	//go MetricsOpenConnections.Inc()
 
-  tc := &Conn{
-    Conn:         c,
-    ReadTimeout:  l.ReadTimeout,
-    WriteTimeout: l.WriteTimeout,
-  }
-  return tc, nil
+	tc := &Conn{
+		Conn:         c,
+		ReadTimeout:  l.ReadTimeout,
+		WriteTimeout: l.WriteTimeout,
+	}
+	return tc, nil
 }
-

internal/util/log.go

@@ -1,14 +1,14 @@
 package util
 
 import (
-  "fmt"
-  "os"
+	"fmt"
+	"os"
 )
 
 func ExitWithMessages(msg ...interface{}) {
-  for _, m := range msg {
-    fmt.Fprintln(os.Stderr, m)
-  }
-  //fmt.Fprintln(os.Stderr, msg...)
-  os.Exit(1)
-}
+	for _, m := range msg {
+		fmt.Fprintln(os.Stderr, m)
+	}
+	//fmt.Fprintln(os.Stderr, msg...)
+	os.Exit(1)
+}