Feature/file cache (#12)

- implement cache

Author: TimoKats

emmer.go

@@ -25,6 +25,7 @@ func main() {
 	// api
 	http.HandleFunc("/ping", server.PingHandler)
 	http.HandleFunc("/logs", server.Auth(server.LogsHandler))
+	http.HandleFunc("/commit", server.Auth(server.CommitHandler))
 	http.HandleFunc("/api/", server.Auth(server.ApiHandler))
 
 	// start the server

server/api.go

@@ -3,9 +3,8 @@ package server
 import (
 	"crypto/rand"
 	"encoding/base64"
-	"encoding/json"
 	"errors"
-	"strings"
+	"strconv"
 
 	emmerFs "github.com/TimoKats/emmer/server/fs"
 
@@ -16,67 +15,27 @@ import (
 	"os"
 )
 
-var config Config
+var session Session
 
-// get HTTP request and format it into Request object used by server
-func parseRequest(r *http.Request) (Request, error) {
-	// parse URL path (parameters, path)
-	request := Request{Method: r.Method, Mode: r.FormValue("mode")}
-	urlPath := r.URL.Path[len("/api/"):]
-	urlItems := strings.Split(urlPath, "/")
-	if len(urlItems) > 0 {
-		request.Table = urlItems[0]
-		if len(urlItems) > 1 {
-			request.Key = urlItems[1:]
-		}
-	}
-	// parse request body
-	payload, err := io.ReadAll(r.Body)
-	defer r.Body.Close() //nolint:errcheck
-	if err != nil {
-		return request, err
-	}
-	if len(payload) > 0 {
-		err = json.Unmarshal(payload, &request.Value)
-	}
-	return request, err
-}
+// helper function that selects the interface based on the URL path
+func ApiHandler(w http.ResponseWriter, r *http.Request) {
 
-// takes response object and writes the HTTP response object
-func parseResponse(w http.ResponseWriter, response Response) error {
-	if response.Error != nil {
-		w.Header().Set("Content-Type", "text/plain")
-		if strings.Contains(response.Error.Error(), "not found") {
-			w.WriteHeader(404)
-		} else {
-			w.WriteHeader(500)
+	// returns the item to apply CRUD operations on
+	toggle := func(request Request) (Item, error) {
+		if len(request.Key) > 0 {
+			return EntryItem{}, nil
 		}
-		return json.NewEncoder(w).Encode(response.Error.Error())
-	}
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(200)
-	return json.NewEncoder(w).Encode(response.Data)
-}
-
-// returns the item to apply CRUD operations on
-func selectItem(request Request) (Item, error) {
-	if len(request.Key) > 0 {
-		return EntryItem{}, nil
+		return TableItem{}, nil
 	}
-	return TableItem{}, nil
-}
 
-// helper function that selects the interface based on the URL path
-func ApiHandler(w http.ResponseWriter, r *http.Request) {
-	// set up
+	// apply CRUD to correct item and return response
 	var response Response
 	request, parseErr := parseRequest(r)
-	item, itemErr := selectItem(request)
+	item, itemErr := toggle(request)
 	if err := errors.Join(parseErr, itemErr); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest) // to response
 		return
 	}
-	// select function
 	switch request.Method {
 	case "PUT":
 		response = item.Add(request)
@@ -85,33 +44,44 @@ func ApiHandler(w http.ResponseWriter, r *http.Request) {
 	case "GET":
 		response = item.Get(request)
 	default:
-		http.Error(w, "please use put/del/get", http.StatusMethodNotAllowed) // to response
+		http.Error(w, "please use put/del/get", http.StatusMethodNotAllowed)
 		return
 	}
-	// check errors and return response
 	if err := parseResponse(w, response); err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 }
 
-// does nothing. Only used for health checks
+// does nothing, only used for health checks
 func PingHandler(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprintln(w, "pong") //nolint:errcheck
 }
 
 // shows last n (20) logs from server
 func LogsHandler(w http.ResponseWriter, r *http.Request) {
-	for _, entry := range config.logBuffer.GetLogs() {
+	for _, entry := range session.logBuffer.GetLogs() {
 		fmt.Fprint(w, entry) //nolint:errcheck
 	}
 }
 
+// write all cache to filesystem
+func CommitHandler(w http.ResponseWriter, r *http.Request) {
+	for filename, data := range session.cache.data {
+		err := session.fs.Put(filename, data)
+		if err != nil {
+			log.Printf("error writing cache of %s", filename)
+		} else {
+			fmt.Fprint(w, "cache written to filesystem") //nolint:errcheck
+		}
+	}
+}
+
 // basic auth that uses public username/password for check
 func Auth(next http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		user, pass, ok := r.BasicAuth()
-		if !ok || user != config.username || pass != config.password {
+		if !ok || user != session.config.username || pass != session.config.password {
 			w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
 			http.Error(w, "Unauthorized", http.StatusUnauthorized)
 			return
@@ -135,15 +105,29 @@ func init() {
 		password = base64.URLEncoding.EncodeToString(b)
 		log.Printf("set password to: %s", password)
 	}
+	// cache settings
+	commit := 1
+	commitEnv := os.Getenv("EM_COMMIT")
+	if commitEnv != "" {
+		commitInt, err := strconv.Atoi(commitEnv)
+		if err != nil {
+			fmt.Printf("Error converting commit strategy to int: %v", err)
+			return
+		}
+		commit = commitInt
+	}
 	// logs settings
 	buffer := NewLogBuffer(20)
 	log.SetOutput(io.MultiWriter(os.Stdout, buffer))
 	// create config object
-	config = Config{
-		logBuffer: buffer,
-		autoTable: os.Getenv("EM_AUTOTABLE") != "false",
-		username:  username,
-		password:  password,
-		fs:        emmerFs.SetupLocal(),
+	session.config = Config{
+		username: username,
+		password: password,
+		commit:   commit,
 	}
+	session.logBuffer = buffer
+	session.cache.data = make(map[string]map[string]any)
+	session.cache.data = make(map[string]map[string]any)
+	session.fs = emmerFs.SetupLocal()
+	session.commits = 1
 }

server/entry.go

@@ -1,79 +1,55 @@
 package server
 
 import (
-	"errors"
 	"log"
-	"strconv"
 )
 
 type EntryItem struct{}
 
-// used to query on multi-keys. E.g. [1,2,3] returns map[1,2,3] > value
-func findKey(data map[string]any, key []string) (any, error) {
-	var current any = data
-	if len(key) == 0 || key[0] == "" {
-		return data, nil
-	}
-	for _, step := range key {
-		switch typed := current.(type) {
-		case map[string]any:
-			val, ok := typed[step]
-			if !ok {
-				return nil, errors.New("key " + step + " not found in map")
-			}
-			current = val
-		case []any:
-			index, err := strconv.Atoi(step)
-			if err != nil {
-				return nil, errors.New("invalid index " + step + " for list")
-			}
-			if index < 0 || index >= len(typed) {
-				return nil, errors.New("index " + step + " out of bounds")
-			}
-			current = typed[index]
-		default:
-			return nil, errors.New("cannot descend into type")
-		}
-	}
-	return current, nil
-}
-
 // fetches path for table name, then removes key from JSON.
 func (EntryItem) Del(request Request) Response {
 	log.Printf("deleting key %s in %v", request.Key, request.Table)
-	if _, err := config.fs.Fetch(request.Table); err != nil {
+	// read file from cache/fs
+	data, err := read(request.Table, request.Mode)
+	if err != nil {
+		return Response{Data: nil, Error: err}
+	}
+	// update contents, and write to cache/fs
+	if err = pop(data, request.Key); err != nil {
+		return Response{Data: nil, Error: err}
+	}
+	if err = write(request.Table, data); err != nil {
 		return Response{Data: nil, Error: err}
 	}
-	err := config.fs.DeleteJSON(request.Table, request.Key)
 	return Response{Data: "deleted key in " + request.Table, Error: err}
 }
 
 // parses entry payload and updates the corresponding table
 func (EntryItem) Add(request Request) Response {
 	log.Printf("adding value for %s in table %s", request.Key, request.Table)
 	// if it doesn't exist, create it. still errors? return error.
-	if _, err := config.fs.Fetch(request.Table); err != nil {
-		if config.autoTable {
-			err = config.fs.CreateJSON(request.Table, nil)
-		}
-		if err != nil {
-			return Response{Data: nil, Error: err}
-		}
+	data, err := read(request.Table, request.Mode)
+	if err != nil {
+		return Response{Data: nil, Error: err}
+	}
+	// update json, and update cache
+	err = insert(data, request.Key, request.Value, request.Mode)
+	if err != nil {
+		return Response{Data: nil, Error: err}
+	}
+	if err = write(request.Table, data); err != nil {
+		return Response{Data: nil, Error: err}
 	}
-	// update json file with new values
-	err := config.fs.UpdateJSON(request.Table, request.Key, request.Value, request.Mode)
 	return Response{Data: "added key in " + request.Table, Error: err}
 }
 
-// query for an entry in a table. Returns query result.
+// query for an entry in a table. Returns query result (and updates cache).
 func (EntryItem) Get(request Request) Response {
-	log.Printf("querying table %s", request.Table)
-	// get complete json data
-	data, err := config.fs.ReadJSON(request.Table)
+	log.Printf("querying table: %s", request.Table)
+	data, err := read(request.Table, request.Mode)
 	if err != nil {
 		return Response{Data: nil, Error: err}
 	}
-	// filter json data
-	result, err := findKey(data, request.Key)
+	result, err := query(data, request.Key)
 	return Response{Data: result, Error: err}
 }