start dns refactor

pkg/roles/dns/handler_coredns.go → pkg/roles/dns/handlers/coredns/handler_coredns.go

@@ -1,9 +1,10 @@
-package dns
+package coredns
 
 import (
 	"reflect"
 	"unsafe"
 
+	"beryju.io/gravity/pkg/roles/dns/handlers"
 	"beryju.io/gravity/pkg/roles/dns/utils"
 	"github.com/coredns/caddy"
 	"github.com/coredns/coredns/core/dnsserver"
@@ -23,11 +24,11 @@ type CoreDNS struct {
 	srv      *dnsserver.Server
 }
 
-func NewCoreDNS(z *Zone, rawConfig map[string]string) *CoreDNS {
+func NewCoreDNS(z handlers.HandlerZoneContext, rawConfig map[string]string) *CoreDNS {
 	core := &CoreDNS{
 		c: rawConfig,
 	}
-	core.log = z.log.With(zap.String("handler", core.Identifier()))
+	core.log = z.Log().With(zap.String("handler", core.Identifier()))
 	dnsserver.Quiet = true
 	corefile := caddy.CaddyfileInput{
 		Contents:       []byte(core.c["config"]),

pkg/roles/dns/handler_coredns_test.go → pkg/roles/dns/handlers/coredns/handler_coredns_test.go

@@ -1,4 +1,4 @@
-package dns_test
+package coredns_test
 
 import (
 	"net"
@@ -19,6 +19,12 @@ const CoreDNSConfig = `.:1342 {
     }
 }`
 
+func RoleConfig() []byte {
+	return []byte(tests.MustJSON(dns.RoleConfig{
+		Port: 1054,
+	}))
+}
+
 func TestRoleDNSHandlerCoreDNS(t *testing.T) {
 	defer tests.Setup(t)()
 	rootInst := instance.New()
@@ -46,7 +52,7 @@ func TestRoleDNSHandlerCoreDNS(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{

pkg/roles/dns/handler_etcd.go → pkg/roles/dns/handlers/etcd/handler_etcd.go

@@ -1,8 +1,9 @@
-package dns
+package etcd
 
 import (
 	"strings"
 
+	"beryju.io/gravity/pkg/roles/dns/handlers"
 	"beryju.io/gravity/pkg/roles/dns/types"
 	"beryju.io/gravity/pkg/roles/dns/utils"
 	"beryju.io/gravity/pkg/storage"
@@ -15,28 +16,28 @@ import (
 const EtcdType = "etcd"
 
 type EtcdHandler struct {
-	log       *zap.Logger
-	z         *Zone
-	lookupKey func(k *storage.Key, qname string, r *utils.DNSRequest) []dns.RR
+	log           *zap.Logger
+	z             handlers.HandlerZoneContext
+	LookupKeyFunc func(k *storage.Key, qname string, r *utils.DNSRequest) []dns.RR
 }
 
-func NewEtcdHandler(z *Zone, config map[string]string) *EtcdHandler {
+func NewEtcdHandler(z handlers.HandlerZoneContext, config map[string]string) *EtcdHandler {
 	eh := &EtcdHandler{
 		z: z,
 	}
-	eh.lookupKey = func(k *storage.Key, qname string, r *utils.DNSRequest) []dns.RR {
+	eh.LookupKeyFunc = func(k *storage.Key, qname string, r *utils.DNSRequest) []dns.RR {
 		answers := []dns.RR{}
 		es := sentry.TransactionFromContext(r.Context()).StartChild("gravity.dns.handler.etcd.get")
 		defer es.Finish()
 		key := k.String()
 		eh.log.Debug("fetching kv key", zap.String("key", key))
 		es.SetTag("gravity.dns.handler.etcd.key", key)
-		res, err := eh.z.inst.KV().Get(r.Context(), key, clientv3.WithPrefix())
+		res, err := eh.z.RoleInstance().KV().Get(r.Context(), key, clientv3.WithPrefix())
 		if err != nil || len(res.Kvs) < 1 {
 			return answers
 		}
 		for _, kv := range res.Kvs {
-			rec, err := eh.z.recordFromKV(kv)
+			rec, err := eh.z.RecordFromKV(kv)
 			if err != nil {
 				continue
 			}
@@ -47,7 +48,7 @@ func NewEtcdHandler(z *Zone, config map[string]string) *EtcdHandler {
 		}
 		return answers
 	}
-	eh.log = z.log.With(zap.String("handler", eh.Identifier()))
+	eh.log = z.Log().With(zap.String("handler", eh.Identifier()))
 	return eh
 }
 
@@ -64,8 +65,8 @@ func (eh *EtcdHandler) findWildcard(r *utils.DNSRequest, relRecordName string, q
 		// Replace the current dot part with a wildcard (make sure to only replace 1 occurrence,
 		// since we replace from left to right)
 		wildcardName = strings.Replace(wildcardName, part, types.DNSWildcard, 1)
-		wildcardKey := eh.z.inst.KV().Key(eh.z.etcdKey, strings.ToLower(wildcardName), dns.Type(question.Qtype).String())
-		wildcardAns := eh.lookupKey(wildcardKey, question.Name, r)
+		wildcardKey := eh.z.RoleInstance().KV().Key(eh.z.EtcdKey(), strings.ToLower(wildcardName), dns.Type(question.Qtype).String())
+		wildcardAns := eh.LookupKeyFunc(wildcardKey, question.Name, r)
 		// If we do get an answer from this wildcard key, stop going further
 		if len(wildcardAns) > 0 {
 			return wildcardAns
@@ -86,8 +87,8 @@ func (eh *EtcdHandler) handleSingleQuestion(question dns.Question, r *utils.DNSR
 		// in the database
 		relRecordName = strings.TrimSuffix(relRecordName, ".")
 	}
-	directRecordKey := eh.z.inst.KV().Key(
-		eh.z.etcdKey,
+	directRecordKey := eh.z.RoleInstance().KV().Key(
+		eh.z.EtcdKey(),
 		strings.ToLower(relRecordName),
 	)
 	if question.Qtype != dns.TypeNone {
@@ -101,7 +102,7 @@ func (eh *EtcdHandler) handleSingleQuestion(question dns.Question, r *utils.DNSR
 		directRecordKey = directRecordKey.Prefix(true)
 	}
 	// Look for direct matches first
-	answers = append(answers, eh.lookupKey(
+	answers = append(answers, eh.LookupKeyFunc(
 		directRecordKey,
 		question.Name,
 		r,
@@ -137,9 +138,9 @@ func (eh *EtcdHandler) Handle(w *utils.FakeDNSWriter, r *utils.DNSRequest) *dns.
 	for un := range uniqueQuestionNames {
 		// Look for CNAMEs
 		relRecordName := strings.TrimSuffix(strings.ToLower(un), strings.ToLower(utils.EnsureLeadingPeriod(eh.z.Name)))
-		cnames := eh.lookupKey(
-			eh.z.inst.KV().Key(
-				eh.z.etcdKey,
+		cnames := eh.LookupKeyFunc(
+			eh.z.RoleInstance().KV().Key(
+				eh.z.EtcdKey(),
 				strings.ToLower(relRecordName),
 				dns.Type(dns.TypeCNAME).String(),
 			),

pkg/roles/dns/handler_etcd_test.go → pkg/roles/dns/handlers/etcd/handler_etcd_test.go

@@ -1,4 +1,4 @@
-package dns_test
+package etcd_test
 
 import (
 	"net"
@@ -54,7 +54,7 @@ func TestRoleDNS_Etcd(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{
@@ -109,7 +109,7 @@ func TestRoleDNS_Etcd_Root(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{
@@ -163,7 +163,7 @@ func TestRoleDNS_Etcd_Wildcard(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{
@@ -231,7 +231,7 @@ func TestRoleDNS_Etcd_CNAME(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{
@@ -244,7 +244,7 @@ func TestRoleDNS_Etcd_CNAME(t *testing.T) {
 	ans := fw.Msg().Answer[0]
 	assert.Equal(t, net.ParseIP("10.2.3.4").String(), ans.(*d.A).A.String())
 
-	fw = NewNullDNSWriter()
+	fw = dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{
@@ -298,7 +298,7 @@ func TestRoleDNS_Etcd_WildcardNested(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{
@@ -352,7 +352,7 @@ func TestRoleDNS_Etcd_MixedCase(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{
@@ -406,7 +406,7 @@ func TestRoleDNS_Etcd_MixedCase_Reverse(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{

pkg/roles/dns/handler_forward_blocky_test.go → pkg/roles/dns/handlers/forward_blocky/handler_forward_blocky_test.go

@@ -48,7 +48,7 @@ func TestRoleDNS_BlockyForwarder(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{

pkg/roles/dns/handler_forward_ip.go → pkg/roles/dns/handlers/forward_ip/handler_forward_ip.go

@@ -1,10 +1,11 @@
-package dns
+package forward_ip
 
 import (
 	"math/rand"
 	"strconv"
 	"strings"
 
+	"beryju.io/gravity/pkg/roles/dns/handlers"
 	"beryju.io/gravity/pkg/roles/dns/types"
 	"beryju.io/gravity/pkg/roles/dns/utils"
 	"github.com/getsentry/sentry-go"
@@ -18,12 +19,12 @@ type IPForwarderHandler struct {
 	c         *dns.Client
 	resolvers []string
 
-	z        *Zone
+	z        handlers.HandlerZoneContext
 	log      *zap.Logger
 	CacheTTL int
 }
 
-func NewIPForwarderHandler(z *Zone, config map[string]string) *IPForwarderHandler {
+func NewIPForwarderHandler(z handlers.HandlerZoneContext, config map[string]string) *IPForwarderHandler {
 	net, ok := config["net"]
 	if !ok {
 		net = ""
@@ -37,7 +38,7 @@ func NewIPForwarderHandler(z *Zone, config map[string]string) *IPForwarderHandle
 		},
 		resolvers: strings.Split(config["to"], ";"),
 	}
-	ipf.log = z.log.With(zap.String("handler", ipf.Identifier()))
+	ipf.log = z.Log().With(zap.String("handler", ipf.Identifier()))
 
 	rawTtl := config["cache_ttl"]
 	cacheTtl, err := strconv.Atoi(rawTtl)

pkg/roles/dns/handler_forward_ip_test.go → pkg/roles/dns/handlers/forward_ip/handler_forward_ip_test.go

@@ -1,4 +1,4 @@
-package dns_test
+package forward_ip_test
 
 import (
 	"net"
@@ -41,7 +41,7 @@ func TestRoleDNS_IPForwarder_v4(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{
@@ -91,7 +91,7 @@ func TestRoleDNS_IPForwarder_v4_Cache(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{
@@ -150,7 +150,7 @@ func TestRoleDNS_IPForwarder_v6(t *testing.T) {
 	assert.Nil(t, role.Start(ctx, RoleConfig()))
 	defer role.Stop()
 
-	fw := NewNullDNSWriter()
+	fw := dns.NewNullDNSWriter()
 	role.Handler(fw, &d.Msg{
 		Question: []d.Question{
 			{

pkg/roles/dns/handlers/handler.go

@@ -0,0 +1,27 @@
+package handlers
+
+import (
+	"beryju.io/gravity/pkg/roles"
+	"beryju.io/gravity/pkg/roles/dns/utils"
+	"github.com/miekg/dns"
+	"go.etcd.io/etcd/api/v3/mvccpb"
+	"go.uber.org/zap"
+)
+
+type Handler interface {
+	Handle(w *utils.FakeDNSWriter, r *utils.DNSRequest) *dns.Msg
+	Identifier() string
+}
+
+type HandlerZoneContext interface {
+	Log() *zap.Logger
+	// // TODO Rename to Zone()
+	// GetZone() *types.Zone
+	RecordFromKV(kv *mvccpb.KeyValue) (HandlerRecord, error)
+	RoleInstance() roles.Instance
+	EtcdKey() string
+}
+
+type HandlerRecord interface {
+	ToDNS(string) dns.RR
+}

pkg/roles/dns/handler_memory.go → pkg/roles/dns/handlers/memory/handler_memory.go

@@ -1,8 +1,10 @@
-package dns
+package memory
 
 import (
 	"strings"
 
+	"beryju.io/gravity/pkg/roles/dns/handlers"
+	"beryju.io/gravity/pkg/roles/dns/handlers/etcd"
 	"beryju.io/gravity/pkg/roles/dns/utils"
 	"beryju.io/gravity/pkg/storage"
 	"github.com/miekg/dns"
@@ -12,17 +14,17 @@ import (
 const MemoryType = "memory"
 
 type MemoryHandler struct {
-	*EtcdHandler
+	*etcd.EtcdHandler
 	log *zap.Logger
-	z   *Zone
+	z   handlers.HandlerZoneContext
 }
 
-func NewMemoryHandler(z *Zone, config map[string]string) *MemoryHandler {
+func NewMemoryHandler(z handlers.HandlerZoneContext, config map[string]string) *MemoryHandler {
 	mh := &MemoryHandler{
-		EtcdHandler: &EtcdHandler{z: z},
+		EtcdHandler: etcd.NewEtcdHandler(z, config),
 		z:           z,
 	}
-	mh.lookupKey = func(k *storage.Key, qname string, r *utils.DNSRequest) []dns.RR {
+	mh.LookupKeyFunc = func(k *storage.Key, qname string, r *utils.DNSRequest) []dns.RR {
 		answers := []dns.RR{}
 		mh.z.recordsSync.RLock()
 		defer mh.z.recordsSync.RUnlock()