mirror of
https://github.com/cloudnativelabs/kube-router.git
synced 2025-09-27 11:01:11 +02:00
88 lines
2.7 KiB
Go
88 lines
2.7 KiB
Go
package utils
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
|
|
"github.com/vishvananda/netlink"
|
|
|
|
apiv1 "k8s.io/api/core/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/client-go/kubernetes"
|
|
)
|
|
|
|
// GetNodeObject returns the node API object for the node
|
|
func GetNodeObject(clientset kubernetes.Interface, hostnameOverride string) (*apiv1.Node, error) {
|
|
// assuming kube-router is running as pod, first check env NODE_NAME
|
|
nodeName := os.Getenv("NODE_NAME")
|
|
if nodeName != "" {
|
|
node, err := clientset.CoreV1().Nodes().Get(context.Background(), nodeName, metav1.GetOptions{})
|
|
if err == nil {
|
|
return node, nil
|
|
}
|
|
}
|
|
|
|
// if env NODE_NAME is not set then check if node is register with hostname
|
|
hostName, _ := os.Hostname()
|
|
node, err := clientset.CoreV1().Nodes().Get(context.Background(), hostName, metav1.GetOptions{})
|
|
if err == nil {
|
|
return node, nil
|
|
}
|
|
|
|
// if env NODE_NAME is not set and node is not registered with hostname, then use host name override
|
|
if hostnameOverride != "" {
|
|
node, err = clientset.CoreV1().Nodes().Get(context.Background(), hostnameOverride, metav1.GetOptions{})
|
|
if err == nil {
|
|
return node, nil
|
|
}
|
|
}
|
|
|
|
return nil, fmt.Errorf("failed to identify the node by NODE_NAME, hostname or --hostname-override")
|
|
}
|
|
|
|
// GetNodeIP returns the most valid external facing IP address for a node.
|
|
// Order of preference:
|
|
// 1. NodeInternalIP
|
|
// 2. NodeExternalIP (Only set on cloud providers usually)
|
|
func GetNodeIP(node *apiv1.Node) (net.IP, error) {
|
|
addresses := node.Status.Addresses
|
|
addressMap := make(map[apiv1.NodeAddressType][]apiv1.NodeAddress)
|
|
for i := range addresses {
|
|
addressMap[addresses[i].Type] = append(addressMap[addresses[i].Type], addresses[i])
|
|
}
|
|
if addresses, ok := addressMap[apiv1.NodeInternalIP]; ok {
|
|
return net.ParseIP(addresses[0].Address), nil
|
|
}
|
|
if addresses, ok := addressMap[apiv1.NodeExternalIP]; ok {
|
|
return net.ParseIP(addresses[0].Address), nil
|
|
}
|
|
return nil, errors.New("host IP unknown")
|
|
}
|
|
|
|
// GetMTUFromNodeIP returns the MTU by detecting it from the IP on the node and figuring in tunneling configurations
|
|
func GetMTUFromNodeIP(nodeIP net.IP, overlayEnabled bool) (int, error) {
|
|
links, err := netlink.LinkList()
|
|
if err != nil {
|
|
return 0, errors.New("failed to get list of links")
|
|
}
|
|
for _, link := range links {
|
|
addresses, err := netlink.AddrList(link, netlink.FAMILY_ALL)
|
|
if err != nil {
|
|
return 0, errors.New("failed to get list of addr")
|
|
}
|
|
for _, addr := range addresses {
|
|
if addr.IPNet.IP.Equal(nodeIP) {
|
|
linkMTU := link.Attrs().MTU
|
|
if overlayEnabled {
|
|
return linkMTU - IPInIPHeaderLength, nil // -20 to accommodate IPIP header
|
|
}
|
|
return linkMTU, nil
|
|
}
|
|
}
|
|
}
|
|
return 0, errors.New("failed to find interface with specified node IP")
|
|
}
|