distinguish the host is inner or outer host of K8s cluster (#10)

Author: WangXiangUSTC

chaos.go

@@ -2,11 +2,11 @@ package kubernetes
 
 import (
 	"context"
+	"fmt"
 	"math/rand"
 	"net"
 	"time"
 
-	"github.com/coredns/coredns/plugin"
 	"github.com/coredns/coredns/request"
 	"github.com/miekg/dns"
 	api "k8s.io/api/core/v1"
@@ -50,7 +50,7 @@ func (p *PodInfo) IsOverdue() bool {
 
 func (k Kubernetes) chaosDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg, state request.Request, podInfo *PodInfo) (int, error) {
 	if podInfo.Action == ActionError {
-		return dns.RcodeServerFailure, nil
+		return dns.RcodeServerFailure, fmt.Errorf("dns chaos error")
 	}
 
 	// return random IP
@@ -156,7 +156,7 @@ func (k Kubernetes) getChaosPod(ip string) (*PodInfo, error) {
 }
 
 // needChaos judges weather should do chaos for the request
-func (k Kubernetes) needChaos(podInfo *PodInfo, state request.Request) bool {
+func (k Kubernetes) needChaos(podInfo *PodInfo, records []dns.RR, err error) bool {
 	if podInfo == nil {
 		return false
 	}
@@ -165,21 +165,30 @@ func (k Kubernetes) needChaos(podInfo *PodInfo, state request.Request) bool {
 		return true
 	}
 
-	// FIXME: this function is wrong, need to fix it
-	qname := state.QName()
-	zone := plugin.Zones(k.Zones).Matches(qname)
+	if err != nil {
+		// not found in cluster, is outer host
+		if k.IsNameError(err) {
+			if podInfo.Scope == ScopeOuter {
+				return true
+			}
+			return false
+		}
+
+		// can't judge the host is outer or inner host, ignore chaos
+		return false
+	}
 
-	log.Infof("qname: %s, zone: %s, scope: %s, zones: %s", qname, zone, podInfo.Scope, k.Zones)
-	if zone == "" {
-		// is outer host
+	if len(records) == 0 {
+		// not found in cluster, is outer host {
 		if podInfo.Scope == ScopeOuter {
 			return true
 		}
-	} else {
-		// is inner host
-		if podInfo.Scope == ScopeInner {
-			return true
-		}
+		return false
+	}
+
+	// is inner host
+	if podInfo.Scope == ScopeInner {
+		return true
 	}
 
 	return false

handler.go

@@ -13,27 +13,60 @@ import (
 func (k Kubernetes) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error) {
 	state := request.Request{W: w, Req: r}
 	sourceIP := state.IP()
-	log.Infof("k8s ServeDNS, source IP: %s", sourceIP)
+	log.Infof("k8s ServeDNS, source IP: %s, state: %v", sourceIP, state)
 
 	chaosPod, err := k.getChaosPod(sourceIP)
 	if err != nil {
 		log.Infof("fail to get pod information from cluster, IP: %s, error: %v", sourceIP, err)
 	}
-	if k.needChaos(chaosPod, state) {
+
+	records, extra, zone, err := k.getRecords(ctx, state)
+	log.Infof("records: %v, err: %v", records, err)
+
+	if k.needChaos(chaosPod, records, err) {
 		return k.chaosDNS(ctx, w, r, state, chaosPod)
 	}
 
+	if k.IsNameError(err) {
+		if k.Fall.Through(state.Name()) {
+			return plugin.NextOrFailure(k.Name(), k.Next, ctx, w, r)
+		}
+		if !k.APIConn.HasSynced() {
+			// If we haven't synchronized with the kubernetes cluster, return server failure
+			return plugin.BackendError(ctx, &k, zone, dns.RcodeServerFailure, state, nil /* err */, plugin.Options{})
+		}
+		return plugin.BackendError(ctx, &k, zone, dns.RcodeNameError, state, nil /* err */, plugin.Options{})
+	}
+	if err != nil {
+		return dns.RcodeServerFailure, err
+	}
+
+	if len(records) == 0 {
+		return plugin.BackendError(ctx, &k, zone, dns.RcodeSuccess, state, nil, plugin.Options{})
+	}
+
+	m := new(dns.Msg)
+	m.SetReply(r)
+	m.Authoritative = true
+	m.Answer = append(m.Answer, records...)
+	m.Extra = append(m.Extra, extra...)
+
+	w.WriteMsg(m)
+	return dns.RcodeSuccess, nil
+}
+
+// get records from cache
+func (k Kubernetes) getRecords(ctx context.Context, state request.Request) ([]dns.RR, []dns.RR, string, error) {
 	qname := state.QName()
 	zone := plugin.Zones(k.Zones).Matches(qname)
-	if zone == "" {
-		return plugin.NextOrFailure(k.Name(), k.Next, ctx, w, r)
-	}
+
 	zone = qname[len(qname)-len(zone):] // maintain case of original query
 	state.Zone = zone
 
 	var (
 		records []dns.RR
 		extra   []dns.RR
+		err     error
 	)
 
 	switch state.QType() {
@@ -68,34 +101,7 @@ func (k Kubernetes) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.M
 		_, err = plugin.A(ctx, &k, zone, fake, nil, plugin.Options{})
 	}
 
-	if k.IsNameError(err) {
-		if k.Fall.Through(state.Name()) {
-			return plugin.NextOrFailure(k.Name(), k.Next, ctx, w, r)
-		}
-		if !k.APIConn.HasSynced() {
-			// If we haven't synchronized with the kubernetes cluster, return server failure
-			return plugin.BackendError(ctx, &k, zone, dns.RcodeServerFailure, state, nil /* err */, plugin.Options{})
-		}
-		return plugin.BackendError(ctx, &k, zone, dns.RcodeNameError, state, nil /* err */, plugin.Options{})
-	}
-	if err != nil {
-		return dns.RcodeServerFailure, err
-	}
-
-	if len(records) == 0 {
-		return plugin.BackendError(ctx, &k, zone, dns.RcodeSuccess, state, nil, plugin.Options{})
-	}
-
-	log.Infof("records %v", records)
-
-	m := new(dns.Msg)
-	m.SetReply(r)
-	m.Authoritative = true
-	m.Answer = append(m.Answer, records...)
-	m.Extra = append(m.Extra, extra...)
-
-	w.WriteMsg(m)
-	return dns.RcodeSuccess, nil
+	return records, extra, zone, err
 }
 
 // Name implements the Handler interface.