Merge branch 'main' into 72-task-investigate-cluster-visualizations

# Conflicts: # App/Frontend/src/app/app.routes.ts # App/Frontend/src/app/dashboard/dashboard.component.ts
EliasDeHondt · Feb 19, 2025 · be52e2b · be52e2b
2 parents 4998c6b + 9a6755a
commit be52e2b
Show file tree

Hide file tree

Showing 34 changed files with 840 additions and 365 deletions.
diff --git a/App/Backend/cmd/kubernetes/handlers/GetConfigMaps.go b/App/Backend/cmd/kubernetes/handlers/GetConfigMaps.go
@@ -4,21 +4,24 @@ import (
 	"context"
 	"github.com/eliasdehondt/K10s/App/Backend/cmd/kubernetes"
 	"github.com/gin-gonic/gin"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"net/http"
+	"sync"
 	"time"
 )
 
 func GetConfigMapsHandler(ctx *gin.Context) {
 	namespace, ok := ctx.GetQuery("namespace")
+	pageSize, pageToken := GetPageSizeAndPageToken(ctx)
 
-	var configMapList *[]kubernetes.ConfigMap
+	var configMapList *PaginatedResponse[[]kubernetes.ConfigMap]
 	var err error
 
 	if ok {
-		configMapList, err = GetConfigMaps(c, namespace)
+		configMapList, err = GetConfigMaps(c, namespace, pageSize, pageToken)
 	} else {
-		configMapList, err = GetConfigMaps(c, "")
+		configMapList, err = GetConfigMaps(c, "", pageSize, pageToken)
 	}
 
 	if err != nil {
@@ -28,19 +31,42 @@ func GetConfigMapsHandler(ctx *gin.Context) {
 	ctx.JSON(http.StatusOK, configMapList)
 }
 
-func GetConfigMaps(c *kubernetes.IClient, namespace string) (*[]kubernetes.ConfigMap, error) {
+func GetConfigMaps(c *kubernetes.IClient, namespace string, pageSize int, pageToken string) (*PaginatedResponse[[]kubernetes.ConfigMap], error) {
 	ct, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
-	list, err := (*c).GetConfigMaps(namespace).List(ct, metav1.ListOptions{})
+	list, err := (*c).GetConfigMaps(namespace).List(ct, metav1.ListOptions{
+		Limit:    int64(pageSize),
+		Continue: pageToken,
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	var configMapList = make([]kubernetes.ConfigMap, len(list.Items))
+	return &PaginatedResponse[[]kubernetes.ConfigMap]{
+		Response:  transformConfigMaps(&list.Items),
+		PageToken: list.Continue,
+	}, nil
+}
+
+func transformConfigMaps(list *[]v1.ConfigMap) []kubernetes.ConfigMap {
+	var configList = make([]kubernetes.ConfigMap, len(*list))
+
+	var wg sync.WaitGroup
+	concurrency := 20
+	semaphore := make(chan struct{}, concurrency)
 
-	for i, configMap := range list.Items {
-		configMapList[i] = kubernetes.NewConfigMap(configMap)
+	for i, config := range *list {
+		wg.Add(1)
+		semaphore <- struct{}{}
+
+		go func(i int, node v1.ConfigMap) {
+			defer wg.Done()
+			configList[i] = kubernetes.NewConfigMap(config)
+			<-semaphore
+		}(i, config)
 	}
-	return &configMapList, nil
+
+	wg.Wait()
+	return configList
 }
diff --git a/App/Backend/cmd/kubernetes/handlers/GetDeployments.go b/App/Backend/cmd/kubernetes/handlers/GetDeployments.go
@@ -4,22 +4,24 @@ import (
 	"context"
 	"github.com/eliasdehondt/K10s/App/Backend/cmd/kubernetes"
 	"github.com/gin-gonic/gin"
+	v1 "k8s.io/api/apps/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"net/http"
+	"sync"
 	"time"
 )
 
 func GetDeploymentsHandler(ctx *gin.Context) {
-
 	namespace, ok := ctx.GetQuery("namespace")
+	pageSize, pageToken := GetPageSizeAndPageToken(ctx)
 
-	var deploymentList *[]kubernetes.Deployment
+	var deploymentList *PaginatedResponse[[]kubernetes.Deployment]
 	var err error
 
 	if ok {
-		deploymentList, err = GetDeployments(c, namespace)
+		deploymentList, err = GetDeployments(c, namespace, pageSize, pageToken)
 	} else {
-		deploymentList, err = GetDeployments(c, "")
+		deploymentList, err = GetDeployments(c, "", pageSize, pageToken)
 	}
 
 	if err != nil {
@@ -29,19 +31,42 @@ func GetDeploymentsHandler(ctx *gin.Context) {
 	ctx.JSON(http.StatusOK, deploymentList)
 }
 
-func GetDeployments(c *kubernetes.IClient, namespace string) (*[]kubernetes.Deployment, error) {
+func GetDeployments(c *kubernetes.IClient, namespace string, pageSize int, pageToken string) (*PaginatedResponse[[]kubernetes.Deployment], error) {
 	ct, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
-	list, err := (*c).GetDeployments(namespace).List(ct, metav1.ListOptions{})
+	list, err := (*c).GetDeployments(namespace).List(ct, metav1.ListOptions{
+		Limit:    int64(pageSize),
+		Continue: pageToken,
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	var deploymentList = make([]kubernetes.Deployment, len(list.Items))
+	return &PaginatedResponse[[]kubernetes.Deployment]{
+		Response:  transformDeployments(&list.Items),
+		PageToken: list.Continue,
+	}, nil
+}
+
+func transformDeployments(list *[]v1.Deployment) []kubernetes.Deployment {
+	var deploymentList = make([]kubernetes.Deployment, len(*list))
 
-	for i, deployment := range list.Items {
-		deploymentList[i] = kubernetes.NewDeployment(deployment)
+	var wg sync.WaitGroup
+	concurrency := 20
+	semaphore := make(chan struct{}, concurrency)
+
+	for i, deployment := range *list {
+		wg.Add(1)
+		semaphore <- struct{}{}
+
+		go func(i int, node v1.Deployment) {
+			defer wg.Done()
+			deploymentList[i] = kubernetes.NewDeployment(deployment)
+			<-semaphore
+		}(i, deployment)
 	}
-	return &deploymentList, nil
+
+	wg.Wait()
+	return deploymentList
 }
diff --git a/App/Backend/cmd/kubernetes/handlers/GetNodes.go b/App/Backend/cmd/kubernetes/handlers/GetNodes.go
@@ -4,33 +4,60 @@ import (
 	"context"
 	"github.com/eliasdehondt/K10s/App/Backend/cmd/kubernetes"
 	"github.com/gin-gonic/gin"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"net/http"
+	"sync"
 	"time"
 )
 
 func GetNodesHandler(ctx *gin.Context) {
-	nodeList, err := GetNodes(c)
+	pageSize, pageToken := GetPageSizeAndPageToken(ctx)
+
+	nodeList, err := GetNodes(c, pageSize, pageToken)
 	if err != nil {
 		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "An error has occurred or the request has been timed out."})
 		return
 	}
 	ctx.JSON(http.StatusOK, nodeList)
 }
 
-func GetNodes(c *kubernetes.IClient) (*[]kubernetes.Node, error) {
+func GetNodes(c *kubernetes.IClient, pageSize int, pageToken string) (*PaginatedResponse[[]kubernetes.Node], error) {
 	ct, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
-	list, err := (*c).GetNodes().List(ct, metav1.ListOptions{})
+	list, err := (*c).GetNodes().List(ct, metav1.ListOptions{
+		Limit:    int64(pageSize),
+		Continue: pageToken,
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	var nodeList = make([]kubernetes.Node, len(list.Items))
+	return &PaginatedResponse[[]kubernetes.Node]{
+		Response:  transformNodes(&list.Items),
+		PageToken: list.Continue,
+	}, nil
+}
+
+func transformNodes(list *[]v1.Node) []kubernetes.Node {
+	var nodeList = make([]kubernetes.Node, len(*list))
 
-	for i, node := range list.Items {
-		nodeList[i] = kubernetes.NewNode(node, c)
+	var wg sync.WaitGroup
+	concurrency := 20
+	semaphore := make(chan struct{}, concurrency)
+
+	for i, node := range *list {
+		wg.Add(1)
+		semaphore <- struct{}{}
+
+		go func(i int, node v1.Node) {
+			defer wg.Done()
+			nodeList[i] = kubernetes.NewNode(node, c)
+			<-semaphore
+		}(i, node)
 	}
-	return &nodeList, nil
+
+	wg.Wait()
+	return nodeList
 }
diff --git a/App/Backend/cmd/kubernetes/handlers/GetPods.go b/App/Backend/cmd/kubernetes/handlers/GetPods.go
@@ -4,21 +4,24 @@ import (
 	"context"
 	"github.com/eliasdehondt/K10s/App/Backend/cmd/kubernetes"
 	"github.com/gin-gonic/gin"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"net/http"
+	"sync"
 	"time"
 )
 
 func GetPodsHandler(ctx *gin.Context) {
 	namespace, ok := ctx.GetQuery("namespace")
+	pageSize, pageToken := GetPageSizeAndPageToken(ctx)
 
-	var podList *[]kubernetes.Pod
+	var podList *PaginatedResponse[[]kubernetes.Pod]
 	var err error
 
 	if ok {
-		podList, err = GetPods(c, namespace)
+		podList, err = GetPods(c, namespace, pageSize, pageToken)
 	} else {
-		podList, err = GetPods(c, "")
+		podList, err = GetPods(c, "", pageSize, pageToken)
 	}
 
 	if err != nil {
@@ -28,19 +31,42 @@ func GetPodsHandler(ctx *gin.Context) {
 	ctx.JSON(http.StatusOK, podList)
 }
 
-func GetPods(c *kubernetes.IClient, namespace string) (*[]kubernetes.Pod, error) {
+func GetPods(c *kubernetes.IClient, namespace string, pageSize int, continueToken string) (*PaginatedResponse[[]kubernetes.Pod], error) {
 	ct, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
-	list, err := (*c).GetPods(namespace).List(ct, metav1.ListOptions{})
+	list, err := (*c).GetPods(namespace).List(ct, metav1.ListOptions{
+		Limit:    int64(pageSize),
+		Continue: continueToken,
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	var podList = make([]kubernetes.Pod, len(list.Items))
+	return &PaginatedResponse[[]kubernetes.Pod]{
+		Response:  transformPods(&list.Items),
+		PageToken: list.Continue,
+	}, nil
+}
+
+func transformPods(list *[]v1.Pod) []kubernetes.Pod {
+	var podList = make([]kubernetes.Pod, len(*list))
+
+	var wg sync.WaitGroup
+	concurrency := 20
+	semaphore := make(chan struct{}, concurrency)
 
-	for i, pod := range list.Items {
-		podList[i] = kubernetes.NewPod(pod, c)
+	for i, pod := range *list {
+		wg.Add(1)
+		semaphore <- struct{}{}
+
+		go func(i int, pod v1.Pod) {
+			defer wg.Done()
+			podList[i] = kubernetes.NewPod(pod, c)
+			<-semaphore
+		}(i, pod)
 	}
-	return &podList, nil
+
+	wg.Wait()
+	return podList
 }
diff --git a/App/Backend/cmd/kubernetes/handlers/GetSecrets.go b/App/Backend/cmd/kubernetes/handlers/GetSecrets.go
@@ -4,21 +4,24 @@ import (
 	"context"
 	"github.com/eliasdehondt/K10s/App/Backend/cmd/kubernetes"
 	"github.com/gin-gonic/gin"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"net/http"
+	"sync"
 	"time"
 )
 
 func GetSecretsHandler(ctx *gin.Context) {
 	namespace, ok := ctx.GetQuery("namespace")
+	pageSize, pageToken := GetPageSizeAndPageToken(ctx)
 
-	var secretList *[]kubernetes.Secret
+	var secretList *PaginatedResponse[[]kubernetes.Secret]
 	var err error
 
 	if ok {
-		secretList, err = GetSecrets(c, namespace)
+		secretList, err = GetSecrets(c, namespace, pageSize, pageToken)
 	} else {
-		secretList, err = GetSecrets(c, "")
+		secretList, err = GetSecrets(c, "", pageSize, pageToken)
 	}
 	if err != nil {
 		ctx.JSON(http.StatusInternalServerError, gin.H{"error": "An error has occurred or the request has been timed out."})
@@ -27,19 +30,43 @@ func GetSecretsHandler(ctx *gin.Context) {
 	ctx.JSON(http.StatusOK, secretList)
 }
 
-func GetSecrets(c *kubernetes.IClient, namespace string) (*[]kubernetes.Secret, error) {
+func GetSecrets(c *kubernetes.IClient, namespace string, pageSize int, pageToken string) (*PaginatedResponse[[]kubernetes.Secret], error) {
 	ct, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
-	list, err := (*c).GetSecrets(namespace).List(ct, metav1.ListOptions{})
+	list, err := (*c).GetSecrets(namespace).List(ct, metav1.ListOptions{
+		Limit:    int64(pageSize),
+		Continue: pageToken,
+	})
 	if err != nil {
 		return nil, err
 	}
 
-	var secretList = make([]kubernetes.Secret, len(list.Items))
+	return &PaginatedResponse[[]kubernetes.Secret]{
+		Response:  transformSecrets(&list.Items),
+		PageToken: list.Continue,
+	}, nil
+}
+
+func transformSecrets(list *[]v1.Secret) []kubernetes.Secret {
+	var secretList = make([]kubernetes.Secret, len(*list))
+
+	var wg sync.WaitGroup
+	concurrency := 20
+	semaphore := make(chan struct{}, concurrency)
+
+	for i, secret := range *list {
+		wg.Add(1)
+		semaphore <- struct{}{}
+
+		go func(i int, node v1.Secret) {
+			defer wg.Done()
+			secretList[i] = kubernetes.NewSecret(secret)
+			<-semaphore
+		}(i, secret)
 
-	for i, secret := range list.Items {
-		secretList[i] = kubernetes.NewSecret(secret)
 	}
-	return &secretList, nil
+	wg.Wait()
+
+	return secretList
 }