Show cluster type

Debug build target

Print kubeconfig in 'env' command

Integrate logger into env initialization, add convenience logging when running containerized

Deleted file

Author: mclasmeier

cmd/deploy.go

@@ -50,9 +50,8 @@ Examples:
 
 func runDeploy(cmd *cobra.Command, args []string) error {
 	log := logger.New()
-
-	if env.RunningInContainer {
-		log.Dim("Running containerized.")
+	if err := env.Initialize(log); err != nil {
+		return err
 	}
 
 	if env.RunningInteractively {
@@ -98,9 +97,9 @@ func runDeploy(cmd *cobra.Command, args []string) error {
 		}
 
 		// On infra OpenShift we already get image pull secrets for Quay automatically.
-		if env.GetCurrentClusterType() != env.InfraOpenShift4 {
+		if clusterType := env.GetCurrentClusterType(); clusterType != env.InfraOpenShift4 {
 			if os.Getenv("REGISTRY_USERNAME") == "" || os.Getenv("REGISTRY_PASSWORD") == "" {
-				return errors.New("containerized mode requires REGISTRY_USERNAME and REGISTRY_PASSWORD environment variables")
+				return fmt.Errorf("containerized mode requires REGISTRY_USERNAME and REGISTRY_PASSWORD environment variables for clusters of type %s", clusterType)
 			}
 			if _, err := os.Stat("/kubeconfig"); err != nil {
 				return fmt.Errorf("containerized mode requires /kubeconfig file: %w", err)

cmd/env.go

@@ -2,9 +2,11 @@ package main
 
 import (
 	"fmt"
+	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/stackrox/roxie/internal/env"
+	"github.com/stackrox/roxie/internal/logger"
 )
 
 func newEnvCmd() *cobra.Command {
@@ -13,16 +15,24 @@ func newEnvCmd() *cobra.Command {
 		Short:  "Display environment information",
 		Long:   `Display detected environment information including cluster type and container status.`,
 		Hidden: true, // Hidden command for debugging/inspection
-		Run:    runEnv,
+		RunE:   runEnv,
 	}
 
 	return cmd
 }
 
-func runEnv(cmd *cobra.Command, args []string) {
+func runEnv(cmd *cobra.Command, args []string) error {
+	log := logger.New()
+	if err := env.Initialize(log); err != nil {
+		return err
+	}
+
 	fmt.Println("Roxie Environment Information:")
 	fmt.Println("==============================")
+	fmt.Printf("Kube config:          %s\n", os.Getenv("KUBECONFIG"))
 	fmt.Printf("Running in Container: %v\n", env.RunningInContainer)
 	fmt.Printf("Current Context:      %s\n", env.GetCurrentContext())
 	fmt.Printf("Cluster Type:         %s\n", env.GetCurrentClusterType().String())
+
+	return nil
 }

cmd/main.go

@@ -27,6 +27,7 @@ var (
 )
 
 func main() {
+
 	if err := rootCmd.Execute(); err != nil {
 		red := color.New(color.FgRed, color.Bold)
 		red.Fprintf(os.Stderr, "Error: %v\n", err)

cmd/teardown.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/stackrox/roxie/internal/deployer"
+	"github.com/stackrox/roxie/internal/env"
 	"github.com/stackrox/roxie/internal/logger"
 )
 
@@ -28,13 +29,16 @@ func newTeardownCmd() *cobra.Command {
 }
 
 func runTeardown(cmd *cobra.Command, args []string) error {
+	log := logger.New()
+	if err := env.Initialize(log); err != nil {
+		return err
+	}
+
 	component := "both"
 	if len(args) > 0 {
 		component = args[0]
 	}
 
-	log := logger.New()
-
 	log.Infof("Tearing down %s", component)
 
 	d, err := deployer.New(log, "", []string{})

internal/env/env.go

@@ -2,13 +2,16 @@ package env
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/url"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 
 	"github.com/stackrox/roxie/internal/containerutil"
+	"github.com/stackrox/roxie/internal/logger"
 	"golang.org/x/term"
 )
 
@@ -65,25 +68,33 @@ func isRunningInteractively() bool {
 
 // ensureInitialized performs lazy initialization of cluster information
 // This avoids contacting the cluster on package import
-func ensureInitialized() {
+func ensureInitialized(log *logger.Logger) error {
 	if !initialized {
-		kubeConfig := fetchKubeConfig()
+		if RunningInContainer {
+			log.Dim("Running containerized.")
+		}
+		kubeConfig, err := fetchKubeConfig(log)
+		if err != nil {
+			return err
+		}
 		currentContext = kubeConfig.CurrentContext
-		apiResources := fetchAPIResources()
+		apiResources, err := fetchAPIResources()
+		if err != nil {
+			return err
+		}
 		currentClusterType = detectClusterType(kubeConfig, apiResources)
 		initialized = true
 	}
+	return nil
 }
 
 // GetCurrentClusterType returns the current cluster type, initializing if needed
 func GetCurrentClusterType() ClusterType {
-	ensureInitialized()
 	return currentClusterType
 }
 
 // GetCurrentContext returns the current kubectl context, initializing if needed
 func GetCurrentContext() string {
-	ensureInitialized()
 	return currentContext
 }
 
@@ -113,13 +124,15 @@ type KubeCluster struct {
 	Server string
 }
 
-// DetectClusterType identifies the cluster type for the current kubectl context
-// This is a convenience wrapper that fetches the kubeconfig and API resources,
-// then delegates to detectClusterType for the actual detection logic
-func DetectClusterType() ClusterType {
-	kubeConfig := fetchKubeConfig()
-	apiResources := fetchAPIResources()
-	return detectClusterType(kubeConfig, apiResources)
+// Initialize performs environment initialization and sets the global variables.
+func Initialize(log *logger.Logger) error {
+	if log == nil {
+		log = logger.New()
+	}
+	if err := ensureInitialized(log); err != nil {
+		return fmt.Errorf("failed to initialize environment: %w", err)
+	}
+	return nil
 }
 
 // detectClusterType implements the cluster type detection logic
@@ -180,20 +193,23 @@ func isOpenShift4(apiResources []string) bool {
 }
 
 // fetchKubeConfig retrieves the current kubectl configuration
-func fetchKubeConfig() KubeConfig {
+func fetchKubeConfig(log *logger.Logger) (KubeConfig, error) {
+	if err := kubeconfigChecks(log); err != nil {
+		return KubeConfig{}, err
+	}
 	// Get current context
 	cmd := exec.Command("kubectl", "config", "current-context")
 	output, err := cmd.Output()
 	if err != nil {
-		return KubeConfig{}
+		return KubeConfig{}, errors.New("failed to get current context")
 	}
 	currentContext := strings.TrimSpace(string(output))
 
 	// Get cluster info
 	cmd = exec.Command("kubectl", "config", "view", "--minify", "-o", "json")
 	output, err = cmd.Output()
 	if err != nil {
-		return KubeConfig{CurrentContext: currentContext}
+		return KubeConfig{}, fmt.Errorf("failed to obtain minified kubeconfig: %w", err)
 	}
 
 	var rawConfig struct {
@@ -207,7 +223,7 @@ func fetchKubeConfig() KubeConfig {
 	}
 
 	if err := json.Unmarshal(output, &rawConfig); err != nil {
-		return KubeConfig{CurrentContext: currentContext}
+		return KubeConfig{}, fmt.Errorf("failed to unmarshal kubeconfig: %w", err)
 	}
 
 	clusters := make([]KubeCluster, len(rawConfig.Clusters))
@@ -221,19 +237,57 @@ func fetchKubeConfig() KubeConfig {
 	return KubeConfig{
 		CurrentContext: currentContext,
 		Clusters:       clusters,
+	}, nil
+}
+
+func kubeconfigChecks(log *logger.Logger) error {
+	kubeConfigPath, err := getKubeConfigPath()
+	if err != nil {
+		return fmt.Errorf("getting kubeconfig path: %w", err)
+	}
+	log.Infof("Using kubeconfig %s", kubeConfigPath)
+	if _, err := os.Stat(kubeConfigPath); err != nil {
+		log.Warningf("Kubeconfig %s cannot be found.", kubeConfigPath)
+		if RunningInContainer {
+			log.Warningf("Make sure that your kubeconfig is mounted into the container, as in: -v $KUBECONFIG:/kubeconfig:U")
+		}
+		return fmt.Errorf("failed to stat kubeconfig %s: %w", kubeConfigPath, err)
+	}
+
+	file, err := os.Open(kubeConfigPath)
+	if err != nil {
+		log.Warningf("Kubeconfig %s cannot be opened for reading.", kubeConfigPath)
+		if RunningInContainer {
+			log.Warningf("Make sure that your kubeconfig is mounted with the 'U' option, as in: -v $KUBECONFIG:/kubeconfig:U")
+		}
+		return fmt.Errorf("failed to open kubeconfig %s: %w", kubeConfigPath, err)
+	}
+	_ = file.Close()
+	return nil
+}
+
+func getKubeConfigPath() (string, error) {
+	kubeConfigPath := os.Getenv("KUBECONFIG")
+	if kubeConfigPath == "" {
+		home := os.Getenv("HOME")
+		if home == "" {
+			return "", errors.New("HOME environment variable is not set")
+		}
+		kubeConfigPath = filepath.Join(home, ".kube", "config")
 	}
+	return kubeConfigPath, nil
 }
 
 // fetchAPIResources retrieves the list of API resources from the cluster
-func fetchAPIResources() []string {
+func fetchAPIResources() ([]string, error) {
 	cmd := exec.Command("kubectl", "api-resources", "-o", "name")
 	output, err := cmd.Output()
 	if err != nil {
-		return nil
+		return nil, fmt.Errorf("failed to retrieve API resources: %w", err)
 	}
 
 	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
-	return lines
+	return lines, nil
 }
 
 func IsInStackroxRepository() bool {

internal/env/env_test.go

@@ -189,9 +189,11 @@ func TestDetectClusterType_GKE_DifferentProject(t *testing.T) {
 }
 
 func TestDetectClusterType_Integration(t *testing.T) {
+	Initialize(nil)
+
 	// This test uses the current kubectl context
 	// The result will depend on the active cluster
-	clusterType := DetectClusterType()
+	clusterType := GetCurrentClusterType()
 
 	t.Logf("Detected cluster type: %s", clusterType)