fix(krnode): apply suggestions from code review

Co-authored-by: Tom Wieczorek <twz123@users.noreply.github.com>

pkg/controllers/netpol/network_policy_controller.go

@@ -63,7 +63,7 @@ var (
 
 // NetworkPolicyController struct to hold information required by NetworkPolicyController
 type NetworkPolicyController struct {
-	krNode                      utils.NodeAware
+	krNode                      utils.NodeIPAndFamilyAware
 	serviceClusterIPRanges      []net.IPNet
 	serviceExternalIPRanges     []net.IPNet
 	serviceLoadBalancerIPRanges []net.IPNet

pkg/controllers/proxy/network_services_controller_test.go

@@ -141,9 +141,11 @@ var _ = Describe("NetworkServicesController", func() {
 			fatalf("failed to create existing services: %v", err)
 		}
 
-		krNode := &utils.KRNode{
+		krNode := &utils.LocalKRNode{
+			KRNode: utils.KRNode{
 				NodeName:  "node-1",
 				PrimaryIP: net.ParseIP("10.0.0.0"),
+			},
 		}
 		nsc = &NetworkServicesController{
 			krNode: krNode,

pkg/controllers/proxy/utils_test.go

@@ -24,9 +24,11 @@ func getMoqNSC() *NetworkServicesController {
 		setupRoutesForExternalIPForDSRFunc: lnm.setupRoutesForExternalIPForDSR,
 	}
 
-	krNode := &utils.KRNode{
+	krNode := &utils.LocalKRNode{
+		KRNode: utils.KRNode{
 			NodeName:  "node-1",
 			PrimaryIP: net.ParseIP("10.0.0.0"),
+		},
 	}
 	return &NetworkServicesController{
 		krNode:    krNode,
@@ -191,9 +193,11 @@ func TestIsValidKubeRouterServiceArtifact(t *testing.T) {
 		loadBalancerIPs: []string{"172.16.0.3"},
 	}
 
-	krNode := &utils.KRNode{
+	krNode := &utils.LocalKRNode{
+		KRNode: utils.KRNode{
 			NodeName:  "node-1",
 			PrimaryIP: net.ParseIP("192.168.1.10"),
+		},
 	}
 
 	nsc := &NetworkServicesController{

pkg/controllers/routing/bgp_policies_test.go

@@ -36,8 +36,10 @@ type PolicyTestCase struct {
 }
 
 func Test_AddPolicies(t *testing.T) {
-	ipv4CapableKRNode := &utils.KRNode{
+	ipv4CapableKRNode := &utils.LocalKRNode{
+		KRNode: utils.KRNode{
 			NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.IPv4(10, 10, 10, 10)}},
+		},
 	}
 	testcases := []PolicyTestCase{
 		{

pkg/controllers/routing/ecmp_vip_test.go

@@ -56,11 +56,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -98,11 +100,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      false,
 				advertiseExternalIP:     false,
 				advertiseLoadBalancerIP: false,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -140,11 +144,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     false,
 				advertiseLoadBalancerIP: false,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -182,11 +188,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      false,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: false,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -224,11 +232,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      false,
 				advertiseExternalIP:     false,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -266,11 +276,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      false,
 				advertiseExternalIP:     false,
 				advertiseLoadBalancerIP: false,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -337,11 +349,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -395,11 +409,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -445,11 +461,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv6),
 						NodeIPv6Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv6)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -495,11 +513,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:               getClusterSvc(),
@@ -541,11 +561,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv6),
 						NodeIPv6Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv6)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:               getClusterSvc(),
@@ -587,11 +609,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv6Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv6)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -637,11 +661,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv6),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:       getClusterSvc(),
@@ -687,11 +713,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:               getClusterSvc(),
@@ -733,11 +761,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv6),
 						NodeIPv6Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv6)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:               getClusterSvc(),
@@ -779,11 +809,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:               getClusterSvc(),
@@ -825,11 +857,13 @@ func Test_getVIPsForService(t *testing.T) {
 				advertiseClusterIP:      true,
 				advertiseExternalIP:     true,
 				advertiseLoadBalancerIP: true,
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv6),
 						NodeIPv6Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv6)}},
 					},
 				},
