Simplify the configuration loading

Moves the options to flags. Also moves the
env variables to the main command, so there are
no sideeffects when running the commands.

Signed-off-by: Petr Kotas <pkotas@redhat.com>

Author: petrkotas

cadctl/cmd/investigate/investigate.go

@@ -19,10 +19,10 @@ package investigate
 import (
 	"fmt"
 	"os"
-	"path/filepath"
 	"strings"
 
 	cmv1 "github.com/openshift-online/ocm-sdk-go/clustersmgmt/v1"
+	config "github.com/openshift/configuration-anomaly-detection/cadctl/config"
 	investigations "github.com/openshift/configuration-anomaly-detection/pkg/investigations"
 	"github.com/openshift/configuration-anomaly-detection/pkg/investigations/ccam"
 	investigation "github.com/openshift/configuration-anomaly-detection/pkg/investigations/investigation"
@@ -31,6 +31,7 @@ import (
 	"github.com/openshift/configuration-anomaly-detection/pkg/metrics"
 	ocm "github.com/openshift/configuration-anomaly-detection/pkg/ocm"
 	"github.com/openshift/configuration-anomaly-detection/pkg/pagerduty"
+	"go.uber.org/zap"
 
 	"github.com/spf13/cobra"
 )
@@ -40,19 +41,40 @@ var InvestigateCmd = &cobra.Command{
 	Use:          "investigate",
 	SilenceUsage: true,
 	Short:        "Filter for and investigate supported alerts",
-	RunE:         run,
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		var err error
+
+		if config.Config.ConfigFile != "" {
+			// loads the configuration unless config file is present
+			// config should be used only when developing
+			if _, err = config.Config.GetCadOcmClientID(cmd); err != nil {
+				return fmt.Errorf("failed to get cadOcmClientID: %w", err)
+			}
+			if _, err = config.Config.GetCadOcmClientSecret(cmd); err != nil {
+				return fmt.Errorf("failed to get cadOcmClientSecret: %w", err)
+			}
+			if _, err = config.Config.GetCadOcmURL(cmd); err != nil {
+				return fmt.Errorf("failed to get cadOcmURL: %w", err)
+			}
+		}
+
+		if _, err = config.Config.GetExperimental(cmd); err != nil {
+			return fmt.Errorf("failed to get experimental flag: %w", err)
+		}
+
+		return nil
+	},
+	RunE: run,
 }
 
