OSASINFRA-4400: Add support for max_allowed_address_pairs OpenStack

bindata/cloud-network-config-controller/managed/controller.yaml

@@ -165,6 +165,9 @@ spec:
               -platform-aws-ca-override={{.PlatformAWSCAPath}} \
               -platform-azure-environment={{.PlatformAzureEnvironment}} \
               -secret-name cloud-network-config-controller-creds \
+{{- if .OpenStackMaxAllowedAddressPairs }}
+              -platform-os-max-allowed-address-pairs={{ .OpenStackMaxAllowedAddressPairs }} \
+{{- end }}
               -kubeconfig /var/run/secrets/hosted_cluster/kubeconfig
         env:
         - name: CONTROLLER_NAMESPACE

bindata/cloud-network-config-controller/self-hosted/controller.yaml

@@ -42,12 +42,16 @@ spec:
         image: {{.CloudNetworkConfigControllerImage}}
         imagePullPolicy: IfNotPresent
         command: ["/usr/bin/cloud-network-config-controller"]
-        args: [ "-platform-type", "{{.PlatformType}}",
-                "-platform-region={{.PlatformRegion}}",
-                "-platform-api-url={{.PlatformAPIURL}}",
-                "-platform-aws-ca-override={{.PlatformAWSCAPath}}",
-                "-platform-azure-environment={{.PlatformAzureEnvironment}}",
-                "-secret-name", "cloud-credentials"]
+        args:
+        - "-platform-type={{.PlatformType}}"
+        - "-platform-region={{.PlatformRegion}}"
+        - "-platform-api-url={{.PlatformAPIURL}}"
+        - "-platform-aws-ca-override={{.PlatformAWSCAPath}}"
+        - "-platform-azure-environment={{.PlatformAzureEnvironment}}"
+        - "-secret-name=cloud-credentials"
+{{- if .OpenStackMaxAllowedAddressPairs }}
+        - "-platform-os-max-allowed-address-pairs={{ .OpenStackMaxAllowedAddressPairs }}"
+{{- end }}
         env:
         - name: CONTROLLER_NAMESPACE
           valueFrom:

pkg/bootstrap/types.go

@@ -97,12 +97,20 @@ type IPTablesAlerterBootstrapResult struct {
 	Enabled bool
 }
 
+// CloudNetworkConfigBootstrapResult contains bootstrap configuration
+// read from the cloud-network-config ConfigMap.
+type CloudNetworkConfigBootstrapResult struct {
+	OpenStackMaxAllowedAddressPairs int
+}
+
 type BootstrapResult struct {
 	Infra InfraStatus
 
 	OVN             OVNBootstrapResult
 	IPTablesAlerter IPTablesAlerterBootstrapResult
 	TLSProfile      TLSProfile
+
+	CloudNetworkConfig CloudNetworkConfigBootstrapResult
 }
 
 type InfraStatus struct {

pkg/network/bootstrap.go

@@ -2,10 +2,14 @@ package network
 
 import (
 	"context"
+	"fmt"
+	"strconv"
 
+	configv1 "github.com/openshift/api/config/v1"
 	operv1 "github.com/openshift/api/operator/v1"
 	"github.com/openshift/cluster-network-operator/pkg/bootstrap"
 	cnoclient "github.com/openshift/cluster-network-operator/pkg/client"
+	"github.com/openshift/cluster-network-operator/pkg/names"
 	"github.com/openshift/cluster-network-operator/pkg/platform"
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
@@ -34,6 +38,14 @@ func Bootstrap(conf *operv1.Network, client cnoclient.Client) (*bootstrap.Bootst
 
 	out.IPTablesAlerter = iptablesAlerterBootstrap(client.ClientFor("").CRClient())
 
+	if infraStatus.PlatformType == configv1.OpenStackPlatformType {
+		cnc, err := cloudNetworkConfigBootstrap(context.Background(), client.ClientFor("").CRClient())
+		if err != nil {
+			return nil, err
+		}
+		out.CloudNetworkConfig = cnc
+	}
+
 	out.TLSProfile, err = GetTLSProfile(client, infraStatus.HostedControlPlane)
 	if err != nil {
 		return nil, err
@@ -67,3 +79,36 @@ func iptablesAlerterBootstrap(cl crclient.Reader) bootstrap.IPTablesAlerterBoots
 
 	return result
 }
+
+func cloudNetworkConfigBootstrap(ctx context.Context, cl crclient.Reader) (bootstrap.CloudNetworkConfigBootstrapResult, error) {
+	result := bootstrap.CloudNetworkConfigBootstrapResult{}
+
+	cm := &corev1.ConfigMap{}
+	if err := cl.Get(ctx, types.NamespacedName{
+		Namespace: names.APPLIED_NAMESPACE,
+		Name:      "cloud-network-config",
+	}, cm); err != nil {
+		if !apierrors.IsNotFound(err) {
+			return result, fmt.Errorf("error fetching cloud-network-config configmap: %w", err)
+		}
+		return result, nil
+	}
+
+	raw, ok := cm.Data["platform-os-max-allowed-address-pairs"]
+	if !ok {
+		return result, nil
+	}
+
+	val, err := strconv.Atoi(raw)
+	if err != nil {
+		return result, fmt.Errorf("error parsing cloud-network-config platform-os-max-allowed-address-pairs=%q: %w", raw, err)
+	}
+
+	if val <= 0 {
+		return result, fmt.Errorf("invalid cloud-network-config: platform-os-max-allowed-address-pairs must be a non-zero, positive integer, got %d", val)
+	}
+
+	result.OpenStackMaxAllowedAddressPairs = val
+
+	return result, nil
+}

pkg/network/bootstrap_test.go

@@ -219,3 +219,169 @@ func TestBootstrap(t *testing.T) {
 		})
 	})
 }
