(feat) block cluster upgrade when installed incompatible operators

Author: gallettilance

cmd/cluster-olm-operator/main.go

@@ -20,6 +20,7 @@ import (
 	"k8s.io/component-base/cli"
 	utilflag "k8s.io/component-base/cli/flag"
 
+	"github.com/openshift/cluster-olm-operator/internal/utils"
 	"github.com/openshift/cluster-olm-operator/pkg/clients"
 	"github.com/openshift/cluster-olm-operator/pkg/controller"
 	"github.com/openshift/cluster-olm-operator/pkg/version"
@@ -105,13 +106,28 @@ func runOperator(ctx context.Context, cc *controllercmd.ControllerContext) error
 		deploymentControllerList = append(deploymentControllerList, controller)
 	}
 
+	operatorImageVersion := status.VersionForOperatorFromEnv()
+	nextOCPMinorVersion, err := utils.GetNextOCPMinorVersion(operatorImageVersion)
+	if err != nil {
+		return err
+	}
+
 	upgradeableConditionController := controller.NewStaticUpgradeableConditionController(
 		"OLMStaticUpgradeableConditionController",
 		cl.OperatorClient,
 		cc.EventRecorder.ForComponent("OLMStaticUpgradeableConditionController"),
 		controllerNames,
 	)
 
+	incompatibleOperatorController := controller.NewIncompatibleOperatorController(
+		"OLMIncompatibleOperatorController",
+		nextOCPMinorVersion,
+		cl.KubeClient,
+		cl.ClusterExtensionClient,
+		cl.OperatorClient,
+		cc.EventRecorder.ForComponent("OLMIncompatibleOperatorController"),
+	)
+
 	versionGetter := status.NewVersionGetter()
 	versionGetter.SetVersion("operator", status.VersionForOperatorFromEnv())
 
@@ -129,7 +145,7 @@ func runOperator(ctx context.Context, cc *controllercmd.ControllerContext) error
 
 	cl.StartInformers(ctx)
 