-var (
-	logLevelFlag = ""
-	payloadPath  = "./payload.json"
-)
+var payloadPath = "./payload.json"
 
 const pagerdutyTitlePrefix = "[CAD Investigated]"
 
 func init() {
+	logging.RawLogger = logging.InitLogger(config.Config.LogLevel, "")
+
 	InvestigateCmd.Flags().StringVarP(&payloadPath, "payload-path", "p", payloadPath, "the path to the payload")
-	InvestigateCmd.Flags().StringVarP(&logging.LogLevelString, "log-level", "l", "", "the log level [debug,info,warn,error,fatal], default = info")
 
 	err := InvestigateCmd.MarkFlagRequired("payload-path")
 	if err != nil {
@@ -62,10 +84,6 @@ func init() {
 
 func run(cmd *cobra.Command, _ []string) error {
 	// early init of logger for logs before clusterID is known
-	if cmd.Flags().Changed("log-level") {
-		flagValue, _ := cmd.Flags().GetString("log-level")
-		logging.RawLogger = logging.InitLogger(flagValue, "")
-	}
 	payload, err := os.ReadFile(payloadPath)
 	if err != nil {
 		return fmt.Errorf("failed to read webhook payload: %w", err)
@@ -87,8 +105,7 @@ func run(cmd *cobra.Command, _ []string) error {
 		}
 	}()
 
-	_, cadExperimentalEnabled := os.LookupEnv("CAD_EXPERIMENTAL_ENABLED")
-	alertInvestigation := investigations.GetInvestigation(pdClient.GetTitle(), cadExperimentalEnabled)
+	alertInvestigation := investigations.GetInvestigation(pdClient.GetTitle(), config.Config.Experimental)
 
 	// Escalate all unsupported alerts
 	if alertInvestigation == nil {
@@ -109,8 +126,17 @@ func run(cmd *cobra.Command, _ []string) error {
 		return err
 	}
 
-	ocmClient, err := GetOCMClient()
-	if err != nil {
+	var ocmClient *ocm.SdkClient
+	var ocmErr error
+	// Initialize the OCM client
+	// If the config file is set, use it to initialize the OCM client
+	// use config file only when developing
+	if config.Config.ConfigFile != "" {
+		ocmClient, ocmErr = ocm.NewFromConfig(config.Config.ConfigFile)
+	} else {
+		ocmClient, ocmErr = ocm.NewFromClientKeyPair(config.Config.CadOcmURL, config.Config.CadOcmClientID, config.Config.CadOcmClientSecret)
+	}
+	if ocmErr != nil {
 		return fmt.Errorf("could not initialize ocm client: %w", err)
 	}
 
@@ -122,13 +148,8 @@ func run(cmd *cobra.Command, _ []string) error {
 	// For installing clusters, externalID can be empty.
 	internalClusterID := cluster.ID()
 
-	// re-initialize logger for the internal-cluster-id context
-	// if log-level flag is set, take priority over env + default
-	if cmd.Flags().Changed("log-level") {
-		logging.RawLogger = logging.InitLogger(logLevelFlag, internalClusterID)
-	} else {
-		logging.RawLogger = logging.InitLogger(logging.LogLevelString, internalClusterID)
-	}
+	// add the internal-cluster-id context to the logger
+	logging.RawLogger = logging.RawLogger.With(zap.String("cluster_id", internalClusterID))
 
 	requiresInvestigation, err := clusterRequiresInvestigation(cluster, pdClient, ocmClient)
 	if err != nil || !requiresInvestigation {
@@ -184,22 +205,6 @@ func handleCADFailure(err error, resources *investigation.Resources, pdClient *p
 	}
 }
 
-// GetOCMClient will retrieve the OcmClient from the 'ocm' package
-func GetOCMClient() (*ocm.SdkClient, error) {
-	cadOcmFilePath := os.Getenv("CAD_OCM_FILE_PATH")
-
-	_, err := os.Stat(cadOcmFilePath)
-	if os.IsNotExist(err) {
-		configDir, err := os.UserConfigDir()
-		if err != nil {
-			return nil, err
-		}
-		cadOcmFilePath = filepath.Join(configDir, "/ocm/ocm.json")
-	}
-
-	return ocm.New(cadOcmFilePath)
-}
-
 // Checks pre-requisites for a cluster investigation:
 // - the cluster's state is supported by CAD for an investigation (= not uninstalling)
 // - the cloud provider is supported by CAD (cluster is AWS)

cadctl/cmd/root.go

@@ -17,16 +17,20 @@ limitations under the License.
 package cmd
 
 import (
+
+	// "github.com/openshift-online/ocm-cli/pkg/config"
 	investigate "github.com/openshift/configuration-anomaly-detection/cadctl/cmd/investigate"
+	config "github.com/openshift/configuration-anomaly-detection/cadctl/config"
 	"github.com/openshift/configuration-anomaly-detection/pkg/logging"
 	"github.com/openshift/configuration-anomaly-detection/pkg/metrics"
 	"github.com/spf13/cobra"
 )
 
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
-	Use:   "cadctl",
-	Short: "A util of configuration-anomaly-detection (CAD) checks",
+	Use:               "cadctl",
+	Short:             "A util of configuration-anomaly-detection (CAD) checks",
+	PersistentPreRunE: loadCommon,
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -41,4 +45,22 @@ func Execute() {
 
 func init() {
 	rootCmd.AddCommand(investigate.InvestigateCmd)
+	rootCmd.PersistentFlags().StringP("ocmconfig", "c", "", "Path to the OCM config file to use for CLI requests. When not set the OCM_CONFIG environment variable will be used. If that is not set, the default OCM config locations will be file will be used.")
+}
+
+func loadCommon(cmd *cobra.Command, args []string) error {
+	var err error
+
+	_, err = config.Config.GetLogLevel(cmd)
+	if err != nil {
+		logging.Fatal(err)
+		return err
+	}
+	_, err = config.Config.GetConfigFile(cmd)
+	if err != nil {
+		logging.Fatal(err)
+		return err
+	}
+
+	return nil
 }

cadctl/config/config.go

@@ -0,0 +1,157 @@
+/*
+Copyright © 2022 Red Hat, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package config
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/openshift/configuration-anomaly-detection/pkg/ocm"
+)
+
+type config struct {
+	ConfigFile         string
+	LogLevel           string
+	CadOcmClientID     string
+	CadOcmClientSecret string
+	CadOcmURL          string
+	Experimental       bool
+}
+
+var Config config
+
+// GetConfigFile retrieves the OCM config file path from the command line flags or environment variables.
+// It checks the following in order:
+// 1. Command line flag --ocmconfig
+// 2. Environment variable OCM_CONFIG
+// 3. Default OCM config locations
+// If the file is not found at any of these locations, the config path remains empty.
+// Missing config is a valid state, as the user may not have a config file.
+func (c *config) GetConfigFile(cmd *cobra.Command) (string, error) {
+	ocmConfigPath, err := cmd.Flags().GetString("ocmconfig")
+	if err != nil {
+		return "", fmt.Errorf("failed to get ocmconfig flag: %w", err)
+	}
+
+	if ocmConfigPath != "" {
+		if _, err := os.Stat(ocmConfigPath); err != nil {
+			return "", fmt.Errorf("ocmconfig file not found at %s: %w", ocmConfigPath, err)
+		}
+
+		c.ConfigFile = ocmConfigPath
+		return ocmConfigPath, nil
+	}
+
+	ocmConfigPath, exists := os.LookupEnv("OCM_CONFIG")
+	if exists {
+		if _, err := os.Stat(ocmConfigPath); err != nil {
+			return "", fmt.Errorf("ocmconfig file not found at %s: %w", ocmConfigPath, err)
+		}
+
+		c.ConfigFile = ocmConfigPath
+		return ocmConfigPath, nil
+	}
+
+	ocmConfigPath, err = ocm.Location()
+	if err != nil {
+		// Location() checks for file existence
+		return "", fmt.Errorf("failed to get ocmconfig file location: %w", err)
+	}
+
+	c.ConfigFile = ocmConfigPath
+	return ocmConfigPath, nil
+}
+
+func (c *config) GetLogLevel(cmd *cobra.Command) (string, error) {
+	logLevel, err := cmd.Flags().GetString("log-level")
+	if err != nil {
+		return "", fmt.Errorf("failed to get log-level flag: %w", err)
+	}
+	if logLevel != "" {
+		c.LogLevel = logLevel
+		return logLevel, nil
+	}
+
+	if envLogLevel, exists := os.LookupEnv("LOG_LEVEL"); exists {
+		c.LogLevel = envLogLevel
+		return logLevel, nil
+	}
+
+	c.LogLevel = "info"
+	return logLevel, nil
+}
+
+// GetExperimental retrieves the experimental flag passed as a command line argument.
+// If not set, it checks the CAD_EXPERIMENTAL_ENABLED environment variable.
+// Defaults to false if neither is set.
+func (c *config) GetExperimental(cmd *cobra.Command) (bool, error) {
+	experimentalFlag, err := cmd.Flags().GetBool("experimental")
+	if err != nil {
+		return false, fmt.Errorf("failed to get experimental flag: %w", err)
+	}
+	if experimentalFlag {
+		c.Experimental = true
+		return experimentalFlag, nil
+	}
+
+	experimental, exist := os.LookupEnv("CAD_EXPERIMENTAL_ENABLED")
+	if exist && experimental == "true" {
+		c.Experimental = true
+		return experimentalFlag, nil
+	}
+
+	c.Experimental = false
+	return experimentalFlag, nil
+}
+
+// GetCadOcmClientID retrieves the OCM cliend ID passed as
+// an CAD_OCM_CLIENT_ID environment variable.
+func (c *config) GetCadOcmClientID(cmd *cobra.Command) (string, error) {
+	cadOcmClientID, exist := os.LookupEnv("CAD_OCM_CLIENT_ID")
+	if !exist {
+		return "", fmt.Errorf("client-id flag or CAD_OCM_CLIENT_ID environment variable must be set")
+	}
+
+	c.CadOcmClientID = cadOcmClientID
+	return cadOcmClientID, nil
+}
+
+// GetCadOcmClientSecret retrieves the OCM client secret passed as
+// an environment CAD_OCM_CLIENT_SECRET variable.
+func (c *config) GetCadOcmClientSecret(cmd *cobra.Command) (string, error) {
+	cadOcmClientSecret, exist := os.LookupEnv("CAD_OCM_CLIENT_SECRET")
+	if !exist {
+		return "", fmt.Errorf("client-secret flag or CAD_OCM_CLIENT_SECRET environment variable must be set")
+	}
+
+	c.CadOcmClientSecret = cadOcmClientSecret
+	return cadOcmClientSecret, nil
+}
+
+// GetCadOcmURL retrieves the OCM URL passed as an environment
+// CAD_OCM_URL variable.
+func (c *config) GetCadOcmURL(cmd *cobra.Command) (string, error) {
+	cadOcmURL, exist := os.LookupEnv("CAD_OCM_URL")
+	if !exist {
+		return "", fmt.Errorf("ocm-url flag or CAD_OCM_URL environment variable must be set")
+	}
+
+	c.CadOcmURL = cadOcmURL
+	return cadOcmURL, nil
+}

interceptor/main.go

@@ -22,7 +22,7 @@ const (
 	idleTimeout  = 60 * time.Second
 )
 
-var logger = logging.InitLogger(logging.LogLevelString, "")
+var logger = logging.RawLogger
 
 func main() {
 	// set up signals so we handle the first shutdown signal gracefully
@@ -71,6 +71,18 @@ func main() {
 	logger.Infof("Server exiting")
 }
 
+func init() {
+	// read log level from environment variable
+	logLevel := os.Getenv("LOG_LEVEL")
+	if logLevel != "" || logLevel == "info" {
+		// no change needed
+		return
+	}
+
+	// set up logging
+	logging.RawLogger = logging.InitLogger(logLevel, "")
+}
+
 func readinessHandler(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 }