+
+func TestBootstrapCloudNetworkConfig(t *testing.T) {
+	baseOperConfig := &operv1.Network{
+		ObjectMeta: metav1.ObjectMeta{Name: names.OPERATOR_CONFIG},
+		Spec: operv1.NetworkSpec{
+			DefaultNetwork: operv1.DefaultNetworkDefinition{
+				Type: operv1.NetworkTypeOVNKubernetes,
+				OVNKubernetesConfig: &operv1.OVNKubernetesConfig{
+					MTU: nil,
+				},
+			},
+		},
+	}
+
+	baseClientObjs := func(platformType configv1.PlatformType) []crclient.Object {
+		return []crclient.Object{
+			&configv1.Infrastructure{
+				ObjectMeta: metav1.ObjectMeta{Name: "cluster"},
+				Status: configv1.InfrastructureStatus{
+					PlatformStatus: &configv1.PlatformStatus{
+						Type: platformType,
+					},
+				},
+			},
+			&configv1.Proxy{
+				ObjectMeta: metav1.ObjectMeta{Name: "cluster"},
+			},
+			&corev1.ConfigMap{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      network.CLUSTER_CONFIG_NAME,
+					Namespace: network.CLUSTER_CONFIG_NAMESPACE,
+				},
+				Data: map[string]string{
+					"install-config": "controlPlane:\n  replicas: 3\n",
+				},
+			},
+			&configv1.APIServer{
+				ObjectMeta: metav1.ObjectMeta{Name: "cluster"},
+			},
+		}
+	}
+
+	tests := []struct {
+		name         string
+		platformType configv1.PlatformType
+		configMap    *corev1.ConfigMap
+		expectValue  int
+		expectErr    bool
+	}{
+		{
+			name:         "skipped on non-OpenStack platform",
+			platformType: configv1.NonePlatformType,
+			configMap: &corev1.ConfigMap{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "cloud-network-config",
+					Namespace: "openshift-network-operator",
+				},
+				Data: map[string]string{
+					"platform-os-max-allowed-address-pairs": "20",
+				},
+			},
+			expectValue: 0,
+		},
+		{
+			name:         "ConfigMap absent",
+			platformType: configv1.OpenStackPlatformType,
+			configMap:    nil,
+			expectValue:  0,
+		},
+		{
+			name:         "key missing from ConfigMap",
+			platformType: configv1.OpenStackPlatformType,
+			configMap: &corev1.ConfigMap{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "cloud-network-config",
+					Namespace: "openshift-network-operator",
+				},
+				Data: map[string]string{"other-key": "value"},
+			},
+			expectValue: 0,
+		},
+		{
+			name:         "valid value 20",
+			platformType: configv1.OpenStackPlatformType,
+			configMap: &corev1.ConfigMap{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "cloud-network-config",
+					Namespace: "openshift-network-operator",
+				},
+				Data: map[string]string{
+					"platform-os-max-allowed-address-pairs": "20",
+				},
+			},
+			expectValue: 20,
+		},
+		{
+			name:         "zero value",
+			platformType: configv1.OpenStackPlatformType,
+			configMap: &corev1.ConfigMap{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "cloud-network-config",
+					Namespace: "openshift-network-operator",
+				},
+				Data: map[string]string{
+					"platform-os-max-allowed-address-pairs": "0",
+				},
+			},
+			expectErr: true,
+		},
+		{
+			name:         "negative value",
+			platformType: configv1.OpenStackPlatformType,
+			configMap: &corev1.ConfigMap{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "cloud-network-config",
+					Namespace: "openshift-network-operator",
+				},
+				Data: map[string]string{
+					"platform-os-max-allowed-address-pairs": "-5",
+				},
+			},
+			expectErr: true,
+		},
+		{
+			name:         "non-integer value",
+			platformType: configv1.OpenStackPlatformType,
+			configMap: &corev1.ConfigMap{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "cloud-network-config",
+					Namespace: "openshift-network-operator",
+				},
+				Data: map[string]string{
+					"platform-os-max-allowed-address-pairs": "abc",
+				},
+			},
+			expectValue: 0,
+			expectErr:   true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			objs := baseClientObjs(tc.platformType)
+			if tc.configMap != nil {
+				objs = append(objs, tc.configMap)
+			}
+			client := fakeclient.NewFakeClient(objs...)
+
+			result, err := network.Bootstrap(baseOperConfig, client)
+			if tc.expectErr {
+				if err == nil {
+					t.Errorf("expected error, got nil")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("Bootstrap failed: %v", err)
+			}
+
+			got := result.CloudNetworkConfig.OpenStackMaxAllowedAddressPairs
+			if got != tc.expectValue {
+				t.Errorf("expected %d, got %d", tc.expectValue, got)
+			}
+		})
+	}
+}

pkg/network/cloud_network.go

@@ -48,6 +48,7 @@ func renderCloudNetworkConfigController(conf *operv1.NetworkSpec, bootstrapResul
 	data.Data["ExternalControlPlane"] = cloudBootstrapResult.ControlPlaneTopology == configv1.ExternalTopologyMode
 	data.Data["PlatformAzureEnvironment"] = ""
 	data.Data["PlatformAWSCAPath"] = ""
+	data.Data["OpenStackMaxAllowedAddressPairs"] = bootstrapResult.CloudNetworkConfig.OpenStackMaxAllowedAddressPairs
 
 	// AWS and azure allow for funky endpoint overriding.
 	// in different ways, of course.