WIP - backend: Fix rename cluster issue for being able to rename a cluster to a name already in use on that config file

works:
- the config path for renaming the config now uses a the accurate source path on user machines for backend logic (should work for multi config env)
- the rename backend prevents renaming if the custom name from the request is already within the config file (either as a context name or a custom name)

to do:
- add some UI to the frontend that responds when the isunique checker returns the http error

Signed-off-by: Vincent T <[email protected]>

Author: vyncent-t

backend/cmd/headlamp.go

@@ -1195,11 +1195,7 @@ func (c *HeadlampConfig) getClusters() []Cluster {
 
 		source := context.SourceStr()
 
-		// find the file name from the kubeconfig path
-		fileName := filepath.Base(kubeconfigPath)
-
-		// create the pathID string using a pipe as the delimiter
-		pathID := fmt.Sprintf("%s:%s:%s", context.SourceStr(), fileName, context.Name)
+		pathID := context.PathID
 
 		clusters = append(clusters, Cluster{
 			Name:     context.Name,
@@ -1568,6 +1564,7 @@ func customNameToExtenstions(config *api.Config, contextName, newClusterName, pa
 	return nil
 }
 
+// MOON - 9. MAKE THIS LOOK BY THE CONTEXT PATH ID
 // updateCustomContextToCache updates the custom context to the cache.
 func (c *HeadlampConfig) updateCustomContextToCache(config *api.Config, clusterName string) []error {
 	contexts, errs := kubeconfig.LoadContextsFromAPIConfig(config, false)
@@ -1581,6 +1578,7 @@ func (c *HeadlampConfig) updateCustomContextToCache(config *api.Config, clusterN
 	for _, context := range contexts {
 		context := context
 
+		// MOON - 7. MAKE THIS LOOK BY THE CONTEXT PATH ID
 		// Remove the old context from the store
 		if err := c.kubeConfigStore.RemoveContext(clusterName); err != nil {
 			logger.Log(logger.LevelError, nil, err, "Removing context from the store")
@@ -1603,31 +1601,35 @@ func (c *HeadlampConfig) updateCustomContextToCache(config *api.Config, clusterN
 
 // getPathAndLoadKubeconfig gets the path of the kubeconfig file and loads it.
 func (c *HeadlampConfig) getPathAndLoadKubeconfig(source, clusterName string) (string, *api.Config, error) {
-	// Get path of kubeconfig from source
-	path, err := c.getKubeConfigPath(source)
-	if err != nil {
-		logger.Log(logger.LevelError, map[string]string{"cluster": clusterName},
-			err, "getting kubeconfig file")
-
-		return "", nil, err
-	}
 
 	// Load kubeconfig file
-	config, err := clientcmd.LoadFromFile(path)
+	config, err := clientcmd.LoadFromFile(source)
 	if err != nil {
 		logger.Log(logger.LevelError, map[string]string{"cluster": clusterName},
 			err, "loading kubeconfig file")
 
 		return "", nil, err
 	}
 
-	return path, config, nil
+	return source, config, nil
 }
 
+// MOON: - 1. ADD THE PATHID TO THE VARS SO WE CAN SORT BY PATH ID
+
 // Handler for renaming a cluster.
 func (c *HeadlampConfig) renameCluster(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	clusterName := vars["name"]
+
+	// takes the actual path to the kubeconfig file from the url pathID
+	clusterPathID:= r.URL.Query().Get("clusterPathID")
+
+	pathID := clusterPathID
+
+	parts := strings.SplitN(pathID, ":", 2)
+	
+	configPath := parts[0]
+	
 	// Parse request body.
 	var reqBody RenameClusterRequest
 	if err := json.NewDecoder(r.Body).Decode(&reqBody); err != nil {
@@ -1646,15 +1648,50 @@ func (c *HeadlampConfig) renameCluster(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Get path of kubeconfig from source
-	path, config, err := c.getPathAndLoadKubeconfig(reqBody.Source, clusterName)
+	path, config, err := c.getPathAndLoadKubeconfig(configPath, clusterName)
 	if err != nil {
 		http.Error(w, "getting kubeconfig file", http.StatusInternalServerError)
 		return
 	}
 
+	// MOON - 2. WE WANT TO FIND THE CONTEXT WITH THE GIVEN PATHID AND NOT THE GIVEN NAME???
 	// Find the context with the given cluster name
 	contextName := clusterName
 
+	// loop through every context in the kubeconfig and collect all the names
+	// we do this because we want to be able to have the same name used for different config files
+	var contextNames []string
+
+	for name := range config.Contexts {
+		contextNames = append(contextNames, name)
+
+		logger.Log(logger.LevelInfo, map[string]string{"cluster added": name},
+			nil, "context name")
+	}
+
+
+	
+
+	// Iterate over the contexts and add the custom names
+	for _, v := range config.Contexts {
+		info := v.Extensions["headlamp_info"]
+		if info != nil {
+			customObj, err := MarshalCustomObject(info, contextName)
+			if err != nil {
+				logger.Log(logger.LevelError, map[string]string{"cluster": contextName},
+					err, "marshaling custom object")
+
+				return
+			}
+
+			// Check if the CustomName field matches the cluster name
+			if customObj.CustomName != "" {
+				contextNames = append(contextNames, customObj.CustomName)
+			}
+		}
+	}
+	
+
 	// Iterate over the contexts to find the context with the given cluster name
 	for k, v := range config.Contexts {
 		info := v.Extensions["headlamp_info"]
@@ -1667,8 +1704,18 @@ func (c *HeadlampConfig) renameCluster(w http.ResponseWriter, r *http.Request) {
 				return
 			}
 
+			// Check if the cluster name exists in the context names
+			isUnique := checkUniqueName(contextNames, reqBody.NewClusterName)
+			if (!isUnique) {
+				http.Error(w, "custom name already in use", http.StatusBadRequest)
+				logger.Log(logger.LevelError, map[string]string{"cluster": clusterName},
+					err, "cluster name already exists in the kubeconfig")
+
+				return
+			}
+
 			// Check if the CustomName field matches the cluster name
-			if customObj.CustomName != "" && customObj.CustomName == clusterName {
+			if customObj.CustomName != "" && customObj.CustomName == clusterName && isUnique {
 				contextName = k
 			}
 		}
@@ -1679,6 +1726,7 @@ func (c *HeadlampConfig) renameCluster(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// MOON - 8. MAKE THIS LOOK BY THE CONTEXT PATH ID
 	if errs := c.updateCustomContextToCache(config, clusterName); len(errs) > 0 {
 		http.Error(w, "setting up contexts from kubeconfig", http.StatusBadRequest)
 		return
@@ -1688,6 +1736,34 @@ func (c *HeadlampConfig) renameCluster(w http.ResponseWriter, r *http.Request) {
 	c.getConfig(w, r)
 }
 
+// checkUniqueName returns false if 'newName' is already in 'names';
+// otherwise returns true.
+func checkUniqueName(names []string, newName string) bool {
+    for _, current := range names {
+		logger.Log(
+			logger.LevelInfo,
+			map[string]string{
+				"message": fmt.Sprintf("now comparing %s to %s", current, newName),
+			},
+			nil,
+			"comparing cluster names",
+		)
+        if current == newName {
+            logger.Log(
+                logger.LevelInfo,
+                map[string]string{
+                    "message": fmt.Sprintf("duplicate cluster name found: %s", current),
+                },
+                nil,
+                "cluster name already in use",
+            )
+            return false
+        }
+    }
+    return true
+}
+
+
 func (c *HeadlampConfig) addClusterSetupRoute(r *mux.Router) {
 	// Do not add the route if dynamic clusters are disabled
 	if !c.enableDynamicClusters {

backend/cmd/stateless.go

@@ -13,6 +13,8 @@ import (
 	"k8s.io/apimachinery/pkg/runtime"
 )
 
+// MOON - 3. SINCE THIS USES THE CONTEXT NAME WE MAY NEED TO CHANGE IT TO THE CONTEXT PATH ID
+// MOON - 4. WE WILL NEED TO CHANGE THE TESTS LATER
 // MarshalCustomObject marshals the runtime.Unknown object into a CustomObject.
 func MarshalCustomObject(info runtime.Object, contextName string) (kubeconfig.CustomObject, error) {
 	// Convert the runtime.Unknown object to a byte slice

backend/pkg/kubeconfig/contextStore.go

@@ -86,6 +86,7 @@ func (c *contextStore) GetContext(name string) (*Context, error) {
 	return context, nil
 }
 
+// MOON - 6. CHANGE THE NAME PARAM TO THE PATH ID PARAM
 // RemoveContext removes a context from the store.
 func (c *contextStore) RemoveContext(name string) error {
 	return c.cache.Delete(context.Background(), name)

backend/pkg/kubeconfig/kubeconfig.go

@@ -8,6 +8,7 @@ import (
 	"net/http/httputil"
 	"net/url"
 	"os"
+	"path/filepath"
 	"runtime"
 	"strings"
 
@@ -46,6 +47,7 @@ type Context struct {
 	Internal    bool                   `json:"internal"`
 	Error       string                 `json:"error"`
 	PathName    string                 `json:"pathName"`
+	PathID    string                 `json:"pathID"`
 }
 
 type OidcConfig struct {
@@ -353,7 +355,16 @@ func LoadContextsFromFile(kubeConfigPath string, source int) ([]Context, []Conte
 
 	// add the PathName to each context
 	for i := range contexts {
-		contexts[i].PathName = kubeConfigPath
+		pathName := kubeConfigPath
+		
+		contexts[i].PathName = pathName
+
+		// find the file name from the kubeconfig path
+		fileName := filepath.Base(pathName)
+
+		// create the pathID string using a pipe as the delimiter
+		pathID := fmt.Sprintf("%s:%s:%s", pathName, fileName, contexts[i].Name)
+		contexts[i].PathID = pathID
 	}
 
 	return contexts, contextErrors, nil

frontend/src/components/App/Settings/SettingsCluster.tsx

@@ -18,7 +18,10 @@ import helpers, { ClusterSettings } from '../../../helpers';
 import { useCluster, useClustersConf } from '../../../lib/k8s';
 import { deleteCluster, parseKubeConfig, renameCluster } from '../../../lib/k8s/apiProxy';
 import { setConfig, setStatelessConfig } from '../../../redux/configSlice';
-import { findKubeconfigByClusterName, updateStatelessClusterKubeconfig } from '../../../stateless/';
+import {
+  findKubeconfigByClusterName,
+  updateStatelessClusterKubeconfig,
+} from '../../../stateless/';
 import { Link, Loader, NameValueTable, SectionBox } from '../../common';
 import ConfirmButton from '../../common/ConfirmButton';
 import Empty from '../../common/EmptyContent';
@@ -98,10 +101,13 @@ export default function SettingsCluster() {
 
   const clusterInfo = (clusterConf && clusterConf[cluster || '']) || null;
   const source = clusterInfo?.meta_data?.source || '';
+  const pathID = clusterInfo?.meta_data?.pathID || '';
+
+  console.log('cluster conf: ', clusterConf);
 
   const handleUpdateClusterName = (source: string) => {
     try {
-      renameCluster(cluster || '', newClusterName, source)
+      renameCluster(pathID, cluster || '', newClusterName, source)
         .then(async config => {
           if (cluster) {
             const kubeconfig = await findKubeconfigByClusterName(cluster);

frontend/src/lib/k8s/api/v1/clusterApi.ts

@@ -4,6 +4,7 @@ import store from '../../../../redux/stores/store';
 import {
   deleteClusterKubeconfig,
   findKubeconfigByClusterName,
+  findKubeconfigByClusterPathID,
   storeStatelessClusterKubeconfig,
 } from '../../../../stateless';
 import { getCluster, getClusterGroup } from '../../../util';
@@ -135,17 +136,23 @@ export function getClusterDefaultNamespace(cluster: string, checkSettings?: bool
  * is the custom name of the cluster used by the user.
  * @param cluster
  */
-export async function renameCluster(cluster: string, newClusterName: string, source: string) {
+export async function renameCluster(
+  pathID: string,
+  cluster: string,
+  newClusterName: string,
+  source: string
+) {
   let stateless = false;
   if (cluster) {
-    const kubeconfig = await findKubeconfigByClusterName(cluster);
+    const kubeconfig = await findKubeconfigByClusterPathID(pathID);
+    // const kubeconfig = await findKubeconfigByClusterName(cluster);
     if (kubeconfig !== null) {
       stateless = true;
     }
   }
 
   return request(
-    `/cluster/${cluster}`,
+    `/cluster/${cluster}?clusterPathID=${pathID}`,
     {
       method: 'PUT',
       headers: { ...getHeadlampAPIHeaders() },

frontend/src/lib/k8s/kubeconfig.ts

@@ -138,6 +138,8 @@ export interface KubeconfigObject {
       user: string;
       /** namespace is the default namespace. */
       namespace?: string;
+      // this is needed for attaching pathID to the cluster for accurate cluster actions
+      pathID?: string;
       /** Extensions holds additional information. This is useful for extenders so that reads and writes don't clobber unknown fields on the Context object. */
       extensions?: Array<{
         /** name is the nickname of the extension. */

frontend/src/stateless/index.ts

@@ -271,6 +271,69 @@ export function findKubeconfigByClusterName(clusterName: string): Promise<string
   });
 }
 
+/**
+ * Finds a kubeconfig by cluster name.
+ * @param clusterName
+ * @returns A promise that resolves with the kubeconfig, or null if not found.
+ * @throws Error if IndexedDB is not supported.
+ * @throws Error if the kubeconfig is invalid.
+ */
+export function findKubeconfigByClusterPathID(pathID: string): Promise<string | null> {
+  return new Promise<string | null>(async (resolve, reject) => {
+    try {
+      const request = indexedDB.open('kubeconfigs', 1) as any;
+
+      // The onupgradeneeded event is fired when the database is created for the first time.
+      request.onupgradeneeded = handleDatabaseUpgrade;
+
+      // The onsuccess event is fired when the database is opened.
+      // This event is where you specify the actions to take when the database is opened.
+      request.onsuccess = function handleDatabaseSuccess(event: DatabaseEvent) {
+        const db = event.target.result;
+        const transaction = db.transaction(['kubeconfigStore'], 'readonly');
+        const store = transaction.objectStore('kubeconfigStore');
+
+        // The onsuccess event is fired when the request has succeeded.
+        // This is where you handle the results of the request.
+        // The result is the cursor. It is used to iterate through the object store.
+        // The cursor is null when there are no more objects to iterate through.
+        // The cursor is used to find the kubeconfig by cluster name.
+        store.openCursor().onsuccess = function storeSuccess(event: Event) {
+          const successEvent = event as CursorSuccessEvent;
+          const cursor = successEvent.target.result;
+          if (cursor) {
+            const kubeconfigObject = cursor.value;
+            const kubeconfig = kubeconfigObject.kubeconfig;
+
+            const parsedKubeconfig = jsyaml.load(atob(kubeconfig)) as KubeconfigObject;
+
+            console.log('parsedKubeconfig', parsedKubeconfig);
+
+            // Check for "headlamp_info" in extensions
+            const matchingContext = parsedKubeconfig.contexts.find(
+              context => context.context.pathID === pathID
+            );
+
+            if (matchingContext) {
+              resolve(kubeconfig);
+            } else {
+              cursor.continue();
+            }
+          } else {
+            resolve(null); // No matching kubeconfig found
+          }
+        };
+      };
+
+      // The onerror event is fired when the database is opened.
+      // This is where you handle errors.
+      request.onerror = handleDataBaseError;
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
 /**
  * In the backend we use a unique ID to identify a user. If there is no ID in localStorage
  * we generate a new one and store it in localStorage. We then combine it with the