Get subscription channel from package manifest if it is not present

Author: edcdavid

pkg/autodiscover/autodiscover.go

@@ -73,6 +73,7 @@ type DiscoveredTestData struct {
 	AllCsvs                []*olmv1Alpha.ClusterServiceVersion
 	AllInstallPlans        []*olmv1Alpha.InstallPlan
 	AllCatalogSources      []*olmv1Alpha.CatalogSource
+	AllPackageManifests    []*PackageManifest
 	Deployments            []appsv1.Deployment
 	StatefulSet            []appsv1.StatefulSet
 	PersistentVolumes      []corev1.PersistentVolume
@@ -158,6 +159,7 @@ func DoAutoDiscover(config *configuration.TestConfiguration) DiscoveredTestData
 	}
 	data.AllInstallPlans = getAllInstallPlans(oc.OlmClient)
 	data.AllCatalogSources = getAllCatalogSources(oc.OlmClient)
+	data.AllPackageManifests = getAllPackageManifests(oc.DynamicClient)
 	data.Namespaces = namespacesListToStringList(config.TargetNameSpaces)
 	data.Pods, data.AllPods = findPodsByLabels(oc.K8sClient.CoreV1(), podsUnderTestLabelsObjects, data.Namespaces)
 	data.AbnormalEvents = findAbnormalEvents(oc.K8sClient.CoreV1(), data.Namespaces)

pkg/autodiscover/autodiscover_operators.go

