Merge pull request #2326 from headlamp-k8s/kubeconfig-refactor

backend: refactor listing all contexts and error

backend/cmd/cluster.go

@@ -9,6 +9,7 @@ type Cluster struct {
  Server string `json:"server,omitempty"`
  AuthType string `json:"auth_type"`
  Metadata map[string]interface{} `json:"meta_data"`
+ Error string `json:"error,omitempty"`
 }
 
 type ClusterReq struct {

backend/cmd/headlamp.go

@@ -256,8 +256,8 @@ func defaultKubeConfigPersistenceFile() (string, error) {
 }
 
 // addPluginRoutes adds plugin routes to a router.
-// It serves plugin list base paths as json at “/plugins”.
-// It serves plugin static files at “/plugins/” and “/static-plugins/”.
+// It serves plugin list base paths as json at "plugins".
+// It serves plugin static files at "plugins/" and "static-plugins/".
 // It disables caching and reloads plugin list base paths if not in-cluster.
 func addPluginRoutes(config *HeadlampConfig, r *mux.Router) {
  // Delete plugin route
@@ -1013,6 +1013,14 @@ func handleClusterAPI(c *HeadlampConfig, router *mux.Router) {
  return
  }
 
+ if kContext.Error != "" {
+ logger.Log(logger.LevelError, map[string]string{"key": contextKey},
+ errors.New(kContext.Error), "context has error")
+ http.Error(w, kContext.Error, http.StatusBadRequest)
+
+ return
+ }
+
  clusterURL, err := url.Parse(kContext.Cluster.Server)
  if err != nil {
  logger.Log(logger.LevelError, map[string]string{"ClusterURL": kContext.Cluster.Server},
@@ -1062,6 +1070,15 @@ func (c *HeadlampConfig) getClusters() []Cluster {
  for _, context := range contexts {
  context := context
 
+ if context.Error != "" {
+ clusters = append(clusters, Cluster{
+ Name: context.Name,
+ Error: context.Error,
+ })
+
+ continue
+ }
+
  // Dynamic clusters should not be visible to other users.
  if context.Internal {
  continue
@@ -1138,43 +1155,33 @@ func parseCustomNameClusters(contexts []kubeconfig.Context) ([]Cluster, []error)
 
 // parseClusterFromKubeConfig parses the kubeconfig and returns a list of contexts and errors.
 func parseClusterFromKubeConfig(kubeConfigs []string) ([]Cluster, []error) {
- clusters := []Cluster{}
+ var clusters []Cluster
 
  var setupErrors []error
 
  for _, kubeConfig := range kubeConfigs {
- var contexts []kubeconfig.Context
-
- kubeConfigByte, err := base64.StdEncoding.DecodeString(kubeConfig)
+ contexts, contextLoadErrors, err := kubeconfig.LoadContextsFromBase64String(kubeConfig, kubeconfig.DynamicCluster)
  if err != nil {
- logger.Log(logger.LevelError, nil, err, "decoding kubeconfig")
-
  setupErrors = append(setupErrors, err)
-
  continue
  }
 
- config, err := clientcmd.Load(kubeConfigByte)
- if err != nil {
- logger.Log(logger.LevelError, nil, err, "loading kubeconfig")
-
- setupErrors = append(setupErrors, err)
-
- continue
+ if len(contextLoadErrors) > 0 {
+ for _, contextError := range contextLoadErrors {
+ setupErrors = append(setupErrors, contextError.Error)
+ }
  }
 
- contexts, errs := kubeconfig.LoadContextsFromAPIConfig(config, true)
- if len(errs) > 0 {
- setupErrors = append(setupErrors, errs...)
- continue
+ parsedClusters, parseErrs := parseCustomNameClusters(contexts)
+ if len(parseErrs) > 0 {
+ setupErrors = append(setupErrors, parseErrs...)
  }
 
- clusters, setupErrors = parseCustomNameClusters(contexts)
+ clusters = append(clusters, parsedClusters...)
  }
 
  if len(setupErrors) > 0 {
  logger.Log(logger.LevelError, nil, setupErrors, "setting up contexts from kubeconfig")
-
  return nil, setupErrors
  }
 
@@ -1191,117 +1198,150 @@ func (c *HeadlampConfig) getConfig(w http.ResponseWriter, r *http.Request) {
  }
 }
 
-//nolint:funlen,nestif
+// addCluster adds cluster to store and updates the kubeconfig file.
 func (c *HeadlampConfig) addCluster(w http.ResponseWriter, r *http.Request) {
  if err := checkHeadlampBackendToken(w, r); err != nil {
  logger.Log(logger.LevelError, nil, err, "invalid token")
+ return
+ }
 
+ clusterReq, err := decodeClusterRequest(r)
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusBadRequest)
  return
  }
 
- clusterReq := ClusterReq{}
- if err := json.NewDecoder(r.Body).Decode(&clusterReq); err != nil {
- logger.Log(logger.LevelError, nil, err, "decoding cluster info")
- http.Error(w, "decoding cluster info", http.StatusBadRequest)
+ contexts, setupErrors := c.processClusterRequest(clusterReq)
+
+ if len(contexts) == 0 {
+ logger.Log(logger.LevelError, nil, errors.New("no contexts found in kubeconfig"), "getting contexts from kubeconfig")
+ http.Error(w, "getting contexts from kubeconfig", http.StatusBadRequest)
 
  return
  }
 
- if (clusterReq.KubeConfig == nil) && (clusterReq.Name == nil || clusterReq.Server == nil) {
- logger.Log(logger.LevelError, nil, errors.New("creating cluster with invalid info"),
-  "please provide a 'name' and 'server' fields at least")
- http.Error(w, "creating cluster with invalid info; please provide a 'name' and 'server' fields at least.",
-  http.StatusBadRequest)
+ setupErrors = c.addContextsToStore(contexts, setupErrors)
+
+ if len(setupErrors) > 0 {
+ logger.Log(logger.LevelError, nil, setupErrors, "setting up contexts from kubeconfig")
+ http.Error(w, "setting up contexts from kubeconfig", http.StatusBadRequest)
 
  return
  }
 
- var contexts []kubeconfig.Context
+ w.WriteHeader(http.StatusCreated)
+ c.getConfig(w, r)
+}
 
- var setupErrors []error
+// decodeClusterRequest decodes the cluster request from the request body.
+func decodeClusterRequest(r *http.Request) (ClusterReq, error) {
+ var clusterReq ClusterReq
+ if err := json.NewDecoder(r.Body).Decode(&clusterReq); err != nil {
+ logger.Log(logger.LevelError, nil, err, "decoding cluster info")
+ return ClusterReq{}, fmt.Errorf("decoding cluster info: %w", err)
+ }
 
- if clusterReq.KubeConfig != nil {
- kubeConfigByte, err := base64.StdEncoding.DecodeString(*clusterReq.KubeConfig)
- if err != nil {
- logger.Log(logger.LevelError, nil, err, "decoding kubeconfig")
- http.Error(w, "decoding kubeconfig", http.StatusBadRequest)
+ if (clusterReq.KubeConfig == nil) && (clusterReq.Name == nil || clusterReq.Server == nil) {
+ return ClusterReq{}, errors.New("please provide a 'name' and 'server' fields at least")
+ }
 
-  return
- }
+ return clusterReq, nil
+}
 
- config, err := clientcmd.Load(kubeConfigByte)
- if err != nil {
- logger.Log(logger.LevelError, nil, err, "loading kubeconfig")
- http.Error(w, "loading kubeconfig", http.StatusBadRequest)
+// processClusterRequest processes the cluster request.
+func (c *HeadlampConfig) processClusterRequest(clusterReq ClusterReq) ([]kubeconfig.Context, []error) {
+ if clusterReq.KubeConfig != nil {
+ return c.processKubeConfig(clusterReq)
+ }
 
-  return
- }
+ return c.processManualConfig(clusterReq)
+}
 
- kubeConfigPersistenceDir, err := defaultKubeConfigPersistenceDir()
- if err != nil {
- logger.Log(logger.LevelError, nil, err, "getting default kubeconfig persistence dir")
- http.Error(w, "getting default kubeconfig persistence dir", http.StatusInternalServerError)
+// processKubeConfig processes the kubeconfig request.
+func (c *HeadlampConfig) processKubeConfig(clusterReq ClusterReq) ([]kubeconfig.Context, []error) {
+ contexts, contextLoadErrors, err := kubeconfig.LoadContextsFromBase64String(
+ *clusterReq.KubeConfig,
+ kubeconfig.DynamicCluster,
+ )
+ setupErrors := c.handleLoadErrors(err, contextLoadErrors)
 
- return
+ if len(contextLoadErrors) == 0 {
+ if err := c.writeKubeConfig(*clusterReq.KubeConfig); err != nil {
+ setupErrors = append(setupErrors, err)
  }
+ }
 
- err = kubeconfig.WriteToFile(*config, kubeConfigPersistenceDir)
- if err != nil {
- logger.Log(logger.LevelError, nil, err, "writing kubeconfig")
- http.Error(w, "writing kubeconfig", http.StatusBadRequest)
-
- return
- }
+ return contexts, setupErrors
+}
 
- contexts, setupErrors = kubeconfig.LoadContextsFromAPIConfig(config, false)
- } else {
- conf := &api.Config{
- Clusters: map[string]*api.Cluster{
- *clusterReq.Name: {
- Server: *clusterReq.Server,
- InsecureSkipTLSVerify: clusterReq.InsecureSkipTLSVerify,
- CertificateAuthorityData: clusterReq.CertificateAuthorityData,
- },
+// processManualConfig processes the manual config request.
+func (c *HeadlampConfig) processManualConfig(clusterReq ClusterReq) ([]kubeconfig.Context, []error) {
+ conf := &api.Config{
+ Clusters: map[string]*api.Cluster{
+ *clusterReq.Name: {
+ Server: *clusterReq.Server,
+ InsecureSkipTLSVerify: clusterReq.InsecureSkipTLSVerify,
+ CertificateAuthorityData: clusterReq.CertificateAuthorityData,
  },
-  Contexts: map[string]*api.Context{
-  *clusterReq.Name: {
-  Cluster: *clusterReq.Name,
- },
+ },
+ Contexts: map[string]*api.Context{
+ *clusterReq.Name: {
+ Cluster: *clusterReq.Name,
  },
- }
+ },
+ }
+
+ return kubeconfig.LoadContextsFromAPIConfig(conf, false)
+}
 
- contexts, setupErrors = kubeconfig.LoadContextsFromAPIConfig(conf, false)
+// handleLoadErrors handles the load errors.
+func (c *HeadlampConfig) handleLoadErrors(err error, contextLoadErrors []kubeconfig.ContextLoadError) []error {
+ var setupErrors []error //nolint:prealloc
+
+ if err != nil {
+ setupErrors = append(setupErrors, err)
  }
 
- if len(contexts) == 0 {
- logger.Log(logger.LevelError, nil, errors.New("no contexts found in kubeconfig"),
- "getting contexts from kubeconfig")
- http.Error(w, "getting contexts from kubeconfig", http.StatusBadRequest)
+ for _, contextError := range contextLoadErrors {
+ setupErrors = append(setupErrors, contextError.Error)
+ }
 
- return
+ return setupErrors
+}
+
+// writeKubeConfig writes the kubeconfig to the kubeconfig file.
+func (c *HeadlampConfig) writeKubeConfig(kubeConfigBase64 string) error {
+ kubeConfigByte, err := base64.StdEncoding.DecodeString(kubeConfigBase64)
+ if err != nil {
+ return fmt.Errorf("decoding kubeconfig: %w", err)
  }
 
- for _, context := range contexts {
- context := context
- context.Source = kubeconfig.DynamicCluster
+ config, err := clientcmd.Load(kubeConfigByte)
+ if err != nil {
+ return fmt.Errorf("loading kubeconfig: %w", err)
+ }
 
- err := c.kubeConfigStore.AddContext(&context)
- if err != nil {
- setupErrors = append(setupErrors, err)
- }
+ kubeConfigPersistenceDir, err := defaultKubeConfigPersistenceDir()
+ if err != nil {
+ return fmt.Errorf("getting default kubeconfig persistence dir: %w", err)
  }
 
- if len(setupErrors) > 0 {
- logger.Log(logger.LevelError, nil, setupErrors, "setting up contexts from kubeconfig")
- http.Error(w, "setting up contexts from kubeconfig", http.StatusBadRequest)
+ return kubeconfig.WriteToFile(*config, kubeConfigPersistenceDir)
+}
 
- return
+// addContextsToStore adds the contexts to the store.
+func (c *HeadlampConfig) addContextsToStore(contexts []kubeconfig.Context, setupErrors []error) []error {
+ for i := range contexts {
+ contexts[i].Source = kubeconfig.DynamicCluster
+ if err := c.kubeConfigStore.AddContext(&contexts[i]); err != nil {
+ setupErrors = append(setupErrors, err)
+ }
  }
 
- w.WriteHeader(http.StatusCreated)
- c.getConfig(w, r)
+ return setupErrors
 }
 
+// deleteCluster deletes the cluster from the store and updates the kubeconfig file.
 func (c *HeadlampConfig) deleteCluster(w http.ResponseWriter, r *http.Request) {
  if err := checkHeadlampBackendToken(w, r); err != nil {
  logger.Log(logger.LevelError, nil, err, "invalid token")

backend/cmd/stateless.go

@@ -66,6 +66,8 @@ func (c *HeadlampConfig) setKeyInCache(key string, context kubeconfig.Context) e
 
 // Handles stateless cluster requests if kubeconfig is set and dynamic clusters are enabled.
 // It returns context key which is used to store the context in the cache.
+//
+//nolint:funlen
 func (c *HeadlampConfig) handleStatelessReq(r *http.Request, kubeConfig string) (string, error) {
  var key string
 
@@ -76,11 +78,17 @@ func (c *HeadlampConfig) handleStatelessReq(r *http.Request, kubeConfig string)
  // unique key for the context
  key = clusterName + userID
 
- contexts, errs := kubeconfig.LoadContextsFromBase64String(kubeConfig, kubeconfig.DynamicCluster)
- if len(errs) > 0 {
+ contexts, contextLoadErrors, err := kubeconfig.LoadContextsFromBase64String(kubeConfig, kubeconfig.DynamicCluster)
+ if len(contextLoadErrors) > 0 {
  // Log all errors
- for _, err := range errs {
+ for _, contextError := range contextLoadErrors {
+ logger.Log(logger.LevelError, nil, contextError.Error, "loading contexts from kubeconfig")
+ }
+
+ if err != nil {
  logger.Log(logger.LevelError, nil, err, "loading contexts from kubeconfig")
+
+ return "", err
  }
 
  // If no contexts were loaded, return an error