Code for extension install and delete

Signed-off-by: Lalatendu Mohanty <[email protected]>

Author: LalatenduMohanty

internal/cmd/internal/olmv1/extension_delete_cmd.go

@@ -0,0 +1,37 @@
+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"
+)
+
+func NewExtensionDeleteCmd(cfg *action.Configuration) *cobra.Command {
+	e := v1action.NewExtensionDelete(cfg)
+	e.Logf = log.Printf
+
+	cmd := &cobra.Command{
+		Use:   "extension <extension-name>",
+		Short: "Delete an extension",
+		Long: `Warning: Permanently deletes the named cluster extension object.
+		If the extension contains CRDs, the CRDs will be deleted, which
+		 cascades to the deletion of all operands.`,
+		Args: cobra.ExactArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			e.ExtensionName = args[0]
+			if err := e.Run(cmd.Context()); err != nil {
+				log.Fatalf("delete extension: %v", err)
+			}
+			log.Printf("deleted extension %q", e.ExtensionName)
+		},
+	}
+	bindExtensionDeleteFlags(cmd.Flags(), e)
+	return cmd
+}
+
+func bindExtensionDeleteFlags(fs *pflag.FlagSet, e *v1action.ExtensionDeletion) {
+	fs.BoolVarP(&e.DeleteAll, "all", "a", false, "delete all extensions")
+}

internal/cmd/internal/olmv1/extension_install.go

@@ -1,7 +1,10 @@
 package olmv1
 
 import (
+	"time"
+
 	"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"
@@ -13,18 +16,31 @@ func NewExtensionInstallCmd(cfg *action.Configuration) *cobra.Command {
 	i.Logf = log.Printf
 
 	cmd := &cobra.Command{
-		Use:   "install <extension>",
+		Use:   "extension <extension_name>",
 		Short: "Install an extension",
 		Args:  cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
-			i.Package = args[0]
+			i.ExtensionName = args[0]
 			_, err := i.Run(cmd.Context())
 			if err != nil {
 				log.Fatalf("failed to install extension: %v", err)
 			}
-			log.Printf("extension %q created", i.Package)
+			log.Printf("extension %q created", i.ExtensionName)
 		},
 	}
+	bindOperatorInstallFlags(cmd.Flags(), i)
 
 	return cmd
 }
+
+func bindOperatorInstallFlags(fs *pflag.FlagSet, i *v1action.ExtensionInstall) {
+	fs.StringVarP(&i.Namespace.Name, "namespace", "n", "", "namespace to install the operator in")
+	fs.ArgsLenAtDash()
+	fs.StringVarP(&i.PackageName, "package-name", "p", "", "package name of the operator to install")
+	fs.StringSliceVarP(&i.Channels, "channels", "c", []string{}, "channels which would be to used for getting updates")
+	fs.StringVarP(&i.Version, "version", "v", "", "version (or version range) from which to resolve bundles")
+	fs.StringVarP(&i.ServiceAccount, "service-account", "s", "default", "service account name to use for the extension installation")
+	fs.StringToStringVarP(&i.CatalogSelector.MatchLabels, "labels", "l", map[string]string{}, "labels that will be used to select catalog")
+	fs.BoolVarP(&i.UnsafeCreateClusterRoleBinding, "unsafe-create-cluster-role-binding", "u", false, "create a cluster role binding for the operator's service account")
+	fs.DurationVarP(&i.CleanupTimeout, "cleanup-timeout", "d", time.Minute, "the amount of time to wait before cancelling cleanup after a failed creation attempt")
+}

internal/cmd/internal/olmv1/extension_uninstall.go

@@ -36,7 +36,10 @@ func newOlmV1Cmd(cfg *action.Configuration) *cobra.Command {
 		Short: "Delete a resource",
 		Long:  "Delete a resource",
 	}
