adelorenzo/kilo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Shorten keepalive key

Browse Source
This commit is contained in:
Francis Nguyen 2020-02-11 19:17:41 -07:00
parent 2082a42527
commit dca1a2b5ae
4 changed files with 66 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
pkg/k8s/backend.go
View File

@ -47,17 +47,17 @@ import (
const ( const (
// Backend is the name of this mesh backend. // Backend is the name of this mesh backend.
Backend = "kubernetes" Backend = "kubernetes"
externalIPAnnotationKey = "kilo.squat.ai/external-ip" externalIPAnnotationKey = "kilo.squat.ai/external-ip"
forceExternalIPAnnotationKey = "kilo.squat.ai/force-external-ip" forceExternalIPAnnotationKey = "kilo.squat.ai/force-external-ip"
forceInternalIPAnnotationKey = "kilo.squat.ai/force-internal-ip" forceInternalIPAnnotationKey = "kilo.squat.ai/force-internal-ip"
internalIPAnnotationKey = "kilo.squat.ai/internal-ip" internalIPAnnotationKey = "kilo.squat.ai/internal-ip"
keyAnnotationKey = "kilo.squat.ai/key" keyAnnotationKey = "kilo.squat.ai/key"
lastSeenAnnotationKey = "kilo.squat.ai/last-seen" lastSeenAnnotationKey = "kilo.squat.ai/last-seen"
leaderAnnotationKey = "kilo.squat.ai/leader" leaderAnnotationKey = "kilo.squat.ai/leader"
locationAnnotationKey = "kilo.squat.ai/location" locationAnnotationKey = "kilo.squat.ai/location"
wireGuardIPAnnotationKey = "kilo.squat.ai/wireguard-ip" persistentKeepAliveKey = "kilo.squat.ai/persistent-keepalive"
wireGuardPersistentKeepAliveKey = "kilo.squat.ai/wireguard-persistent-keepalive" wireGuardIPAnnotationKey = "kilo.squat.ai/wireguard-ip"
regionLabelKey = "topology.kubernetes.io/region" regionLabelKey = "topology.kubernetes.io/region"
jsonPatchSlash = "~1" jsonPatchSlash = "~1"
@ -264,12 +264,12 @@ func translateNode(node *v1.Node) *mesh.Node {
internalIP = node.ObjectMeta.Annotations[internalIPAnnotationKey] internalIP = node.ObjectMeta.Annotations[internalIPAnnotationKey]
} }
// Set Wireguard PersistentKeepAlive setting for the node. // Set Wireguard PersistentKeepAlive setting for the node.
var wireGuardPersistentKeepAlive int64 var persistentKeepAlive int64
if wgKeepAlive, ok := node.ObjectMeta.Annotations[wireGuardPersistentKeepAliveKey]; !ok { if keepAlive, ok := node.ObjectMeta.Annotations[persistentKeepAliveKey]; !ok {
wireGuardPersistentKeepAlive = 0 persistentKeepAlive = 0
} else { } else {
if wireGuardPersistentKeepAlive, err = strconv.ParseInt(wgKeepAlive, 10, 64); err != nil { if persistentKeepAlive, err = strconv.ParseInt(keepAlive, 10, 64); err != nil {
wireGuardPersistentKeepAlive = 0 persistentKeepAlive = 0
} }
} }
var lastSeen int64 var lastSeen int64
@ -285,19 +285,19 @@ func translateNode(node *v1.Node) *mesh.Node {
// remote node's agent has not yet set its IP address; // remote node's agent has not yet set its IP address;
// in this case the IP will be nil and // in this case the IP will be nil and
// the mesh can wait for the node to be updated. // the mesh can wait for the node to be updated.
ExternalIP: normalizeIP(externalIP), ExternalIP: normalizeIP(externalIP),
InternalIP: normalizeIP(internalIP), InternalIP: normalizeIP(internalIP),
Key: []byte(node.ObjectMeta.Annotations[keyAnnotationKey]), Key: []byte(node.ObjectMeta.Annotations[keyAnnotationKey]),
LastSeen: lastSeen, LastSeen: lastSeen,
Leader: leader, Leader: leader,
Location: location, Location: location,
Name: node.Name, Name: node.Name,
Subnet: subnet, PersistentKeepAlive: int(persistentKeepAlive),
Subnet: subnet,
// WireGuardIP can fail to parse if the node is not a leader or if // WireGuardIP can fail to parse if the node is not a leader or if
// the node's agent has not yet reconciled. In either case, the IP // the node's agent has not yet reconciled. In either case, the IP
// will parse as nil. // will parse as nil.
WireGuardIP: normalizeIP(node.ObjectMeta.Annotations[wireGuardIPAnnotationKey]), WireGuardIP: normalizeIP(node.ObjectMeta.Annotations[wireGuardIPAnnotationKey]),
WireGuardPersistentKeepAlive: int(wireGuardPersistentKeepAlive),
} }
} }

