PackageRevision field selectors for Kptfile labels

Author: mozesl-nokia

pkg/cache/dbcache/dbsqlfiltering.go

@@ -16,6 +16,7 @@ package dbcache
 
 import (
 	"fmt"
+	"strings"
 
 	porchapi "github.com/nephio-project/porch/api/porch/v1alpha1"
 	"github.com/nephio-project/porch/pkg/repository"
@@ -59,7 +60,8 @@ func prListFilter2WhereClause(filter repository.ListPackageRevisionFilter) strin
 	whereStatement, first = filter2SubClauseInt(whereStatement, prKey.Revision, "package_revisions.revision", first)
 	whereStatement, first = filter2SubClauseWorkspace(whereStatement, prKey.WorkspaceName, "package_revisions.k8s_name", first)
 
-	whereStatement, _ = filter2SubClauseLifecycle(whereStatement, filter.Lifecycles, "package_revisions.lifecycle", first)
+	whereStatement, first = filter2SubClauseLifecycle(whereStatement, filter.Lifecycles, "package_revisions.lifecycle", first)
+	whereStatement, _ = filter2SubClauseKptfileLabels(whereStatement, filter.KptfileLabels, first)
 
 	if whereStatement == "" {
 		return whereStatement
@@ -131,3 +133,24 @@ func filter2SubClauseLifecycle(whereStatement string, filterField []porchapi.Pac
 		return whereStatement + "AND " + subClause, false
 	}
 }
+
+func filter2SubClauseKptfileLabels(whereStatement string, filterLabels map[string]string, first bool) (string, bool) {
+	if len(filterLabels) == 0 {
+		return whereStatement, first
+	}
+
+	var subClauses []string
+	for labelKey, labelValue := range filterLabels {
+		subClause := fmt.Sprintf("(package_revisions.spec::jsonb->'packageMetadata'->'labels'->>'%s' = '%s')",
+			labelKey, labelValue)
+		subClauses = append(subClauses, subClause)
+	}
+
+	combinedClause := "(" + strings.Join(subClauses, " AND ") + ")"
+
+	if first {
+		return whereStatement + combinedClause, false
+	} else {
+		return whereStatement + "AND " + combinedClause, false
+	}
+}

pkg/registry/porch/fieldselector.go

@@ -96,6 +96,18 @@ func convertPackageRevisionFieldSelector(label, value string) (internalLabel, in
 	if slices.Contains(porchapi.PackageRevisionSelectableFields, porchapi.PkgRevFieldSelector(label)) {
 		return label, value, nil
 	}
+
+	if strings.HasPrefix(label, "spec.packageMetadata.labels[") && strings.HasSuffix(label, "]") {
+		start := len("spec.packageMetadata.labels[")
+		end := len(label) - 1
+		labelKey := label[start:end]
+		if labelKey == "" {
+			return "", "", fmt.Errorf("label key cannot be empty in field selector %q", label)
+		}
+
+		return label, value, nil
+	}
+
 	return "", "", fmt.Errorf("%q is not a known field selector", label)
 }
 
@@ -166,6 +178,25 @@ func parsePackageRevisionFieldSelector(options *metainternalversion.ListOptions)
 			return filter, apierrors.NewBadRequest(fmt.Sprintf("unsupported fieldSelector operator %q for field %q", requirement.Operator, requirement.Field))
 		}
 
