Adding support for ModifyLoadbalancer in windows kubeproxy.

Author: princepereira

pkg/proxy/winkernel/hcnutils.go

@@ -20,7 +20,6 @@ limitations under the License.
 package winkernel
 
 import (
-	"github.com/Microsoft/hcsshim"
 	"github.com/Microsoft/hcsshim/hcn"
 	"k8s.io/klog/v2"
 )
@@ -41,6 +40,7 @@ type HcnService interface {
 	ListLoadBalancers() ([]hcn.HostComputeLoadBalancer, error)
 	GetLoadBalancerByID(loadBalancerId string) (*hcn.HostComputeLoadBalancer, error)
 	CreateLoadBalancer(loadBalancer *hcn.HostComputeLoadBalancer) (*hcn.HostComputeLoadBalancer, error)
+	UpdateLoadBalancer(loadBalancer *hcn.HostComputeLoadBalancer, hnsID string) (*hcn.HostComputeLoadBalancer, error)
 	DeleteLoadBalancer(loadBalancer *hcn.HostComputeLoadBalancer) error
 	// Features functions
 	GetSupportedFeatures() hcn.SupportedFeatures
@@ -104,6 +104,10 @@ func (hcnObj hcnImpl) CreateLoadBalancer(loadBalancer *hcn.HostComputeLoadBalanc
 	return loadBalancer.Create()
 }
 
+func (hcnObj hcnImpl) UpdateLoadBalancer(loadBalancer *hcn.HostComputeLoadBalancer, hnsID string) (*hcn.HostComputeLoadBalancer, error) {
+	return loadBalancer.Update(hnsID)
+}
+
 func (hcnObj hcnImpl) DeleteLoadBalancer(loadBalancer *hcn.HostComputeLoadBalancer) error {
 	return loadBalancer.Delete()
 }
@@ -121,15 +125,16 @@ func (hcnObj hcnImpl) DsrSupported() error {
 }
 
 func (hcnObj hcnImpl) DeleteAllHnsLoadBalancerPolicy() {
-	plists, err := hcsshim.HNSListPolicyListRequest()
+	lbs, err := hcnObj.ListLoadBalancers()
 	if err != nil {
+		klog.V(2).ErrorS(err, "Deleting all existing loadbalancers failed.")
 		return
 	}
-	for _, plist := range plists {
-		klog.V(3).InfoS("Remove policy", "policies", plist)
-		_, err = plist.Delete()
+	klog.V(3).InfoS("Deleting all existing loadbalancers", "lbCount", len(lbs))
+	for _, lb := range lbs {
+		err = lb.Delete()
 		if err != nil {
-			klog.ErrorS(err, "Failed to delete policy list")
+			klog.V(2).ErrorS(err, "Error deleting existing loadbalancer", "lb", lb)
 		}
 	}
 }

pkg/proxy/winkernel/hns.go

@@ -40,6 +40,7 @@ type HostNetworkService interface {
 	deleteEndpoint(hnsID string) error
 	getLoadBalancer(endpoints []endpointInfo, flags loadBalancerFlags, sourceVip string, vip string, protocol uint16, internalPort uint16, externalPort uint16, previousLoadBalancers map[loadBalancerIdentifier]*loadBalancerInfo) (*loadBalancerInfo, error)
 	getAllLoadBalancers() (map[loadBalancerIdentifier]*loadBalancerInfo, error)
+	updateLoadBalancer(hnsID string, sourceVip, vip string, endpoints []endpointInfo, flags loadBalancerFlags, protocol, internalPort, externalPort uint16, previousLoadBalancers map[loadBalancerIdentifier]*loadBalancerInfo) (*loadBalancerInfo, error)
 	deleteLoadBalancer(hnsID string) error
 }
 
@@ -54,6 +55,33 @@ var (
 	LoadBalancerPortMappingFlagsVipExternalIP hcn.LoadBalancerPortMappingFlags = 16
 )
 
+func getLoadBalancerPolicyFlags(flags loadBalancerFlags) (lbPortMappingFlags hcn.LoadBalancerPortMappingFlags, lbFlags hcn.LoadBalancerFlags) {
+	lbPortMappingFlags = hcn.LoadBalancerPortMappingFlagsNone
+	if flags.isILB {
+		lbPortMappingFlags |= hcn.LoadBalancerPortMappingFlagsILB
+	}
+	if flags.useMUX {
+		lbPortMappingFlags |= hcn.LoadBalancerPortMappingFlagsUseMux
+	}
+	if flags.preserveDIP {
+		lbPortMappingFlags |= hcn.LoadBalancerPortMappingFlagsPreserveDIP
+	}
+	if flags.localRoutedVIP {
+		lbPortMappingFlags |= hcn.LoadBalancerPortMappingFlagsLocalRoutedVIP
+	}
+	if flags.isVipExternalIP {
+		lbPortMappingFlags |= LoadBalancerPortMappingFlagsVipExternalIP
+	}
+	lbFlags = hcn.LoadBalancerFlagsNone
+	if flags.isDSR {
+		lbFlags |= hcn.LoadBalancerFlagsDSR
+	}
+	if flags.isIPv6 {
+		lbFlags |= LoadBalancerFlagsIPv6
+	}
+	return
+}
+
 func (hns hns) getNetworkByName(name string) (*hnsNetworkInfo, error) {
 	hnsnetwork, err := hns.hcn.GetNetworkByName(name)
 	if err != nil {
@@ -406,6 +434,84 @@ func (hns hns) getLoadBalancer(endpoints []endpointInfo, flags loadBalancerFlags
 	return lbInfo, err
 }
 
+func (hns hns) updateLoadBalancer(hnsID string,
+	sourceVip,
+	vip string,
+	endpoints []endpointInfo,
+	flags loadBalancerFlags,
+	protocol,
+	internalPort,
+	externalPort uint16,
+	previousLoadBalancers map[loadBalancerIdentifier]*loadBalancerInfo) (*loadBalancerInfo, error) {
+	klog.V(3).InfoS("Updating existing loadbalancer called", "hnsLbID", hnsID, "endpointCount", len(endpoints), "vip", vip, "sourceVip", sourceVip, "internalPort", internalPort, "externalPort", externalPort)
+
+	var id loadBalancerIdentifier
+	vips := []string{}
+	// Compute hash from backends (endpoint IDs)
+	hash, err := hashEndpoints(endpoints)
+	if err != nil {
+		klog.V(2).ErrorS(err, "Error hashing endpoints", "endpoints", endpoints)
+		return nil, err
+	}
+	if len(vip) > 0 {
+		id = loadBalancerIdentifier{protocol: protocol, internalPort: internalPort, externalPort: externalPort, vip: vip, endpointsHash: hash}
+		vips = append(vips, vip)
+	} else {
+		id = loadBalancerIdentifier{protocol: protocol, internalPort: internalPort, externalPort: externalPort, endpointsHash: hash}
+	}
+
+	if lb, found := previousLoadBalancers[id]; found {
+		klog.V(1).InfoS("Found cached Hns loadbalancer policy resource", "policies", lb)
+		return lb, nil
+	}
+
+	lbPortMappingFlags, lbFlags := getLoadBalancerPolicyFlags(flags)
+
+	lbDistributionType := hcn.LoadBalancerDistributionNone
+
+	if flags.sessionAffinity {
+		lbDistributionType = hcn.LoadBalancerDistributionSourceIP
+	}
+
+	loadBalancer := &hcn.HostComputeLoadBalancer{
+		SourceVIP: sourceVip,
+		PortMappings: []hcn.LoadBalancerPortMapping{
+			{
+				Protocol:         uint32(protocol),
+				InternalPort:     internalPort,
+				ExternalPort:     externalPort,
+				DistributionType: lbDistributionType,
+				Flags:            lbPortMappingFlags,
+			},
+		},
+		FrontendVIPs: vips,
+		SchemaVersion: hcn.SchemaVersion{
+			Major: 2,
+			Minor: 0,
+		},
+		Flags: lbFlags,
+	}
+
+	for _, ep := range endpoints {
+		loadBalancer.HostComputeEndpoints = append(loadBalancer.HostComputeEndpoints, ep.hnsID)
+	}
+
+	lb, err := hns.hcn.UpdateLoadBalancer(loadBalancer, hnsID)
+
+	if err != nil {
+		klog.V(2).ErrorS(err, "Error updating existing loadbalancer", "hnsLbID", hnsID, "error", err, "endpoints", endpoints)
+		return nil, err
+	}
+
+	klog.V(1).InfoS("Update loadbalancer is successful", "loadBalancer", lb)
+	lbInfo := &loadBalancerInfo{
+		hnsID: lb.Id,
+	}
+	// Add to map of load balancers
+	previousLoadBalancers[id] = lbInfo
+	return lbInfo, err
+}
+
 func (hns hns) deleteLoadBalancer(hnsID string) error {
 	lb, err := hns.hcn.GetLoadBalancerByID(hnsID)
 	if err != nil {
@@ -440,7 +546,7 @@ func hashEndpoints[T string | endpointInfo](endpoints []T) (hash [20]byte, err e
 		case endpointInfo:
 			id = strings.ToUpper(x.hnsID)
 		case string:
-			id = x
+			id = strings.ToUpper(x)
 		}
 		if len(id) > 0 {
 			// We XOR the hashes of endpoints, since they are an unordered set.