Clearly separate loading config from CLI and file

cmd/otel-allocator/config/config.go

@@ -71,12 +71,33 @@ func (c Config) GetTargetsFilterStrategy() string {
 	return ""
 }
 
-func Load(file string) (Config, error) {
-	cfg := createDefaultConfig()
-	if err := unmarshal(&cfg, file); err != nil {
-		return Config{}, err
+func LoadFromFile(file string, target *Config) error {
+	return unmarshal(target, file)
+}
+
+func LoadFromCLI(target *Config) error {
+	// set the rest of the config attributes based on command-line flag values
+	target.RootLogger = zap.New(zap.UseFlagOptions(&zapCmdLineOpts))
+	klog.SetLogger(target.RootLogger)
+	ctrl.SetLogger(target.RootLogger)
+
+	target.KubeConfigFilePath = *kubeConfigPathFlag
+	clusterConfig, err := clientcmd.BuildConfigFromFlags("", *kubeConfigPathFlag)
+	if err != nil {
+		pathError := &fs.PathError{}
+		if ok := errors.As(err, &pathError); !ok {
+			return err
+		}
+		clusterConfig, err = rest.InClusterConfig()
+		if err != nil {
+			return err
+		}
 	}
-	return cfg, nil
+	target.ListenAddr = *listenAddrFlag
+	target.PrometheusCR.Enabled = *prometheusCREnabledFlag
+	target.ClusterConfig = clusterConfig
+
+	return nil
 }
 
 func unmarshal(cfg *Config, configFile string) error {
@@ -91,43 +112,29 @@ func unmarshal(cfg *Config, configFile string) error {
 	return nil
 }
 
-func createDefaultConfig() Config {
+func CreateDefaultConfig() Config {
 	return Config{
 		PrometheusCR: PrometheusCRConfig{
 			ScrapeInterval: DefaultCRScrapeInterval,
 		},
 	}
 }
 
-func FromCLI() (*Config, string, error) {
+func Load() (*Config, string, error) {
 	pflag.Parse()
+	config := CreateDefaultConfig()
 
 	// load the config from the config file
-	config, err := Load(*configFilePathFlag)
+	err := LoadFromFile(*configFilePathFlag, &config)
 	if err != nil {
 		return nil, "", err
 	}
 
-	// set the rest of the config attributes based on command-line flag values
-	config.RootLogger = zap.New(zap.UseFlagOptions(&zapCmdLineOpts))
-	klog.SetLogger(config.RootLogger)
-	ctrl.SetLogger(config.RootLogger)
-
-	config.KubeConfigFilePath = *kubeConfigPathFlag
-	clusterConfig, err := clientcmd.BuildConfigFromFlags("", *kubeConfigPathFlag)
+	err = LoadFromCLI(&config)
 	if err != nil {
-		pathError := &fs.PathError{}
-		if ok := errors.As(err, &pathError); !ok {
-			return nil, "", err
-		}
-		clusterConfig, err = rest.InClusterConfig()
-		if err != nil {
-			return nil, "", err
-		}
+		return nil, "", err
 	}
-	config.ListenAddr = *listenAddrFlag
-	config.PrometheusCR.Enabled = *prometheusCREnabledFlag
-	config.ClusterConfig = clusterConfig
+
 	return &config, *configFilePathFlag, nil
 }
 

cmd/otel-allocator/config/config_test.go

@@ -99,7 +99,7 @@ func TestLoad(t *testing.T) {
 			args: args{
 				file: "./testdata/no_config.yaml",
 			},
-			want:    createDefaultConfig(),
+			want:    CreateDefaultConfig(),
 			wantErr: assert.NoError,
 		},
 		{
@@ -163,7 +163,8 @@ func TestLoad(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := Load(tt.args.file)
+			got := CreateDefaultConfig()
+			err := LoadFromFile(tt.args.file, &got)
 			if !tt.wantErr(t, err, fmt.Sprintf("Load(%v)", tt.args.file)) {
 				return
 			}

cmd/otel-allocator/main.go

@@ -64,7 +64,7 @@ func main() {
 		interrupts      = make(chan os.Signal, 1)
 		errChan         = make(chan error)
 	)
-	cfg, configFilePath, err := config.FromCLI()
+	cfg, configFilePath, err := config.Load()
 	if err != nil {
 		setupLog.Error(err, "Failed to parse parameters")
 		os.Exit(1)

cmd/otel-allocator/target/discovery_test.go

@@ -83,7 +83,8 @@ func TestDiscovery(t *testing.T) {
 	}()
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			cfg, err := config.Load(tt.args.file)
+			cfg := config.CreateDefaultConfig()
+			err := config.LoadFromFile(tt.args.file, &cfg)
 			assert.NoError(t, err)
 			assert.True(t, len(cfg.PromConfig.ScrapeConfigs) > 0)
 			err = manager.ApplyConfig(allocatorWatcher.EventSourcePrometheusCR, cfg.PromConfig)

cmd/otel-allocator/watcher/file.go

@@ -50,7 +50,8 @@ func NewFileWatcher(logger logr.Logger, configFilePath string) (*FileWatcher, er
 }
 
 func (f *FileWatcher) LoadConfig(_ context.Context) (*promconfig.Config, error) {
-	cfg, err := config.Load(f.configFilePath)
+	cfg := config.CreateDefaultConfig()
+	err := config.LoadFromFile(f.configFilePath, &cfg)
 	if err != nil {
 		f.logger.Error(err, "Unable to load configuration")
 		return nil, err