feat: reduce hot paths memory usage (#56)

* fix: no pretty print output

* fix: typo

* feat: cache file read by stat mod time

Author: bcho

fs.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"os"
+	"sync"
+)
+
+func readFileWithStatCache(file string) func() ([]byte, error) {
+	mu := new(sync.RWMutex)
+	var (
+		lastReadContent []byte
+		lastStat os.FileInfo
+	)
+
+	fast := func() (bool, []byte, error) {
+		stat, err := os.Stat(file)
+		if err != nil {
+			return false, nil, err
+		}
+
+		mu.RLock()
+		defer mu.RUnlock()
+
+		if lastStat == nil {
+			// no cache
+			return false, nil, nil
+		}
+
+		if lastStat.ModTime() == stat.ModTime() {
+			return true, lastReadContent, nil
+		}
+
+		// mod time changed
+		return false, nil, nil
+	}
+
+	slow := func() ([]byte, error) {
+		mu.Lock()
+		defer mu.Unlock()
+
+		stat, err := os.Stat(file)
+		if err != nil {
+			return nil, err
+		}
+
+		if lastStat != nil && lastStat.ModTime() == stat.ModTime() {
+			return lastReadContent, nil
+		}
+
+		lastStat = stat
+		lastReadContent = nil
+
+		content, err := os.ReadFile(file)
+		if err != nil {
+			return nil, err
+		}
+		lastReadContent = content
+
+		return content, nil
+	}
+
+	return func() ([]byte, error) {
+		readFromCache, content, err := fast()
+		if err != nil {
+			return nil, err
+		}
+		if readFromCache {
+			return content, nil
+		}
+
+		return slow()
+	}
+}

server.go

@@ -152,10 +152,9 @@ func (server *dbServer) responseData(w http.ResponseWriter, data interface{}, st
 	w.WriteHeader(statusCode)
 
 	enc := json.NewEncoder(w)
-	enc.SetIndent("", " ")
 	if encodeErr := enc.Encode(data); encodeErr != nil {
 		server.logger.Error(encodeErr, "failed to write response")
-		w.WriteHeader(http.StatusCreated)
+		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 }

server_auth.go

@@ -3,7 +3,6 @@ package main
 import (
 	"fmt"
 	"net/http"
-	"os"
 	"strings"
 
 	"github.com/golang-jwt/jwt"
@@ -66,14 +65,16 @@ func (opts *ServerAuthOptions) createAuthMiddleware(
 
 	switch {
 	case opts.RSAPublicKeyFilePath != "":
+		keyReader := readFileWithStatCache(opts.RSAPublicKeyFilePath)
+
 		jwtParser.ValidMethods = append(
 			jwtParser.ValidMethods,
 			jwt.SigningMethodRS256.Name,
 			jwt.SigningMethodRS384.Name,
 			jwt.SigningMethodRS512.Name,
 		)
 		jwtKeyFunc = func(t *jwt.Token) (interface{}, error) {
-			b, err := os.ReadFile(opts.RSAPublicKeyFilePath)
+			b, err := keyReader()
 			if err != nil {
 				return nil, err
 			}
@@ -85,14 +86,16 @@ func (opts *ServerAuthOptions) createAuthMiddleware(
 			return v, nil
 		}
 	case opts.TokenFilePath != "":
+		tokenReader := readFileWithStatCache(opts.TokenFilePath)
+
 		jwtParser.ValidMethods = append(
 			jwtParser.ValidMethods,
 			jwt.SigningMethodHS256.Name,
 			jwt.SigningMethodHS384.Name,
 			jwt.SigningMethodHS512.Name,
 		)
 		jwtKeyFunc = func(t *jwt.Token) (interface{}, error) {
-			b, err := os.ReadFile(opts.TokenFilePath)
+			b, err := tokenReader()
 			if err != nil {
 				return nil, err
 			}

server_security.go

@@ -30,16 +30,16 @@ func (opts *ServerSecurityOptions) defaults() error {
 func (opts *ServerSecurityOptions) createTableOrViewAccessCheckMiddleware(
 	responseErr func(w http.ResponseWriter, err error),
 ) func(http.Handler) http.Handler {
-	accesibleTableOrViews := make(map[string]struct{})
+	accessibleTableOrViews := make(map[string]struct{})
 	for _, t := range opts.EnabledTableOrViews {
-		accesibleTableOrViews[t] = struct{}{}
+		accessibleTableOrViews[t] = struct{}{}
 	}
 
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 			target := chi.URLParam(req, routeVarTableOrView)
 
-			if _, ok := accesibleTableOrViews[target]; !ok {
+			if _, ok := accessibleTableOrViews[target]; !ok {
 				responseErr(w, ErrAccessRestricted)
 				return
 			}