42
pkg/k8s/backend_test.go
View File

@ -114,10 +114,10 @@ func TestTranslateNode(t *testing.T) {
{ {
name: "wireguard persistent keepalive override", name: "wireguard persistent keepalive override",
annotations: map[string]string{ annotations: map[string]string{
wireGuardPersistentKeepAliveKey: "25", persistentKeepAliveKey: "25",
}, },
out: &mesh.Node{ out: &mesh.Node{
WireGuardPersistentKeepAlive: 25, PersistentKeepAlive: 25,
}, },
}, },
{ {
@ -140,30 +140,30 @@ func TestTranslateNode(t *testing.T) {
{ {
name: "complete", name: "complete",
annotations: map[string]string{ annotations: map[string]string{
externalIPAnnotationKey: "10.0.0.1/24", externalIPAnnotationKey: "10.0.0.1/24",
forceExternalIPAnnotationKey: "10.0.0.2/24", forceExternalIPAnnotationKey: "10.0.0.2/24",
forceInternalIPAnnotationKey: "10.1.0.2/32", forceInternalIPAnnotationKey: "10.1.0.2/32",
internalIPAnnotationKey: "10.1.0.1/32", internalIPAnnotationKey: "10.1.0.1/32",
keyAnnotationKey: "foo", keyAnnotationKey: "foo",
lastSeenAnnotationKey: "1000000000", lastSeenAnnotationKey: "1000000000",
leaderAnnotationKey: "", leaderAnnotationKey: "",
locationAnnotationKey: "b", locationAnnotationKey: "b",
wireGuardIPAnnotationKey: "10.4.0.1/16", persistentKeepAliveKey: "25",
wireGuardPersistentKeepAliveKey: "25", wireGuardIPAnnotationKey: "10.4.0.1/16",
}, },
labels: map[string]string{ labels: map[string]string{
regionLabelKey: "a", regionLabelKey: "a",
}, },
out: &mesh.Node{ out: &mesh.Node{
ExternalIP: &net.IPNet{IP: net.ParseIP("10.0.0.2"), Mask: net.CIDRMask(24, 32)}, ExternalIP: &net.IPNet{IP: net.ParseIP("10.0.0.2"), Mask: net.CIDRMask(24, 32)},
InternalIP: &net.IPNet{IP: net.ParseIP("10.1.0.2"), Mask: net.CIDRMask(32, 32)}, InternalIP: &net.IPNet{IP: net.ParseIP("10.1.0.2"), Mask: net.CIDRMask(32, 32)},
Key: []byte("foo"), Key: []byte("foo"),
LastSeen: 1000000000, LastSeen: 1000000000,
Leader: true, Leader: true,
Location: "b", Location: "b",
Subnet: &net.IPNet{IP: net.ParseIP("10.2.1.0"), Mask: net.CIDRMask(24, 32)}, PersistentKeepAlive: 25,
WireGuardIP: &net.IPNet{IP: net.ParseIP("10.4.0.1"), Mask: net.CIDRMask(16, 32)}, Subnet: &net.IPNet{IP: net.ParseIP("10.2.1.0"), Mask: net.CIDRMask(24, 32)},
WireGuardPersistentKeepAlive: 25, WireGuardIP: &net.IPNet{IP: net.ParseIP("10.4.0.1"), Mask: net.CIDRMask(16, 32)},
}, },
subnet: "10.2.1.0/24", subnet: "10.2.1.0/24",
}, },

12
pkg/mesh/mesh.go
View File

@ -79,12 +79,12 @@ type Node struct {
LastSeen int64 LastSeen int64
// Leader is a suggestion to Kilo that // Leader is a suggestion to Kilo that
// the node wants to lead its segment. // the node wants to lead its segment.
Leader bool Leader bool
Location string Location string
Name string Name string
Subnet *net.IPNet PersistentKeepAlive int
WireGuardIP *net.IPNet Subnet *net.IPNet
WireGuardPersistentKeepAlive int WireGuardIP *net.IPNet
} }
// Ready indicates whether or not the node is ready. // Ready indicates whether or not the node is ready.

26
pkg/mesh/topology.go
View File

@ -64,14 +64,14 @@ type segment struct {
hostnames []string hostnames []string
// leader is the index of the leader of the segment. // leader is the index of the leader of the segment.
leader int leader int
// persistentKeepAlive is the interval in seconds of the emission
// of keepalive packets to the peer.
persistentKeepAlive int
// privateIPs is a slice of private IPs of all peers in the segment. // privateIPs is a slice of private IPs of all peers in the segment.
privateIPs []net.IP privateIPs []net.IP
// wireGuardIP is the allocated IP address of the WireGuard // wireGuardIP is the allocated IP address of the WireGuard
// interface on the leader of the segment. // interface on the leader of the segment.
wireGuardIP net.IP wireGuardIP net.IP
// wireGuardPersistentKeepAlive is the interval in seconds of the emission
// of keepalive packets to the peer.
wireGuardPersistentKeepAlive int
} }
// NewTopology creates a new Topology struct from a given set of nodes and peers. // NewTopology creates a new Topology struct from a given set of nodes and peers.
@ -120,15 +120,15 @@ func NewTopology(nodes map[string]*Node, peers map[string]*Peer, granularity Gra
privateIPs = append(privateIPs, node.InternalIP.IP) privateIPs = append(privateIPs, node.InternalIP.IP)
} }
t.segments = append(t.segments, &segment{ t.segments = append(t.segments, &segment{
allowedIPs: allowedIPs, allowedIPs: allowedIPs,
endpoint: topoMap[location][leader].ExternalIP.IP, endpoint: topoMap[location][leader].ExternalIP.IP,
key: topoMap[location][leader].Key, key: topoMap[location][leader].Key,
location: location, location: location,
cidrs: cidrs, cidrs: cidrs,
hostnames: hostnames, hostnames: hostnames,
leader: leader, leader: leader,
privateIPs: privateIPs, privateIPs: privateIPs,
wireGuardPersistentKeepAlive: topoMap[location][leader].WireGuardPersistentKeepAlive, persistentKeepAlive: topoMap[location][leader].PersistentKeepAlive,
}) })
} }
// Sort the Topology segments so the result is stable. // Sort the Topology segments so the result is stable.
@ -339,7 +339,7 @@ func (t *Topology) Conf() *wireguard.Conf {
Port: uint32(t.port), Port: uint32(t.port),
}, },
PublicKey: s.key, PublicKey: s.key,
PersistentKeepalive: s.wireGuardPersistentKeepAlive, PersistentKeepalive: s.persistentKeepAlive,
} }
c.Peers = append(c.Peers, peer) c.Peers = append(c.Peers, peer)
} }