+		if strings.HasPrefix(requirement.Field, "spec.packageMetadata.labels[") && strings.HasSuffix(requirement.Field, "]") {
+			start := len("spec.packageMetadata.labels[")
+			end := len(requirement.Field) - 1
+			labelKey := requirement.Field[start:end]
+
+			if labelKey == "" {
+				return filter, apierrors.NewBadRequest(fmt.Sprintf("label key cannot be empty in field selector %q", requirement.Field))
+			}
+
+			if filter.KptfileLabels == nil {
+				filter.KptfileLabels = make(map[string]string)
+			}
+
+			filter.KptfileLabels[labelKey] = requirement.Value
+
+			// skip the upcoming requirement.Field check
+			return filter, nil
+		}
+
 		filteredField := porchapi.PkgRevFieldSelector(requirement.Field)
 		if filterFunc, fieldSelectable := PrFilterFieldMappings[filteredField]; fieldSelectable {
 			if err := filterFunc(filter, requirement.Value); err != nil {

pkg/repository/repository.go

@@ -329,6 +329,9 @@ type ListPackageRevisionFilter struct {
 	// Lifecycle matches the spec.lifecycle of the package
 	Lifecycles []porchapi.PackageRevisionLifecycle
 
+	// KptfileLabels matches labels specified in the Kptfile
+	KptfileLabels map[string]string
+
 	Label labels.Selector
 }
 
@@ -342,6 +345,24 @@ func (f *ListPackageRevisionFilter) Matches(ctx context.Context, p PackageRevisi
 		return false
 	}
 
+	if len(f.KptfileLabels) > 0 {
+		packageRevision, err := p.GetPackageRevision(ctx)
+		if err != nil {
+			return false
+		}
+
+		if packageRevision.Spec.PackageMetadata == nil {
+			return false
+		}
+
+		for labelKey, expectedlValue := range f.KptfileLabels {
+			actualValue, exists := packageRevision.Spec.PackageMetadata.Labels[labelKey]
+			if !exists || actualValue != expectedlValue {
+				return false
+			}
+		}
+	}
+
 	if !f.MatchesLabels(ctx, p) {
 		return false
 	}

test/e2e/metadata_test.go

@@ -15,9 +15,12 @@
 package e2e
 
 import (
+	"fmt"
+
 	porchapi "github.com/nephio-project/porch/api/porch/v1alpha1"
 	"github.com/nephio-project/porch/pkg/repository"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/fields"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
@@ -92,6 +95,7 @@ func (t *PorchSuite) TestPackageMetadataFromKptfile() {
 			"config.kubernetes.io/local-config": "true",                 // from upstream
 			"porch.dev/new-annotation":          "new-annotation-value", // from PackageMetadata
 		}
+		t.Require().NotNil(clonePr.Spec.PackageMetadata)
 		t.Require().Equal(expectedLabels, clonePr.Spec.PackageMetadata.Labels)
 		for k, v := range expectedAnnotations {
 			actual, ok := clonePr.Spec.PackageMetadata.Annotations[k]
@@ -131,6 +135,7 @@ func (t *PorchSuite) TestPackageMetadataFromKptfile() {
 			"porch.dev/test-annotation":         "e2e-test-annotation-value",
 		}
 
+		t.Require().NotNil(clonePr.Spec.PackageMetadata)
 		t.Require().Equal(expectedLabelsAfterManual, clonePr.Spec.PackageMetadata.Labels)
 		for k, v := range expectedAnnotationsAfterManual {
 			actual, ok := clonePr.Spec.PackageMetadata.Annotations[k]
@@ -171,6 +176,7 @@ func (t *PorchSuite) TestPackageMetadataFromKptfile() {
 			"porch.dev/added-annotation": "added-annotation-value",
 		}
 
+		t.Require().NotNil(clonePr.Spec.PackageMetadata)
 		t.Require().Equal(expectedLabels, clonePr.Spec.PackageMetadata.Labels)
 		for k, v := range expectedAnnotations {
 			actual, ok := clonePr.Spec.PackageMetadata.Annotations[k]
@@ -189,3 +195,77 @@ func (t *PorchSuite) TestPackageMetadataFromKptfile() {
 		}
 	})
 }
+
+func (t *PorchSuite) TestPackageMetadataFieldSelectors() {
+	const (
+		repositoryName = "test-package-field-selector-repo"
+	)
+
+	t.RegisterMainGitRepositoryF(repositoryName)
+
+	t.RegisterTestBlueprintRepository("test-blueprints", "")
+
+	t.Run("filter by existing label", func() {
+		var list porchapi.PackageRevisionList
+
+		t.ListE(&list, client.InNamespace(t.Namespace))
+
+		simplePackage := t.MustFindPackageRevision(&list, repository.PackageRevisionKey{
+			PkgKey: repository.PackageKey{
+				RepoKey: repository.RepositoryKey{
+					Name: "test-blueprints",
+				},
+				Package: "simple",
+			},
+			Revision: 1,
+		})
+
+		t.Require().NotNil(simplePackage.Spec.PackageMetadata)
+		t.Require().NotNil(simplePackage.Spec.PackageMetadata.Labels)
+		t.Require().NotEmpty(simplePackage.Spec.PackageMetadata.Labels)
+
+		var testLabelKey, testLabelValue string
+		for key, value := range simplePackage.Spec.PackageMetadata.Labels {
+			testLabelKey = key
+			testLabelValue = value
+			break
+		}
+
+		fieldSelector := fmt.Sprintf("spec.packageMetadata.labels[%s]=%s", testLabelKey, testLabelValue)
+		listOptions := &client.ListOptions{
+			FieldSelector: fields.ParseSelectorOrDie(fieldSelector),
+		}
+
+		var filteredList porchapi.PackageRevisionList
+		t.ListE(&filteredList, client.InNamespace(t.Namespace), listOptions)
+
+		found := false
+		for _, item := range filteredList.Items {
+			t.Require().NotNil(item.Spec.PackageMetadata)
+			t.Require().NotNil(item.Spec.PackageMetadata.Labels)
+
+			actualValue, exists := item.Spec.PackageMetadata.Labels[testLabelKey]
+			t.Require().True(exists, testLabelKey)
+			t.Require().Equal(testLabelValue, actualValue)
+
+			if item.Spec.PackageName == "simple" && item.Spec.RepositoryName == "test-blueprints" {
+				found = true
+				t.Logf("Found expected simple package: %s", item.Name)
+			}
+		}
+
+		t.Require().True(found)
+	})
+
+	t.Run("filter by non-existing label", func() {
+		fieldSelector := "spec.packageMetadata.labels[non-existing-label-key]=non-existing-value"
+		listOptions := &client.ListOptions{
+			FieldSelector: fields.ParseSelectorOrDie(fieldSelector),
+		}
+
+		var filteredList porchapi.PackageRevisionList
+		t.ListE(&filteredList, client.InNamespace(t.Namespace), listOptions)
+
+		t.Require().Empty(filteredList.Items, len(filteredList.Items))
+	})
+}