+			},
 			serviceAdvertisedIPs: []*ServiceAdvertisedIPs{
 				{
 					service:               getClusterSvc(),

pkg/controllers/routing/network_routes_controller.go

@@ -984,7 +984,7 @@ func (nrc *NetworkRoutingController) syncNodeIPSets(nodeIPAware utils.NodeIPAwar
 		}
 
 		var ipv4Addrs, ipv6Addrs [][]string
-		for _, nodeIPv4 := range nodeIPAware.GetNodeIPv6Addrs() {
+		for _, nodeIPv4 := range nodeIPAware.GetNodeIPv4Addrs() {
 			ipv4Addrs = append(ipv4Addrs, []string{nodeIPv4.String(), utils.OptionTimeout, "0"})
 		}
 		for _, nodeIPv6 := range nodeIPAware.GetNodeIPv6Addrs() {

pkg/controllers/routing/network_routes_controller_test.go

@@ -38,11 +38,13 @@ func Test_advertiseClusterIPs(t *testing.T) {
 			"add bgp path for service with ClusterIP",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -82,11 +84,13 @@ func Test_advertiseClusterIPs(t *testing.T) {
 			"add bgp path for service with ClusterIP/NodePort/LoadBalancer",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -182,11 +186,13 @@ func Test_advertiseClusterIPs(t *testing.T) {
 			"add bgp path for invalid service type",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -252,11 +258,13 @@ func Test_advertiseClusterIPs(t *testing.T) {
 			"add bgp path for headless service",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -467,11 +475,13 @@ func Test_advertiseExternalIPs(t *testing.T) {
 			"add bgp path for service with external IPs",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP("10.0.0.1"),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -513,11 +523,13 @@ func Test_advertiseExternalIPs(t *testing.T) {
 			"add bgp path for services with external IPs of type ClusterIP/NodePort/LoadBalancer",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -617,11 +629,13 @@ func Test_advertiseExternalIPs(t *testing.T) {
 			"add bgp path for invalid service type",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -690,11 +704,13 @@ func Test_advertiseExternalIPs(t *testing.T) {
 			"add bgp path for headless service",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -791,11 +807,13 @@ func Test_advertiseExternalIPs(t *testing.T) {
 			"skip bgp path to loadbalancerIP for service without LoadBalancer IP",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -842,11 +860,13 @@ func Test_advertiseExternalIPs(t *testing.T) {
 			"add bgp path to loadbalancerIP for service with LoadBalancer IP",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -899,11 +919,13 @@ func Test_advertiseExternalIPs(t *testing.T) {
 			"no bgp path to nil loadbalancerIPs for service with LoadBalancer",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -946,11 +968,13 @@ func Test_advertiseExternalIPs(t *testing.T) {
 			"no bgp path to loadbalancerIPs for service with LoadBalancer and skiplbips annotation",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -1120,11 +1144,13 @@ func Test_advertiseAnnotationOptOut(t *testing.T) {
 			"add bgp paths for all service IPs",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -1241,11 +1267,13 @@ func Test_advertiseAnnotationOptOut(t *testing.T) {
 			"opt out to advertise any IPs via annotations",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -1419,11 +1447,13 @@ func Test_advertiseAnnotationOptIn(t *testing.T) {
 			"no bgp paths for any service IPs",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -1532,11 +1562,13 @@ func Test_advertiseAnnotationOptIn(t *testing.T) {
 			"opt in to advertise all IPs via annotations",
 			&NetworkRoutingController{
 				bgpServer: gobgp.NewBgpServer(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			[]*v1core.Service{
 				{
 					ObjectMeta: metav1.ObjectMeta{
@@ -1786,12 +1818,14 @@ func Test_nodeHasEndpointsForService(t *testing.T) {
 		{
 			"node has endpoints for service",
 			&NetworkRoutingController{
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			&v1core.Service{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "svc-1",
@@ -1831,12 +1865,14 @@ func Test_nodeHasEndpointsForService(t *testing.T) {
 		{
 			"node has no endpoints for service",
 			&NetworkRoutingController{
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			&v1core.Service{
 				ObjectMeta: metav1.ObjectMeta{
 					Name:      "svc-1",
@@ -1925,12 +1961,14 @@ func Test_advertisePodRoute(t *testing.T) {
 				bgpServer:    gobgp.NewBgpServer(),
 				podCidr:      "172.20.0.0/24",
 				podIPv4CIDRs: []string{"172.20.0.0/24"},
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			"node-1",
 			&v1core.Node{
 				ObjectMeta: metav1.ObjectMeta{
@@ -1955,12 +1993,14 @@ func Test_advertisePodRoute(t *testing.T) {
 				hostnameOverride: "node-1",
 				podCidr:          "172.20.0.0/24",
 				podIPv4CIDRs:     []string{"172.20.0.0/24"},
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
 				},
+			},
 			"",
 			&v1core.Node{
 				ObjectMeta: metav1.ObjectMeta{
@@ -1985,7 +2025,8 @@ func Test_advertisePodRoute(t *testing.T) {
 				hostnameOverride: "node-1",
 				podCidr:          "2001:db8:42:2::/64",
 				podIPv6CIDRs:     []string{"2001:db8:42:2::/64"},
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
@@ -1994,6 +2035,7 @@ func Test_advertisePodRoute(t *testing.T) {
 						},
 					},
 				},
+			},
 			"",
 			&v1core.Node{
 				ObjectMeta: metav1.ObjectMeta{
@@ -2163,11 +2205,13 @@ func Test_syncInternalPeers(t *testing.T) {
 			&NetworkRoutingController{
 				bgpFullMeshMode: true,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				bgpServer:   gobgp.NewBgpServer(),
 				activeNodes: make(map[string]bool),
 			},
@@ -2195,11 +2239,13 @@ func Test_syncInternalPeers(t *testing.T) {
 			&NetworkRoutingController{
 				bgpFullMeshMode: true,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				bgpServer:   gobgp.NewBgpServer(),
 				activeNodes: make(map[string]bool),
 			},
@@ -2241,11 +2287,13 @@ func Test_syncInternalPeers(t *testing.T) {
 			&NetworkRoutingController{
 				bgpFullMeshMode: true,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				bgpServer: gobgp.NewBgpServer(),
 				activeNodes: map[string]bool{
 					"10.0.0.2": true,
@@ -2275,11 +2323,13 @@ func Test_syncInternalPeers(t *testing.T) {
 			&NetworkRoutingController{
 				bgpFullMeshMode: false,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				bgpServer:     gobgp.NewBgpServer(),
 				activeNodes:   make(map[string]bool),
 				nodeAsnNumber: 100,
@@ -2388,11 +2438,13 @@ func Test_routeReflectorConfiguration(t *testing.T) {
 				bgpFullMeshMode: false,
 				bgpPort:         10000,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				routerID:         testNodeIPv4,
 				bgpServer:        gobgp.NewBgpServer(),
 				activeNodes:      make(map[string]bool),
@@ -2419,11 +2471,13 @@ func Test_routeReflectorConfiguration(t *testing.T) {
 				bgpFullMeshMode: false,
 				bgpPort:         10000,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				routerID:         testNodeIPv4,
 				bgpServer:        gobgp.NewBgpServer(),
 				activeNodes:      make(map[string]bool),
@@ -2450,11 +2504,13 @@ func Test_routeReflectorConfiguration(t *testing.T) {
 				bgpFullMeshMode: false,
 				bgpPort:         10000,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				routerID:         testNodeIPv4,
 				bgpServer:        gobgp.NewBgpServer(),
 				activeNodes:      make(map[string]bool),
@@ -2481,11 +2537,13 @@ func Test_routeReflectorConfiguration(t *testing.T) {
 				bgpFullMeshMode: false,
 				bgpPort:         10000,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				routerID:         testNodeIPv4,
 				bgpServer:        gobgp.NewBgpServer(),
 				activeNodes:      make(map[string]bool),
@@ -2512,11 +2570,13 @@ func Test_routeReflectorConfiguration(t *testing.T) {
 				bgpFullMeshMode: false,
 				bgpPort:         10000,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				bgpServer:        gobgp.NewBgpServer(),
 				activeNodes:      make(map[string]bool),
 				nodeAsnNumber:    100,
@@ -2542,11 +2602,13 @@ func Test_routeReflectorConfiguration(t *testing.T) {
 				bgpFullMeshMode: false,
 				bgpPort:         10000,
 				clientset:       fake.NewSimpleClientset(),
-				krNode: &utils.KRNode{
+				krNode: &utils.LocalKRNode{
+					KRNode: utils.KRNode{
 						NodeName:      "node-1",
 						PrimaryIP:     net.ParseIP(testNodeIPv4),
 						NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
 					},
+				},
 				bgpServer:        gobgp.NewBgpServer(),
 				activeNodes:      make(map[string]bool),
 				nodeAsnNumber:    100,

pkg/utils/node.go

@@ -15,42 +15,32 @@ import (
 	netutils "k8s.io/utils/net"
 )
 
-// nodeAddressMap is a mapping of address types to a list of addresses of that type.
+// nodeAddressMap contains Kubernetes node address types (apiv1.NodeAddressType) grouped by Kubernetes Node Object
-// It preallocates the slices of addresses.
+// address type (internal / external).
 type nodeAddressMap map[apiv1.NodeAddressType][]apiv1.NodeAddress
 
-// add adds an address of the given type to the address map. If the given type
+// addressMap contains net.IP addresses grouped by Kubernetes Node Object address type (internal / external).
-// was not already in the map, it creates a new preallocated entry for it.
-func (m nodeAddressMap) add(address apiv1.NodeAddress) {
-	if _, ok := m[address.Type]; ok {
-		m[address.Type] = append(m[address.Type], address)
-	} else {
-		m[address.Type] = make([]apiv1.NodeAddress, 0)
-		m[address.Type] = append(m[address.Type], address)
-	}
-}
-
-// nodeAddressMap is a mapping of address types to a list of addresses of that type.
-// It preallocates the slices of addresses.
 type addressMap map[apiv1.NodeAddressType][]net.IP
 
 // KRNode is a struct that holds information about a node that is used by kube-router.
 type KRNode struct {
-	NodeInterfaceName string
 	NodeIPv4Addrs addressMap
 	NodeIPv6Addrs addressMap
 	NodeName      string
-	linkQ             LocalLinkQuerier
-	PrimaryNodeSubnet net.IPNet
 	PrimaryIP     net.IP
 }
 
+// LocalKRNode is a struct that holds information about this kube-router node.
+type LocalKRNode struct {
+	KRNode
+	NodeInterfaceName string
+	linkQ             LocalLinkQuerier
+}
+
 // NodeIPAware is an interface that provides methods to get the node's IP addresses in various data structures.
 type NodeIPAware interface {
 	FindBestIPv4NodeAddress() net.IP
 	FindBestIPv6NodeAddress() net.IP
-	GetNodeIPv4AddrsTypeMap() addressMap
-	GetNodeIPv6AddrsTypeMap() addressMap
 	GetNodeIPv4Addrs() []net.IP
 	GetNodeIPv6Addrs() []net.IP
 	GetNodeIPAddrs() []net.IP
@@ -63,7 +53,6 @@ type NodeIPAware interface {
 // functions on a remote node, they will return nil or an error.
 type NodeInterfaceAware interface {
 	GetNodeInterfaceName() string
-	GetPrimaryNodeSubnet() net.IPNet
 	GetNodeMTU() (int, error)
 }
 
@@ -93,12 +82,6 @@ type NodeAware interface {
 	NodeNameAware
 }
 
-// GetNodeIPv4AddrsTypeMap returns the node's IPv4 addresses grouped by Kubernetes Node Object address type (internal /
-// external).
-func (n *KRNode) GetNodeIPv4AddrsTypeMap() addressMap {
-	return n.NodeIPv4Addrs
-}
-
 // GetNodeIPv4Addrs returns the node's IPv4 addresses as defined by the Kubernetes Node Object.
 func (n *KRNode) GetNodeIPv4Addrs() []net.IP {
 	var nodeIPs []net.IP
@@ -108,12 +91,6 @@ func (n *KRNode) GetNodeIPv4Addrs() []net.IP {
 	return nodeIPs
 }
 
-// GetNodeIPv6AddrsTypeMap returns the node's IPv6 addresses grouped by Kubernetes Node Object address type (internal /
-// external).
-func (n *KRNode) GetNodeIPv6AddrsTypeMap() addressMap {
-	return n.NodeIPv6Addrs
-}
-
 // GetNodeIPv6Addrs returns the node's IPv6 addresses as defined by the Kubernetes Node Object.
 func (n *KRNode) GetNodeIPv6Addrs() []net.IP {
 	var nodeIPs []net.IP
@@ -130,17 +107,10 @@ func (n *KRNode) GetPrimaryNodeIP() net.IP {
 	return n.PrimaryIP
 }
 
-// GetPrimaryNodeSubnet returns the node's primary subnet as defined by the primary IP address. This function is only
-// available if you are running on the node itself, as kube-router determines this by looking at the node's interfaces
-// and parsing the address data there. If you attempt to call this function on a remote node, it will return nil.
-func (n *KRNode) GetPrimaryNodeSubnet() net.IPNet {
-	return n.PrimaryNodeSubnet
-}
-
 // GetNodeInterfaceName returns the node's interface name as defined by the primary IP address. This function is only
 // available if you are running on the node itself, as kube-router determines this by looking at the node's interfaces
 // and parsing the address data there. If you attempt to call this function on a remote node, it will return nil.
-func (n *KRNode) GetNodeInterfaceName() string {
+func (n *LocalKRNode) GetNodeInterfaceName() string {
 	return n.NodeInterfaceName
 }
 
@@ -162,7 +132,7 @@ func (n *KRNode) GetNodeName() string {
 // FindBestIPv6NodeAddress returns the best available IPv6 address for the node. If the primary IP is already an IPv6
 // address, it will return that. Otherwise, it will return the first internal or external IPv6 address defined in the
 // Kubernetes Node Object.
-func (n KRNode) FindBestIPv6NodeAddress() net.IP {
+func (n *KRNode) FindBestIPv6NodeAddress() net.IP {
 	if n.PrimaryIP != nil && n.PrimaryIP.To4() == nil && n.PrimaryIP.To16() != nil {
 		// the NRC's primary IP is already an IPv6 address, so we'll use that
 		return n.PrimaryIP
@@ -182,7 +152,7 @@ func (n KRNode) FindBestIPv6NodeAddress() net.IP {
 // FindBestIPv4NodeAddress returns the best available IPv4 address for the node. If the primary IP is already an IPv4
 // address, it will return that. Otherwise, it will return the first internal or external IPv4 address defined in the
 // Kubernetes Node Object.
-func (n KRNode) FindBestIPv4NodeAddress() net.IP {
+func (n *KRNode) FindBestIPv4NodeAddress() net.IP {
 	if n.PrimaryIP != nil && n.PrimaryIP.To4() != nil {
 		// the NRC's primary IP is already an IPv6 address, so we'll use that
 		return n.PrimaryIP
@@ -202,7 +172,7 @@ func (n KRNode) FindBestIPv4NodeAddress() net.IP {
 // GetNodeMTU returns the MTU of the interface that the node's primary IP address is assigned to. This function is only
 // available if you are running on the node itself, as kube-router determines this by looking at the node's interfaces
 // and parsing the address data there. If you attempt to call this function on a remote node, it will return an error.
-func (n KRNode) GetNodeMTU() (int, error) {
+func (n *LocalKRNode) GetNodeMTU() (int, error) {
 	links, err := n.linkQ.LinkList()
 	if err != nil {
 		return 0, errors.New("failed to get list of links")
@@ -224,7 +194,7 @@ func (n KRNode) GetNodeMTU() (int, error) {
 
 // GetNodeIPAddrs returns all of the node's IP addresses (whether internal or external) as defined by the Kubernetes
 // Node Object.
-func (n KRNode) GetNodeIPAddrs() []net.IP {
+func (n *KRNode) GetNodeIPAddrs() []net.IP {
 	var nodeIPs []net.IP
 	for _, ip := range n.NodeIPv4Addrs {
 		nodeIPs = append(nodeIPs, ip...)
@@ -240,7 +210,7 @@ func (n KRNode) GetNodeIPAddrs() []net.IP {
 // a remote node, it will result in an error as it will not be able to find the correct subnet / interface information.
 // For this use-case use NewRemoteKRNode instead. It will also return an error if the node does not have any IPv4 or
 // IPv6 addresses defined in the Kubernetes Node Object.
-func NewKRNode(node *apiv1.Node, linkQ LocalLinkQuerier, enableIPv4, enableIPv6 bool) (NodeAware, error) {
+func NewKRNode(node *apiv1.Node, linkQ LocalLinkQuerier, enableIPv4, enableIPv6 bool) (*LocalKRNode, error) {
 	if linkQ == nil {
 		linkQ = &netlink.Handle{}
 	}
@@ -261,18 +231,19 @@ func NewKRNode(node *apiv1.Node, linkQ LocalLinkQuerier, enableIPv4, enableIPv6
 		return nil, fmt.Errorf("IPv6 was enabled, but no IPv6 address was found on the node")
 	}
 
-	primaryNodeSubnet, nodeInterfaceName, err := GetNodeSubnet(primaryNodeIP, linkQ)
+	_, nodeInterfaceName, err := GetNodeSubnet(primaryNodeIP, linkQ)
 	if err != nil {
 		return nil, fmt.Errorf("error getting node subnet: %w", err)
 	}
 
-	krNode := &KRNode{
+	krNode := &LocalKRNode{
-		linkQ:             linkQ,
+		KRNode: KRNode{
 			NodeName:      node.Name,
 			PrimaryIP:     primaryNodeIP,
 			NodeIPv4Addrs: ipv4Addrs,
 			NodeIPv6Addrs: ipv6Addrs,
-		PrimaryNodeSubnet: primaryNodeSubnet,
+		},
+		linkQ:             linkQ,
 		NodeInterfaceName: nodeInterfaceName,
 	}
 
@@ -282,7 +253,7 @@ func NewKRNode(node *apiv1.Node, linkQ LocalLinkQuerier, enableIPv4, enableIPv6
 // NewRemoteKRNode creates a new KRNode object from a Kubernetes Node Object. This function is used when kube-router is
 // attempting to parse a remote node and does not have access to the node's interfaces and address data. It will return
 // an error if the node does not have any IPv4 or IPv6 addresses defined in the Kubernetes Node Object.
-func NewRemoteKRNode(node *apiv1.Node) (NodeIPAndFamilyAware, error) {
+func NewRemoteKRNode(node *apiv1.Node) (*KRNode, error) {
 	primaryNodeIP, err := getPrimaryNodeIP(node)
 	if err != nil {
 		return nil, fmt.Errorf("error getting primary NodeIP: %w", err)
@@ -337,7 +308,7 @@ func GetNodeObject(clientset kubernetes.Interface, hostnameOverride string) (*ap
 // 2. NodeExternalIP (usually only set on cloud providers usually)
 func getPrimaryNodeIP(node *apiv1.Node) (net.IP, error) {
 	addresses := node.Status.Addresses
-	addressMap := make(map[apiv1.NodeAddressType][]apiv1.NodeAddress)
+	addressMap := make(nodeAddressMap)
 	for i := range addresses {
 		addressMap[addresses[i].Type] = append(addressMap[addresses[i].Type], addresses[i])
 	}
@@ -352,13 +323,13 @@ func getPrimaryNodeIP(node *apiv1.Node) (net.IP, error) {
 
 // getAllNodeIPs returns all internal and external IP addresses grouped as IPv4 and IPv6 in a map that is indexed by
 // the Kubernetes Node Object address type (internal / external).
-func getAllNodeIPs(node *apiv1.Node) (map[apiv1.NodeAddressType][]net.IP, map[apiv1.NodeAddressType][]net.IP) {
+func getAllNodeIPs(node *apiv1.Node) (addressMap, addressMap) {
 	ipAddrv4 := make(addressMap)
 	ipAddrv6 := make(addressMap)
 	addresses := node.Status.Addresses
 	addressesPerType := make(nodeAddressMap)
 	for _, address := range addresses {
-		addressesPerType.add(address)
+		addressesPerType[address.Type] = append(addressesPerType[address.Type], address)
 	}
 	if internalAddresses, ok := addressesPerType[apiv1.NodeInternalIP]; ok {
 		for _, address := range internalAddresses {