feat: response time goes brrrr

Author: byPixelTV

main.go

@@ -83,6 +83,7 @@ func main() {
 		}))
 
 		routes.RegisterGetDatedDataRoute(r)
+		routes.RegisterGetBulkDatedDataRoute(r)
 
 		util.Logger.Info().Msg("Started Gin HTTP server on :" + os.Getenv("HTTP_PORT"))
 		if err := r.Run(":" + os.Getenv("HTTP_PORT")); err != nil {

routes/getBulkDatedData.go

@@ -0,0 +1,93 @@
+package routes
+
+import (
+	"MineTracker/data"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+
+	"github.com/gin-gonic/gin"
+)
+
+type serverResult struct {
+	server     string
+	dataPoints interface{}
+	step       string
+	err        error
+}
+
+func RegisterGetBulkDatedDataRoute(r *gin.Engine) {
+	r.GET("/api/bulk/:servers/:time", func(c *gin.Context) {
+		serversParam := c.Param("servers")
+		time := c.Param("time")
+
+		servers := strings.Split(serversParam, ",")
+
+		// Remove empty servers
+		var validServers []string
+		for _, s := range servers {
+			s = strings.TrimSpace(s)
+			if s != "" {
+				validServers = append(validServers, s)
+			}
+		}
+
+		if len(validServers) == 0 {
+			c.JSON(http.StatusNotFound, gin.H{"error": "No valid servers provided"})
+			return
+		}
+
+		// Parallel processing with goroutines
+		resultChan := make(chan serverResult, len(validServers))
+		var wg sync.WaitGroup
+
+		for _, server := range validServers {
+			wg.Add(1)
+			go func(srv string) {
+				defer wg.Done()
+
+				dataPoints, step, err := data.QueryDataPoints(srv, fmt.Sprintf("-%s", time))
+
+				resultChan <- serverResult{
+					server:     srv,
+					dataPoints: dataPoints,
+					step:       step,
+					err:        err,
+				}
+			}(server)
+		}
+
+		// Close channel when all goroutines are done
+		go func() {
+			wg.Wait()
+			close(resultChan)
+		}()
+
+		// Collect results
+		result := make(map[string]interface{})
+		var commonStep string
+
+		for res := range resultChan {
+			if res.err != nil {
+				result[res.server] = gin.H{"error": res.err.Error()}
+				continue
+			}
+
+			if res.dataPoints == nil {
+				result[res.server] = gin.H{"error": "No data found"}
+				continue
+			}
+
+			result[res.server] = res.dataPoints
+			if commonStep == "" {
+				commonStep = res.step
+			}
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"data": result,
+			"step": commonStep,
+		})
+	})
+}

routes/getDatedData.go

@@ -4,16 +4,45 @@ import (
 	"MineTracker/data"
 	"fmt"
 	"net/http"
+	"sync"
+	"time"
 
 	"github.com/gin-gonic/gin"
 )
 
+type cacheEntry struct {
+	data      interface{}
+	step      string
+	timestamp time.Time
+}
+
+var (
+	cache      = make(map[string]cacheEntry)
+	cacheMutex sync.RWMutex
+	cacheTTL   = 30 * time.Second // Cache für 30 Sekunden
+)
+
 func RegisterGetDatedDataRoute(r *gin.Engine) {
 	r.GET("/api/:server/:time", func(c *gin.Context) {
 		server := c.Param("server")
-		time := c.Param("time")
+		timeParam := c.Param("time")
+
+		cacheKey := fmt.Sprintf("%s:%s", server, timeParam)
 
-		dataPoints, step, err := data.QueryDataPoints(server, fmt.Sprintf("-%s", time))
+		// Check cache first
+		cacheMutex.RLock()
+		if entry, found := cache[cacheKey]; found && time.Since(entry.timestamp) < cacheTTL {
+			cacheMutex.RUnlock()
+			c.JSON(http.StatusOK, gin.H{
+				"data": entry.data,
+				"step": entry.step,
+			})
+			return
+		}
+		cacheMutex.RUnlock()
+
+		// Query data
+		dataPoints, step, err := data.QueryDataPoints(server, fmt.Sprintf("-%s", timeParam))
 
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
@@ -25,7 +54,16 @@ func RegisterGetDatedDataRoute(r *gin.Engine) {
 			return
 		}
 
-		c.JSON(200, gin.H{
+		// Store in cache
+		cacheMutex.Lock()
+		cache[cacheKey] = cacheEntry{
+			data:      dataPoints,
+			step:      step,
+			timestamp: time.Now(),
+		}
+		cacheMutex.Unlock()
+
+		c.JSON(http.StatusOK, gin.H{
 			"data": dataPoints,
 			"step": step,
 		})