catalog install->add, uninstall->remove; add list-available catalog selector flag

Author: joelanford

internal/cmd/catalog.go

@@ -12,9 +12,9 @@ func newCatalogCmd(cfg *action.Configuration) *cobra.Command {
 		Short: "Manage operator catalogs",
 	}
 	cmd.AddCommand(
-		newCatalogInstallCmd(cfg),
+		newCatalogAddCmd(cfg),
 		newCatalogListCmd(cfg),
-		newCatalogUninstallCmd(cfg),
+		newCatalogRemoveCmd(cfg),
 	)
 	return cmd
 }

internal/cmd/catalog_install.go renamed to internal/cmd/catalog_add.go

@@ -12,34 +12,34 @@ import (
 	"github.com/joelanford/kubectl-operator/internal/pkg/log"
 )
 
-func newCatalogInstallCmd(cfg *action.Configuration) *cobra.Command {
-	i := action.NewInstallCatalog(cfg)
+func newCatalogAddCmd(cfg *action.Configuration) *cobra.Command {
+	a := action.NewAddCatalog(cfg)
 
 	cmd := &cobra.Command{
-		Use:   "install <index_image>",
-		Short: "Install an operator catalog",
+		Use:   "add <index_image>",
+		Short: "Add an operator catalog",
 		Args:  cobra.ExactArgs(1),
 		PreRun: func(cmd *cobra.Command, args []string) {
 			regLogger := logrus.New()
 			regLogger.SetOutput(ioutil.Discard)
-			i.RegistryOptions = []containerdregistry.RegistryOption{
+			a.RegistryOptions = []containerdregistry.RegistryOption{
 				containerdregistry.WithLog(logrus.NewEntry(regLogger)),
 			}
 		},
 		Run: func(cmd *cobra.Command, args []string) {
-			ctx, cancel := context.WithTimeout(cmd.Context(), i.InstallTimeout)
+			ctx, cancel := context.WithTimeout(cmd.Context(), a.AddTimeout)
 			defer cancel()
 
-			i.IndexImage = args[0]
+			a.IndexImage = args[0]
 
-			cs, err := i.Run(ctx)
+			cs, err := a.Run(ctx)
 			if err != nil {
-				log.Fatalf("failed to install catalog: %v", err)
+				log.Fatalf("failed to add catalog: %v", err)
 			}
 			log.Printf("created catalogsource %q\n", cs.Name)
 		},
 	}
-	i.BindFlags(cmd.Flags())
+	a.BindFlags(cmd.Flags())
 
 	return cmd
 }

internal/cmd/catalog_uninstall.go renamed to internal/cmd/catalog_remove.go

@@ -7,19 +7,19 @@ import (
 	"github.com/joelanford/kubectl-operator/internal/pkg/log"
 )
 
-func newCatalogUninstallCmd(cfg *action.Configuration) *cobra.Command {
-	u := action.NewUninstallCatalog(cfg)
+func newCatalogRemoveCmd(cfg *action.Configuration) *cobra.Command {
+	u := action.NewRemoveCatalog(cfg)
 	cmd := &cobra.Command{
-		Use:   "uninstall <catalog_name>",
-		Short: "Uninstall an operator catalog",
+		Use:   "remove <catalog_name>",
+		Short: "Remove a operator catalog",
 		Args:  cobra.ExactArgs(1),
 		Run: func(cmd *cobra.Command, args []string) {
 			u.CatalogName = args[0]
 
 			if err := u.Run(cmd.Context()); err != nil {
-				log.Fatalf("failed to uninstall catalog %q: %v", u.CatalogName, err)
+				log.Fatalf("failed to remove catalog %q: %v", u.CatalogName, err)
 			}
-			log.Printf("catalogsource %q uninstalled", u.CatalogName)
+			log.Printf("catalogsource %q removed", u.CatalogName)
 		},
 	}
 

internal/cmd/operator_list_available.go

@@ -50,5 +50,6 @@ func newListAvailableCmd(cfg *action.Configuration) *cobra.Command {
 			_ = tw.Flush()
 		},
 	}
+	l.BindFlags(cmd.Flags())
 	return cmd
 }

internal/pkg/action/catalog_install.go renamed to internal/pkg/action/catalog_add.go

@@ -18,102 +18,102 @@ import (
 	"github.com/joelanford/kubectl-operator/internal/pkg/log"
 )
 
-type InstallCatalog struct {
+type AddCatalog struct {
 	config *Configuration
 
 	IndexImage     string
 	DisplayName    string
 	Publisher      string
-	InstallTimeout time.Duration
+	AddTimeout     time.Duration
 	CleanupTimeout time.Duration
 
 	RegistryOptions []containerdregistry.RegistryOption
 
 	registry *containerdregistry.Registry
 }
 
-func NewInstallCatalog(cfg *Configuration) *InstallCatalog {
-	return &InstallCatalog{
+func NewAddCatalog(cfg *Configuration) *AddCatalog {
+	return &AddCatalog{
 		config: cfg,
 	}
 }
 
-func (i *InstallCatalog) BindFlags(fs *pflag.FlagSet) {
-	fs.StringVarP(&i.DisplayName, "display-name", "d", "", "display name of the index")
-	fs.StringVarP(&i.Publisher, "publisher", "p", "", "publisher of the index")
-	fs.DurationVarP(&i.InstallTimeout, "timeout", "t", time.Minute, "the amount of time to wait before cancelling the install")
-	fs.DurationVar(&i.CleanupTimeout, "cleanup-timeout", time.Minute, "the amount to time to wait before cancelling cleanup")
+func (a *AddCatalog) BindFlags(fs *pflag.FlagSet) {
+	fs.StringVarP(&a.DisplayName, "display-name", "d", "", "display name of the index")
+	fs.StringVarP(&a.Publisher, "publisher", "p", "", "publisher of the index")
+	fs.DurationVarP(&a.AddTimeout, "timeout", "t", time.Minute, "the amount of time to wait before cancelling the catalog addition")
+	fs.DurationVar(&a.CleanupTimeout, "cleanup-timeout", time.Minute, "the amount to time to wait before cancelling cleanup")
 }
 
-func (i *InstallCatalog) Run(ctx context.Context) (*v1alpha1.CatalogSource, error) {
+func (a *AddCatalog) Run(ctx context.Context) (*v1alpha1.CatalogSource, error) {
 	var err error
-	i.registry, err = containerdregistry.NewRegistry(i.RegistryOptions...)
+	a.registry, err = containerdregistry.NewRegistry(a.RegistryOptions...)
 	if err != nil {
 		return nil, err
 	}
 
 	defer func() {
-		if err := i.registry.Destroy(); err != nil {
+		if err := a.registry.Destroy(); err != nil {
 			log.Printf("registry cleanup: %v", err)
 		}
 	}()
 
-	imageRef, err := container.ImageFromString(i.IndexImage)
+	imageRef, err := container.ImageFromString(a.IndexImage)
 	if err != nil {
 		return nil, err
 	}
 	csKey := types.NamespacedName{
-		Namespace: i.config.Namespace,
+		Namespace: a.config.Namespace,
 		Name:      imageRef.Name,
 	}
 
-	labels, err := i.labelsFor(ctx, i.IndexImage)
+	labels, err := a.labelsFor(ctx, a.IndexImage)
 	if err != nil {
 		return nil, err
 	}
 
-	i.setDefaults(labels)
+	a.setDefaults(labels)
 
 	opts := []catalog.Option{
-		catalog.Image(i.IndexImage),
-		catalog.DisplayName(i.DisplayName),
-		catalog.Publisher(i.Publisher),
+		catalog.Image(a.IndexImage),
+		catalog.DisplayName(a.DisplayName),
+		catalog.Publisher(a.Publisher),
 	}
 	cs := catalog.Build(csKey, opts...)
-	if err := i.install(ctx, cs); err != nil {
-		defer i.cleanup(cs)
+	if err := a.add(ctx, cs); err != nil {
+		defer a.cleanup(cs)
 		return nil, err
 	}
 	return cs, nil
 }
 
-func (i *InstallCatalog) labelsFor(ctx context.Context, indexImage string) (map[string]string, error) {
+func (a *AddCatalog) labelsFor(ctx context.Context, indexImage string) (map[string]string, error) {
 	simpleRef := image.SimpleReference(indexImage)
-	if err := i.registry.Pull(ctx, simpleRef); err != nil {
+	if err := a.registry.Pull(ctx, simpleRef); err != nil {
 		return nil, fmt.Errorf("pull image: %v", err)
 	}
-	labels, err := i.registry.Labels(ctx, simpleRef)
+	labels, err := a.registry.Labels(ctx, simpleRef)
 	if err != nil {
 		return nil, fmt.Errorf("get image labels: %v", err)
 	}
 	return labels, nil
 }
 
-func (i *InstallCatalog) setDefaults(labels map[string]string) {
-	if i.DisplayName == "" {
+func (a *AddCatalog) setDefaults(labels map[string]string) {
+	if a.DisplayName == "" {
 		if v, ok := labels["operators.operatorframework.io.index.display-name"]; ok {
-			i.DisplayName = v
+			a.DisplayName = v
 		}
 	}
-	if i.Publisher == "" {
+	if a.Publisher == "" {
 		if v, ok := labels["operators.operatorframework.io.index.publisher"]; ok {
-			i.Publisher = v
+			a.Publisher = v
 		}
 	}
 }
 
-func (i *InstallCatalog) install(ctx context.Context, cs *v1alpha1.CatalogSource) error {
-	if err := i.config.Client.Create(ctx, cs); err != nil {
+func (a *AddCatalog) add(ctx context.Context, cs *v1alpha1.CatalogSource) error {
+	if err := a.config.Client.Create(ctx, cs); err != nil {
 		return fmt.Errorf("create catalogsource: %v", err)
 	}
 
@@ -122,7 +122,7 @@ func (i *InstallCatalog) install(ctx context.Context, cs *v1alpha1.CatalogSource
 		return fmt.Errorf("get catalogsource key: %v", err)
 	}
 	if err := wait.PollImmediateUntil(time.Millisecond*250, func() (bool, error) {
-		if err := i.config.Client.Get(ctx, csKey, cs); err != nil {
+		if err := a.config.Client.Get(ctx, csKey, cs); err != nil {
 			return false, err
 		}
 		if cs.Status.GRPCConnectionState != nil {
@@ -137,10 +137,10 @@ func (i *InstallCatalog) install(ctx context.Context, cs *v1alpha1.CatalogSource
 	return nil
 }
 
-func (i *InstallCatalog) cleanup(cs *v1alpha1.CatalogSource) {
-	ctx, cancel := context.WithTimeout(context.Background(), i.CleanupTimeout)
+func (a *AddCatalog) cleanup(cs *v1alpha1.CatalogSource) {
+	ctx, cancel := context.WithTimeout(context.Background(), a.CleanupTimeout)
 	defer cancel()
-	if err := i.config.Client.Delete(ctx, cs); err != nil {
+	if err := a.config.Client.Delete(ctx, cs); err != nil {
 		log.Printf("delete catalogsource %q: %v", cs.Name, err)
 	}
 }

internal/pkg/action/catalog_remove.go

@@ -0,0 +1,30 @@
+package action
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/operator-framework/api/pkg/operators/v1alpha1"
+)
+
+type RemoveCatalog struct {
+	config *Configuration
+
+	CatalogName string
+}
+
+func NewRemoveCatalog(cfg *Configuration) *RemoveCatalog {
+	return &RemoveCatalog{
+		config: cfg,
+	}
+}
+
+func (r *RemoveCatalog) Run(ctx context.Context) error {
+	cs := v1alpha1.CatalogSource{}
+	cs.SetNamespace(r.config.Namespace)
+	cs.SetName(r.CatalogName)
+	if err := r.config.Client.Delete(ctx, &cs); err != nil {
+		return fmt.Errorf("delete catalogsource %q: %v", cs.Name, err)
+	}
+	return nil
+}

internal/pkg/action/catalog_uninstall.go

@@ -2,22 +2,70 @@ package action
 
 import (
 	"context"
+	"fmt"
+	"strings"
 
 	v1 "github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators/v1"
+	"github.com/spf13/pflag"
+	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 type ListAvailableOperators struct {
 	config *Configuration
+
+	Catalog NamespacedName
 }
 
 func NewListAvailableOperators(cfg *Configuration) *ListAvailableOperators {
-	return &ListAvailableOperators{cfg}
+	return &ListAvailableOperators{
+		config: cfg,
+	}
 }
 
 func (l *ListAvailableOperators) Run(ctx context.Context) ([]v1.PackageManifest, error) {
 	pms := v1.PackageManifestList{}
-	if err := l.config.Client.List(ctx, &pms); err != nil {
+
+	labelSelector := client.MatchingLabels{}
+	if l.Catalog.Name != "" {
+		labelSelector["catalog"] = l.Catalog.Name
+	}
+	if l.Catalog.Namespace != "" {
+		labelSelector["catalog-namespace"] = l.Catalog.Namespace
+	}
+	if err := l.config.Client.List(ctx, &pms, labelSelector); err != nil {
 		return nil, err
 	}
 	return pms.Items, nil
 }
+
+func (l *ListAvailableOperators) BindFlags(fs *pflag.FlagSet) {
+	fs.VarP(&l.Catalog, "catalog", "c", "catalog to query (default: search all cluster catalogs)")
+}
+
+type NamespacedName struct {
+	types.NamespacedName
+}
+
+func (f *NamespacedName) Set(str string) error {
+	split := strings.Split(str, "/")
+	switch len(split) {
+	case 0:
+	case 1:
+		f.Name = split[0]
+	case 2:
+		f.Namespace = split[0]
+		f.Name = split[1]
+	default:
+		return fmt.Errorf("invalid namespaced name value %q", str)
+	}
+	return nil
+}
+
+func (f NamespacedName) String() string {
+	return f.NamespacedName.String()
+}
+
+func (f NamespacedName) Type() string {
+	return "NamespacedNameValue"
+}