[chore] make Config a struct with config fields, but no logic - move the logic out to autodetect

Author: github-actions[bot]

controllers/opampbridge_controller_test.go

@@ -16,6 +16,7 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/tools/record"
+	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	k8sconfig "sigs.k8s.io/controller-runtime/pkg/client/config"
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
@@ -24,6 +25,7 @@ import (
 
 	"github.com/open-telemetry/opentelemetry-operator/apis/v1alpha1"
 	"github.com/open-telemetry/opentelemetry-operator/controllers"
+	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect"
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/openshift"
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/prometheus"
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/rbac"
@@ -47,7 +49,6 @@ func TestNewObjectsOnReconciliation_OpAMPBridge(t *testing.T) {
 	// prepare
 	cfg := config.New(
 		config.WithOperatorOpAMPBridgeImage("default-opamp-bridge"),
-		config.WithAutoDetect(opampBridgeMockAutoDetector),
 	)
 	nsn := types.NamespacedName{Name: "my-instance", Namespace: "default"}
 	reconciler := controllers.NewOpAMPBridgeReconciler(controllers.OpAMPBridgeReconcilerParams{
@@ -57,7 +58,7 @@ func TestNewObjectsOnReconciliation_OpAMPBridge(t *testing.T) {
 		Recorder: record.NewFakeRecorder(10),
 		Config:   cfg,
 	})
-	require.NoError(t, cfg.AutoDetect())
+	require.NoError(t, autodetect.ApplyAutoDetect(opampBridgeMockAutoDetector, &cfg, ctrl.Log.WithName("autodetect")))
 	created := &v1alpha1.OpAMPBridge{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      nsn.Name,

controllers/opentelemetrycollector_controller.go

@@ -364,17 +364,17 @@ func (r *OpenTelemetryCollectorReconciler) GetOwnedResourceTypes() []client.Obje
 		&policyV1.PodDisruptionBudget{},
 	}
 
-	if r.config.CreateRBACPermissions() == rbac.Available {
+	if r.config.CreateRBACPermissions == rbac.Available {
 		ownedResources = append(ownedResources, &rbacv1.ClusterRole{})
 		ownedResources = append(ownedResources, &rbacv1.ClusterRoleBinding{})
 	}
 
-	if featuregate.PrometheusOperatorIsAvailable.IsEnabled() && r.config.PrometheusCRAvailability() == prometheus.Available {
+	if featuregate.PrometheusOperatorIsAvailable.IsEnabled() && r.config.PrometheusCRAvailability == prometheus.Available {
 		ownedResources = append(ownedResources, &monitoringv1.PodMonitor{})
 		ownedResources = append(ownedResources, &monitoringv1.ServiceMonitor{})
 	}
 
-	if r.config.OpenShiftRoutesAvailability() == openshift.RoutesAvailable {
+	if r.config.OpenshiftRoutesAvailability == openshift.RoutesAvailable {
 		ownedResources = append(ownedResources, &routev1.Route{})
 	}
 
@@ -385,7 +385,7 @@ const collectorFinalizer = "opentelemetrycollector.opentelemetry.io/finalizer"
 
 func (r *OpenTelemetryCollectorReconciler) finalizeCollector(ctx context.Context, params manifests.Params) error {
 	// The cluster scope objects do not have owner reference. They need to be deleted explicitly
-	if params.Config.CreateRBACPermissions() == rbac.Available {
+	if params.Config.CreateRBACPermissions == rbac.Available {
 		objects, err := r.findClusterRoleObjects(ctx, params)
 		if err != nil {
 			return err

controllers/suite_test.go

@@ -395,8 +395,8 @@ func testCollectorWithPDB(minAvailable, maxUnavailable int32) v1alpha1.OpenTelem
 		fmt.Printf("Error getting yaml file: %v", err)
 	}
 
-	configuration := config.New(config.WithAutoDetect(mockAutoDetector), config.WithCollectorImage(defaultCollectorImage), config.WithTargetAllocatorImage(defaultTaAllocationImage))
-	err = configuration.AutoDetect()
+	configuration := config.New(config.WithCollectorImage(defaultCollectorImage), config.WithTargetAllocatorImage(defaultTaAllocationImage))
+	err = autodetect.ApplyAutoDetect(mockAutoDetector, &configuration, ctrl.Log.WithName("autodetect"))
 	if err != nil {
 		logger.Error(err, "configuration.autodetect failed")
 	}

controllers/targetallocator_controller.go

@@ -191,7 +191,7 @@ func (r *TargetAllocatorReconciler) SetupWithManager(mgr ctrl.Manager) error {
 		Owns(&appsv1.Deployment{}).
 		Owns(&policyV1.PodDisruptionBudget{})
 
-	if featuregate.PrometheusOperatorIsAvailable.IsEnabled() && r.config.PrometheusCRAvailability() == prometheus.Available {
+	if featuregate.PrometheusOperatorIsAvailable.IsEnabled() && r.config.PrometheusCRAvailability == prometheus.Available {
 		ctrlBuilder.Owns(&monitoringv1.ServiceMonitor{})
 		ctrlBuilder.Owns(&monitoringv1.PodMonitor{})
 	}

internal/autodetect/main.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"slices"
 
+	"github.com/go-logr/logr"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/rest"
@@ -19,6 +20,7 @@ import (
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/prometheus"
 	autoRBAC "github.com/open-telemetry/opentelemetry-operator/internal/autodetect/rbac"
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/targetallocator"
+	"github.com/open-telemetry/opentelemetry-operator/internal/config"
 	"github.com/open-telemetry/opentelemetry-operator/internal/rbac"
 )
 
@@ -185,3 +187,45 @@ func (a *autoDetect) TargetAllocatorAvailability() (targetallocator.Availability
 func (a *autoDetect) FIPSEnabled(_ context.Context) bool {
 	return fips.IsFipsEnabled()
 }
+
+// ApplyAutoDetect attempts to automatically detect relevant information for this operator.
+func ApplyAutoDetect(autoDetect AutoDetect, c *config.Config, logger logr.Logger) error {
+	logger.V(2).Info("auto-detecting the configuration based on the environment")
+
+	ora, err := autoDetect.OpenShiftRoutesAvailability()
+	if err != nil {
+		return err
+	}
+	c.OpenshiftRoutesAvailability = ora
+	logger.V(2).Info("openshift routes detected", "availability", ora)
+
+	pcrd, err := autoDetect.PrometheusCRsAvailability()
+	if err != nil {
+		return err
+	}
+	c.PrometheusCRAvailability = pcrd
+	logger.V(2).Info("prometheus cr detected", "availability", pcrd)
+
+	rAuto, err := autoDetect.RBACPermissions(context.Background())
+	if err != nil {
+		logger.V(2).Info("the rbac permissions are not set for the operator", "reason", err)
+	}
+	c.CreateRBACPermissions = rAuto
+	logger.V(2).Info("create rbac permissions detected", "availability", rAuto)
+
+	cmAvl, err := autoDetect.CertManagerAvailability(context.Background())
+	if err != nil {
+		logger.V(2).Info("the cert manager crd and permissions are not set for the operator", "reason", err)
+	}
+	c.CertManagerAvailability = cmAvl
+	logger.V(2).Info("the cert manager crd and permissions are set for the operator", "availability", cmAvl)
+
+	taAvl, err := autoDetect.TargetAllocatorAvailability()
+	if err != nil {
+		return err
+	}
+	c.TargetAllocatorAvailability = taAvl
+	logger.V(2).Info("determined TargetAllocator CRD availability", "availability", cmAvl)
+
+	return nil
+}

internal/autodetect/main_test.go

@@ -20,13 +20,16 @@ import (
 	"k8s.io/client-go/kubernetes/fake"
 	"k8s.io/client-go/rest"
 	kubeTesting "k8s.io/client-go/testing"
+	ctrl "sigs.k8s.io/controller-runtime"
 
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect"
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/autodetectutils"
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/certmanager"
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/openshift"
 	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/prometheus"
 	autoRBAC "github.com/open-telemetry/opentelemetry-operator/internal/autodetect/rbac"
+	"github.com/open-telemetry/opentelemetry-operator/internal/autodetect/targetallocator"
+	"github.com/open-telemetry/opentelemetry-operator/internal/config"
 	"github.com/open-telemetry/opentelemetry-operator/internal/rbac"
 )
 
@@ -349,3 +352,93 @@ func TestCertManagerAvailability(t *testing.T) {
 		})
 	}
 }
+
+func TestConfigChangesOnAutoDetect(t *testing.T) {
+	// prepare
+	mock := &mockAutoDetect{
+		OpenShiftRoutesAvailabilityFunc: func() (openshift.RoutesAvailability, error) {
+			return openshift.RoutesAvailable, nil
+		},
+		PrometheusCRsAvailabilityFunc: func() (prometheus.Availability, error) {
+			return prometheus.Available, nil
+		},
+		RBACPermissionsFunc: func(ctx context.Context) (autoRBAC.Availability, error) {
+			return autoRBAC.Available, nil
+		},
+		CertManagerAvailabilityFunc: func(ctx context.Context) (certmanager.Availability, error) {
+			return certmanager.Available, nil
+		},
+		TargetAllocatorAvailabilityFunc: func() (targetallocator.Availability, error) {
+			return targetallocator.Available, nil
+		},
+	}
+	cfg := config.New()
+	autodetect.ApplyAutoDetect(mock, &cfg, ctrl.Log.WithName("autodetect"))
+
+	// sanity check
+	require.Equal(t, openshift.RoutesNotAvailable, cfg.OpenshiftRoutesAvailability)
+	require.Equal(t, prometheus.NotAvailable, cfg.PrometheusCRAvailability)
+	require.Equal(t, autoRBAC.NotAvailable, cfg.CreateRBACPermissions)
+	require.Equal(t, certmanager.NotAvailable, cfg.CertManagerAvailability)
+	require.Equal(t, targetallocator.NotAvailable, cfg.TargetAllocatorAvailability)
+
+	// test
+	err := autodetect.ApplyAutoDetect(mock, &cfg, ctrl.Log.WithName("test"))
+	require.NoError(t, err)
+
+	// verify
+	assert.Equal(t, openshift.RoutesAvailable, cfg.OpenshiftRoutesAvailability)
+	require.Equal(t, prometheus.Available, cfg.PrometheusCRAvailability)
+	require.Equal(t, autoRBAC.Available, cfg.CreateRBACPermissions)
+	require.Equal(t, certmanager.Available, cfg.CertManagerAvailability)
+	require.Equal(t, targetallocator.Available, cfg.TargetAllocatorAvailability)
+}
+
+var _ autodetect.AutoDetect = (*mockAutoDetect)(nil)
+
+type mockAutoDetect struct {
+	OpenShiftRoutesAvailabilityFunc func() (openshift.RoutesAvailability, error)
+	PrometheusCRsAvailabilityFunc   func() (prometheus.Availability, error)
+	RBACPermissionsFunc             func(ctx context.Context) (autoRBAC.Availability, error)
+	CertManagerAvailabilityFunc     func(ctx context.Context) (certmanager.Availability, error)
+	TargetAllocatorAvailabilityFunc func() (targetallocator.Availability, error)
+}
+
+func (m *mockAutoDetect) FIPSEnabled(_ context.Context) bool {
+	return false
+}
+
+func (m *mockAutoDetect) OpenShiftRoutesAvailability() (openshift.RoutesAvailability, error) {
+	if m.OpenShiftRoutesAvailabilityFunc != nil {
+		return m.OpenShiftRoutesAvailabilityFunc()
+	}
+	return openshift.RoutesNotAvailable, nil
+}
+
+func (m *mockAutoDetect) PrometheusCRsAvailability() (prometheus.Availability, error) {
+	if m.PrometheusCRsAvailabilityFunc != nil {
+		return m.PrometheusCRsAvailabilityFunc()
+	}
+	return prometheus.NotAvailable, nil
+}
+
+func (m *mockAutoDetect) RBACPermissions(ctx context.Context) (autoRBAC.Availability, error) {
+	if m.RBACPermissionsFunc != nil {
+		return m.RBACPermissionsFunc(ctx)
+	}
+	return autoRBAC.NotAvailable, nil
+}
+
+func (m *mockAutoDetect) CertManagerAvailability(ctx context.Context) (certmanager.Availability, error) {
+	if m.CertManagerAvailabilityFunc != nil {
+		return m.CertManagerAvailabilityFunc(ctx)
+	}
+	return certmanager.NotAvailable, nil
+}
+
+func (m *mockAutoDetect) TargetAllocatorAvailability() (targetallocator.Availability, error) {
+	if m.TargetAllocatorAvailabilityFunc != nil {
+		return m.TargetAllocatorAvailabilityFunc()
+	}
+	return targetallocator.NotAvailable, nil
+}