backend: cmd/pagination: Add pagination implementation to return only

page that was requested from the client.

This improves the pagination functionality, which help to return only
page that was requested from the client not the full list, this help
the frontend to fetch only page that the user wants to see the page not
the full list.

Currently the page size is limit =15, we can make it dynamic according
to the headlamp.

Author: upsaurav12

backend/cmd/pagination.go

@@ -2,14 +2,20 @@ package main
 
 import (
 	"bytes"
+	"compress/gzip"
 	"encoding/json"
+	"fmt"
+	"io"
+	"log"
 	"net/http"
+	"strconv"
+	"time"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"github.com/gorilla/mux"
 )
 
-var limit string = "15"
-
 type responseCapture struct {
 	http.ResponseWriter
 	StatusCode int
@@ -22,8 +28,8 @@ func (r *responseCapture) WriteHeader(code int) {
 }
 
 func (r *responseCapture) Write(b []byte) (int, error) {
-	r.Body.Write(b)
-	return r.ResponseWriter.Write(b)
+	return r.Body.Write(b)
+	// return r.ResponseWriter.Write(b)
 }
 
 // CreateResponseCapture initializes responseCapture with a http.ResponseWriter and empty bytes.Buffer for the body.
@@ -35,73 +41,123 @@ func CreateResponseCapture(w http.ResponseWriter) *responseCapture {
 	}
 }
 
-type ResourceMetadata struct {
-	ResourceVersion string `json:"resourceVersion"`
-	ContinueToken   string `json:"continue"`
+type Item struct {
+	Metadata metav1.ObjectMeta `json:"metadata"`
 }
+type ResourceResponse struct {
+	Kind     string          `json:"kind"`
+	Verison  string          `json:"apiVersion"`
+	Metadata metav1.ListMeta `json:"metadata"`
+	Items    []Item          `json:"items"`
+}
+
+// handleGzip function compress response if the response  header have Content-Encoding as gzip.
+func handleGzip(rcw *responseCapture) ([]byte, error) {
+	bodyBytes := rcw.Body.Bytes()
+	if rcw.Header().Get("Content-Encoding") == "gzip" {
+		reader, err := gzip.NewReader(bytes.NewReader(bodyBytes))
+		if err != nil {
+			return nil, err
+		}
+		defer reader.Close()
+		bodyBytes, err = io.ReadAll(reader)
+		if err != nil {
+			return nil, err
+		}
+	}
 
-type Metadata struct {
-	Name      string `json:"name"`
-	Namespace string `json:"namespace"`
-	Uuid      string `json:"uuid"`
+	return bodyBytes, nil
 }
 
-type Item struct {
-	Metadata Metadata `json:"metadata"`
+// returnResponseToClient helps to return the response to the client.
+func returnResponseToClient(rcw *responseCapture, v any, w http.ResponseWriter) error {
+	var err error
+	if rcw.Header().Get("Content-Encoding") == "gzip" {
+		w.Header().Set("Content-Encoding", "gzip")
+		gz := gzip.NewWriter(w)
+		defer gz.Close()
+		err = json.NewEncoder(gz).Encode(v)
+	} else {
+		err = json.NewEncoder(w).Encode(v)
+	}
+
+	return err
 }
-type ResourceResponse struct {
-	Metadata ResourceMetadata `json:"metadata"`
-	Items    []Item           `json:"items"`
+
+// sliceTheResponse helps to slice the full list to identify the startIndex and endIndex that will be
+// equal to the full page, which is going to be sliced from the full list.
+func sliceTheResponse(page int, pageSize int, sizeOfResponse int) (int, int) {
+	start := (page - 1) * pageSize
+	if start >= sizeOfResponse {
+		return sizeOfResponse, sizeOfResponse // slice empty if page out of range
+	}
+	end := start + pageSize
+	if end > sizeOfResponse {
+		end = sizeOfResponse
+	}
+	return start, end
 }
 
-var paginationMap = make(map[int]*ResourceResponse)
+// This helps to unmarshal the response that is coming from K8s server, so we can
+// further slice the full list of response into the pages.
+func UnmarshalCacheData(bodyBytes []byte) (ResourceResponse, error) {
+	var resourceResponseFullList ResourceResponse
+
+	err := json.Unmarshal(bodyBytes, &resourceResponseFullList)
+	if err != nil {
+		return ResourceResponse{}, err
+	}
 
+	return resourceResponseFullList, nil
+}
+
+var limit = 15
+
+// handlePagination is the middleware which will help to paginate the response coming from
+// the K8's server.
 func handlePagination(c *HeadlampConfig) mux.MiddlewareFunc {
 	return func(h http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			start := time.Now()
 
 			rcw := CreateResponseCapture(w)
 
 			q := r.URL.Query()
-			q.Set("limit", limit)
-			r.URL.RawQuery = q.Encode()
+
+			pageNo := q.Get("pageNo")
 
 			h.ServeHTTP(rcw, r)
 
-			var currentPageResponse ResourceResponse
-			json.Unmarshal(rcw.Body.Bytes(), &currentPageResponse)
+			bodyBytes, err := handleGzip(rcw)
+			if err != nil {
+				log.Fatalf("error while converting from gzip: %v ", err)
+			}
 
-			paginationMap[0] = &currentPageResponse
+			responseFullList, err := UnmarshalCacheData(bodyBytes)
+			if err != nil {
+				log.Fatalf("error while unmarshalling bodybytes: %v", responseFullList)
+			}
 
-			// Loop to pre-fetch pages 1 through 4
-			currentContinueToken := currentPageResponse.Metadata.ContinueToken
-			for i := 1; i <= 4; i++ {
-				// Stop if there is no next page
-				if currentContinueToken == "" {
-					break
+			if pageNo == "" {
+				if err := returnResponseToClient(rcw, responseFullList, w); err != nil {
+					log.Fatalf("error while returning response to client: %v", err)
 				}
+				return
+			}
 
-				// Create a new request for the next page
-				query := r.URL.Query()
-				query.Set("continue", currentContinueToken)
-				r.URL.RawQuery = query.Encode()
-
-				// Clear the response capture buffer before the next request
-				rcw.Body.Reset()
-
-				// Serve the next request
-				h.ServeHTTP(rcw, r)
+			page, _ := strconv.Atoi(pageNo)
 
-				// Unmarshal the new response
-				var nextResponse ResourceResponse
-				json.Unmarshal(rcw.Body.Bytes(), &nextResponse)
+			startPage, endPage := sliceTheResponse(page, limit, len(responseFullList.Items))
 
-				// Store the new response in the map
-				paginationMap[i] = &nextResponse
+			returnedData := responseFullList.Items[startPage:endPage]
 
-				// Update the continue token for the next loop iteration
-				currentContinueToken = nextResponse.Metadata.ContinueToken
+			if err := returnResponseToClient(rcw, returnedData, w); err != nil {
+				log.Fatalf("error while returning response to client: %v", err)
 			}
+
+			// To check the response time, this help understand how much time is it taking to send
+			// the desired page that the client wants to access in the frontend.
+			fmt.Println("time: ", time.Since(start))
 		})
 	}
 }