operator_uninstall.go

package action

import (
	"context"
	"fmt"
	"strings"

	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/types"
	"sigs.k8s.io/controller-runtime/pkg/client"

	"github.com/operator-framework/kubectl-operator/internal/pkg/operand"
	"github.com/operator-framework/kubectl-operator/pkg/action"
)

type OperatorUninstall struct {
	config *action.Configuration

	Package                  string
	OperandStrategy          operand.DeletionStrategy
	DeleteOperatorGroups     bool
	DeleteOperatorGroupNames []string
	Logf                     func(string, ...interface{})
}

func NewOperatorUninstall(cfg *action.Configuration) *OperatorUninstall {
	return &OperatorUninstall{
		config: cfg,
		Logf:   func(string, ...interface{}) {},
	}
}

type ErrPackageNotFound struct {
	PackageName string
}

func (e ErrPackageNotFound) Error() string {
	return fmt.Sprintf("package %q not found", e.PackageName)
}

func (u *OperatorUninstall) Run(ctx context.Context) error {
	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)
	}

	var sub *v1alpha1.Subscription
	for _, s := range subs.Items {
		s := s
		if u.Package == s.Spec.Package {
			sub = &s
			break
		}
	}
	if sub == nil {
		return &ErrPackageNotFound{u.Package}
	}

	csv, csvName, err := u.getSubscriptionCSV(ctx, sub)
	if err != nil && !apierrors.IsNotFound(err) {
		if csvName == "" {
			return fmt.Errorf("get subscription CSV: %v", err)
		}
		return fmt.Errorf("get subscription CSV %q: %v", csvName, err)
	}

	// Subscriptions can be deleted asynchronously.
	if err := u.deleteObjects(ctx, sub); err != nil {
		return err
	}

	// If we could not find a csv associated with the subscription, that likely
	// means there is no CSV associated with it yet. Return a nil error.
	if csv == nil {
		u.Logf("csv for package %q not found", u.Package)
		return nil
	}

	// Deletion order:
	//
	// 1. Subscription to prevent further installs or upgrades of the operator while cleaning up.
	// 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.

	// create lister and list operands
	lister := action.NewOperatorListOperands(u.config)
	operands, err := lister.Run(ctx, u.Package)
	if err != nil {
		return fmt.Errorf("listing operands associated with operator %s: %s", u.Package, err)
	}

	switch u.OperandStrategy.Kind {
	case operand.Cancel:
		if len(operands.Items) > 0 {
			return fmt.Errorf("%d operands exist and operand strategy %q is in use; "+
				"delete operands or re-run with a different operand strategy", len(operands.Items), operand.Cancel)
		}
	case operand.Ignore:
		for _, op := range operands.Items {
			u.Logf("%s %q orphaned", strings.ToLower(op.GetKind()), op.GetName()+"/"+op.GetNamespace())
		}
	case operand.Delete:
		for _, op := range operands.Items {
			op := op
			if err := u.deleteObjects(ctx, &op); err != nil {
				return err
			}
			u.Logf("%s %q deleted", strings.ToLower(op.GetKind()), op.GetName()+"/"+op.GetNamespace())
		}
	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
	}

	// If there are no subscriptions left, delete the operator group(s).
	if len(subs.Items) == 0 {
		ogs := v1.OperatorGroupList{}
		if err := u.config.Client.List(ctx, &ogs, client.InNamespace(u.config.Namespace)); err != nil {
			return fmt.Errorf("list operatorgroups: %v", err)
		}
		for _, og := range ogs.Items {
			og := og
			if len(u.DeleteOperatorGroupNames) == 0 || contains(u.DeleteOperatorGroupNames, og.GetName()) {
				if err := u.deleteObjects(ctx, &og); err != nil {
					return err
				}
			}
		}
	}

	return nil
}

func (u *OperatorUninstall) deleteObjects(ctx context.Context, objs ...client.Object) error {
	for _, obj := range objs {
		obj := obj
		lowerKind := strings.ToLower(obj.GetObjectKind().GroupVersionKind().Kind)
		if err := u.config.Client.Delete(ctx, obj); err != nil && !apierrors.IsNotFound(err) {
			return fmt.Errorf("delete %s %q: %v", lowerKind, obj.GetName(), err)
		} else if err == nil {
			u.Logf("%s %q deleted", lowerKind, obj.GetName())
		}
	}
	return waitForDeletion(ctx, u.config.Client, objs...)
}

// getSubscriptionCSV looks up the installed CSV name from the provided subscription and fetches it.
func (u *OperatorUninstall) getSubscriptionCSV(ctx context.Context, subscription *v1alpha1.Subscription) (*v1alpha1.ClusterServiceVersion, string, error) {
	name := csvNameFromSubscription(subscription)

	// If we could not find a name in the subscription, that likely
	// means there is no CSV associated with it yet. This should
	// not be treated as an error, so return a nil CSV with a nil error.
	if name == "" {
		return nil, "", nil
	}

	key := types.NamespacedName{
		Name:      name,
		Namespace: subscription.GetNamespace(),
	}

	csv := &v1alpha1.ClusterServiceVersion{}
	if err := u.config.Client.Get(ctx, key, csv); err != nil {
		return nil, name, err
	}
	csv.SetGroupVersionKind(v1alpha1.SchemeGroupVersion.WithKind(csvKind))
	return csv, name, nil
}

func csvNameFromSubscription(subscription *v1alpha1.Subscription) string {
	if subscription.Status.InstalledCSV != "" {
		return subscription.Status.InstalledCSV
	}
	return subscription.Status.CurrentCSV
}

func contains(haystack []string, needle string) bool {
	for _, n := range haystack {
		if n == needle {
			return true
		}
	}
	return false
}