Uninstall improvements (#55)

* add options for deleting all objects, operator object, simplify operand.Strategy type

Signed-off-by: Joe Lanford <[email protected]>

* add note that dependencies are not uninstalled

Signed-off-by: Joe Lanford <[email protected]>

* uninstall: rename 'cancel' operand strategy to 'abort'

Signed-off-by: Joe Lanford <[email protected]>

Author: joelanford

internal/cmd/operator_uninstall.go

@@ -1,11 +1,14 @@
 package cmd
 
 import (
+	"errors"
+
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 
 	"github.com/operator-framework/kubectl-operator/internal/cmd/internal/log"
 	internalaction "github.com/operator-framework/kubectl-operator/internal/pkg/action"
+	"github.com/operator-framework/kubectl-operator/internal/pkg/operand"
 	"github.com/operator-framework/kubectl-operator/pkg/action"
 )
 
@@ -16,42 +19,73 @@ func newOperatorUninstallCmd(cfg *action.Configuration) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "uninstall <operator>",
 		Short: "Uninstall an operator and operands",
-		Long: `Uninstall removes the subscription, operator and optionally operands managed by the operator as well as 
-the relevant operatorgroup.
-
-Warning: this command permanently deletes objects from the cluster. Running uninstall concurrently with other operations
-could result in undefined behavior. 
-
-The uninstall command first checks to find the subscription associated with the operator. It then 
-lists all operands found throughout the cluster for the operator
-specified if one is found. Since the scope of an operator is restricted by
-its operator group, this search will include namespace-scoped operands from the
-operator group's target namespaces and all cluster-scoped operands. 
-
-The operand-deletion strategy is then considered if any operands are found on-cluster. One of cancel|ignore|delete. 
-By default, the strategy is "cancel", which means that if any operands are found when deleting the operator abort the 
-uninstall without deleting anything. 
-The "ignore" strategy keeps the operands on cluster and deletes the subscription and the operator.
-The "delete" strategy deletes the subscription, operands, and after they have finished finalizing, the operator itself.
-
-Setting --delete-operator-groups to true will delete the operatorgroup in the provided namespace if no other active 
-subscriptions are currently in that namespace, after removing the operator. The subscription and operatorgroup will be 
-removed even if the operator is not found.`,
+		Long: `Uninstall removes the subscription, operator and optionally operands managed
+by the operator as well as the relevant operatorgroup.
+
+Warning: this command permanently deletes objects from the cluster. Running
+uninstall concurrently with other operations could result in undefined behavior.
+
+The uninstall command first checks to find the subscription associated with the
+operator. It then lists all operands found throughout the cluster for the
+operator specified if one is found. Since the scope of an operator is restricted
+by its operator group, this search will include namespace-scoped operands from
+the operator group's target namespaces and all cluster-scoped operands.
+
+The operand-deletion strategy is then considered if any operands are found
+on-cluster. One of abort|ignore|delete. By default, the strategy is "abort",
+which means that if any operands are found when deleting the operator abort the
+uninstall without deleting anything. The "ignore" strategy keeps the operands on
+cluster and deletes the subscription and the operator. The "delete" strategy
+deletes the subscription, operands, and after they have finished finalizing, the
+operator itself.
+
+Setting --delete-operator-groups to true will delete the operatorgroup in the
+provided namespace if no other active subscriptions are currently in that
+namespace, after removing the operator. The subscription and operatorgroup will
+be removed even if the operator is not found.
+
+There are other deletion flags for removing additional objects, such as custom
+resource definitions, operator objects, and any other objects deployed alongside
+the operator (e.g. RBAC objects for the operator). These flags are:
+
+  --delete-operator
+
+      Deletes all objects associated with the operator by looking up the
+      operator object for the operator and deleting every referenced object
+      and then deleting the operator object itself. This implies the flag
+      '--operand-strategy=delete' because it is impossible to delete CRDs
+      without also deleting instances of those CRDs.
+
+  -X, --delete-all
+
+      This is a convenience flag that is effectively equivalent to the flags
+      '--delete-operator=true --delete-operator-groups=true'.
+
+NOTE: This command does not recursively uninstall unused dependencies. To return
+a cluster to its state prior to a 'kubectl operator install' call, each
+dependency of the operator that was installed automatically by OLM must be
+individually uninstalled.
+`,
 		Args: cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			u.Package = args[0]
 			if err := u.Run(cmd.Context()); err != nil {
+				if errors.Is(err, operand.ErrAbortStrategy) {
+					log.Fatalf("uninstall operator: %v"+"\n\n%s", err,
+						"See kubectl operator uninstall --help for more information on operand deletion strategies.")
+				}
 				log.Fatalf("uninstall operator: %v", err)
 			}
-			log.Printf("operator %q uninstalled", u.Package)
 		},
 	}
 	bindOperatorUninstallFlags(cmd.Flags(), u)
 	return cmd
 }
 
 func bindOperatorUninstallFlags(fs *pflag.FlagSet, u *internalaction.OperatorUninstall) {
+	fs.BoolVarP(&u.DeleteAll, "delete-all", "X", false, "delete all objects associated with the operator, implies --delete-operator, --operand-strategy=delete, --delete-operator-groups")
+	fs.BoolVar(&u.DeleteOperator, "delete-operator", false, "delete operator object associated with the operator, --operand-strategy=delete")
 	fs.BoolVar(&u.DeleteOperatorGroups, "delete-operator-groups", false, "delete operator groups if no other operators remain")
 	fs.StringSliceVar(&u.DeleteOperatorGroupNames, "delete-operator-group-names", nil, "specific operator group names to delete (only effective with --delete-operator-groups)")
-	fs.VarP(&u.OperandStrategy, "operand-strategy", "s", "determines how to handle operands when deleting the operator, one of cancel|ignore|delete")
+	fs.VarP(&u.OperandStrategy, "operand-strategy", "s", "determines how to handle operands when deleting the operator, one of abort|ignore|delete (default: abort)")
 }

