more stuff; insight: use proxy for upstream queries

middleware/etcd/etcd.go

@@ -8,6 +8,7 @@ import (
 	"github.com/miekg/coredns/middleware"
 	"github.com/miekg/coredns/middleware/etcd/msg"
 	"github.com/miekg/coredns/middleware/etcd/singleflight"
+	"github.com/miekg/coredns/middleware/proxy"
 
 	etcdc "github.com/coreos/etcd/client"
 	"golang.org/x/net/context"
@@ -17,6 +18,7 @@ type (
 	Etcd struct {
 		Next       middleware.Handler
 		Zones      []string
+		Proxy      proxy.Proxy
 		client     etcdc.KeysAPI
 		ctx        context.Context
 		inflight   *singleflight.Group
@@ -28,6 +30,7 @@ func NewEtcd(client etcdc.KeysAPI, next middleware.Handler, zones []string) Etcd
 	return Etcd{
 		Next:       next,
 		Zones:      zones,
+		Proxy:      proxy.New([]string{"8.8.8.8:53"}),
 		client:     client,
 		ctx:        context.Background(),
 		inflight:   &singleflight.Group{},

middleware/etcd/etcd.md

@@ -4,9 +4,6 @@
 a [message](https://github.com/skynetservices/skydns/blob/2fcff74cdc9f9a7dd64189a447ef27ac354b725f/msg/service.go#L26)
 like [SkyDNS](https//github.com/skynetservices/skydns).
 
-If you need replies to SOA and NS queries you should add a little zone after etcd directive that has
-these resource records.
-
 ## Syntax
 
 ~~~

middleware/etcd/lookup.go

@@ -1,8 +1,18 @@
 package etcd
 
-/*
+import (
-func (s *server) AddressRecords(q dns.Question, name string, previousRecords []dns.RR, state middleware.State) (records []dns.RR, err error) {
+	"math"
-	services, err := s.backend.Records(name, false)
+	"net"
+
+	"github.com/miekg/coredns/middleware"
+	"github.com/miekg/coredns/middleware/etcd/msg"
+	"github.com/miekg/dns"
+)
+
+// need current zone argument.
+
+func (e Etcd) AddressRecords(zone string, state middleware.State, previousRecords []dns.RR) (records []dns.RR, err error) {
+	services, err := e.Records(state.Name(), false)
 	if err != nil {
 		return nil, err
 	}
@@ -14,24 +24,25 @@ func (s *server) AddressRecords(q dns.Question, name string, previousRecords []d
 		switch {
 		case ip == nil:
 			// Try to resolve as CNAME if it's not an IP, but only if we don't create loops.
-			if q.Name == dns.Fqdn(serv.Host) {
+			// TODO(miek): lowercasing, use Match in middleware/
+			if state.Name() == dns.Fqdn(serv.Host) {
 				// x CNAME x is a direct loop, don't add those
 				continue
 			}
 
-			newRecord := serv.NewCNAME(q.Name, dns.Fqdn(serv.Host))
+			newRecord := serv.NewCNAME(state.QName(), dns.Fqdn(serv.Host))
 			if len(previousRecords) > 7 {
-				logf("CNAME lookup limit of 8 exceeded for %s", newRecord)
 				// don't add it, and just continue
 				continue
 			}
-			if s.isDuplicateCNAME(newRecord, previousRecords) {
+			if isDuplicateCNAME(newRecord, previousRecords) {
-				logf("CNAME loop detected for record %s", newRecord)
 				continue
 			}
 
-			nextRecords, err := s.AddressRecords(dns.Question{Name: dns.Fqdn(serv.Host), Qtype: q.Qtype, Qclass: q.Qclass},
+			// Fucks up recursion, need to define this in the function
-				strings.ToLower(dns.Fqdn(serv.Host)), append(previousRecords, newRecord), state)
+			// are use another var
+			state.Req.Question[0] = dns.Question{Name: dns.Fqdn(serv.Host), Qtype: state.QType(), Qclass: state.QClass()}
+			nextRecords, err := e.AddressRecords(zone, state, append(previousRecords, newRecord))
 			if err == nil {
 				// Only have we found something we should add the CNAME and the IP addresses.
 				if len(nextRecords) > 0 {
@@ -42,59 +53,31 @@ func (s *server) AddressRecords(q dns.Question, name string, previousRecords []d
 			}
 			// This means we can not complete the CNAME, try to look else where.
 			target := newRecord.Target
-			if dns.IsSubDomain(s.config.Domain, target) {
+			if dns.IsSubDomain(zone, target) {
 				// We should already have found it
 				continue
 			}
-			m1, e1 := s.Lookup(target, q.Qtype, bufsize, dnssec)
+			m1, e1 := e.Proxy.Lookup(state, target, state.QType())
 			if e1 != nil {
-				logf("incomplete CNAME chain: %s", e1)
 				continue
 			}
 			// Len(m1.Answer) > 0 here is well?
 			records = append(records, newRecord)
 			records = append(records, m1.Answer...)
 			continue
-		case ip.To4() != nil && (q.Qtype == dns.TypeA || both):
+		case ip.To4() != nil && (state.QType() == dns.TypeA):
-			records = append(records, serv.NewA(q.Name, ip.To4()))
+			records = append(records, serv.NewA(state.QName(), ip.To4()))
-		case ip.To4() == nil && (q.Qtype == dns.TypeAAAA || both):
+		case ip.To4() == nil && (state.QType() == dns.TypeAAAA):
-			records = append(records, serv.NewAAAA(q.Name, ip.To16()))
+			records = append(records, serv.NewAAAA(state.QName(), ip.To16()))
 		}
 	}
 	return records, nil
 }
 
-// NSRecords returns NS records from etcd.
-func (s *server) NSRecords(q dns.Question, state middleware.State) (records []dns.RR, extra []dns.RR, err error) {
-	services, err := s.backend.Records(name, false)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	services = msg.Group(services)
-
-	for _, serv := range services {
-		ip := net.ParseIP(serv.Host)
-		switch {
-		case ip == nil:
-			return nil, nil, fmt.Errorf("NS record must be an IP address")
-		case ip.To4() != nil:
-			serv.Host = msg.Domain(serv.Key)
-			records = append(records, serv.NewNS(q.Name, serv.Host))
-			extra = append(extra, serv.NewA(serv.Host, ip.To4()))
-		case ip.To4() == nil:
-			serv.Host = msg.Domain(serv.Key)
-			records = append(records, serv.NewNS(q.Name, serv.Host))
-			extra = append(extra, serv.NewAAAA(serv.Host, ip.To16()))
-		}
-	}
-	return records, extra, nil
-}
-
 // SRVRecords returns SRV records from etcd.
-// If the Target is not a name but an IP address, a name is created.
+// If the Target is not a name but an IP address, a name is created on the fly.
-func (s *server) SRVRecords(s middleware.State) (records []dns.RR, extra []dns.RR, err error) {
+func (e Etcd) SRVRecords(zone string, state middleware.State) (records []dns.RR, extra []dns.RR, err error) {
-	services, err := s.backend.Records(name, false)
+	services, err := e.Records(name, false)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -126,7 +109,7 @@ func (s *server) SRVRecords(s middleware.State) (records []dns.RR, extra []dns.R
 		ip := net.ParseIP(serv.Host)
 		switch {
 		case ip == nil:
-			srv := serv.NewSRV(q.Name, weight)
+			srv := serv.NewSRV(state.QName(), weight)
 			records = append(records, srv)
 
 			if _, ok := lookup[srv.Target]; ok {
@@ -135,12 +118,12 @@ func (s *server) SRVRecords(s middleware.State) (records []dns.RR, extra []dns.R
 
 			lookup[srv.Target] = true
 
-			if !dns.IsSubDomain(s.config.Domain, srv.Target) {
+			if !dns.IsSubDomain(zone, srv.Target) {
-				m1, e1 := s.Lookup(srv.Target, dns.TypeA, bufsize, dnssec)
+				m1, e1 := e.Proxy.Lookup(state, srv.Target, dns.TypeA)
 				if e1 == nil {
 					extra = append(extra, m1.Answer...)
 				}
-				m1, e1 = s.Lookup(srv.Target, dns.TypeAAAA, bufsize, dnssec)
+				m1, e1 = e.Proxy.Lookup(state, srv.Target, dns.TypeAAAA)
 				if e1 == nil {
 					// If we have seen CNAME's we *assume* that they are already added.
 					for _, a := range m1.Answer {
@@ -154,7 +137,7 @@ func (s *server) SRVRecords(s middleware.State) (records []dns.RR, extra []dns.R
 			// Internal name, we should have some info on them, either v4 or v6
 			// Clients expect a complete answer, because we are a recursor in their
 			// view.
-			addr, e1 := s.AddressRecords(dns.Question{srv.Target, dns.ClassINET, dns.TypeA},
+			addr, e1 := e.AddressRecords(dns.Question{srv.Target, dns.ClassINET, dns.TypeA},
 				srv.Target, nil, bufsize, dnssec, true)
 			if e1 == nil {
 				extra = append(extra, addr...)
@@ -177,9 +160,9 @@ func (s *server) SRVRecords(s middleware.State) (records []dns.RR, extra []dns.R
 }
 
 // MXRecords returns MX records from etcd.
-// If the Target is not a name but an IP address, a name is created.
+// If the Target is not a name but an IP address, a name is created on the fly.
-func (s *server) MXRecords(q dns.Question, name string, s middleware.State) (records []dns.RR, extra []dns.RR, err error) {
+func (e Etcd) MXRecords(zone string, state middleware.State) (records []dns.RR, extra []dns.RR, err error) {
-	services, err := s.backend.Records(name, false)
+	services, err := e.Records(name, false)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -201,11 +184,11 @@ func (s *server) MXRecords(q dns.Question, name string, s middleware.State) (rec
 			lookup[mx.Mx] = true
 
 			if !dns.IsSubDomain(s.config.Domain, mx.Mx) {
-				m1, e1 := s.Lookup(mx.Mx, dns.TypeA, bufsize, dnssec)
+				m1, e1 := e.Proxy.Lookup(state, mx.Mx, dns.TypeA)
 				if e1 == nil {
 					extra = append(extra, m1.Answer...)
 				}
-				m1, e1 = s.Lookup(mx.Mx, dns.TypeAAAA, bufsize, dnssec)
+				m1, e1 = e.Proxy.Lookup(state, mx.Mx, dns.TypeAAAA)
 				if e1 == nil {
 					// If we have seen CNAME's we *assume* that they are already added.
 					for _, a := range m1.Answer {
@@ -235,8 +218,8 @@ func (s *server) MXRecords(q dns.Question, name string, s middleware.State) (rec
 	return records, extra, nil
 }
 
-func (s *server) CNAMERecords(q dns.Question, state middleware.State) (records []dns.RR, err error) {
+func (e Etcd) CNAMERecords(zone string, state middleware.State) (records []dns.RR, err error) {
-	services, err := s.backend.Records(name, true)
+	services, err := e.Records(name, true)
 	if err != nil {
 		return nil, err
 	}
@@ -252,8 +235,8 @@ func (s *server) CNAMERecords(q dns.Question, state middleware.State) (records [
 	return records, nil
 }
 
-func (s *server) TXTRecords(q dns.Question, state middleware.State) (records []dns.RR, err error) {
+func (e Etcd) TXTRecords(zone string, state middleware.State) (records []dns.RR, err error) {
-	services, err := s.backend.Records(name, false)
+	services, err := e.Records(state.Name(), false)
 	if err != nil {
 		return nil, err
 	}
@@ -280,6 +263,7 @@ func isDuplicateCNAME(r *dns.CNAME, records []dns.RR) bool {
 	return false
 }
 
+/*
 // Move to state.go somehow?
 func (s *server) NameError(req *dns.Msg) *dns.Msg {
 	m := new(dns.Msg)
@@ -289,30 +273,6 @@ func (s *server) NameError(req *dns.Msg) *dns.Msg {
 	return m
 }
 
-// overflowOrTruncated writes back an error to the client if the message does not fit.
-// It updates prometheus metrics. If something has been written to the client, true
-// will be returned.
-func (s *server) overflowOrTruncated(w dns.ResponseWriter, m *dns.Msg, bufsize int, sy metrics.System) bool {
-	switch isTCP(w) {
-	case true:
-		if _, overflow := Fit(m, dns.MaxMsgSize, true); overflow {
-			metrics.ReportErrorCount(m, sy)
-			msgFail := s.ServerFailure(m)
-			w.WriteMsg(msgFail)
-			return true
-		}
-	case false:
-		// Overflow with udp always results in TC.
-		Fit(m, bufsize, false)
-		metrics.ReportErrorCount(m, sy)
-		if m.Truncated {
-			w.WriteMsg(m)
-			return true
-		}
-	}
-	return false
-}
-
 // etcNameError return a NameError to the client if the error
 // returned from etcd has ErrorCode == 100.
 func isEtcdNameError(err error, s *server) bool {

middleware/exchange.go

@@ -2,13 +2,7 @@ package middleware
 
 import "github.com/miekg/dns"
 
-// Exchang sends message m to the server.
-// TODO(miek): optionally it can do retries of other silly stuff.
 func Exchange(c *dns.Client, m *dns.Msg, server string) (*dns.Msg, error) {
 	r, _, err := c.Exchange(m, server)
 	return r, err
 }
-
-// Lookup functions, ala
-// LookupHost
-// LookupCNAME

middleware/proxy/lookup.go

@@ -0,0 +1,105 @@
+package proxy
+
+// function OTHER middleware might want to use to do lookup in the same
+// style as the proxy.
+
+import (
+	"net/http"
+	"sync/atomic"
+	"time"
+
+	"github.com/miekg/coredns/middleware"
+	"github.com/miekg/dns"
+)
+
+func New(hosts []string) Proxy {
+	p := Proxy{Next: nil, Client: Clients()}
+
+	upstream := &staticUpstream{
+		from:         "",
+		proxyHeaders: make(http.Header),
+		Hosts:        make([]*UpstreamHost, len(hosts)),
+		Policy:       &Random{},
+		FailTimeout:  10 * time.Second,
+		MaxFails:     1,
+	}
+
+	for i, host := range hosts {
+		uh := &UpstreamHost{
+			Name:         host,
+			Conns:        0,
+			Fails:        0,
+			FailTimeout:  upstream.FailTimeout,
+			Unhealthy:    false,
+			ExtraHeaders: upstream.proxyHeaders,
+			CheckDown: func(upstream *staticUpstream) UpstreamHostDownFunc {
+				return func(uh *UpstreamHost) bool {
+					if uh.Unhealthy {
+						return true
+					}
+					if uh.Fails >= upstream.MaxFails &&
+						upstream.MaxFails != 0 {
+						return true
+					}
+					return false
+				}
+			}(upstream),
+			WithoutPathPrefix: upstream.WithoutPathPrefix,
+		}
+		upstream.Hosts[i] = uh
+	}
+	p.Upstreams = []Upstream{upstream}
+	return p, nil
+}
+
+func (p Proxy) Lookup(state middleware.State, name string, tpe uint16) (*dns.Msg, error) {
+	req := new(dns.Msg)
+	req.SetQuestion(name, tpe)
+	// TODO(miek):
+	// USE STATE FOR DNSSEC ETCD BUFSIZE BLA BLA
+	return p.lookup(state, req)
+}
+
+func (p Proxy) lookup(state middleware.State, r *dns.Msg) (*dns.Msg, error) {
+	var (
+		reply *dns.Msg
+		err   error
+	)
+	for _, upstream := range p.Upstreams {
+		// allowed bla bla bla TODO(miek): fix full proxy spec from caddy
+		start := time.Now()
+
+		// Since Select() should give us "up" hosts, keep retrying
+		// hosts until timeout (or until we get a nil host).
+		for time.Now().Sub(start) < tryDuration {
+			host := upstream.Select()
+			if host == nil {
+				return nil, errUnreachable
+			}
+
+			atomic.AddInt64(&host.Conns, 1)
+			// tls+tcp ?
+			if state.Proto() == "tcp" {
+				reply, err = middleware.Exchange(p.Client.TCP, r, host.Name)
+			} else {
+				reply, err = middleware.Exchange(p.Client.UDP, r, host.Name)
+			}
+			atomic.AddInt64(&host.Conns, -1)
+
+			if err == nil {
+				return reply, nil
+			}
+			timeout := host.FailTimeout
+			if timeout == 0 {
+				timeout = 10 * time.Second
+			}
+			atomic.AddInt32(&host.Fails, 1)
+			go func(host *UpstreamHost, timeout time.Duration) {
+				time.Sleep(timeout)
+				atomic.AddInt32(&host.Fails, -1)
+			}(host, timeout)
+		}
+		return nil, errUnreachable
+	}
+	return nil, errUnreachable
+}

middleware/zone.go

@@ -4,12 +4,12 @@ import "strings"
 
 type Zones []string
 
-// Matches checks to see if other matches p.
+// Matches checks to see if other matches p.  The match will return the most
-// The match will return the most specific zones
+// specific zones that matches other. The empty string signals a not found
-// that matches other. The empty string signals a not found
 // condition.
 func (z Zones) Matches(qname string) string {
 	zone := ""
+	// TODO(miek): use IsSubDomain here?
 	for _, zname := range z {
 		if strings.HasSuffix(qname, zname) {
 			if len(zname) > len(zone) {