-	deleteCmd.AddCommand(olmv1.NewCatalogDeleteCmd(cfg))
+	deleteCmd.AddCommand(
+		olmv1.NewCatalogDeleteCmd(cfg),
+		olmv1.NewExtensionDeleteCmd(cfg),
+	)
 
 	updateCmd := &cobra.Command{
 		Use:   "update",
@@ -47,9 +50,15 @@ func newOlmV1Cmd(cfg *action.Configuration) *cobra.Command {
 		olmv1.NewExtensionUpdateCmd(cfg),
 	)
 
+	installCmd := &cobra.Command{
+		Use:   "install",
+		Short: "Install a resource",
+		Long:  "Install a resource",
+	}
+	installCmd.AddCommand(olmv1.NewExtensionInstallCmd(cfg))
+
 	cmd.AddCommand(
-		olmv1.NewExtensionInstallCmd(cfg),
-		olmv1.NewExtensionUninstallCmd(cfg),
+		installCmd,
 		getCmd,
 		createCmd,
 		deleteCmd,

internal/cmd/olmv1.go

@@ -13,28 +13,27 @@ import (
 	"github.com/operator-framework/kubectl-operator/pkg/action"
 )
 
-type ExtensionUninstall struct {
-	config *action.Configuration
-
-	Package string
-
-	Logf func(string, ...interface{})
+type ExtensionDeletion struct {
+	config        *action.Configuration
+	ExtensionName string
+	DeleteAll     bool
+	Logf          func(string, ...interface{})
 }
 
-func NewExtensionUninstall(cfg *action.Configuration) *ExtensionUninstall {
-	return &ExtensionUninstall{
+func NewExtensionDelete(cfg *action.Configuration) *ExtensionDeletion {
+	return &ExtensionDeletion{
 		config: cfg,
 		Logf:   func(string, ...interface{}) {},
 	}
 }
 
-func (u *ExtensionUninstall) Run(ctx context.Context) error {
-	opKey := types.NamespacedName{Name: u.Package}
+func (u *ExtensionDeletion) Run(ctx context.Context) error {
+	opKey := types.NamespacedName{Name: u.ExtensionName}
 	op := &olmv1.ClusterExtension{}
 	op.SetName(opKey.Name)
-	op.SetGroupVersionKind(olmv1.GroupVersion.WithKind("Extension"))
-
+	op.SetGroupVersionKind(olmv1.GroupVersion.WithKind("ClusterExtension"))
 	lowerKind := strings.ToLower(op.GetObjectKind().GroupVersionKind().Kind)
+	//Lala:Fixme: return error if extension does not exist
 	if err := u.config.Client.Delete(ctx, op); err != nil && !apierrors.IsNotFound(err) {
 		return fmt.Errorf("delete %s %q: %v", lowerKind, op.GetName(), err)
 	}

internal/pkg/v1/action/extension_uninstall.go renamed to internal/pkg/v1/action/extension_delete.go

@@ -2,24 +2,39 @@ package action
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"time"
 
+	"github.com/operator-framework/kubectl-operator/pkg/action"
+	ocv1 "github.com/operator-framework/operator-controller/api/v1"
+	olmv1 "github.com/operator-framework/operator-controller/api/v1"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/wait"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 
-	olmv1 "github.com/operator-framework/operator-controller/api/v1"
-
-	"github.com/operator-framework/kubectl-operator/pkg/action"
+	corev1 "k8s.io/api/core/v1"
+	rbacv1 "k8s.io/api/rbac/v1"
 )
 
 type ExtensionInstall struct {
-	config *action.Configuration
-
-	Package string
-
-	Logf func(string, ...interface{})
+	config                         *action.Configuration
+	ExtensionName                  string
+	Namespace                      NamespaceConfig
+	PackageName                    string
+	Channels                       []string
+	Version                        string
+	ServiceAccount                 string
+	CatalogSelector                metav1.LabelSelector
+	UnsafeCreateClusterRoleBinding bool
+	CleanupTimeout                 time.Duration
+	Logf                           func(string, ...interface{})
+}
+type NamespaceConfig struct {
+	Name        string
+	Labels      map[string]string
+	Annotations map[string]string
 }
 
 func NewExtensionInstall(cfg *action.Configuration) *ExtensionInstall {
@@ -29,47 +44,121 @@ func NewExtensionInstall(cfg *action.Configuration) *ExtensionInstall {
 	}
 }
 
-func (i *ExtensionInstall) Run(ctx context.Context) (*olmv1.ClusterExtension, error) {
-	// TODO(developer): Lookup package information when the OLMv1 equivalent of the
-	//     packagemanifests API is available. That way, we can check to see if the
-	//     package is actually available to the cluster before creating the Extension
-	//     object.
-
-	opKey := types.NamespacedName{Name: i.Package}
-	op := &olmv1.ClusterExtension{
-		ObjectMeta: metav1.ObjectMeta{Name: opKey.Name},
+func (i *ExtensionInstall) buildClusterExtension() olmv1.ClusterExtension {
+	extension := olmv1.ClusterExtension{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: i.ExtensionName,
+		},
 		Spec: olmv1.ClusterExtensionSpec{
 			Source: olmv1.SourceConfig{
-				SourceType: "Catalog",
+				SourceType: olmv1.SourceTypeCatalog,
 				Catalog: &olmv1.CatalogFilter{
-					PackageName: i.Package,
+					PackageName: i.PackageName,
+					Version:     i.Version,
 				},
 			},
+			Namespace: i.Namespace.Name,
+			ServiceAccount: olmv1.ServiceAccountReference{
+				Name: i.ServiceAccount,
+			},
+		},
+	}
+
+	return extension
+}
+
+func (i *ExtensionInstall) Run(ctx context.Context) (*ocv1.ClusterExtension, error) {
+	extension := i.buildClusterExtension()
+	// Add catalog selector to extension
+	if len(i.CatalogSelector.MatchLabels) > 0 {
+		extension.Spec.Source.Catalog.Selector = &i.CatalogSelector
+	}
+	// Add Channels to extension
+	if len(i.Channels) > 0 {
+		extension.Spec.Source.Catalog.Channels = i.Channels
+	}
+	//Add CatalogSelector to extension
+	if len(i.CatalogSelector.MatchLabels) > 0 {
+		extension.Spec.Source.Catalog.Selector = &i.CatalogSelector
+	}
+	// Create namespace
+	namespace := &corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:        i.Namespace.Name,
+			Labels:      i.Namespace.Labels,
+			Annotations: i.Namespace.Annotations,
 		},
 	}
-	if err := i.config.Client.Create(ctx, op); err != nil {
+	if err := i.config.Client.Create(ctx, namespace); err != nil {
 		return nil, err
 	}
+	if err := i.config.Client.Create(ctx, &extension); err != nil {
+		return nil, err
+	}
+	clusterExtension, err := i.waitForClusterExtensionInstalled(ctx)
+	if err != nil {
+		cleanupCtx, cancelCleanup := context.WithTimeout(context.Background(), i.CleanupTimeout)
+		defer cancelCleanup()
+		cleanupErr := i.cleanup(cleanupCtx)
+		return nil, errors.Join(err, cleanupErr)
+	}
+	return clusterExtension, nil
+}
 
-	// TODO(developer): Improve the logic in this poll wait once the Extension reconciler
-	//     and conditions types and reasons are improved. For now, this will stop waiting as
-	//     soon as a Ready condition is found, but we should probably wait until the Extension
-	//     stops progressing.
-	// All Types will exist, so Ready may have a false Status. So, wait until
-	// Type=Ready,Status=True happens
-
-	if err := wait.PollUntilContextCancel(ctx, pollInterval, true, func(conditionCtx context.Context) (bool, error) {
-		if err := i.config.Client.Get(conditionCtx, opKey, op); err != nil {
+func (i *ExtensionInstall) waitForClusterExtensionInstalled(ctx context.Context) (*ocv1.ClusterExtension, error) {
+	clusterExtension := &ocv1.ClusterExtension{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: i.ExtensionName,
+		},
+	}
+	errMsg := ""
+	key := client.ObjectKeyFromObject(clusterExtension)
+	if err := wait.PollUntilContextCancel(ctx, time.Millisecond*250, true, func(conditionCtx context.Context) (bool, error) {
+		if err := i.config.Client.Get(conditionCtx, key, clusterExtension); err != nil {
 			return false, err
 		}
-		installedCondition := meta.FindStatusCondition(op.Status.Conditions, olmv1.TypeInstalled)
-		if installedCondition != nil && installedCondition.Status == metav1.ConditionTrue {
-			return true, nil
+		progressingCondition := meta.FindStatusCondition(clusterExtension.Status.Conditions, ocv1.TypeProgressing)
+		if progressingCondition != nil && progressingCondition.Reason != ocv1.ReasonSucceeded {
+			errMsg = progressingCondition.Message
+			return false, nil
+		}
+		if !meta.IsStatusConditionPresentAndEqual(clusterExtension.Status.Conditions, ocv1.TypeInstalled, metav1.ConditionTrue) {
+			return false, nil
 		}
-		return false, nil
+		return true, nil
 	}); err != nil {
-		return nil, fmt.Errorf("waiting for extension to become ready: %v", err)
+		if errMsg == "" {
+			errMsg = err.Error()
+		}
+		return nil, fmt.Errorf("cluster extension %q did not finish installing: %s", clusterExtension.Name, errMsg)
 	}
+	return clusterExtension, nil
+}
 
-	return op, nil
+func (i *ExtensionInstall) cleanup(ctx context.Context) error {
+	clusterExtension := &ocv1.ClusterExtension{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: i.ExtensionName,
+		},
+	}
+	clusterRoleBinding := &rbacv1.ClusterRoleBinding{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: fmt.Sprintf("kubectl-operator-%s-cluster-admin", i.ServiceAccount),
+		},
+	}
+	serviceAccount := &corev1.ServiceAccount{
+		ObjectMeta: metav1.ObjectMeta{
+			Namespace: i.Namespace.Name,
+			Name:      i.ServiceAccount,
+		},
+	}
+	namespace := &corev1.Namespace{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: i.Namespace.Name,
+		},
+	}
+	if err := waitForDeletion(ctx, i.config.Client, clusterExtension); err != nil {
+		return fmt.Errorf("delete clusterextension %q: %v", i.ExtensionName, err)
+	}
+	return waitForDeletion(ctx, i.config.Client, clusterRoleBinding, serviceAccount, namespace)
 }