mirrors/kube-router
1
0
Fork 0
mirror of https://github.com/cloudnativelabs/kube-router.git synced 2025-09-26 18:41:05 +02:00
Code Issues Packages Projects Releases Wiki Activity

fix(krnode): apply suggestions from code review

Browse Source 
Co-authored-by: Tom Wieczorek <twz123@users.noreply.github.com>
This commit is contained in:
Aaron U'Ren 2024-09-23 09:46:34 -05:00
parent 7d55309e18
commit e4fa335acb
8 changed files with 308 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/controllers/netpol/network_policy_controller.go
View File

@ -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

8
pkg/controllers/proxy/network_services_controller_test.go
View File

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

16
pkg/controllers/proxy/utils_test.go
View File

@ -24,9 +24,11 @@ func getMoqNSC() *NetworkServicesController {
setupRoutesForExternalIPForDSRFunc: lnm.setupRoutesForExternalIPForDSR,
}
krNode := &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP("10.0.0.0"),
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{
NodeName: "node-1",
PrimaryIP: net.ParseIP("192.168.1.10"),
krNode := &utils.LocalKRNode{
KRNode: utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP("192.168.1.10"),
},
}
nsc := &NetworkServicesController{

6
pkg/controllers/routing/bgp_policies_test.go
View File

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

136
pkg/controllers/routing/ecmp_vip_test.go
View File

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

2
pkg/controllers/routing/network_routes_controller.go
View File

@ -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() {

282
pkg/controllers/routing/network_routes_controller_test.go
View File

@ -38,9 +38,11 @@ func Test_advertiseClusterIPs(t *testing.T) {
"add bgp path for service with ClusterIP",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -82,9 +84,11 @@ func Test_advertiseClusterIPs(t *testing.T) {
"add bgp path for service with ClusterIP/NodePort/LoadBalancer",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -182,9 +186,11 @@ func Test_advertiseClusterIPs(t *testing.T) {
"add bgp path for invalid service type",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -252,9 +258,11 @@ func Test_advertiseClusterIPs(t *testing.T) {
"add bgp path for headless service",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -467,9 +475,11 @@ func Test_advertiseExternalIPs(t *testing.T) {
"add bgp path for service with external IPs",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP("10.0.0.1"),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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{
@ -513,9 +523,11 @@ 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{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -617,9 +629,11 @@ func Test_advertiseExternalIPs(t *testing.T) {
"add bgp path for invalid service type",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -690,9 +704,11 @@ func Test_advertiseExternalIPs(t *testing.T) {
"add bgp path for headless service",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -791,9 +807,11 @@ func Test_advertiseExternalIPs(t *testing.T) {
"skip bgp path to loadbalancerIP for service without LoadBalancer IP",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -842,9 +860,11 @@ func Test_advertiseExternalIPs(t *testing.T) {
"add bgp path to loadbalancerIP for service with LoadBalancer IP",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -899,9 +919,11 @@ func Test_advertiseExternalIPs(t *testing.T) {
"no bgp path to nil loadbalancerIPs for service with LoadBalancer",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -946,9 +968,11 @@ 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{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -1120,9 +1144,11 @@ func Test_advertiseAnnotationOptOut(t *testing.T) {
"add bgp paths for all service IPs",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -1241,9 +1267,11 @@ func Test_advertiseAnnotationOptOut(t *testing.T) {
"opt out to advertise any IPs via annotations",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -1419,9 +1447,11 @@ func Test_advertiseAnnotationOptIn(t *testing.T) {
"no bgp paths for any service IPs",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -1532,9 +1562,11 @@ func Test_advertiseAnnotationOptIn(t *testing.T) {
"opt in to advertise all IPs via annotations",
&NetworkRoutingController{
bgpServer: gobgp.NewBgpServer(),
krNode: &utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
[]*v1core.Service{
@ -1786,10 +1818,12 @@ func Test_nodeHasEndpointsForService(t *testing.T) {
{
"node has endpoints for service",
&NetworkRoutingController{
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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{
@ -1831,10 +1865,12 @@ func Test_nodeHasEndpointsForService(t *testing.T) {
{
"node has no endpoints for service",
&NetworkRoutingController{
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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{
@ -1925,10 +1961,12 @@ 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{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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",
@ -1955,10 +1993,12 @@ 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{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
},
},
},
"",
@ -1985,12 +2025,14 @@ 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{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
NodeIPv6Addrs: map[v1core.NodeAddressType][]net.IP{
v1core.NodeInternalIP: {net.IPv6loopback},
krNode: &utils.LocalKRNode{
KRNode: utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
NodeIPv6Addrs: map[v1core.NodeAddressType][]net.IP{
v1core.NodeInternalIP: {net.IPv6loopback},
},
},
},
},
@ -2163,10 +2205,12 @@ func Test_syncInternalPeers(t *testing.T) {
&NetworkRoutingController{
bgpFullMeshMode: true,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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,10 +2239,12 @@ func Test_syncInternalPeers(t *testing.T) {
&NetworkRoutingController{
bgpFullMeshMode: true,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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,10 +2287,12 @@ func Test_syncInternalPeers(t *testing.T) {
&NetworkRoutingController{
bgpFullMeshMode: true,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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{
@ -2275,10 +2323,12 @@ func Test_syncInternalPeers(t *testing.T) {
&NetworkRoutingController{
bgpFullMeshMode: false,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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),
@ -2388,10 +2438,12 @@ func Test_routeReflectorConfiguration(t *testing.T) {
bgpFullMeshMode: false,
bgpPort: 10000,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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(),
@ -2419,10 +2471,12 @@ func Test_routeReflectorConfiguration(t *testing.T) {
bgpFullMeshMode: false,
bgpPort: 10000,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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(),
@ -2450,10 +2504,12 @@ func Test_routeReflectorConfiguration(t *testing.T) {
bgpFullMeshMode: false,
bgpPort: 10000,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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(),
@ -2481,10 +2537,12 @@ func Test_routeReflectorConfiguration(t *testing.T) {
bgpFullMeshMode: false,
bgpPort: 10000,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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(),
@ -2512,10 +2570,12 @@ func Test_routeReflectorConfiguration(t *testing.T) {
bgpFullMeshMode: false,
bgpPort: 10000,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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),
@ -2542,10 +2602,12 @@ func Test_routeReflectorConfiguration(t *testing.T) {
bgpFullMeshMode: false,
bgpPort: 10000,
clientset: fake.NewSimpleClientset(),
krNode: &utils.KRNode{
NodeName: "node-1",
PrimaryIP: net.ParseIP(testNodeIPv4),
NodeIPv4Addrs: map[v1core.NodeAddressType][]net.IP{v1core.NodeInternalIP: {net.ParseIP(testNodeIPv4)}},
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),

89
pkg/utils/node.go
View File

@ -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.
// It preallocates the slices of addresses.
// nodeAddressMap contains Kubernetes node address types (apiv1.NodeAddressType) grouped by Kubernetes Node Object
// 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
// 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.
// addressMap contains net.IP addresses grouped by Kubernetes Node Object address type (internal / external).
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 {
NodeIPv4Addrs addressMap
NodeIPv6Addrs addressMap
NodeName string
PrimaryIP net.IP
}
// LocalKRNode is a struct that holds information about this kube-router node.
type LocalKRNode struct {
KRNode
NodeInterfaceName string
NodeIPv4Addrs addressMap
NodeIPv6Addrs addressMap
NodeName string
linkQ LocalLinkQuerier
PrimaryNodeSubnet net.IPNet
PrimaryIP net.IP
}
// 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{
KRNode: KRNode{
NodeName: node.Name,
PrimaryIP: primaryNodeIP,
NodeIPv4Addrs: ipv4Addrs,
NodeIPv6Addrs: ipv6Addrs,
},
linkQ: linkQ,
NodeName: node.Name,
PrimaryIP: primaryNodeIP,
NodeIPv4Addrs: ipv4Addrs,
NodeIPv6Addrs: ipv6Addrs,
PrimaryNodeSubnet: primaryNodeSubnet,
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 {