Bug 1870922: oc get PodNetworkConnectivityCheck -n openshift-apiserver has no resource

pkg/operator/connectivitycheckcontroller/connectivity_check_controller.go

@@ -17,12 +17,8 @@ import (
 	"github.com/openshift/library-go/pkg/controller/factory"
 	"github.com/openshift/library-go/pkg/operator/connectivitycheckcontroller"
 	"github.com/openshift/library-go/pkg/operator/events"
-	"github.com/openshift/library-go/pkg/operator/resource/resourcehelper"
 	"github.com/openshift/library-go/pkg/operator/v1helpers"
 	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/equality"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/client-go/kubernetes"
@@ -86,27 +82,22 @@ type connectivityCheckTemplateProvider struct {
 }
 
 func (c *connectivityCheckTemplateProvider) generate(ctx context.Context, syncContext factory.SyncContext) ([]*v1alpha1.PodNetworkConnectivityCheck, error) {
-	return nil, nil
-}
-
-func (c *connectivityCheckTemplateProvider) getPodNetworkConnectivityChecks(ctx context.Context, operatorSpec *operatorv1.OperatorSpec, recorder events.Recorder) {
-
 	var templates []*v1alpha1.PodNetworkConnectivityCheck
 	// each storage endpoint
-	templates = append(templates, c.getTemplatesForStorageChecks(recorder)...)
+	templates = append(templates, c.getTemplatesForEtcdChecks(syncContext.Recorder())...)
 	// kas service IP
-	templates = append(templates, c.getTemplatesForKubernetesServiceMonitorService(recorder)...)
+	templates = append(templates, c.getTemplatesForKubernetesServiceMonitorService(syncContext.Recorder())...)
 	// kas default service IP
-	templates = append(templates, c.getTemplatesForKubernetesDefaultServiceCheck(recorder)...)
+	templates = append(templates, c.getTemplatesForKubernetesDefaultServiceCheck(syncContext.Recorder())...)
 	// each kas endpoint IP
-	templates = append(templates, c.getTemplatesForKubernetesServiceEndpointsChecks(recorder)...)
+	templates = append(templates, c.getTemplatesForKubernetesServiceEndpointsChecks(syncContext.Recorder())...)
 	// each api load balancer hostname
-	templates = append(templates, c.getTemplatesForApiLoadBalancerChecks(recorder)...)
+	templates = append(templates, c.getTemplatesForApiLoadBalancerChecks(syncContext.Recorder())...)
 
 	pods, err := c.podLister.List(labels.Set{"apiserver": "true"}.AsSelector())
 	if err != nil {
-		recorder.Warningf("EndpointDetectionFailure", "failed to list openshift-apiserver pods: %v", err)
-		return
+		syncContext.Recorder().Warningf("EndpointDetectionFailure", "failed to list openshift-apiserver pods: %v", err)
+		return nil, nil
 	}
 
 	// create each check per static pod
@@ -123,33 +114,7 @@ func (c *connectivityCheckTemplateProvider) getPodNetworkConnectivityChecks(ctx
 			checks = append(checks, check)
 		}
 	}
-
-	pnccClient := c.operatorcontrolplaneClient.ControlplaneV1alpha1().PodNetworkConnectivityChecks(operatorclient.TargetNamespace)
-	for _, check := range checks {
-		existing, err := pnccClient.Get(ctx, check.Name, metav1.GetOptions{})
-		if err == nil {
-			if equality.Semantic.DeepEqual(existing.Spec, check.Spec) {
-				// already exists, no changes, skip
-				continue
-			}
-			updated := existing.DeepCopy()
-			updated.Spec = *check.Spec.DeepCopy()
-			_, err := pnccClient.Update(ctx, updated, metav1.UpdateOptions{})
-			if err != nil {
-				recorder.Warningf("EndpointDetectionFailure", "%s: %v", resourcehelper.FormatResourceForCLIWithNamespace(check), err)
-				continue
-			}
-			recorder.Eventf("EndpointCheckUpdated", "Updated %s because it changed.", resourcehelper.FormatResourceForCLIWithNamespace(check))
-		}
-		if apierrors.IsNotFound(err) {
-			_, err = pnccClient.Create(ctx, check, metav1.CreateOptions{})
-		}
-		if err != nil {
-			recorder.Warningf("EndpointDetectionFailure", "%s: %v", resourcehelper.FormatResourceForCLIWithNamespace(check), err)
-			continue
-		}
-		recorder.Eventf("EndpointCheckCreated", "Created %s because it was missing.", resourcehelper.FormatResourceForCLIWithNamespace(check))
-	}
+	return checks, nil
 }
 
 func (c *connectivityCheckTemplateProvider) getTemplatesForKubernetesDefaultServiceCheck(recorder events.Recorder) []*v1alpha1.PodNetworkConnectivityCheck {
@@ -220,18 +185,18 @@ func (c *connectivityCheckTemplateProvider) listAddressesForKubeAPIServerService
 	return results, nil
 }
 