internal/pkg/action/operator_uninstall.go

@@ -4,12 +4,14 @@ import (
 	"context"
 	"fmt"
 	"strings"
+	"time"
 
 	v1 "github.com/operator-framework/api/pkg/operators/v1"
 	"github.com/operator-framework/api/pkg/operators/v1alpha1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	"github.com/operator-framework/kubectl-operator/internal/pkg/operand"
@@ -21,15 +23,18 @@ type OperatorUninstall struct {
 
 	Package                  string
 	OperandStrategy          operand.DeletionStrategy
+	DeleteAll                bool
+	DeleteOperator           bool
 	DeleteOperatorGroups     bool
 	DeleteOperatorGroupNames []string
 	Logf                     func(string, ...interface{})
 }
 
 func NewOperatorUninstall(cfg *action.Configuration) *OperatorUninstall {
 	return &OperatorUninstall{
-		config: cfg,
-		Logf:   func(string, ...interface{}) {},
+		config:          cfg,
+		OperandStrategy: operand.Abort,
+		Logf:            func(string, ...interface{}) {},
 	}
 }
 
@@ -42,6 +47,18 @@ func (e ErrPackageNotFound) Error() string {
 }
 
 func (u *OperatorUninstall) Run(ctx context.Context) error {
+	if u.DeleteAll {
+		u.DeleteOperator = true
+		u.DeleteOperatorGroups = true
+	}
+	if u.DeleteOperator {
+		u.OperandStrategy = operand.Delete
+	}
+
+	if err := u.OperandStrategy.Valid(); err != nil {
+		return err
+	}
+
 	subs := v1alpha1.SubscriptionList{}
 	if err := u.config.Client.List(ctx, &subs, client.InNamespace(u.config.Namespace)); err != nil {
 		return fmt.Errorf("list subscriptions: %v", err)
@@ -75,20 +92,23 @@ func (u *OperatorUninstall) Run(ctx context.Context) error {
 	}
 	// validate the provided deletion strategy before proceeding to deletion
 	if err := u.validStrategy(operands); err != nil {
-		return fmt.Errorf("could not proceed with deletion of %q: %s", u.Package, err)
+		return fmt.Errorf("could not proceed with deletion of %q: %w", u.Package, err)
 	}
 
 	/*
 		Deletion order:
-		1. Subscription to prevent further installs or upgrades of the operator while cleaning up.
-
-		If the CSV exists:
-		  2. Operands so the operator has a chance to handle CRs that have finalizers.
-		  Note: the correct strategy must be chosen in order to process an opertor delete with operand on-cluster.
-		  3. ClusterServiceVersion. OLM puts an ownerref on every namespaced resource to the CSV,
-		   and an owner label on every cluster scoped resource so they get gc'd on deletion.
-
-		4. OperatorGroup in the namespace if no other subscriptions are in that namespace and OperatorGroup deletion is specified
+			1. Subscription to prevent further installs or upgrades of the operator while cleaning up.
+
+			If the CSV exists:
+				2. Operands so the operator has a chance to handle CRs that have finalizers.
+				   Note: the correct strategy must be chosen in order to process an opertor delete with operand
+				   on-cluster.
+				3. ClusterServiceVersion. OLM puts an ownerref on every namespaced resource to the CSV,
+				   and an owner label on every cluster scoped resource so they get gc'd on deletion.
+
+			4. The Operator and all objects referenced by it if Operator deletion is specified
+			5. OperatorGroup in the namespace if no other subscriptions are in that namespace and OperatorGroup deletion
+			   is specified
 	*/
 
 	// Subscriptions can be deleted asynchronously.
@@ -106,6 +126,12 @@ func (u *OperatorUninstall) Run(ctx context.Context) error {
 		}
 	}
 
+	if u.DeleteOperator {
+		if err := u.deleteOperator(ctx); err != nil {
+			return fmt.Errorf("delete operator: %v", err)
+		}
+	}
+
 	if u.DeleteOperatorGroups {
 		if err := u.deleteOperatorGroup(ctx); err != nil {
 			return fmt.Errorf("delete operatorgroup: %v", err)
@@ -115,6 +141,10 @@ func (u *OperatorUninstall) Run(ctx context.Context) error {
 	return nil
 }
 
+func (u *OperatorUninstall) operatorName() string {
+	return fmt.Sprintf("%s.%s", u.Package, u.config.Namespace)
+}
+
 func (u *OperatorUninstall) deleteObjects(ctx context.Context, objs ...client.Object) error {
 	for _, obj := range objs {
 		obj := obj
@@ -152,6 +182,64 @@ func (u *OperatorUninstall) getSubscriptionCSV(ctx context.Context, subscription
 	return csv, name, nil
 }
 
+// deleteOperator deletes the operator and everything it references. It:
+//   - gets the operator object so that we can look up its references
+//   - deletes the references
+//   - waits until the operator object references are all deleted (this step is
+//     necessary because OLM recreates the operator object until no other
+//     referenced objects exist)
+//   - deletes the operator
+func (u *OperatorUninstall) deleteOperator(ctx context.Context) error {
+	// get the operator
+	var op v1.Operator
+	key := types.NamespacedName{Name: u.operatorName()}
+	if err := u.config.Client.Get(ctx, key, &op); err != nil {
+		if apierrors.IsNotFound(err) {
+			return nil
+		}
+		return fmt.Errorf("get operator: %w", err)
+	}
+
+	// build objects for each of the references and then delete them
+	objs := []client.Object{}
+	for _, ref := range op.Status.Components.Refs {
+		obj := unstructured.Unstructured{}
+		obj.SetName(ref.Name)
+		obj.SetNamespace(ref.Namespace)
+		obj.SetGroupVersionKind(ref.GroupVersionKind())
+		objs = append(objs, &obj)
+	}
+	if err := u.deleteObjects(ctx, objs...); err != nil {
+		return fmt.Errorf("delete operator references: %v", err)
+	}
+
+	// wait until all of the objects we just deleted disappear from the
+	// operator's references.
+	if err := wait.PollImmediateUntil(time.Millisecond*100, func() (bool, error) {
+		var check v1.Operator
+		if err := u.config.Client.Get(ctx, key, &check); err != nil {
+			if apierrors.IsNotFound(err) {
+				return true, nil
+			}
+			return false, fmt.Errorf("get operator: %w", err)
+		}
+		if check.Status.Components == nil || len(check.Status.Components.Refs) == 0 {
+			return true, nil
+		}
+		return false, nil
+	}, ctx.Done()); err != nil {
+		return err
+	}
+
+	// delete the operator
+	op.SetGroupVersionKind(v1.GroupVersion.WithKind("Operator"))
+	if err := u.deleteObjects(ctx, &op); err != nil {
+		return fmt.Errorf("delete operator: %v", err)
+	}
+
+	return nil
+}
+
 func (u *OperatorUninstall) deleteOperatorGroup(ctx context.Context) error {
 	subs := v1alpha1.SubscriptionList{}
 	if err := u.config.Client.List(ctx, &subs, client.InNamespace(u.config.Namespace)); err != nil {
@@ -177,18 +265,15 @@ func (u *OperatorUninstall) deleteOperatorGroup(ctx context.Context) error {
 }
 
 // validStrategy validates the deletion strategy against the operands on-cluster
-// TODO define and use an OperandStrategyError that the cmd can use errors.As() on to provide external callers a more generic error
 func (u *OperatorUninstall) validStrategy(operands *unstructured.UnstructuredList) error {
-	if len(operands.Items) > 0 && u.OperandStrategy.Kind == operand.Cancel {
-		return fmt.Errorf("%d operands exist and operand strategy %q is in use: "+
-			"delete operands manually or re-run uninstall with a different operand deletion strategy."+
-			"\n\nSee kubectl operator uninstall --help for more information on operand deletion strategies.", len(operands.Items), operand.Cancel)
+	if len(operands.Items) > 0 && u.OperandStrategy == operand.Abort {
+		return operand.ErrAbortStrategy
 	}
 	return nil
 }
 
 func (u *OperatorUninstall) deleteCSVRelatedResources(ctx context.Context, csv *v1alpha1.ClusterServiceVersion, operands *unstructured.UnstructuredList) error {
-	switch u.OperandStrategy.Kind {
+	switch u.OperandStrategy {
 	case operand.Ignore:
 		for _, op := range operands.Items {
 			u.Logf("%s %q orphaned", strings.ToLower(op.GetKind()), prettyPrint(op))
@@ -197,18 +282,16 @@ func (u *OperatorUninstall) deleteCSVRelatedResources(ctx context.Context, csv *
 		for _, op := range operands.Items {
 			op := op
 			if err := u.deleteObjects(ctx, &op); err != nil {
-				return err
+				return fmt.Errorf("delete operand: %v", err)
 			}
 		}
-	default:
-		return fmt.Errorf("unknown operand deletion strategy %q", u.OperandStrategy)
 	}
 
 	// OLM puts an ownerref on every namespaced resource to the CSV,
 	// and an owner label on every cluster scoped resource. When CSV is deleted
 	// kube and olm gc will remove all the referenced resources.
 	if err := u.deleteObjects(ctx, csv); err != nil {
-		return err
+		return fmt.Errorf("delete csv: %v", err)
 	}
 
 	return nil

internal/pkg/action/operator_uninstall_test.go

@@ -162,6 +162,7 @@ var _ = Describe("OperatorUninstall", func() {
 
 		uninstaller := internalaction.NewOperatorUninstall(&cfg)
 		uninstaller.Package = etcd
+		uninstaller.OperandStrategy = operand.Ignore
 		err := uninstaller.Run(context.TODO())
 		Expect(err).To(BeNil())
 
@@ -173,23 +174,23 @@ var _ = Describe("OperatorUninstall", func() {
 	It("should fail due to invalid operand deletion strategy", func() {
 		uninstaller := internalaction.NewOperatorUninstall(&cfg)
 		uninstaller.Package = etcd
-		uninstaller.OperandStrategy.Kind = "foo"
+		uninstaller.OperandStrategy = "foo"
 		err := uninstaller.Run(context.TODO())
 		Expect(err.Error()).To(ContainSubstring("unknown operand deletion strategy"))
 	})
 
-	It("should error with operands on cluster when default cancel strategy is set", func() {
+	It("should error with operands on cluster when default abort strategy is set", func() {
 		uninstaller := internalaction.NewOperatorUninstall(&cfg)
 		uninstaller.Package = etcd
-		uninstaller.OperandStrategy.Kind = operand.Cancel
+		uninstaller.OperandStrategy = operand.Abort
 		err := uninstaller.Run(context.TODO())
-		Expect(err.Error()).To(ContainSubstring("delete operands manually or re-run uninstall with a different operand deletion strategy"))
+		Expect(err).To(MatchError(operand.ErrAbortStrategy))
 	})
 
 	It("should ignore operands and delete sub and csv when ignore strategy is set", func() {
 		uninstaller := internalaction.NewOperatorUninstall(&cfg)
 		uninstaller.Package = etcd
-		uninstaller.OperandStrategy.Kind = operand.Ignore
+		uninstaller.OperandStrategy = operand.Ignore
 		err := uninstaller.Run(context.TODO())
 		Expect(err).To(BeNil())
 
@@ -215,7 +216,7 @@ var _ = Describe("OperatorUninstall", func() {
 	It("should delete sub, csv, and operands when delete strategy is set", func() {
 		uninstaller := internalaction.NewOperatorUninstall(&cfg)
 		uninstaller.Package = etcd
-		uninstaller.OperandStrategy.Kind = operand.Delete
+		uninstaller.OperandStrategy = operand.Delete
 		err := uninstaller.Run(context.TODO())
 		Expect(err).To(BeNil())
 
@@ -239,6 +240,7 @@ var _ = Describe("OperatorUninstall", func() {
 	It("should delete sub and operatorgroup when no CSV is found", func() {
 		uninstaller := internalaction.NewOperatorUninstall(&cfg)
 		uninstaller.Package = etcd
+		uninstaller.OperandStrategy = operand.Ignore
 		uninstaller.DeleteOperatorGroups = true
 
 		sub.Status.InstalledCSV = "foo" // returns nil CSV