feat: allow to save cluster + token to kubeconf (#23649)

Signed-off-by: Andre Dietisheim <[email protected]>
Assisted by: gemini-cli
Assisted by: cursor
Assisted by: qwen-code

Author: adietish

build.gradle.kts

@@ -40,6 +40,7 @@ dependencies {
     testImplementation("io.mockk:mockk:1.14.6")
     testImplementation("io.mockk:mockk-agent-jvm:1.14.6")
 
+    // Use version compatible with IntelliJ platform 2025.1.1 to avoid service loader conflicts
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
     testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2")
 

src/main/kotlin/com/redhat/devtools/gateway/kubeconfig/KubeConfigUtils.kt

@@ -21,11 +21,13 @@ object KubeConfigUtils {
     fun getClusters(kubeconfigPaths: List<Path>): List<Cluster> {
         logger.info("Getting clusters from kubeconfig paths: $kubeconfigPaths")
         val kubeConfigs = toKubeConfigs(kubeconfigPaths)
-        logger.info("Loaded ${kubeConfigs.size} kubeconfig files")
+        logger.info("Loaded ${kubeConfigs.size} kubeconfig files from paths: $kubeconfigPaths")
+
         val clusters = kubeConfigs
             .flatMap { kubeConfig ->
-                val clusters = KubeConfigNamedCluster.fromKubeConfig(kubeConfig)
-                clusters.map { clusterEntry ->
+                val namedClusters = KubeConfigNamedCluster.fromKubeConfig(kubeConfig)
+                logger.info("kubeConfig.clusters size for this config: ${kubeConfig.clusters?.size}")
+                namedClusters.map { clusterEntry ->
                     val cluster = toCluster(clusterEntry, kubeConfig)
                     logger.info("Parsed cluster: ${cluster.name} at ${cluster.url}")
                     cluster
@@ -99,21 +101,75 @@ object KubeConfigUtils {
 
     fun getAllConfigsMerged(): String? {
         val kubeConfigPaths = getAllConfigs()
-
         if (kubeConfigPaths.isEmpty()) {
             logger.debug("No kubeconfig files found.")
             return null
         }
-
         val mergedKubeConfigs = mergeConfigs(kubeConfigPaths)
         if (mergedKubeConfigs.isEmpty()) {
             logger.debug("No valid kubeconfig content found.")
             return null
         }
-
         return mergedKubeConfigs
     }
 
+    fun getCurrentUser(kubeConfig: KubeConfig): String {
+        try {
+            val currentContextName = kubeConfig.currentContext
+            val currentContext = (kubeConfig.contexts as? List<*>)?.find {
+                (it as? Map<*, *>)?.get("name") == currentContextName
+            }
+            val contextMap = currentContext as? Map<*, *>
+            return (contextMap?.get("context") as? Map<*, *>)?.get("user") as? String ?: ""
+        } catch (e: Exception) {
+            logger.warn("Failed to get current user from kubeconfig: ${e.message}", e)
+            return ""
+        }
+    }
+
+    fun getCurrentContext(kubeConfig: KubeConfig): KubeConfigNamedContext? {
+        val currentContextName = kubeConfig.currentContext
+        return (kubeConfig.contexts as? List<*>)
+            ?.mapNotNull { contextObject ->
+                val contextMap = contextObject as? Map<*, *> ?: return@mapNotNull null
+                val name = contextMap["name"] as? String ?: return@mapNotNull null
+                val contextDetails = contextMap["context"] as? Map<*, *> ?: return@mapNotNull null
+                if (name == currentContextName) {
+                    KubeConfigNamedContext(
+                        name = name,
+                        context = KubeConfigContext.fromMap(contextDetails) ?: return@mapNotNull null
+                    )
+                } else {
+                    null
+                }
+            }?.firstOrNull()
+    }
+
+    fun getCurrentContextClusterName(): String? {
+        return try {
+            getAllConfigs().firstNotNullOfOrNull { path ->
+                if (!isValid(path)) {
+                    null
+                } else {
+                    try {
+                        val kubeConfig = KubeConfig.loadKubeConfig(path.toFile().bufferedReader())
+                        if (!kubeConfig.currentContext.isNullOrBlank()) {
+                            getCurrentContext(kubeConfig)?.context?.cluster
+                        } else {
+                            null
+                        }
+                    } catch (e: Exception) {
+                        logger.warn("Error parsing kubeconfig file '$path' while determining current context: ${e.message}", e)
+                        null
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            logger.warn("Failed to get current context cluster name from kubeconfig: ${e.message}", e)
+            null
+        }
+    }
+
     private fun mergeConfigs(kubeconfigs: List<Path>): String {
         return kubeconfigs
             .mapNotNull { path ->

src/main/kotlin/com/redhat/devtools/gateway/kubeconfig/KubeConfigWriter.kt

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2025 Red Hat, Inc.
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Red Hat, Inc. - initial API and implementation
+ */
+package com.redhat.devtools.gateway.kubeconfig
+
+import io.kubernetes.client.util.KubeConfig
+import java.io.File
+import java.io.FileReader
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.yaml.snakeyaml.Yaml
+import java.io.FileWriter
+
+class KubeConfigWriter {
+    companion object {
+        /**
+         * Finds the path to the kubeconfig file that contains a specific user.
+         *
+         * @param userName The name of the user to find.
+         * @param kubeConfigEnv The value of the KUBECONFIG environment variable.
+         * @return The absolute path to the kubeconfig file, or null if the user is not found.
+         */
+        fun findKubeConfigFileForUser(userName: String, kubeConfigEnv: String?): String? {
+            val files = if (kubeConfigEnv.isNullOrEmpty()) {
+                listOf(File(System.getProperty("user.home"), ".kube/config"))
+            } else {
+                kubeConfigEnv.split(File.pathSeparator).map { File(it) }
+            }
+            for (file in files) {
+                if (!file.exists() || !file.isFile) {
+                    continue
+                }
+                try {
+                    val kubeConfig = KubeConfig.loadKubeConfig(FileReader(file))
+                    val users = kubeConfig.users as? List<*>
+                    val userFound = users?.any { userObject ->
+                        val userMap = userObject as? Map<*, *>
+                        userMap?.get("name") as? String == userName
+                    }
+                    if (userFound == true) {
+                        return file.absolutePath
+                    }
+                } catch (e: Exception) {
+                    // Log the exception, e.g., failed to parse
+                }
+            }
+            return null
+        }
+
+        /**
+         * Applies changes to a kubeconfig file and saves it.
+         *
+         * @param filePath The path to the kubeconfig file to modify.
+         * @param serverUrl The new server URL.
+         * @param token The new token.
+         */
+        suspend fun applyChangesAndSave(filePath: String, serverUrl: String, token: String) = withContext(Dispatchers.IO) {
+            val yaml = Yaml()
+            val file = File(filePath)
+            val kubeConfigMap = yaml.load(file.inputStream()) as? MutableMap<String, Any> ?: mutableMapOf()
+
+            val clusters = kubeConfigMap["clusters"] as? MutableList<MutableMap<String, Any>> ?: mutableListOf()
+            val existingCluster = clusters.find { (it["cluster"] as? Map<*, *>)?.get("server") == serverUrl }
+
+            if (existingCluster != null) {
+                // Update existing
+                val clusterName = existingCluster["name"] as? String
+                val contexts = kubeConfigMap["contexts"] as? List<Map<String, Any>> ?: emptyList()
+                val currentContext = contexts.find { it["name"] == kubeConfigMap["current-context"] }
+                val userName = (currentContext?.get("context") as? Map<*, *>)?.get("user") as? String
+                
+                if (userName != null) {
+                    val users = kubeConfigMap["users"] as? MutableList<MutableMap<String, Any>> ?: mutableListOf()
+                    val userToUpdate = users.find { it["name"] == userName }
+                    (userToUpdate?.get("user") as? MutableMap<String, Any>)?.set("token", token)
+                }
+            } else {
+                // Create new
+                val newName = serverUrl.substringAfter("://").replace(".", "-").replace(":", "-")
+                val newClusterName = newName
+                val newUserName = "$newName-user"
+                val newContextName = "$newName-context"
+
+                val newCluster = mutableMapOf<String, Any>(
+                    "name" to newClusterName,
+                    "cluster" to mutableMapOf("server" to serverUrl)
+                )
+                clusters.add(newCluster)
+
+                val newUser = mutableMapOf<String, Any>(
+                    "name" to newUserName,
+                    "user" to mutableMapOf("token" to token)
+                )
+                val users = kubeConfigMap["users"] as? MutableList<MutableMap<String, Any>> ?: mutableListOf()
+                users.add(newUser)
+
+                val newContext = mutableMapOf<String, Any>(
+                    "name" to newContextName,
+                    "context" to mutableMapOf(
+                        "cluster" to newClusterName,
+                        "user" to newUserName
+                    )
+                )
+                val contexts = kubeConfigMap["contexts"] as? MutableList<MutableMap<String, Any>> ?: mutableListOf()
+                contexts.add(newContext)
+
+                kubeConfigMap["clusters"] = clusters
+                kubeConfigMap["users"] = users
+                kubeConfigMap["contexts"] = contexts
+                kubeConfigMap["current-context"] = newContextName
+            }
+
+            val writer = FileWriter(file)
+            yaml.dump(kubeConfigMap, writer)
+            writer.close()
+        }
+    }
+}

src/main/kotlin/com/redhat/devtools/gateway/view/steps/DevSpacesServerStepView.kt

@@ -15,6 +15,7 @@ import com.intellij.openapi.application.invokeLater
 import com.intellij.openapi.components.service
 import com.intellij.openapi.progress.ProgressManager
 import com.intellij.openapi.wm.impl.welcomeScreen.WelcomeScreenUIManager
+import com.intellij.ui.components.JBCheckBox
 import com.intellij.ui.components.JBTextField
 import com.intellij.ui.dsl.builder.Align
 import com.intellij.ui.dsl.builder.panel
@@ -23,18 +24,16 @@ import com.intellij.util.ui.JBUI
 import com.redhat.devtools.gateway.DevSpacesBundle
 import com.redhat.devtools.gateway.DevSpacesContext
 import com.redhat.devtools.gateway.kubeconfig.FileWatcher
-import com.redhat.devtools.gateway.kubeconfig.KubeConfigUtils
 import com.redhat.devtools.gateway.kubeconfig.KubeConfigMonitor
+import com.redhat.devtools.gateway.kubeconfig.KubeConfigUtils
+import com.redhat.devtools.gateway.kubeconfig.KubeConfigWriter
 import com.redhat.devtools.gateway.openshift.Cluster
 import com.redhat.devtools.gateway.openshift.OpenShiftClientFactory
 import com.redhat.devtools.gateway.openshift.Projects
 import com.redhat.devtools.gateway.settings.DevSpacesSettings
 import com.redhat.devtools.gateway.util.message
-import com.redhat.devtools.gateway.view.ui.Dialogs
-import com.redhat.devtools.gateway.view.ui.FilteringComboBox
-import com.redhat.devtools.gateway.view.ui.PasteClipboardMenu
-import com.redhat.devtools.gateway.view.ui.getAllElements
-import com.redhat.devtools.gateway.view.ui.requestInitialFocus
+import com.redhat.devtools.gateway.view.ui.*
+import io.kubernetes.client.util.KubeConfig
 import kotlinx.coroutines.*
 import java.awt.event.ItemEvent
 import javax.swing.JTextField
@@ -51,12 +50,18 @@ class DevSpacesServerStepView(
 
     private lateinit var kubeconfigMonitor: KubeConfigMonitor
 
+    private var kubeconfigServerUrl: String? = null
+    private var kubeconfigToken: String? = null
+    private var hasUnsavedChanges: Boolean = false
+
+    private val updateKubeconfigCheckbox = JBCheckBox("Update kubeconfig")
+    private lateinit var saveKubeconfigCheckbox: com.intellij.ui.dsl.builder.Row
+
     private var tfToken = JBTextField()
         .apply {
             document.addDocumentListener(onTokenChanged())
             PasteClipboardMenu.addTo(this)
         }
-
     private var tfServer =
         FilteringComboBox.create(
             { it?.toString() ?: "" },
@@ -78,6 +83,13 @@ class DevSpacesServerStepView(
         row(DevSpacesBundle.message("connector.wizard_step.openshift_connection.label.token")) {
             cell(tfToken).align(Align.FILL)
         }
+        saveKubeconfigCheckbox = row("") {
+            cell(updateKubeconfigCheckbox).applyToComponent {
+                isOpaque = false
+                background = WelcomeScreenUIManager.getMainAssociatedComponentBackground()
+            }
+            visible(false)
+        }
     }.apply {
         background = WelcomeScreenUIManager.getMainAssociatedComponentBackground()
         border = JBUI.Borders.empty(8)
@@ -101,30 +113,60 @@ class DevSpacesServerStepView(
                 }
             }
         }
+        updateSaveKubeconfigCheckbox((tfServer.selectedItem as Cluster?), tfToken.text)
     }
 
     private fun onTokenChanged(): DocumentListener = object : DocumentListener {
         override fun insertUpdate(event: DocumentEvent) {
             enableNextButton?.invoke()
+            updateSaveKubeconfigCheckbox((tfServer.selectedItem as Cluster?), tfToken.text)
         }
 
         override fun removeUpdate(e: DocumentEvent) {
             enableNextButton?.invoke()
+            updateSaveKubeconfigCheckbox((tfServer.selectedItem as Cluster?), tfToken.text)
         }
 
         override fun changedUpdate(e: DocumentEvent?) {
             enableNextButton?.invoke()
+            updateSaveKubeconfigCheckbox((tfServer.selectedItem as Cluster?), tfToken.text)
         }
     }
 
+    private fun updateSaveKubeconfigCheckbox(cluster: Cluster?, token: String?) {
+        if (cluster == null
+            || token.isNullOrBlank()) {
+            return
+        }
+        this.hasUnsavedChanges =
+            (kubeconfigServerUrl != null && kubeconfigServerUrl != cluster.url)
+                    || (!kubeconfigToken.isNullOrBlank() && kubeconfigToken != token)
+
+        saveKubeconfigCheckbox.visible(hasUnsavedChanges)
+    }
+
     private fun onClustersChanged(): suspend (List<Cluster>) -> Unit = { updatedClusters ->
-        invokeLater {
-            val selectedName = (tfServer.selectedItem as? Cluster)?.name
-            setClusters(updatedClusters)
-            setSelectedCluster(selectedName, updatedClusters)
+        if (updatedClusters.isNotEmpty()) {
+            invokeLater {
+                val kubeConfigCurrentCluster = KubeConfigUtils.getCurrentContextClusterName()
+                val previouslySelected = tfServer.selectedItem as? Cluster?
+                setClusters(updatedClusters)
+                setSelectedCluster(
+                    (previouslySelected)?.name ?: kubeConfigCurrentCluster,
+                    updatedClusters
+                )
+                val newSelected = tfServer.selectedItem as? Cluster
+                setKubeconfigValues(newSelected?.url, tfToken.text)
+                updateSaveKubeconfigCheckbox(newSelected, tfToken.text)
+            }
         }
     }
 
+    private fun setKubeconfigValues(url: String?, token: String?) {
+        this.kubeconfigServerUrl = url
+        this.kubeconfigToken = token
+    }
+
     override fun onPrevious(): Boolean {
         stopKubeconfigMonitor()
         return true
@@ -138,6 +180,27 @@ class DevSpacesServerStepView(
         var success = false
         stopKubeconfigMonitor()
 
+        if (updateKubeconfigCheckbox.isVisible && updateKubeconfigCheckbox.isSelected) {
+            val mergedKubeConfigContent = KubeConfigUtils.getAllConfigsMerged()
+            val currentKubeConfig = mergedKubeConfigContent?.reader()?.let { KubeConfig.loadKubeConfig(it) }
+            val currentUser = if (currentKubeConfig != null) KubeConfigUtils.getCurrentUser(currentKubeConfig) else ""
+            val kubeConfigFilePath = KubeConfigWriter.findKubeConfigFileForUser(currentUser, System.getenv("KUBECONFIG")) ?: ""
+
+            if (kubeConfigFilePath.isNotBlank()) {
+                kubeconfigScope.launch {
+                    try {
+                        KubeConfigWriter.applyChangesAndSave(kubeConfigFilePath, server, token)
+                        Dialogs.info("Kubeconfig updated successfully.", "Kubeconfig Update")
+                    } catch (e: Exception) {
+                        Dialogs.error("Failed to update kubeconfig: ${e.message}", "Kubeconfig Update Failed")
+                        e.printStackTrace()
+                    }
+                }
+            } else {
+                Dialogs.error("Could not determine kubeconfig file path to update.", "Kubeconfig Update Failed")
+            }
+        }
+
         ProgressManager.getInstance().runProcessWithProgressSynchronously(
             {
                 try {