-func (c *connectivityCheckTemplateProvider) getTemplatesForStorageChecks(recorder events.Recorder) []*v1alpha1.PodNetworkConnectivityCheck {
+func (c *connectivityCheckTemplateProvider) getTemplatesForEtcdChecks(recorder events.Recorder) []*v1alpha1.PodNetworkConnectivityCheck {
 	operatorSpec, _, _, err := c.operatorClient.GetOperatorState()
 	if err != nil {
-		recorder.Warningf("EndpointDetectionFailure", "unable to determine storage endpoints: %v", err)
+		recorder.Warningf("EndpointDetectionFailure", "unable to determine etcd server endpoints: %v", err)
 		return nil
 	}
 	var templates []*v1alpha1.PodNetworkConnectivityCheck
 	for _, endpointInfo := range c.listAddressesForStorageEndpoints(operatorSpec, recorder) {
 		templates = append(templates, NewPodNetworkConnectivityCheckTemplate(
 			net.JoinHostPort(endpointInfo.hostName, endpointInfo.port),
 			operatorclient.TargetNamespace,
-			withTarget("storage-endpoint", endpointInfo.nodeName),
+			withTarget("etcd-server", endpointInfo.nodeName),
 			WithTlsClientCert("etcd-client")))
 	}
 	return templates

test/e2e/connectivity_check_test.go

@@ -0,0 +1,71 @@
+package e2e
+
+import (
+	"context"
+	"regexp"
+	"testing"
+
+	operatorcontrolplaneclient "github.com/openshift/client-go/operatorcontrolplane/clientset/versioned"
+	"github.com/openshift/cluster-openshift-apiserver-operator/pkg/operator/operatorclient"
+	test "github.com/openshift/cluster-openshift-apiserver-operator/test/library"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func TestConnectivityChecksCreated(t *testing.T) {
+	kubeConfig, err := test.NewClientConfigForTest()
+	require.NoError(t, err)
+	operatorControlPlaneClient, err := operatorcontrolplaneclient.NewForConfig(kubeConfig)
+	require.NoError(t, err)
+	checks, err := operatorControlPlaneClient.ControlplaneV1alpha1().PodNetworkConnectivityChecks(operatorclient.TargetNamespace).List(context.TODO(), metav1.ListOptions{})
+	require.NoError(t, err)
+	testCases := []struct {
+		name    string
+		pattern string
+		count   int
+	}{
+		{
+			name:    "etcd-server",
+			pattern: `^apiserver-.*-to-etcd-server-.*$`,
+			count:   9,
+		},
+		{
+			name:    "kubernetes-apiserver-service",
+			pattern: `^apiserver-.*-to-kubernetes-apiserver-service-.*$`,
+			count:   3,
+		},
+		{
+			name:    "kubernetes-apiserver-endpoint",
+			pattern: `^apiserver-.*-to-kubernetes-apiserver-endpoint-.*$`,
+			count:   9,
+		},
+		{
+			name:    "kubernetes-default-service",
+			pattern: `^apiserver-.*-to-kubernetes-default-service-.*$`,
+			count:   3,
+		},
+		{
+			name:    "load-balancer-api-external",
+			pattern: `^apiserver-.*-to-load-balancer-api-external$`,
+			count:   3,
+		},
+		{
+			name:    "load-balancer-api-internal",
+			pattern: `^apiserver-.*-to-load-balancer-api-internal$`,
+			count:   3,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			var count int
+			regex := regexp.MustCompile(tc.pattern)
+			for _, check := range checks.Items {
+				if regex.MatchString(check.Name) {
+					count++
+				}
+			}
+			assert.Equal(t, tc.count, count)
+		})
+	}
+}