EVEREST-633 Update subscription on install calls

Author: recharte

pkg/install/install.go

@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	"os"
 	"strings"
 
 	"github.com/AlecAivazis/survey/v2"
@@ -82,6 +83,8 @@ const (
 	monitoringNamespace = "everest-monitoring"
 	// EverestMonitoringNamespaceEnvVar is the name of the environment variable that holds the monitoring namespace.
 	EverestMonitoringNamespaceEnvVar = "MONITORING_NAMESPACE"
+	// disableTelemetryEnvVar is the name of the environment variable that disables telemetry.
+	disableTelemetryEnvVar = "DISABLE_TELEMETRY"
 )
 
 type (
@@ -471,6 +474,11 @@ func (o *Install) installOperator(ctx context.Context, channel, operatorName, na
 
 		o.l.Infof("Installing %s operator", operatorName)
 
+		disableTelemetry, ok := os.LookupEnv(disableTelemetryEnvVar)
+		if !ok || disableTelemetry != "true" {
+			disableTelemetry = "false"
+		}
+
 		params := kubernetes.InstallOperatorRequest{
 			Namespace:              namespace,
 			Name:                   operatorName,
@@ -479,21 +487,27 @@ func (o *Install) installOperator(ctx context.Context, channel, operatorName, na
 			CatalogSourceNamespace: catalogSourceNamespace,
 			Channel:                channel,
 			InstallPlanApproval:    v1alpha1.ApprovalManual,
-		}
-		if len(o.config.Namespaces) != 0 && operatorName == everestOperatorName {
-			params.TargetNamespaces = o.config.Namespaces
-			params.SubscriptionConfig = &v1alpha1.SubscriptionConfig{
+			SubscriptionConfig: &v1alpha1.SubscriptionConfig{
 				Env: []corev1.EnvVar{
 					{
-						Name:  kubernetes.EverestDBNamespacesEnvVar,
-						Value: strings.Join(o.config.Namespaces, ","),
-					},
-					{
-						Name:  EverestMonitoringNamespaceEnvVar,
-						Value: monitoringNamespace,
+						Name:  disableTelemetryEnvVar,
+						Value: disableTelemetry,
 					},
 				},
-			}
+			},
+		}
+		if operatorName == everestOperatorName {
+			params.TargetNamespaces = o.config.Namespaces
+			params.SubscriptionConfig.Env = append(params.SubscriptionConfig.Env, []corev1.EnvVar{
+				{
+					Name:  EverestMonitoringNamespaceEnvVar,
+					Value: monitoringNamespace,
+				},
+				{
+					Name:  kubernetes.EverestDBNamespacesEnvVar,
+					Value: strings.Join(o.config.Namespaces, ","),
+				},
+			}...)
 		}
 
 		if err := o.kubeClient.InstallOperator(ctx, params); err != nil {

pkg/kubernetes/client/client.go

@@ -1192,6 +1192,22 @@ func (c *Client) CreateSubscription(ctx context.Context, namespace string, subsc
 	return sub, nil
 }
 
+// UpdateSubscription updates an OLM subscription.
+func (c *Client) UpdateSubscription(ctx context.Context, namespace string, subscription *v1alpha1.Subscription) (*v1alpha1.Subscription, error) {
+	operatorClient, err := versioned.NewForConfig(c.restConfig)
+	if err != nil {
+		return nil, errors.Join(err, errors.New("cannot create an operator client instance"))
+	}
+	sub, err := operatorClient.
+		OperatorsV1alpha1().
+		Subscriptions(namespace).
+		Update(ctx, subscription, metav1.UpdateOptions{})
+	if err != nil {
+		return sub, err
+	}
+	return sub, nil
+}
+
 // CreateSubscriptionForCatalog creates an OLM subscription.
 func (c *Client) CreateSubscriptionForCatalog(ctx context.Context, namespace, name, catalogNamespace, catalog,
 	packageName, channel, startingCSV string, approval v1alpha1.Approval,

pkg/kubernetes/kubernetes.go

@@ -26,7 +26,6 @@ import (
 	"io/fs"
 	"log"
 	"net/http"
-	"os"
 	"strings"
 	"time"
 
@@ -87,7 +86,6 @@ const (
 	databaseClusterAPIVersion    = "everest.percona.com/v1alpha1"
 	restartAnnotationKey         = "everest.percona.com/restart"
 	managedByKey                 = "everest.percona.com/managed-by"
-	disableTelemetryEnvVar       = "DISABLE_TELEMETRY"
 	// ContainerStateWaiting represents a state when container requires some
 	// operations being done in order to complete start up.
 	ContainerStateWaiting ContainerState = "waiting"
@@ -629,47 +627,96 @@ type InstallOperatorRequest struct {
 	SubscriptionConfig     *olmv1alpha1.SubscriptionConfig
 }
 
+func mergeSubscriptionConfig(sub *olmv1alpha1.SubscriptionConfig, cfg *olmv1alpha1.SubscriptionConfig) *olmv1alpha1.SubscriptionConfig {
+	if sub == nil {
+		sub = &olmv1alpha1.SubscriptionConfig{Env: []corev1.EnvVar{}}
+	}
+
+	if cfg == nil {
+		return sub
+	}
+
+	for _, e := range cfg.Env {
+		found := false
+		for i, se := range sub.Env {
+			if e.Name == se.Name {
+				found = true
+				// If the environment variable is not the namespaces, just override it
+				if e.Name != EverestDBNamespacesEnvVar {
+					sub.Env[i].Value = e.Value
+					break
+				}
+
+				// Merge the namespaces
+				subNamespaces := strings.Split(se.Value, ",")
+				cfgNamespaces := strings.Split(e.Value, ",")
+				namespacesMap := map[string]struct{}{}
+				for _, ns := range subNamespaces {
+					namespacesMap[ns] = struct{}{}
+				}
+				for _, ns := range cfgNamespaces {
+					namespacesMap[ns] = struct{}{}
+				}
+				namespaces := []string{}
+				for ns := range namespacesMap {
+					namespaces = append(namespaces, ns)
+				}
+				sub.Env[i].Value = strings.Join(namespaces, ",")
+
+				break
+			}
+		}
+		if !found {
+			sub.Env = append(sub.Env, e)
+		}
+	}
+
+	return sub
+}
+
 // InstallOperator installs an operator via OLM.
 func (k *Kubernetes) InstallOperator(ctx context.Context, req InstallOperatorRequest) error { //nolint:funlen
-	disableTelemetry, ok := os.LookupEnv(disableTelemetryEnvVar)
-	if !ok || disableTelemetry != "true" {
-		disableTelemetry = "false"
-	}
-	config := &olmv1alpha1.SubscriptionConfig{Env: []corev1.EnvVar{}}
-	if req.SubscriptionConfig != nil {
-		config = req.SubscriptionConfig
+	subscription, err := k.client.GetSubscription(ctx, req.Namespace, req.Name)
+	if err != nil && !apierrors.IsNotFound(err) {
+		return errors.Join(err, errors.New("cannot get subscription"))
 	}
-	config.Env = append(config.Env, corev1.EnvVar{
-		Name:  disableTelemetryEnvVar,
-		Value: disableTelemetry,
-	})
-	subscription := &olmv1alpha1.Subscription{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       olmv1alpha1.SubscriptionKind,
-			APIVersion: olmv1alpha1.SubscriptionCRDAPIVersion,
-		},
-		ObjectMeta: metav1.ObjectMeta{
-			Namespace: req.Namespace,
-			Name:      req.Name,
-		},
-		Spec: &olmv1alpha1.SubscriptionSpec{
-			CatalogSource:          req.CatalogSource,
-			CatalogSourceNamespace: req.CatalogSourceNamespace,
-			Package:                req.Name,
-			Channel:                req.Channel,
-			StartingCSV:            req.StartingCSV,
-			InstallPlanApproval:    req.InstallPlanApproval,
-			Config:                 config,
-		},
+	if apierrors.IsNotFound(err) {
+		subscription = &olmv1alpha1.Subscription{
+			TypeMeta: metav1.TypeMeta{
+				Kind:       olmv1alpha1.SubscriptionKind,
+				APIVersion: olmv1alpha1.SubscriptionCRDAPIVersion,
+			},
+			ObjectMeta: metav1.ObjectMeta{
+				Namespace: req.Namespace,
+				Name:      req.Name,
+			},
+			Spec: &olmv1alpha1.SubscriptionSpec{
+				CatalogSource:          req.CatalogSource,
+				CatalogSourceNamespace: req.CatalogSourceNamespace,
+				Package:                req.Name,
+				Channel:                req.Channel,
+				StartingCSV:            req.StartingCSV,
+				InstallPlanApproval:    req.InstallPlanApproval,
+			},
+		}
 	}
-	subs, err := k.client.CreateSubscription(ctx, req.Namespace, subscription)
-	if err != nil {
-		return errors.Join(err, errors.New("cannot create a subscription to install the operator"))
+
+	subscription.Spec.Config = mergeSubscriptionConfig(subscription.Spec.Config, req.SubscriptionConfig)
+	if apierrors.IsNotFound(err) {
+		_, err := k.client.CreateSubscription(ctx, req.Namespace, subscription)
+		if err != nil {
+			return errors.Join(err, errors.New("cannot create a subscription to install the operator"))
+		}
+	} else {
+		_, err := k.client.UpdateSubscription(ctx, req.Namespace, subscription)
+		if err != nil {
+			return errors.Join(err, errors.New("cannot update a subscription to install the operator"))
+		}
 	}
 
 	err = wait.PollUntilContextTimeout(ctx, pollInterval, pollDuration, false, func(ctx context.Context) (bool, error) {
 		k.l.Debugf("Polling subscription %s/%s", req.Namespace, req.Name)
-		subs, err = k.client.GetSubscription(ctx, req.Namespace, req.Name)
+		subs, err := k.client.GetSubscription(ctx, req.Namespace, req.Name)
 		if err != nil {
 			return false, errors.Join(err, fmt.Errorf("cannot get an install plan for the operator subscription: %q", req.Name))
 		}