Add command to update olmv1 operator

Signed-off-by: Artur Zych <[email protected]>

Author: azych

internal/cmd/internal/olmv1/operator_update.go

@@ -0,0 +1,40 @@
+package olmv1
+
+import (
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+
+	"github.com/operator-framework/kubectl-operator/internal/cmd/internal/log"
+	v1action "github.com/operator-framework/kubectl-operator/internal/pkg/v1/action"
+	"github.com/operator-framework/kubectl-operator/pkg/action"
+)
+
+// NewOperatorUpdateCmd allows updating a selected operator
+func NewOperatorUpdateCmd(cfg *action.Configuration) *cobra.Command {
+	i := v1action.NewOperatorUpdate(cfg)
+	i.Logf = log.Printf
+
+	cmd := &cobra.Command{
+		Use:   "operator <operator>",
+		Short: "Update an operator",
+		Args:  cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			i.Package = args[0]
+			_, err := i.Run(cmd.Context())
+			if err != nil {
+				log.Fatalf("failed to update operator: %v", err)
+			}
+			log.Printf("operator %q updated", i.Package)
+		},
+	}
+	bindOperatorUpdateFlags(cmd.Flags(), i)
+
+	return cmd
+}
+
+func bindOperatorUpdateFlags(fs *pflag.FlagSet, i *v1action.OperatorUpdate) {
+	fs.StringVar(&i.Version, "version", "", "desired operator version (single or range) in semver format. AND operation with channels")
+	fs.StringArrayVar(&i.Channels, "channels", []string{}, "desired channels for operator versions. AND operation with version")
+	fs.StringVar(&i.UpgradeConstraintPolicy, "upgrade-constraint-policy", "", "controls whether the upgrade path(s) defined in the catalog are enforced, one of CatalogProvided|SelfCertified), Default: CatalogProvided")
+	fs.BoolVar(&i.OverrideUnset, "override-unset-with-current", false, "when enabled, any unset flag value will be overridden with value already set in current operator")
+}

internal/cmd/olmv1.go

@@ -38,12 +38,22 @@ func newOlmV1Cmd(cfg *action.Configuration) *cobra.Command {
 	}
 	deleteCmd.AddCommand(olmv1.NewCatalogDeleteCmd(cfg))
 
+	updateCmd := &cobra.Command{
+		Use:   "update",
+		Short: "Update a resource",
+		Long:  "Update a resource",
+	}
+	updateCmd.AddCommand(
+		olmv1.NewOperatorUpdateCmd(cfg),
+	)
+
 	cmd.AddCommand(
 		olmv1.NewOperatorInstallCmd(cfg),
 		olmv1.NewOperatorUninstallCmd(cfg),
 		getCmd,
 		createCmd,
 		deleteCmd,
+		updateCmd,
 	)
 
 	return cmd

internal/pkg/v1/action/errors.go

@@ -5,4 +5,5 @@ import "errors"
 var (
 	errNoResourcesFound = errors.New("no resources found")
 	errNameAndSelector  = errors.New("name cannot be provided when a selector is specified")
+	errNoChange         = errors.New("no changes detected - operator already in desired state")
 )

internal/pkg/v1/action/helpers.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"slices"
+	"strings"
 	"time"
 
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
@@ -13,6 +14,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	olmv1catalogd "github.com/operator-framework/catalogd/api/v1"
+	olmv1 "github.com/operator-framework/operator-controller/api/v1"
 )
 
 const pollInterval = 250 * time.Millisecond
@@ -46,20 +48,26 @@ func waitUntilCatalogStatusCondition(
 	})
 }
 