@@ -19,16 +19,21 @@ package autodiscover
 import (
 	"context"
 	"fmt"
+	"time"
 
 	helmclient "github.com/mittwald/go-helm-client"
 	olmv1Alpha "github.com/operator-framework/api/pkg/operators/v1alpha1"
 	clientOlm "github.com/operator-framework/operator-lifecycle-manager/pkg/api/client/clientset/versioned"
 	"github.com/redhat-best-practices-for-k8s/certsuite/internal/log"
 	"github.com/redhat-best-practices-for-k8s/certsuite/pkg/configuration"
+
 	"github.com/redhat-best-practices-for-k8s/certsuite/pkg/stringhelper"
 	"helm.sh/helm/v3/pkg/release"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/dynamic"
 	appv1client "k8s.io/client-go/kubernetes/typed/apps/v1"
 	corev1client "k8s.io/client-go/kubernetes/typed/core/v1"
 	"k8s.io/client-go/rest"
@@ -39,6 +44,34 @@ const (
 	istioDeploymentName = "istiod"
 )
 
+type PackageManifest struct {
+	APIVersion string `json:"apiVersion"`
+	Kind       string `json:"kind"`
+	Metadata   struct {
+		CreationTimestamp time.Time         `json:"creationTimestamp"`
+		Labels            map[string]string `json:"labels"`
+		Name              string            `json:"name"`
+		Namespace         string            `json:"namespace"`
+	} `json:"metadata"`
+	Spec struct {
+	} `json:"spec"`
+	Status struct {
+		CatalogSource            string `json:"catalogSource"`
+		CatalogSourceDisplayName string `json:"catalogSourceDisplayName"`
+		CatalogSourceNamespace   string `json:"catalogSourceNamespace"`
+		CatalogSourcePublisher   string `json:"catalogSourcePublisher"`
+		Channels                 []struct {
+			CurrentCSV string `json:"currentCSV"`
+			Name       string `json:"name"`
+		} `json:"channels"`
+		DefaultChannel string `json:"defaultChannel"`
+		PackageName    string `json:"packageName"`
+		Provider       struct {
+			Name string `json:"name"`
+		} `json:"provider"`
+	} `json:"status"`
+}
+
 func isIstioServiceMeshInstalled(appClient appv1client.AppsV1Interface, allNs []string) bool {
 	// The Istio namespace must be present
 	if !stringhelper.StringInSlice(allNs, istioNamespace, false) {
@@ -202,3 +235,27 @@ func getAllCatalogSources(olmClient clientOlm.Interface) (out []*olmv1Alpha.Cata
 	}
 	return out
 }
+
+// getAllPackageManifests is a helper function to get the all the PackageManifests in a cluster.
+func getAllPackageManifests(dynamicClient dynamic.Interface) (out []*PackageManifest) {
+	gvr := schema.GroupVersionResource{
+		Group:    "packages.operators.coreos.com",
+		Version:  "v1",
+		Resource: "packagemanifests",
+	}
+	// Query the package manifest for the operator
+	pkgManifest, err := dynamicClient.Resource(gvr).Namespace("").List(context.TODO(), metav1.ListOptions{})
+	if err != nil {
+		log.Error("Unable get PackageManifests in cluster, err: %v", err)
+		return out
+	}
+	for _, item := range pkgManifest.Items {
+		var manifest PackageManifest
+		if err := runtime.DefaultUnstructuredConverter.FromUnstructured(item.Object, &manifest); err != nil {
+			log.Error("Failed to convert to PackageManifestWithNs: %v", err)
+		}
+
+		out = append(out, &manifest)
+	}
+	return out
+}

pkg/provider/operators.go

@@ -32,6 +32,7 @@ import (
 	olmv1Alpha "github.com/operator-framework/api/pkg/operators/v1alpha1"
 	"github.com/redhat-best-practices-for-k8s/certsuite/internal/clientsholder"
 	"github.com/redhat-best-practices-for-k8s/certsuite/internal/log"
+	"github.com/redhat-best-practices-for-k8s/certsuite/pkg/autodiscover"
 	"github.com/redhat-openshift-ecosystem/openshift-preflight/artifacts"
 	plibRuntime "github.com/redhat-openshift-ecosystem/openshift-preflight/certification"
 	plibOperator "github.com/redhat-openshift-ecosystem/openshift-preflight/operator"
@@ -150,6 +151,7 @@ func getUniqueCsvListByName(csvs []*olmv1Alpha.ClusterServiceVersion) []*olmv1Al
 
 func createOperators(csvs []*olmv1Alpha.ClusterServiceVersion,
 	allSubscriptions []olmv1Alpha.Subscription,
+	allPackageManifests []*autodiscover.PackageManifest,
 	allInstallPlans []*olmv1Alpha.InstallPlan,
 	allCatalogSources []*olmv1Alpha.CatalogSource,
 	succeededRequired,
@@ -181,7 +183,7 @@ func createOperators(csvs []*olmv1Alpha.ClusterServiceVersion,
 		op.PackageFromCsvName = packageAndVersion[0]
 		op.Version = csv.Spec.Version.String()
 		// Get at least one subscription and update the Operator object with it.
-		if getAtLeastOneSubscription(op, csv, allSubscriptions) {
+		if getAtLeastOneSubscription(op, csv, allSubscriptions, allPackageManifests) {
 			targetNamespaces, err := getOperatorTargetNamespaces(op.SubscriptionNamespace)
 			if err != nil {
 				log.Error("Failed to get target namespaces for operator %s: %v", csv.Name, err)
@@ -200,7 +202,7 @@ func createOperators(csvs []*olmv1Alpha.ClusterServiceVersion,
 	return operators
 }
 
-func getAtLeastOneSubscription(op *Operator, csv *olmv1Alpha.ClusterServiceVersion, subscriptions []olmv1Alpha.Subscription) (atLeastOneSubscription bool) {
+func getAtLeastOneSubscription(op *Operator, csv *olmv1Alpha.ClusterServiceVersion, subscriptions []olmv1Alpha.Subscription, packageManifests []*autodiscover.PackageManifest) (atLeastOneSubscription bool) {
 	atLeastOneSubscription = false
 	for s := range subscriptions {
 		subscription := &subscriptions[s]
@@ -214,11 +216,32 @@ func getAtLeastOneSubscription(op *Operator, csv *olmv1Alpha.ClusterServiceVersi
 		op.Org = subscription.Spec.CatalogSource
 		op.Channel = subscription.Spec.Channel
 		atLeastOneSubscription = true
+
+		// If the channel is not present in the subscription, get the default channel from the package manifest
+		if op.Channel == "" {
+			aPackageManifest := getPackageManifestWithSubscription(subscription, packageManifests)
+			if aPackageManifest != nil {
+				op.Channel = aPackageManifest.Status.DefaultChannel
+			} else {
+				log.Error("Could not determine the default channel, this operator will always fail certification")
+			}
+		}
 		break
 	}
 	return atLeastOneSubscription
 }
 
+func getPackageManifestWithSubscription(subscription *olmv1Alpha.Subscription, packageManifests []*autodiscover.PackageManifest) *autodiscover.PackageManifest {
+	for index := range packageManifests {
+		if packageManifests[index].Status.PackageName == subscription.Spec.Package &&
+			packageManifests[index].Metadata.Namespace == subscription.Spec.CatalogSourceNamespace &&
+			packageManifests[index].Status.CatalogSource == subscription.Spec.CatalogSource {
+			return packageManifests[index]
+		}
+	}
+	return nil
+}
+
 func getAtLeastOneCsv(csv *olmv1Alpha.ClusterServiceVersion, installPlan *olmv1Alpha.InstallPlan) (atLeastOneCsv bool) {
 	atLeastOneCsv = false
 	for _, csvName := range installPlan.Spec.ClusterServiceVersionNames {

pkg/provider/operators_test.go

@@ -24,6 +24,7 @@ import (
 	olmv1 "github.com/operator-framework/api/pkg/operators/v1"
 	olmv1Alpha "github.com/operator-framework/api/pkg/operators/v1alpha1"
 	"github.com/redhat-best-practices-for-k8s/certsuite/internal/clientsholder"
+	"github.com/redhat-best-practices-for-k8s/certsuite/pkg/autodiscover"
 	"github.com/stretchr/testify/assert"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -296,7 +297,8 @@ func TestCreateOperators(t *testing.T) {
 		_ = clientsholder.GetTestClientsHolder(nil)
 		clientsholder.SetupFakeOlmClient(runtimeObjects)
 
-		ops := createOperators(tc.csvs, tc.subscriptions, tc.installPlan, tc.catalogSource, false, true)
+		emptyManifests := []*autodiscover.PackageManifest{}
+		ops := createOperators(tc.csvs, tc.subscriptions, emptyManifests, tc.installPlan, tc.catalogSource, false, true)
 		assert.Equal(t, tc.expectedOperators, ops)
 	}
 }

pkg/provider/provider.go

@@ -112,10 +112,11 @@ type TestEnvironment struct { // rename this with testTarget
 	ResourceQuotas         []corev1.ResourceQuota
 	PodDisruptionBudgets   []policyv1.PodDisruptionBudget
 	NetworkPolicies        []networkingv1.NetworkPolicy
-	AllInstallPlans        []*olmv1Alpha.InstallPlan   `json:"AllInstallPlans"`
-	AllSubscriptions       []olmv1Alpha.Subscription   `json:"AllSubscriptions"`
-	AllCatalogSources      []*olmv1Alpha.CatalogSource `json:"-"`
-	OperatorGroups         []*olmv1.OperatorGroup      `json:"OperatorGroups"`
+	AllInstallPlans        []*olmv1Alpha.InstallPlan       `json:"AllInstallPlans"`
+	AllSubscriptions       []olmv1Alpha.Subscription       `json:"AllSubscriptions"`
+	AllCatalogSources      []*olmv1Alpha.CatalogSource     `json:"AllCatalogSources"`
+	AllPackageManifests    []*autodiscover.PackageManifest `json:"AllPackageManifests"`
+	OperatorGroups         []*olmv1.OperatorGroup          `json:"OperatorGroups"`
 	IstioServiceMeshFound  bool
 	ValidProtocolNames     []string
 	DaemonsetFailedToSpawn bool
@@ -240,7 +241,8 @@ func buildTestEnvironment() { //nolint:funlen
 	}
 	env.AllSubscriptions = data.AllSubscriptions
 	env.AllCatalogSources = data.AllCatalogSources
-	env.AllOperators = createOperators(data.AllCsvs, data.AllSubscriptions, data.AllInstallPlans, data.AllCatalogSources, false, true)
+	env.AllPackageManifests = data.AllPackageManifests
+	env.AllOperators = createOperators(data.AllCsvs, data.AllSubscriptions, data.AllPackageManifests, data.AllInstallPlans, data.AllCatalogSources, false, true)
 	env.AllOperatorsSummary = getSummaryAllOperators(env.AllOperators)
 	env.AllCrds = data.AllCrds
 	env.Namespaces = data.Namespaces
@@ -344,7 +346,7 @@ func buildTestEnvironment() { //nolint:funlen
 	env.CollectorAppPassword = data.CollectorAppPassword
 	env.CollectorAppEndpoint = data.CollectorAppEndpoint
 
-	operators := createOperators(data.Csvs, data.AllSubscriptions,
+	operators := createOperators(data.Csvs, data.AllSubscriptions, data.AllPackageManifests,
 		data.AllInstallPlans, data.AllCatalogSources, false, true)
 	env.Operators = operators
 	log.Info("Operators found: %d", len(env.Operators))

tests/certification/suite.go

@@ -134,6 +134,14 @@ func testAllOperatorCertified(check *checksdb.Check, env *provider.TestEnvironme
 	}
 	for _, operator := range operatorsUnderTest {
 		check.LogInfo("Testing Operator %q", operator)
+		if operator.Channel == "" {
+			check.LogError("Operator %q failed to be certified for OpenShift %s because its subscription channel is empty (also failing to retrieve default channel)", operator.Name, ocpMinorVersion)
+			nonCompliantObjects = append(nonCompliantObjects, testhelper.NewOperatorReportObject(operator.Namespace, operator.Name,
+				"Operator failed to be certified for OpenShift because its subscription does not have a valid channel (non-empty) and a default channel could not be found"+
+					". Maybe this operator was using a default channel and its catalog source was removed.", false).
+				AddField(testhelper.OCPVersion, ocpMinorVersion).
+				AddField(testhelper.OCPChannel, operator.Channel))
+		}
 		isCertified := validator.IsOperatorCertified(operator.Name, ocpMinorVersion, operator.Channel)
 		if !isCertified {
 			check.LogError("Operator %q (channel %q) failed to be certified for OpenShift %s", operator.Name, operator.Channel, ocpMinorVersion)