Refactor: Prelink providers to domains (#305)

pkg/nameservers/nameservers.go

@@ -8,26 +8,22 @@ import (
 	"strconv"
 
 	"github.com/StackExchange/dnscontrol/models"
-	"github.com/StackExchange/dnscontrol/providers"
 	"github.com/miekg/dns/dnsutil"
 )
 
 // DetermineNameservers will find all nameservers we should use for a domain. It follows the following rules:
 // 1. All explicitly defined NAMESERVER records will be used.
 // 2. Each DSP declares how many nameservers to use. Default is all. 0 indicates to use none.
-func DetermineNameservers(dc *models.DomainConfig, maxNS int, dsps map[string]providers.DNSServiceProvider) ([]*models.Nameserver, error) {
+func DetermineNameservers(dc *models.DomainConfig) ([]*models.Nameserver, error) {
 	// always take explicit
 	ns := dc.Nameservers
-	for dsp, n := range dc.DNSProviders {
+	for _, dnsProvider := range dc.DNSProviderInstances {
+		n := dnsProvider.NumberOfNameservers
 		if n == 0 {
 			continue
 		}
-		fmt.Printf("----- Getting nameservers from: %s\n", dsp)
-		p, ok := dsps[dsp]
-		if !ok {
-			return nil, fmt.Errorf("DNS provider %s not declared", dsp)
-		}
-		nss, err := p.GetNameservers(dc.Name)
+		fmt.Printf("----- Getting nameservers from: %s\n", dnsProvider.Name)
+		nss, err := dnsProvider.Driver.GetNameservers(dc.Name)
 		if err != nil {
 			return nil, err
 		}

pkg/normalize/validate.go

@@ -246,30 +246,19 @@ type Warning struct {
 
 // NormalizeAndValidateConfig performs and normalization and/or validation of the IR.
 func NormalizeAndValidateConfig(config *models.DNSConfig) (errs []error) {
-	ptypeMap := map[string]string{}
-	for _, p := range config.DNSProviders {
-		ptypeMap[p.Name] = p.Type
-	}
-
 	for _, domain := range config.Domains {
 		pTypes := []string{}
 		txtMultiDissenters := []string{}
-		for p := range domain.DNSProviders {
-			pType, ok := ptypeMap[p]
-			if !ok {
-				errs = append(errs, fmt.Errorf("%s uses undefined DNS provider %s", domain.Name, p))
-			} else {
-				pTypes = append(pTypes, pType)
-			}
-
+		for _, provider := range domain.DNSProviderInstances {
+			pType := provider.ProviderType
 			// If NO_PURGE is in use, make sure this *isn't* a provider that *doesn't* support NO_PURGE.
 			if domain.KeepUnknown && providers.ProviderHasCabability(pType, providers.CantUseNOPURGE) {
-				errs = append(errs, fmt.Errorf("%s uses NO_PURGE which is not supported by %s(%s)", domain.Name, p, pType))
+				errs = append(errs, fmt.Errorf("%s uses NO_PURGE which is not supported by %s(%s)", domain.Name, provider.Name, pType))
 			}
 
 			// Record if any providers do not support TXTMulti:
 			if !providers.ProviderHasCabability(pType, providers.CanUseTXTMulti) {
-				txtMultiDissenters = append(txtMultiDissenters, p)
+				txtMultiDissenters = append(txtMultiDissenters, provider.Name)
 			}
 		}
 
@@ -374,7 +363,7 @@ func NormalizeAndValidateConfig(config *models.DNSConfig) (errs []error) {
 
 	// Check that if any aliases / ptr / etc.. are used in a domain, every provider for that domain supports them
 	for _, d := range config.Domains {
-		err := checkProviderCapabilities(d, config.DNSProviders)
+		err := checkProviderCapabilities(d)
 		if err != nil {
 			errs = append(errs, err)
 		}
@@ -401,7 +390,7 @@ func checkCNAMEs(dc *models.DomainConfig) (errs []error) {
 	return
 }
 
-func checkProviderCapabilities(dc *models.DomainConfig, pList []*models.DNSProviderConfig) error {
+func checkProviderCapabilities(dc *models.DomainConfig) error {
 	types := []struct {
 		rType string
 		cap   providers.Capability
@@ -423,14 +412,9 @@ func checkProviderCapabilities(dc *models.DomainConfig, pList []*models.DNSProvi
 		if !hasAny {
 			continue
 		}
-		for pName := range dc.DNSProviders {
-			for _, p := range pList {
-				if p.Name == pName {
-					if !providers.ProviderHasCabability(p.Type, ty.cap) {
-						return fmt.Errorf("Domain %s uses %s records, but DNS provider type %s does not support them", dc.Name, ty.rType, p.Type)
-					}
-					break
-				}
+		for _, provider := range dc.DNSProviderInstances {
+			if !providers.ProviderHasCabability(provider.ProviderType, ty.cap) {
+				return fmt.Errorf("Domain %s uses %s records, but DNS provider type %s does not support them", dc.Name, ty.rType, provider.ProviderType)
 			}
 		}
 	}

pkg/normalize/validate_test.go

@@ -193,8 +193,8 @@ func TestCAAValidation(t *testing.T) {
 	config := &models.DNSConfig{
 		Domains: []*models.DomainConfig{
 			{
-				Name:      "example.com",
-				Registrar: "BIND",
+				Name:          "example.com",
+				RegistrarName: "BIND",
 				Records: []*models.RecordConfig{
 					{Name: "@", Type: "CAA", CaaTag: "invalid", Target: "example.com"},
 				},
@@ -211,8 +211,8 @@ func TestTLSAValidation(t *testing.T) {
 	config := &models.DNSConfig{
 		Domains: []*models.DomainConfig{
 			{
-				Name:      "_443._tcp.example.com",
-				Registrar: "BIND",
+				Name:          "_443._tcp.example.com",
+				RegistrarName: "BIND",
 				Records: []*models.RecordConfig{
 					{Name: "_443._tcp", Type: "TLSA", TlsaUsage: 4, TlsaSelector: 1, TlsaMatchingType: 1, Target: "abcdef0"},
 				},