Shorten keepalive key

pkg/k8s/backend.go

@@ -56,8 +56,8 @@ const (
 	lastSeenAnnotationKey        = "kilo.squat.ai/last-seen"
 	leaderAnnotationKey          = "kilo.squat.ai/leader"
 	locationAnnotationKey        = "kilo.squat.ai/location"
+	persistentKeepAliveKey       = "kilo.squat.ai/persistent-keepalive"
 	wireGuardIPAnnotationKey     = "kilo.squat.ai/wireguard-ip"
-	wireGuardPersistentKeepAliveKey = "kilo.squat.ai/wireguard-persistent-keepalive"
 
 	regionLabelKey  = "topology.kubernetes.io/region"
 	jsonPatchSlash  = "~1"
@@ -264,12 +264,12 @@ func translateNode(node *v1.Node) *mesh.Node {
 		internalIP = node.ObjectMeta.Annotations[internalIPAnnotationKey]
 	}
 	// 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 {
-		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
@@ -292,12 +292,12 @@ func translateNode(node *v1.Node) *mesh.Node {
 		Leader:              leader,
 		Location:            location,
 		Name:                node.Name,
+		PersistentKeepAlive: int(persistentKeepAlive),
 		Subnet:              subnet,
 		// 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
 		// will parse as nil.
 		WireGuardIP: normalizeIP(node.ObjectMeta.Annotations[wireGuardIPAnnotationKey]),
-		WireGuardPersistentKeepAlive: int(wireGuardPersistentKeepAlive),
 	}
 }
 

pkg/k8s/backend_test.go

@@ -114,10 +114,10 @@ func TestTranslateNode(t *testing.T) {
 		{
 			name: "wireguard persistent keepalive override",
 			annotations: map[string]string{
-				wireGuardPersistentKeepAliveKey: "25",
+				persistentKeepAliveKey: "25",
 			},
 			out: &mesh.Node{
-				WireGuardPersistentKeepAlive: 25,
+				PersistentKeepAlive: 25,
 			},
 		},
 		{
@@ -148,8 +148,8 @@ func TestTranslateNode(t *testing.T) {
 				lastSeenAnnotationKey:        "1000000000",
 				leaderAnnotationKey:          "",
 				locationAnnotationKey:        "b",
+				persistentKeepAliveKey:       "25",
 				wireGuardIPAnnotationKey:     "10.4.0.1/16",
-				wireGuardPersistentKeepAliveKey: "25",
 			},
 			labels: map[string]string{
 				regionLabelKey: "a",
@@ -161,9 +161,9 @@ func TestTranslateNode(t *testing.T) {
 				LastSeen:            1000000000,
 				Leader:              true,
 				Location:            "b",
+				PersistentKeepAlive: 25,
 				Subnet:              &net.IPNet{IP: net.ParseIP("10.2.1.0"), Mask: net.CIDRMask(24, 32)},
 				WireGuardIP:         &net.IPNet{IP: net.ParseIP("10.4.0.1"), Mask: net.CIDRMask(16, 32)},
-				WireGuardPersistentKeepAlive: 25,
 			},
 			subnet: "10.2.1.0/24",
 		},

pkg/mesh/mesh.go

@@ -82,9 +82,9 @@ type Node struct {
 	Leader              bool
 	Location            string
 	Name                string
+	PersistentKeepAlive int
 	Subnet              *net.IPNet
 	WireGuardIP         *net.IPNet
-	WireGuardPersistentKeepAlive int
 }
 
 // Ready indicates whether or not the node is ready.

pkg/mesh/topology.go

@@ -64,14 +64,14 @@ type segment struct {
 	hostnames []string
 	// leader is the index of the leader of the segment.
 	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 []net.IP
 	// wireGuardIP is the allocated IP address of the WireGuard
 	// interface on the leader of the segment.
 	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.
@@ -128,7 +128,7 @@ func NewTopology(nodes map[string]*Node, peers map[string]*Peer, granularity Gra
 			hostnames:           hostnames,
 			leader:              leader,
 			privateIPs:          privateIPs,
-			wireGuardPersistentKeepAlive: topoMap[location][leader].WireGuardPersistentKeepAlive,
+			persistentKeepAlive: topoMap[location][leader].PersistentKeepAlive,
 		})
 	}
 	// Sort the Topology segments so the result is stable.
@@ -339,7 +339,7 @@ func (t *Topology) Conf() *wireguard.Conf {
 				Port: uint32(t.port),
 			},
 			PublicKey:           s.key,
-			PersistentKeepalive: s.wireGuardPersistentKeepAlive,
+			PersistentKeepalive: s.persistentKeepAlive,
 		}
 		c.Peers = append(c.Peers, peer)
 	}