-func waitForDeletion(ctx context.Context, cl client.Client, obj client.Object) error {
-	key := objectKeyForObject(obj)
-	if err := wait.PollUntilContextCancel(ctx, pollInterval, true, func(conditionCtx context.Context) (bool, error) {
-		if err := cl.Get(conditionCtx, key, obj); apierrors.IsNotFound(err) {
-			return true, nil
-		} else if err != nil {
+func waitUntilOperatorStatusCondition(
+	ctx context.Context,
+	cl getter,
+	operator *olmv1.ClusterExtension,
+	conditionType string,
+	conditionStatus metav1.ConditionStatus,
+) error {
+	opKey := objectKeyForObject(operator)
+	return wait.PollUntilContextCancel(ctx, pollInterval, true, func(conditionCtx context.Context) (bool, error) {
+		if err := cl.Get(conditionCtx, opKey, operator); err != nil {
 			return false, err
 		}
-		return false, nil
-	}); err != nil {
-		return fmt.Errorf("waiting for deletion: %w", err)
-	}
 
-	return nil
+		if slices.ContainsFunc(operator.Status.Conditions, func(cond metav1.Condition) bool {
+			return cond.Type == conditionType && cond.Status == conditionStatus
+		}) {
+			return true, nil
+		}
+		return false, nil
+	})
 }
 
 func deleteWithTimeout(cl deleter, obj client.Object, timeout time.Duration) error {
@@ -72,3 +80,22 @@ func deleteWithTimeout(cl deleter, obj client.Object, timeout time.Duration) err
 
 	return nil
 }
+
+func waitForDeletion(ctx context.Context, cl client.Client, objs ...client.Object) error {
+	for _, obj := range objs {
+		obj := obj
+		lowerKind := strings.ToLower(obj.GetObjectKind().GroupVersionKind().Kind)
+		key := objectKeyForObject(obj)
+		if err := wait.PollUntilContextCancel(ctx, pollInterval, true, func(conditionCtx context.Context) (bool, error) {
+			if err := cl.Get(conditionCtx, key, obj); apierrors.IsNotFound(err) {
+				return true, nil
+			} else if err != nil {
+				return false, err
+			}
+			return false, nil
+		}); err != nil {
+			return fmt.Errorf("wait for %s %q deleted: %v", lowerKind, key.Name, err)
+		}
+	}
+	return nil
+}

internal/pkg/v1/action/operator_update.go

@@ -0,0 +1,106 @@
+package action
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"time"
+
+	"github.com/blang/semver/v4"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+
+	olmv1 "github.com/operator-framework/operator-controller/api/v1"
+
+	"github.com/operator-framework/kubectl-operator/pkg/action"
+)
+
+type OperatorUpdate struct {
+	config *action.Configuration
+
+	Package string
+
+	Version                 string
+	Channels                []string
+	UpgradeConstraintPolicy string
+	OverrideUnset           bool
+
+	CleanupTimeout time.Duration
+
+	Logf func(string, ...interface{})
+}
+
+func NewOperatorUpdate(cfg *action.Configuration) *OperatorUpdate {
+	return &OperatorUpdate{
+		config: cfg,
+		Logf:   func(string, ...interface{}) {},
+	}
+}
+
+func (ou *OperatorUpdate) Run(ctx context.Context) (*olmv1.ClusterExtension, error) {
+	var ext olmv1.ClusterExtension
+
+	opKey := types.NamespacedName{Name: ou.Package}
+	if err := ou.config.Client.Get(ctx, opKey, &ext); err != nil {
+		return nil, err
+	}
+
+	if ext.Spec.Source.SourceType != olmv1.SourceTypeCatalog {
+		return nil, fmt.Errorf("unrecognized source type: %q", ext.Spec.Source.SourceType)
+	}
+
+	ou.setDefaults(ext.Spec.Source.Catalog)
+	constraintPolicy := olmv1.UpgradeConstraintPolicy(ou.UpgradeConstraintPolicy)
+	if !ou.needsUpdate(ext.Spec.Source.Catalog, constraintPolicy) {
+		return nil, errNoChange
+	}
+
+	if ou.Version != "" {
+		if _, err := semver.ParseRange(ou.Version); err != nil {
+			return nil, fmt.Errorf("failed parsing version: %w", err)
+		}
+	}
+
+	ext.Spec.Source.Catalog.Version = ou.Version
+	ext.Spec.Source.Catalog.Channels = ou.Channels
+	ext.Spec.Source.Catalog.UpgradeConstraintPolicy = constraintPolicy
+	if err := ou.config.Client.Update(ctx, &ext); err != nil {
+		return nil, err
+	}
+
+	if err := waitUntilOperatorStatusCondition(ctx, ou.config.Client, &ext, olmv1.TypeInstalled, metav1.ConditionTrue); err != nil {
+		return nil, fmt.Errorf("timed out waiting for operator: %w", err)
+	}
+
+	return &ext, nil
+}
+
+func (ou *OperatorUpdate) setDefaults(catalogSrc *olmv1.CatalogSource) {
+	if ou.OverrideUnset {
+		if ou.Version == "" {
+			ou.Version = catalogSrc.Version
+		}
+		if len(ou.Channels) == 0 {
+			ou.Channels = catalogSrc.Channels
+		}
+		if ou.UpgradeConstraintPolicy == "" {
+			ou.UpgradeConstraintPolicy = string(catalogSrc.UpgradeConstraintPolicy)
+		}
+
+		return
+	}
+
+	if ou.UpgradeConstraintPolicy == "" {
+		ou.UpgradeConstraintPolicy = string(olmv1.UpgradeConstraintPolicyCatalogProvided)
+	}
+}
+
+func (ou *OperatorUpdate) needsUpdate(catalogSrc *olmv1.CatalogSource, constraintPolicy olmv1.UpgradeConstraintPolicy) bool {
+	if catalogSrc.Version == ou.Version &&
+		slices.Equal(catalogSrc.Channels, ou.Channels) &&
+		catalogSrc.UpgradeConstraintPolicy == constraintPolicy {
+		return false
+	}
+
+	return true
+}