Only considering pods in ready state for DNS resolution (this fixes #5)

    Now suporting multiple pods having the same hostname.
    Also taking the ready state of a pod into account. This means:
    * only allowing lookup of a pod when all containers are ready
    * and when it is not being deleted.

    Readiness detection using the pod status ready status.
    Deletion detection using the metadata.deletionTimestamp field.

Author: ErikEngerd

cmd/dns-server/performance_test.go

@@ -24,6 +24,7 @@ func BenchmarkCreateNetworks(b *testing.B) {
 				fmt.Sprintf("pod%d", ipod),
 				[]model.Hostname{model.Hostname(fmt.Sprintf("host%d", j))},
 				[]model.NetworkId{model.NetworkId(fmt.Sprintf("network%d", i))},
+				true,
 			)
 			assert.Nil(b, err)
 			pods.AddOrUpdate(pod)

internal/admissioncontroller/admissioncontroller_test.go

@@ -221,13 +221,10 @@ func (s *MutatorTestSuite) Test_DuplicateHost() {
 		},
 		"20.21.22.23")
 	response := s.mutator.Handle(s.ctx, request)
-	s.False(response.Allowed)
-
-	klog.V(3).Infof("Message: %s", response.Result.Message)
-	s.True(strings.Contains(response.Result.Message, "already mapped to"))
+	s.True(response.Allowed)
 
 	s.NotNil(s.pods.Get("kubedock", "db"))
-	s.Nil(s.pods.Get("kubedock", "db2"))
+	s.NotNil(s.pods.Get("kubedock", "db2"))
 }
 
 func (s *MutatorTestSuite) Test_SecondHost() {

internal/dns/dns_test.go

@@ -33,7 +33,7 @@ func (dnsFunc DnsFunc) Resolve(r *dns.Msg) *dns.Msg {
 
 func (s *DNSTestSuite) newPod(ip model.IPAddress, namespace string, name string, hostAliases []model.Hostname,
 	networks []model.NetworkId) *model.Pod {
-	pod, err := model.NewPod(ip, namespace, name, hostAliases, networks)
+	pod, err := model.NewPod(ip, namespace, name, hostAliases, networks, true)
 	s.Nil(err)
 	s.NotNil(pod)
 	return pod

internal/model/networks.go

@@ -27,10 +27,11 @@ type Pod struct {
 	Name        string
 	HostAliases []Hostname
 	Networks    []NetworkId
+	Ready       bool
 }
 
 func NewPod(ip IPAddress, namespace string, name string, hostAliases []Hostname,
-	networks []NetworkId) (*Pod, error) {
+	networks []NetworkId, ready bool) (*Pod, error) {
 
 	hostAliases = slices.Clone(hostAliases)
 	slices.Sort(hostAliases)
@@ -53,6 +54,7 @@ func NewPod(ip IPAddress, namespace string, name string, hostAliases []Hostname,
 		Name:        name,
 		HostAliases: hostAliases,
 		Networks:    networks,
+		Ready:       ready,
 	}, nil
 }
 
@@ -67,36 +69,33 @@ func (pod *Pod) Copy() *Pod {
 		Name:        pod.Name,
 		HostAliases: slices.Clone(pod.HostAliases),
 		Networks:    slices.Clone(pod.Networks),
+		Ready:       pod.Ready,
 	}
 }
 
 type Network struct {
-	Id             NetworkId
-	IPToPod        map[IPAddress]*Pod
-	HostAliasToPod map[Hostname]*Pod
+	Id              NetworkId
+	IPToPod         map[IPAddress]*Pod
+	HostAliasToPods map[Hostname][]*Pod
 }
 
 func NewNetwork(id NetworkId) *Network {
 	network := Network{
-		Id:             id,
-		IPToPod:        make(map[IPAddress]*Pod),
-		HostAliasToPod: make(map[Hostname]*Pod),
+		Id:              id,
+		IPToPod:         make(map[IPAddress]*Pod),
+		HostAliasToPods: make(map[Hostname][]*Pod),
 	}
 	return &network
 }
 
 func (net *Network) Add(pod *Pod) error {
-	for _, hostAlias := range pod.HostAliases {
-		existingPod := net.HostAliasToPod[hostAlias]
-		if existingPod != nil && !(existingPod.Namespace == pod.Namespace && existingPod.Name == pod.Name) {
-			return fmt.Errorf("Pod %s/%s: hostAlias %s in network %s already mapped to %s/%s",
-				pod.Namespace, pod.Name, hostAlias, net.Id, existingPod.Namespace, existingPod.Name)
-		}
-	}
-
 	net.IPToPod[pod.IP] = pod
 	for _, hostAlias := range pod.HostAliases {
-		net.HostAliasToPod[hostAlias] = pod
+		pods := net.HostAliasToPods[hostAlias]
+		// when building the network from the pods, each pod is added in turn,
+		// so we do not need to check for duplicate additions of pods.
+		pods = append(pods, pod)
+		net.HostAliasToPods[hostAlias] = pods
 	}
 	return nil
 }
@@ -170,7 +169,7 @@ func (net *Networks) Log() {
 	for networkId, network := range net.NameToNetwork {
 		klog.Infof("Network %s", networkId)
 		for ip, pod := range network.IPToPod {
-			klog.Infof("  Pod: %s/%s", pod.Namespace, pod.Name)
+			klog.Infof("  Pod: %s/%s ready %v", pod.Namespace, pod.Name, pod.Ready)
 			klog.Infof("    IP: %s", ip)
 			for _, hostAlias := range pod.HostAliases {
 				klog.Infof("    Hostalias: %s", hostAlias)
@@ -191,9 +190,11 @@ func (net *Networks) Lookup(sourceIp IPAddress, hostname Hostname) []IPAddress {
 		return make([]IPAddress, 0)
 	}
 	for _, network := range networks {
-		pod := network.HostAliasToPod[hostname]
-		if pod != nil {
-			res = append(res, pod.IP)
+		pods := network.HostAliasToPods[hostname]
+		for _, pod := range pods {
+			if pod.Ready {
+				res = append(res, pod.IP)
+			}
 		}
 	}
 	return res
@@ -214,7 +215,7 @@ func (net *Networks) ReverseLookup(sourceIp IPAddress, ip IPAddress) []Hostname
 	for _, network := range networks {
 		klog.V(3).Infof("Trying %s %v", network.Id, network)
 		pod := network.IPToPod[ip]
-		if pod != nil {
+		if pod != nil && pod.Ready {
 			klog.V(3).Infof("Found hostaliases %v", pod.HostAliases)
 			return pod.HostAliases
 		}