feat(packageserver): support label queries and copy CSV labels onto the

packagemanifest

Author: ecordell

pkg/package-server/provider/interfaces.go

@@ -1,8 +1,11 @@
 package provider
 
-import "github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators"
+import (
+	"github.com/operator-framework/operator-lifecycle-manager/pkg/package-server/apis/operators"
+	"k8s.io/apimachinery/pkg/labels"
+)
 
 type PackageManifestProvider interface {
 	Get(namespace, name string) (*operators.PackageManifest, error)
-	List(namespace string) (*operators.PackageManifestList, error)
+	List(namespace string, selector labels.Selector) (*operators.PackageManifestList, error)
 }

pkg/package-server/provider/registry.go

@@ -370,7 +370,7 @@ func (p *RegistryProvider) Get(namespace, name string) (*operators.PackageManife
 		"namespace": namespace,
 	})
 
-	pkgs, err := p.List(namespace)
+	pkgs, err := p.List(namespace, labels.Everything())
 	if err != nil {
 		return nil, fmt.Errorf("could not list packages in namespace %s", namespace)
 	}
@@ -385,7 +385,7 @@ func (p *RegistryProvider) Get(namespace, name string) (*operators.PackageManife
 	return nil, nil
 }
 
-func (p *RegistryProvider) List(namespace string) (*operators.PackageManifestList, error) {
+func (p *RegistryProvider) List(namespace string, selector labels.Selector) (*operators.PackageManifestList, error) {
 	var pkgs []*operators.PackageManifest
 	if namespace == metav1.NamespaceAll {
 		all, err := p.pkgLister.List(labels.Everything())
@@ -394,14 +394,14 @@ func (p *RegistryProvider) List(namespace string) (*operators.PackageManifestLis
 		}
 		pkgs = append(pkgs, all...)
 	} else {
-		nsPkgs, err := p.pkgLister.PackageManifests(namespace).List(labels.Everything())
+		nsPkgs, err := p.pkgLister.PackageManifests(namespace).List(selector)
 		if err != nil {
 			return nil, err
 		}
 		pkgs = append(pkgs, nsPkgs...)
 
 		if namespace != p.globalNamespace {
-			globalPkgs, err := p.pkgLister.PackageManifests(p.globalNamespace).List(labels.Everything())
+			globalPkgs, err := p.pkgLister.PackageManifests(p.globalNamespace).List(selector)
 			if err != nil {
 				return nil, err
 			}
@@ -464,6 +464,11 @@ func newPackageManifest(ctx context.Context, logger *logrus.Entry, pkg *api.Pack
 			defaultElided = defaultElided || pkgChannel.Name == manifest.Status.DefaultChannel
 			continue
 		}
+		manifestLabels := manifest.GetLabels()
+		for k, v := range csv.GetLabels() {
+			manifestLabels[k] = v
+		}
+		manifest.SetLabels(manifest.GetLabels())
 		manifest.Status.Channels = append(manifest.Status.Channels, operators.PackageChannel{
 			Name:           pkgChannel.GetName(),
 			CurrentCSV:     csv.GetName(),

pkg/package-server/provider/registry_test.go

@@ -2,12 +2,10 @@ package storage
 
 import (
 	"context"
-	"fmt"
 
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metainternalversion "k8s.io/apimachinery/pkg/apis/meta/internalversion"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -68,24 +66,12 @@ func (m *PackageManifestStorage) List(ctx context.Context, options *metainternal
 		labelSelector = options.LabelSelector
 	}
 
-	name, err := nameFor(options.FieldSelector)
-	if err != nil {
-		return nil, err
-	}
-
-	res, err := m.prov.List(namespace)
+	res, err := m.prov.List(namespace, labelSelector)
 	if err != nil {
 		return nil, k8serrors.NewInternalError(err)
 	}
 
-	// Filter by label selector
-	filtered := []operators.PackageManifest{}
-	for _, manifest := range res.Items {
-		if matches(manifest, name, labelSelector) {
-			filtered = append(filtered, manifest)
-		}
-	}
-	// Strip logo icons
+	filtered := res.Items
 	for i := range filtered {
 		for j := range filtered[i].Status.Channels {
 			filtered[i].Status.Channels[j].CurrentCSVDesc.Icon = []operators.Icon{}
@@ -115,23 +101,3 @@ func (m *PackageManifestStorage) Get(ctx context.Context, name string, opts *met
 func (m *PackageManifestStorage) NamespaceScoped() bool {
 	return true
 }
-
-func nameFor(fs fields.Selector) (string, error) {
-	if fs == nil {
-		fs = fields.Everything()
-	}
-	name := ""
-	if value, found := fs.RequiresExactMatch("metadata.name"); found {
-		name = value
-	} else if !fs.Empty() {
-		return "", fmt.Errorf("field label not supported: %s", fs.Requirements()[0].Field)
-	}
-	return name, nil
-}
-
-func matches(pm operators.PackageManifest, name string, ls labels.Selector) bool {
-	if name == "" {
-		name = pm.GetName()
-	}
-	return ls.Matches(labels.Set(pm.GetLabels())) && pm.GetName() == name
-}

pkg/package-server/storage/reststorage.go

@@ -66,7 +66,6 @@ func TestPackageManifestLoading(t *testing.T) {
 	catalogSourceName := genName("mock-ocs")
 	namedStrategy := newNginxInstallStrategy(genName("dep-"), nil, nil)
 	csv := newCSV(packageStable, testNamespace, "", semver.MustParse("0.1.0"), []apiextensions.CustomResourceDefinition{crd}, nil, namedStrategy)
-
 	c := newKubeClient(t)
 	crc := newCRClient(t)
 	pmc := newPMClient(t)
@@ -115,3 +114,76 @@ func TestPackageManifestLoading(t *testing.T) {
 	require.NotNil(t, pmList.ListMeta, "package manifest list metadata empty")
 	require.NotNil(t, pmList.Items)
 }
+
+func TestPackageManifestLoading(t *testing.T) {
+	defer cleaner.NotifyTestComplete(t, true)
+
+	// create a simple catalogsource
+	packageName := genName("nginx")
+	stableChannel := "stable"
+	packageStable := packageName + "-stable"
+	manifests := []registry.PackageManifest{
+		{
+			PackageName: packageName,
+			Channels: []registry.PackageChannel{
+				{Name: stableChannel, CurrentCSVName: packageStable},
+			},
+			DefaultChannelName: stableChannel,
+		},
+	}
+
+	crdPlural := genName("ins")
+	crd := newCRD(crdPlural)
+	catalogSourceName := genName("mock-ocs")
+	namedStrategy := newNginxInstallStrategy(genName("dep-"), nil, nil)
+	csv := newCSV(packageStable, testNamespace, "", semver.MustParse("0.1.0"), []apiextensions.CustomResourceDefinition{crd}, nil, namedStrategy)
+	csv.SetLabels(map[string]string{"projected": "label"})
+	c := newKubeClient(t)
+	crc := newCRClient(t)
+	pmc := newPMClient(t)
+
+	expectedStatus := packagev1.PackageManifestStatus{
+		CatalogSource:          catalogSourceName,
+		CatalogSourceNamespace: testNamespace,
+		PackageName:            packageName,
+		Channels: []packagev1.PackageChannel{
+			{
+				Name:           stableChannel,
+				CurrentCSV:     packageStable,
+				CurrentCSVDesc: packagev1.CreateCSVDescription(&csv),
+			},
+		},
+		DefaultChannel: stableChannel,
+	}
+
+	// Wait for package-server to be ready
+	err := wait.Poll(pollInterval, 1*time.Minute, func() (bool, error) {
+		t.Logf("Polling package-server...")
+		_, err := pmc.OperatorsV1().PackageManifests(testNamespace).List(metav1.ListOptions{})
+		if err == nil {
+			return true, nil
+		}
+		return false, nil
+	})
+	require.NoError(t, err, "package-server not available")
+
+	_, cleanupCatalogSource := createInternalCatalogSource(t, c, crc, catalogSourceName, testNamespace, manifests, []apiextensions.CustomResourceDefinition{crd}, []v1alpha1.ClusterServiceVersion{csv})
+	require.NoError(t, err)
+	defer cleanupCatalogSource()
+
+	_, err = fetchCatalogSource(t, crc, catalogSourceName, testNamespace, catalogSourceRegistryPodSynced)
+	require.NoError(t, err)
+
+	pm, err := fetchPackageManifest(t, pmc, testNamespace, packageName, packageManifestHasStatus)
+	require.NoError(t, err, "error getting package manifest")
+	require.NotNil(t, pm)
+	require.Equal(t, packageName, pm.GetName())
+	require.Equal(t, expectedStatus, pm.Status)
+	require.Contains(t, pm.GetLabels(), map[string]string{"projected": "label"})
+
+	// Filter PackageManifestList and ensure it has the correct items
+	pmList, err := pmc.OperatorsV1().PackageManifests(testNamespace).List(metav1.ListOptions{LabelSelector: "projected=label"})
+	require.NoError(t, err, "could not access package manifests list meta")
+	require.NotNil(t, pmList.ListMeta, "package manifest list metadata empty")
+	require.NotNil(t, pmList.Items)
+}