-	for _, c := range append(staticResourceControllerList, upgradeableConditionController, clusterOperatorController, operatorLoggingController) {
+	for _, c := range append(staticResourceControllerList, upgradeableConditionController, incompatibleOperatorController, clusterOperatorController, operatorLoggingController) {
 		go func(c factory.Controller) {
 			defer runtime.HandleCrash()
 			c.Run(ctx, 1)

pkg/internal/dependencymagnet/dependencies.go renamed to internal/dependencymagnet/dependencies.go

@@ -0,0 +1,53 @@
+package utils
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	semver "github.com/blang/semver/v4"
+)
+
+func GetNextOCPMinorVersion(versionString string) (*semver.Version, error) {
+	v, err := semver.Parse(versionString)
+	if err != nil {
+		return &v, err
+	}
+	v.Build = nil                 // Builds are irrelevant
+	v.Pre = nil                   // Next Y release
+	return &v, v.IncrementMinor() // Sets Y=Y+1 and Z=0
+}
+
+func ToAllowedSemver(data []byte) (*semver.Version, error) {
+	var raw interface{}
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return nil, err
+	}
+
+	var versionStr string
+
+	switch v := raw.(type) {
+	case float64:
+		versionStr = fmt.Sprintf("%d.%d", int(v), int((v-float64(int(v)))*100)+1)
+	case string:
+		versionStr = v
+	default:
+		return nil, fmt.Errorf("invalid type %T for olm.maxOpenshiftVersion: %s", v, string(data))
+	}
+
+	if !strings.Contains(versionStr, ".") || strings.Count(versionStr, ".") != 1 {
+		return nil, fmt.Errorf("invalid version format")
+	}
+
+	if strings.HasPrefix(versionStr, "v") || strings.Count(versionStr, ".") != 1 {
+		return nil, fmt.Errorf("invalid version format")
+	}
+
+	// So it accepts only Major.Minor without Patch
+	version, err := semver.ParseTolerant(versionStr)
+	if err != nil {
+		return nil, err
+	}
+
+	return &version, nil
+}

internal/utils/utils.go

@@ -0,0 +1,62 @@
+package utils
+
+import (
+	"testing"
+
+	"github.com/blang/semver/v4"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseSemver(t *testing.T) {
+	tests := []struct {
+		name      string
+		jsonInput string
+		want      *semver.Version
+		wantErr   bool
+	}{
+		{
+			name:      "valid float version",
+			jsonInput: `4.18`,
+			want:      &semver.Version{Major: 4, Minor: 18, Patch: 0},
+			wantErr:   false,
+		},
+		{
+			name:      "valid string version",
+			jsonInput: `"4.18"`,
+			want:      &semver.Version{Major: 4, Minor: 18, Patch: 0},
+			wantErr:   false,
+		},
+		{
+			name:      "invalid float version with patch",
+			jsonInput: `4.18.0`,
+			wantErr:   true,
+		},
+		{
+			name:      "invalid string version with patch",
+			jsonInput: `"4.18.0"`,
+			wantErr:   true,
+		},
+		{
+			name:      "invalid string with v prefix",
+			jsonInput: `"v4.18"`,
+			wantErr:   true,
+		},
+		{
+			name:      "invalid string with v prefix and patch",
+			jsonInput: `"v4.18.0"`,
+			wantErr:   true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ToAllowedSemver([]byte(tt.jsonInput))
+			if tt.wantErr {
+				assert.Error(t, err, "expected an error but got none")
+			} else {
+				assert.NoError(t, err, "expected no error but got one")
+				assert.Equal(t, tt.want, got, "unexpected semver version")
+			}
+		})
+	}
+}

internal/utils/utils_test.go

@@ -72,6 +72,14 @@ rules:
       - get
       - list
       - watch
+  - apiGroups:
+      - ""
+    resources:
+      - secrets
+    verbs:
+      - get
+      - list
+      - watch
   - apiGroups:
       - ""
     resources:
@@ -210,6 +218,7 @@ rules:
     verbs:
     - get
     - list
+    - watch
   - apiGroups:
     - ""
     resources:

manifests/0000_51_olm_02_operator_clusterrole.yaml

@@ -58,7 +58,6 @@ spec:
         - /cluster-olm-operator
         args:
         - start
-        - -v=2
         imagePullPolicy: IfNotPresent
         env:
         - name: OPERATOR_NAME

manifests/0000_51_olm_06_deployment.yaml

@@ -17,6 +17,7 @@ import (
 	"github.com/openshift/library-go/pkg/controller/controllercmd"
 	"github.com/openshift/library-go/pkg/operator/resource/resourceapply"
 	"github.com/openshift/library-go/pkg/operator/v1helpers"
+	ocv1alpha1 "github.com/operator-framework/operator-controller/api/v1alpha1"
 	apiextensionsclient "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -26,6 +27,7 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/dynamic/dynamicinformer"
 	"k8s.io/client-go/informers"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
@@ -43,6 +45,7 @@ type Clients struct {
 	RESTMapper                 meta.RESTMapper
 	OperatorClient             *OperatorClient
 	OperatorInformers          operatorinformers.SharedInformerFactory
+	ClusterExtensionClient     *ClusterExtensionClient
 	ConfigClient               configclient.Interface
 	KubeInformerFactory        informers.SharedInformerFactory
 	ConfigInformerFactory      configinformer.SharedInformerFactory
@@ -91,23 +94,34 @@ func New(cc *controllercmd.ControllerContext) (*Clients, error) {
 		return nil, err
 	}
 
+	infFact := dynamicinformer.NewDynamicSharedInformerFactory(dynClient, defaultResyncPeriod)
+	clusterExtensionGVR := ocv1alpha1.GroupVersion.WithResource("clusterextensions")
+	inf := infFact.ForResource(clusterExtensionGVR)
+
+	ceClient := &ClusterExtensionClient{
+		factory:  infFact,
+		informer: inf,
+	}
+
 	return &Clients{
-		KubeClient:            kubeClient,
-		APIExtensionsClient:   apiExtensionsClient,
-		DynamicClient:         dynClient,
-		RESTMapper:            rm,
-		OperatorClient:        opClient,
-		OperatorInformers:     operatorInformersFactory,
-		ConfigClient:          configClient,
-		KubeInformerFactory:   informers.NewSharedInformerFactory(kubeClient, defaultResyncPeriod),
-		ConfigInformerFactory: configinformer.NewSharedInformerFactory(configClient, defaultResyncPeriod),
+		KubeClient:             kubeClient,
+		APIExtensionsClient:    apiExtensionsClient,
+		DynamicClient:          dynClient,
+		RESTMapper:             rm,
+		OperatorClient:         opClient,
+		OperatorInformers:      operatorInformersFactory,
+		ClusterExtensionClient: ceClient,
+		ConfigClient:           configClient,
+		KubeInformerFactory:    informers.NewSharedInformerFactory(kubeClient, defaultResyncPeriod),
+		ConfigInformerFactory:  configinformer.NewSharedInformerFactory(configClient, defaultResyncPeriod),
 	}, nil
 }
 
 func (c *Clients) StartInformers(ctx context.Context) {
 	c.KubeInformerFactory.Start(ctx.Done())
 	c.ConfigInformerFactory.Start(ctx.Done())
 	c.OperatorInformers.Start(ctx.Done())
+	c.ClusterExtensionClient.factory.Start(ctx.Done())
 	if c.KubeInformersForNamespaces != nil {
 		c.KubeInformersForNamespaces.Start(ctx.Done())
 	}
@@ -131,6 +145,15 @@ const (
 	fieldManager     = "cluster-olm-operator"
 )
 
+type ClusterExtensionClient struct {
+	factory  dynamicinformer.DynamicSharedInformerFactory
+	informer informers.GenericInformer
+}
+
+func (ce ClusterExtensionClient) Informer() informers.GenericInformer {
+	return ce.informer
+}
+
 type OperatorClient struct {
 	clientset operatorclient.Interface
 	informers operatorinformers.SharedInformerFactory