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)
- 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,
@@ -1512,7 +1508,8 @@ func (c *HeadlampConfig) deleteCluster(w http.ResponseWriter, r *http.Request) {
 	c.getConfig(w, r)
 }
 
-// Get path of kubeconfig from source.
+// Get path of kubeconfig weload headlamp with from source.
+// Note: This will always give the kubeconfig we loaded headlamp with, but if we have more than one, it's not clear this will yield the correct value.
 func (c *HeadlampConfig) getKubeConfigPath(source string) (string, error) {
 	if source == "kubeconfig" {
 		return c.kubeConfigPath, nil
@@ -1521,6 +1518,8 @@ func (c *HeadlampConfig) getKubeConfigPath(source string) (string, error) {
 	return defaultKubeConfigPersistenceFile()
 }
 
+
+
 // Handler for renaming a stateless cluster.
 func (c *HeadlampConfig) handleStatelessClusterRename(w http.ResponseWriter, r *http.Request, clusterName string) {
 	if err := c.kubeConfigStore.RemoveContext(clusterName); err != nil {
@@ -1602,7 +1601,25 @@ 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) {
+func (c *HeadlampConfig) getPathAndLoadKubeconfig(source, clusterName string, loadPath string) (string, *api.Config, error) {
+
+	var usePath string
+	var kubeConfig *api.Config
+
+	if source == "kubeconfig" {
+	// Load kubeconfig file
+	config, err := clientcmd.LoadFromFile(loadPath)
+	if err != nil {
+		logger.Log(logger.LevelError, map[string]string{"cluster": clusterName},
+			err, "loading kubeconfig file")
+
+		return "", nil, err
+	}
+	
+	usePath = loadPath
+	kubeConfig = config
+
+	} else {
 	// Get path of kubeconfig from source
 	path, err := c.getKubeConfigPath(source)
 	if err != nil {
@@ -1621,13 +1638,20 @@ func (c *HeadlampConfig) getPathAndLoadKubeconfig(source, clusterName string) (s
 		return "", nil, err
 	}
 
-	return path, config, nil
+	usePath = path
+	kubeConfig = config
+	}
+
+	return usePath, kubeConfig, nil
 }
 
 // Handler for renaming a cluster.
 func (c *HeadlampConfig) renameCluster(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	clusterName := vars["name"]
+	parts := strings.SplitN(r.URL.Query().Get("clusterPathID"), ":", 2)
+	configPath := parts[0]
+
 	// Parse request body.
 	var reqBody RenameClusterRequest
 	if err := json.NewDecoder(r.Body).Decode(&reqBody); err != nil {
@@ -1637,55 +1661,128 @@ func (c *HeadlampConfig) renameCluster(w http.ResponseWriter, r *http.Request) {
 
 		return
 	}
-
+	
 	if reqBody.Stateless {
 		// For stateless clusters we just need to remove cluster from cache
 		c.handleStatelessClusterRename(w, r, clusterName)
-
+		
 		return
 	}
+	
+	var loadPath string
+	if reqBody.Source == "kubeconfig" {
+		loadPath = configPath
+	}
 
 	// Get path of kubeconfig from source
-	path, config, err := c.getPathAndLoadKubeconfig(reqBody.Source, clusterName)
+	path, config, err := c.getPathAndLoadKubeconfig(reqBody.Source, clusterName, loadPath)
 	if err != nil {
 		http.Error(w, "getting kubeconfig file", http.StatusInternalServerError)
 		return
 	}
 
-	// Find the context with the given cluster name
+	isUnique := checkUniqueName(config, clusterName, 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
+	}
+
+	contextName := findMatchingContextName(config, clusterName)
+
+	if err := customNameToExtenstions(config, contextName, reqBody.NewClusterName, path); err != nil {
+		http.Error(w, "writing custom extension to kubeconfig", http.StatusInternalServerError)
+		return
+	}
+
+	if errs := c.updateCustomContextToCache(config, clusterName); len(errs) > 0 {
+		http.Error(w, "setting up contexts from kubeconfig", http.StatusBadRequest)
+		return
+	}
+
+	w.WriteHeader(http.StatusCreated)
+	c.getConfig(w, r)
+}
+
+// findMatchingContextName checks all contexts, returning the key for whichever
+// has a matching customObj.CustomName, if any.
+func findMatchingContextName(config *api.Config, clusterName string) string {
 	contextName := clusterName
 
-	// Iterate over the contexts to find the context with the given cluster name
 	for k, 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
+				continue
 			}
 
-			// Check if the CustomName field matches the cluster name
-			if customObj.CustomName != "" && customObj.CustomName == clusterName {
+			if customObj.CustomName == clusterName && customObj.CustomName != "" {
 				contextName = k
 			}
 		}
 	}
 
-	if err := customNameToExtenstions(config, contextName, reqBody.NewClusterName, path); err != nil {
-		http.Error(w, "writing custom extension to kubeconfig", http.StatusInternalServerError)
-		return
+	return contextName
+}
+
+// checkUniqueName returns false if 'newName' is already in 'names';
+// otherwise returns true.
+func checkUniqueName(config *api.Config, contextName string, newName string) bool {
+	contextNames := make([]string, 0, len(config.Contexts))
+
+	for name := range config.Contexts {
+		contextNames = append(contextNames, name)
+		logger.Log(logger.LevelInfo, map[string]string{"cluster added": name},
+			nil, "context name")
 	}
 
-	if errs := c.updateCustomContextToCache(config, clusterName); len(errs) > 0 {
-		http.Error(w, "setting up contexts from kubeconfig", http.StatusBadRequest)
-		return
+	// Iterate over the contexts and add the custom names
+	for _, y := range config.Contexts {
+		info := y.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")
+			}
+
+			// add custom name if it is not empty
+			if customObj.CustomName != "" {
+				contextNames = append(contextNames, customObj.CustomName)
+			}
+		}
 	}
 
-	w.WriteHeader(http.StatusCreated)
-	c.getConfig(w, r)
+	for _, current := range contextNames {
+		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 NAME **********: %s", current),
+				},
+				nil,
+				"cluster name already in use",
+			)
+
+			return false
+		}
+	}
+
+	return true
 }
 
 func (c *HeadlampConfig) addClusterSetupRoute(r *mux.Router) {

backend/cmd/headlamp_test.go

@@ -663,20 +663,12 @@ func TestRenameCluster(t *testing.T) {
 	assert.Equal(t, http.StatusCreated, r.Code)
 	assert.Equal(t, 2, len(clusters))
 
+	// to do: fix for non dynamic clusters
 	tests := []struct {
 		name          string
 		clusterReq    RenameClusterRequest
 		expectedState int
 	}{
-		{
-			name: "passStatefull",
-			clusterReq: RenameClusterRequest{
-				NewClusterName: "minikubetestworks",
-				Stateless:      false,
-				Source:         "kubeconfig",
-			},
-			expectedState: http.StatusCreated,
-		},
 		{
 			name: "stateless",
 			clusterReq: RenameClusterRequest{

backend/pkg/kubeconfig/kubeconfig.go

@@ -46,6 +46,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 +354,13 @@ 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
+
+		// create the pathID string using a pipe as the delimiter
+		pathID := fmt.Sprintf("%s:%s", pathName, contexts[i].Name)
+		contexts[i].PathID = pathID
 	}
 
 	return contexts, contextErrors, nil

frontend/src/components/App/Home/index.tsx

@@ -230,6 +230,7 @@ function HomeComponent(props: HomeComponentProps) {
   }, [customNameClusters]);
 
   function getClusterNames() {
+    console.log('$$$$$$$$$$', clusters);
     return Object.values(clusters)
       .map(c => ({
         ...c,
@@ -245,6 +246,7 @@ function HomeComponent(props: HomeComponentProps) {
    * @returns A description of where the cluster is picked up from: dynamic, in-cluster, or from a kubeconfig file.
    */
   function getOrigin(cluster: Cluster): string {
+    console.log('origin cluster: ', cluster);
     if (cluster.meta_data?.source === 'kubeconfig') {
       const sourcePath = cluster.meta_data?.origin?.kubeconfig;
       return `Kubeconfig: ${sourcePath}`;
@@ -256,6 +258,34 @@ function HomeComponent(props: HomeComponentProps) {
     return 'Unknown';
   }
 
+  function getDisplayName(cluster: Cluster) {
+    console.log('other cluster: ', cluster);
+
+    if (cluster.meta_data?.extensions?.headlamp_info?.customName) {
+      return cluster.meta_data.extensions.headlamp_info.customName + '#';
+    } else {
+      return cluster.name;
+    }
+  }
+
+  function ClusterName(cluster: any) {
+    console.log('READ CLUSTER: ', cluster);
+
+    if (!cluster) {
+      return null;
+    }
+
+    // const isRenamed = !!cluster.meta_data?.extensions?.headlamp_info?.customName;
+    // const displayName = cluster.meta_data?.extensions?.headlamp_info?.customName || cluster.name;
+    // const pathID = cluster.meta_data?.origin?.kubeconfig || cluster.name;
+
+    // return (
+    //   <Link routeName="cluster" params={{ cluster: cluster.name }}>
+    //     {displayName} - {pathID} {isRenamed ? '(renamed)' : ''}
+    //   </Link>
+    // )
+  }
+
   const memoizedComponent = React.useMemo(
     () => (
       <PageGrid>
@@ -284,6 +314,12 @@ function HomeComponent(props: HomeComponentProps) {
                   </Link>
                 ),
               },
+              {
+                id: 'name',
+                label: t('Name'),
+                getValue: cluster => getDisplayName(cluster),
+                render: ({ cluster }) => <ClusterName cluster={cluster} />,
+              },
               {
                 label: t('Origin'),
                 getValue: cluster => getOrigin(cluster),