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

Author: mclasmeier

cmd/env.go

@@ -1,11 +1,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 {
@@ -21,10 +21,10 @@ func newEnvCmd() *cobra.Command {
 }
 
 func runEnv(cmd *cobra.Command, args []string) {
-	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())
+	log := logger.New()
+	env.Initialize(log)
+	log.Infof("Kube config:          %s", os.Getenv("KUBECONFIG"))
+	log.Infof("Running in Container: %v", env.RunningInContainer)
+	log.Infof("Current Context:      %s", env.GetCurrentContext())
+	log.Infof("Cluster Type:         %s", env.GetCurrentClusterType().String())
 }

internal/deployer/deployer.go

@@ -308,6 +308,8 @@ func (d *Deployer) deleteSecuredClusterResources(ctx context.Context, wait bool)
 }
 
 func New(log *logger.Logger, overrideFile string, overrideSetExpressions []string) (*Deployer, error) {
+	env.Initialize(log)
+
 	// Check required tools first
 	if err := checkRequiredTools(); err != nil {
 		return nil, err

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,9 +68,9 @@ 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) {
 	if !initialized {
-		kubeConfig := fetchKubeConfig()
+		kubeConfig := fetchKubeConfig(log)
 		currentContext = kubeConfig.CurrentContext
 		apiResources := fetchAPIResources()
 		currentClusterType = detectClusterType(kubeConfig, apiResources)
@@ -77,13 +80,11 @@ func ensureInitialized() {
 
 // 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,11 +114,16 @@ type KubeCluster struct {
 	Server string
 }
 
+// Initialize performs environment initialization and sets the global variables.
+func Initialize(log *logger.Logger) {
+	ensureInitialized(log)
+}
+
 // 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()
+	kubeConfig := fetchKubeConfig(nil)
 	apiResources := fetchAPIResources()
 	return detectClusterType(kubeConfig, apiResources)
 }
@@ -180,7 +186,9 @@ func isOpenShift4(apiResources []string) bool {
 }
 
 // fetchKubeConfig retrieves the current kubectl configuration
-func fetchKubeConfig() KubeConfig {
+func fetchKubeConfig(log *logger.Logger) KubeConfig {
+	kubeconfigChecks(log)
+
 	// Get current context
 	cmd := exec.Command("kubectl", "config", "current-context")
 	output, err := cmd.Output()
@@ -224,6 +232,44 @@ func fetchKubeConfig() KubeConfig {
 	}
 }
 
+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 {
 	cmd := exec.Command("kubectl", "api-resources", "-o", "name")