Add listener based on the machine label and listener label

Author: Shilpa-Gokul

api/v1beta2/ibmvpccluster_types.go

@@ -127,6 +127,10 @@ type AdditionalListenerSpec struct {
 	// Will default to TCP protocol if not specified.
 	// +optional
 	Protocol *VPCLoadBalancerListenerProtocol `json:"protocol,omitempty"`
+
+	// selector is used to select the machines with same label to assign the listener
+	// +kubebuilder:validation:Optional
+	Selector metav1.LabelSelector `json:"selector,omitempty"`
 }
 
 // VPCLoadBalancerBackendPoolSpec defines the desired configuration of a VPC Load Balancer Backend Pool.

api/v1beta2/zz_generated.deepcopy.go

@@ -44,6 +44,8 @@ import (
 	"github.com/IBM/vpc-go-sdk/vpcv1"
 
 	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/intstr"
 	"k8s.io/client-go/tools/cache"
@@ -996,7 +998,45 @@ func (m *PowerVSMachineScope) CreateVPCLoadBalancerPoolMember(ctx context.Contex
 
 		internalIP := m.GetMachineInternalIP()
 
+		// lbAdditionalListeners is a mapping of additionalListener's port-protocol to the additionalListener as defined in the specification
+		// It will be used later to get the default pool associated with the listener
+		lbAdditionalListeners := map[string]infrav1beta2.AdditionalListenerSpec{}
+		for _, additionalListener := range lb.AdditionalListeners {
+			if additionalListener.Protocol == nil {
+				additionalListener.Protocol = &infrav1beta2.VPCLoadBalancerListenerProtocolTCP
+			}
+			lbAdditionalListeners[fmt.Sprintf("%d-%s", additionalListener.Port, *additionalListener.Protocol)] = additionalListener
+		}
+
+		// loadBalancerListeners is a mapping of the loadBalancer listener's defaultPoolName to the additionalListener
+		// as the default pool name might be empty in spec and should be fetched from the cloud's listener
+		loadBalancerListeners := map[string]infrav1beta2.AdditionalListenerSpec{}
+		for _, listener := range loadBalancer.Listeners {
+			listenerOptions := &vpcv1.GetLoadBalancerListenerOptions{}
+			listenerOptions.SetLoadBalancerID(*loadBalancer.ID)
+			listenerOptions.SetID(*listener.ID)
+			loadBalancerListener, _, err := m.IBMVPCClient.GetLoadBalancerListener(listenerOptions)
+			if err != nil {
+				return nil, fmt.Errorf("failed to list %s load balancer listener: %w", *listener.ID, err)
+			}
+			if additionalListener, ok := lbAdditionalListeners[fmt.Sprintf("%d-%s", *loadBalancerListener.Port, *loadBalancerListener.Protocol)]; ok {
+				if loadBalancerListener.DefaultPool != nil {
+					loadBalancerListeners[*loadBalancerListener.DefaultPool.Name] = additionalListener
+				}
+			} else if loadBalancerListener.Port != nil && *loadBalancerListener.Port == int64(6443) {
+				// add default pool 6443 to all control plane machines
+				log.V(3).Info("loadbalancerlisteners port match", "port", loadBalancerListener.Port)
+
+				protocol := infrav1beta2.VPCLoadBalancerListenerProtocol(*loadBalancerListener.Protocol)
+				listener := infrav1beta2.AdditionalListenerSpec{
+					Port:     *loadBalancerListener.Port,
+					Protocol: &protocol,
+				}
+				loadBalancerListeners[*loadBalancerListener.DefaultPool.Name] = listener
+			}
+		}
 		// Update each LoadBalancer pool
+		// For each pool, get the additionalListener associated with the pool from the loadBalancerListeners map.
 		for _, pool := range loadBalancer.Pools {
 			log.V(3).Info("Updating LoadBalancer pool member", "pool", *pool.Name, "loadBalancerName", *loadBalancer.Name, "IP", internalIP)
 			listOptions := &vpcv1.ListLoadBalancerPoolMembersOptions{}
@@ -1009,32 +1049,35 @@ func (m *PowerVSMachineScope) CreateVPCLoadBalancerPoolMember(ctx context.Contex
 			var targetPort int64
 			var alreadyRegistered bool
 
-			if len(listLoadBalancerPoolMembers.Members) == 0 {
-				// For adding the first member to the pool we depend on the pool name to get the target port
-				// pool name will have port number appended at the end
-				lbNameSplit := strings.Split(*pool.Name, "-")
-				if len(lbNameSplit) == 0 {
-					// user might have created additional pool
-					log.V(3).Info("Not updating pool as it might be created externally", "poolName", *pool.Name)
+			if loadBalancerListener, ok := loadBalancerListeners[*pool.Name]; ok {
+				targetPort = loadBalancerListener.Port
+				log.V(3).Info("Checking if machine label matches with the label selector in listener", "machine label", m.IBMPowerVSMachine.Labels, "label selector", loadBalancerListener.Selector)
+				selector, err := metav1.LabelSelectorAsSelector(&loadBalancerListener.Selector)
+				if err != nil {
+					log.V(5).Error(err, "Skipping listener addition, failed to get label selector from spec selector")
 					continue
 				}
-				targetPort, err = strconv.ParseInt(lbNameSplit[len(lbNameSplit)-1], 10, 64)
-				if err != nil {
-					// user might have created additional pool
-					log.Error(err, "unable to fetch target port from pool name", "poolName", *pool.Name)
+
+				if selector.Empty() && !util.IsControlPlaneMachine(m.Machine) {
+					log.V(3).Info("Skipping listener addition as the selector is empty and not a control plane machine")
+					continue
+				}
+				// Skip adding the listener if the selector does not match
+				if !selector.Empty() && !selector.Matches(labels.Set(m.IBMPowerVSMachine.Labels)) {
+					log.V(3).Info("Skip adding listener, machine label doesn't match with the listener label selector", "pool", *pool.Name, "IP", internalIP)
 					continue
 				}
-			} else {
-				for _, member := range listLoadBalancerPoolMembers.Members {
-					if target, ok := member.Target.(*vpcv1.LoadBalancerPoolMemberTarget); ok {
-						targetPort = *member.Port
-						if *target.Address == internalIP {
-							alreadyRegistered = true
-							log.V(3).Info("Target IP already configured for pool", "IP", internalIP, "poolName", *pool.Name)
-						}
+			}
+
+			for _, member := range listLoadBalancerPoolMembers.Members {
+				if target, ok := member.Target.(*vpcv1.LoadBalancerPoolMemberTarget); ok {
+					if *target.Address == internalIP {
+						alreadyRegistered = true
+						log.V(3).Info("Target IP already configured for pool", "IP", internalIP, "poolName", *pool.Name)
 					}
 				}
 			}
+
 			if alreadyRegistered {
 				log.V(3).Info("PoolMember already exist", "poolName", *pool.Name, "IP", internalIP, "targetPort", targetPort)
 				continue