Merge pull request #1 from LevenLabs/cachingGroups

Added support for groups of addresses and defaulted to serial queries

Author: Brian Picciano

README.md

@@ -30,7 +30,15 @@ non-empty answer section. If so that is returned, otherwise the server at
 `8.8.8.8:53` will be checked. The order of checking is always in the order the
 `--fwd-to` parameters are specified.
 
-In reality struggledns will make a dns request for every `--fwd-to` at the same
-time, for every incoming request. It then checks responses in order. This way
-there's not much of a speed penalty, at the cost of more bandwidth and more hits
-to the remote servers.
+### Groups
+
+    struggledns --fwd-to 10.0.0.5:53,8.8.8.8:53 --fwd-to 10.0.0.6:53,8.8.4.4:53
+
+Each `--fwd-to` can be a group of comma-delimited addresses to query in
+parallel. Every address in a group is queried in parallel and groups are queried
+in serial unless `--parallel` is specified, which causes **all** sent addresses
+from all groups to be queried in parallel. The response still respects the order
+of the addresses despite being sent in parallel. In the above example, when a
+query is received it will be first sent to both `10.0.0.5:53` and `8.8.8.8:53`
+and if both of those fail then it will make a request to both `10.0.0.6:53` and
+`8.8.4.4:53`.

main.go

@@ -5,9 +5,10 @@ import (
 
 	"github.com/mediocregopher/lever"
 	"github.com/miekg/dns"
+	"strings"
 )
 
-var dnsServers []string
+var dnsServerGroups [][]string
 
 func tryProxy(m *dns.Msg, addr string) *dns.Msg {
 	aM, err := dns.Exchange(m, addr)
@@ -20,21 +21,32 @@ func tryProxy(m *dns.Msg, addr string) *dns.Msg {
 	return aM
 }
 
-func handleRequest(w dns.ResponseWriter, r *dns.Msg) {
-	chs := make([]chan *dns.Msg, len(dnsServers))
-	for i := range dnsServers {
+func queryServers(r *dns.Msg, servers []string) *dns.Msg {
+	chs := make([]chan *dns.Msg, len(servers))
+	for i := range servers {
 		chs[i] = make(chan *dns.Msg, 1)
 		go func(ch chan *dns.Msg, addr string) {
 			ch <- tryProxy(r, addr)
-		}(chs[i], dnsServers[i])
+		}(chs[i], servers[i])
 	}
 
 	var m *dns.Msg
-	for i := range dnsServers {
+	for i := range servers {
 		if m = <-chs[i]; m != nil {
 			break
 		}
 	}
+	return m
+}
+
+func handleRequest(w dns.ResponseWriter, r *dns.Msg) {
+	var m *dns.Msg
+	for i := range dnsServerGroups {
+		m = queryServers(r, dnsServerGroups[i])
+		if m != nil {
+			break
+		}
+	}
 	if m == nil {
 		dns.HandleFailed(w, r)
 		return
@@ -55,10 +67,31 @@ func main() {
 		Name:        "--fwd-to",
 		Description: "Address (ip:port) of a dns server to attempt forward requests to. Specify multiple times to make multiple request attempts. Order specified dictates precedence should more than one server respond for a request",
 	})
+	l.Add(lever.Param{
+		Name:        "--parallel",
+		Description: "If sent the query will be sent to all addresses in parallel",
+		Flag:        true,
+	})
 	l.Parse()
 
 	addr, _ := l.ParamStr("--listen-addr")
-	dnsServers, _ = l.ParamStrs("--fwd-to")
+	dnsServers, _ := l.ParamStrs("--fwd-to")
+	combineGroups := l.ParamFlag("--parallel")
+
+	if combineGroups {
+		//combine all the servers sent into one group
+		dnsServerGroups = make([][]string, 1)
+		var groupServers []string
+		for i := range dnsServers {
+			groupServers = strings.Split(dnsServers[i], ",")
+			dnsServerGroups[0] = append(dnsServerGroups[0], groupServers...)
+		}
+	} else {
+		dnsServerGroups = make([][]string, len(dnsServers))
+		for i := range dnsServers {
+			dnsServerGroups[i] = strings.Split(dnsServers[i], ",")
+		}
+	}
 
 	handler := dns.HandlerFunc(handleRequest)
 	go func() {