mirror/stackexchange-dnscontrol
1
0
Fork 0
mirror of https://github.com/StackExchange/dnscontrol.git synced 2024-05-11 05:55:12 +00:00
Code Issues Releases Activity

Rename DomainCreator to the more accurate ZoneCreator (#2038)

Browse Source 
Co-authored-by: Yannik Sembritzki <yannik@sembritzki.org>
Co-authored-by: Tom Limoncelli <tlimoncelli@stackoverflow.com>
This commit is contained in:
Yannik Sembritzki
2023-02-07 17:52:49 +05:30
committed by GitHub
parent e8ae619f89
commit 5e06c249d6
23 changed files with 52 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
commands/createDomains.go
View File

@ -54,9 +54,9 @@ func CreateDomains(args CreateDomainsArgs) error {
for _, domain := range cfg.Domains { for _, domain := range cfg.Domains {
fmt.Println("*** ", domain.Name) fmt.Println("*** ", domain.Name)
for _, provider := range domain.DNSProviderInstances { for _, provider := range domain.DNSProviderInstances {
if creator, ok := provider.Driver.(providers.DomainCreator); ok { if creator, ok := provider.Driver.(providers.ZoneCreator); ok {
fmt.Println(" -", provider.Name) fmt.Println(" -", provider.Name)
err := creator.EnsureDomainExists(domain.Name) err := creator.EnsureZoneExists(domain.Name)
if err != nil { if err != nil {
fmt.Printf("Error creating domain: %s\n", err) fmt.Printf("Error creating domain: %s\n", err)
} }

6
commands/previewPush.go
View File

@ -151,12 +151,12 @@ DomainLoop:
out.Warnf("DEBUG: zones: %v\n", zones) out.Warnf("DEBUG: zones: %v\n", zones)
out.Warnf("DEBUG: Name: %v\n", domain.Name) out.Warnf("DEBUG: Name: %v\n", domain.Name)
out.Warnf("Domain '%s' does not exist in the '%s' profile and will be added automatically.\n", domain.Name, provider.Name) out.Warnf("Zone '%s' does not exist in the '%s' profile and will be added automatically.\n", domain.Name, provider.Name)
continue // continue with next provider, as we can not determine corrections without an existing zone continue // continue with next provider, as we can not determine corrections without an existing zone
} }
} else if creator, ok := provider.Driver.(providers.DomainCreator); ok && push { } else if creator, ok := provider.Driver.(providers.ZoneCreator); ok && push {
// this is the actual push, ensure domain exists at DSP // this is the actual push, ensure domain exists at DSP
if err := creator.EnsureDomainExists(domain.Name); err != nil { if err := creator.EnsureZoneExists(domain.Name); err != nil {
out.Warnf("Error creating domain: %s\n", err) out.Warnf("Error creating domain: %s\n", err)
continue // continue with next provider, as we couldn't create this one continue // continue with next provider, as we couldn't create this one
} }

4
providers/akamaiedgedns/akamaiEdgeDnsProvider.go
View File

@ -95,8 +95,8 @@ func newEdgeDNSDSP(config map[string]string, metadata json.RawMessage) (provider
return api, nil return api, nil
} }
// EnsureDomainExists configures a new zone if the zone does not already exist. // EnsureZoneExists creates a zone if it does not exist
func (a *edgeDNSProvider) EnsureDomainExists(domain string) error { func (a *edgeDNSProvider) EnsureZoneExists(domain string) error {
if zoneDoesExist(domain) { if zoneDoesExist(domain) {
printer.Debugf("Zone %s already exists\n", domain) printer.Debugf("Zone %s already exists\n", domain)
return nil return nil

2
providers/azuredns/azureDnsProvider.go
View File

@ -662,7 +662,7 @@ func (a *azurednsProvider) fetchRecordSets(zoneName string) ([]*adns.RecordSet,
return records, nil return records, nil
} }
func (a *azurednsProvider) EnsureDomainExists(domain string) error { func (a *azurednsProvider) EnsureZoneExists(domain string) error {
if _, ok := a.zones[domain]; ok { if _, ok := a.zones[domain]; ok {
return nil return nil
} }

4
providers/cloudflare/cloudflareProvider.go
View File

@ -870,8 +870,8 @@ func getProxyMetadata(r *models.RecordConfig) map[string]string {
} }
} }
// EnsureDomainExists returns an error of domain does not exist. // EnsureZoneExists creates a zone if it does not exist
func (c *cloudflareProvider) EnsureDomainExists(domain string) error { func (c *cloudflareProvider) EnsureZoneExists(domain string) error {
if c.domainIndex == nil { if c.domainIndex == nil {
if err := c.fetchDomainList(); err != nil { if err := c.fetchDomainList(); err != nil {
return err return err

6
providers/cloudns/cloudnsProvider.go
View File

@ -206,12 +206,12 @@ func (c *cloudnsProvider) GetZoneRecords(domain string) (models.Records, error)
return existingRecords, nil return existingRecords, nil
} }
// EnsureDomainExists returns an error if domain doesn't exist. // EnsureZoneExists creates a zone if it does not exist
func (c *cloudnsProvider) EnsureDomainExists(domain string) error { func (c *cloudnsProvider) EnsureZoneExists(domain string) error {
if err := c.fetchDomainList(); err != nil { if err := c.fetchDomainList(); err != nil {
return err return err
} }
// domain already exists // zone already exists
if _, ok := c.domainIndex[domain]; ok { if _, ok := c.domainIndex[domain]; ok {
return nil return nil
} }

5
providers/desec/desecProvider.go
View File

@ -112,9 +112,8 @@ func (c *desecProvider) GetZoneRecords(domain string) (models.Records, error) {
return existingRecords, nil return existingRecords, nil
} }
// EnsureDomainExists returns an error if domain doesn't exist. // EnsureZoneExists creates a zone if it does not exist
func (c *desecProvider) EnsureDomainExists(domain string) error { func (c *desecProvider) EnsureZoneExists(domain string) error {
// domain already exists
c.mutex.Lock() c.mutex.Lock()
defer c.mutex.Unlock() defer c.mutex.Unlock()
if _, ok := c.domainIndex[domain]; ok { if _, ok := c.domainIndex[domain]; ok {

4
providers/digitalocean/digitaloceanProvider.go
View File

@ -87,8 +87,8 @@ func init() {
providers.RegisterDomainServiceProviderType("DIGITALOCEAN", fns, features) providers.RegisterDomainServiceProviderType("DIGITALOCEAN", fns, features)
} }
// EnsureDomainExists returns an error if domain doesn't exist. // EnsureZoneExists creates a zone if it does not exist
func (api *digitaloceanProvider) EnsureDomainExists(domain string) error { func (api *digitaloceanProvider) EnsureZoneExists(domain string) error {
retry: retry:
ctx := context.Background() ctx := context.Background()
_, resp, err := api.client.Domains.Get(ctx, domain) _, resp, err := api.client.Domains.Get(ctx, domain)

8
providers/dnsmadeeasy/dnsMadeEasyProvider.go
View File

@ -177,9 +177,9 @@ func (api *dnsMadeEasyProvider) GetDomainCorrections(dc *models.DomainConfig) ([
return corrections, nil return corrections, nil
} }
// EnsureDomainExists returns an error if domain doesn't exist. // EnsureZoneExists creates a zone if it does not exist
func (api *dnsMadeEasyProvider) EnsureDomainExists(domainName string) error { func (api *dnsMadeEasyProvider) EnsureZoneExists(domain string) error {
exists, err := api.domainExists(domainName) exists, err := api.domainExists(domain)
if err != nil { if err != nil {
return err return err
} }
@ -189,7 +189,7 @@ func (api *dnsMadeEasyProvider) EnsureDomainExists(domainName string) error {
return nil return nil
} }
return api.createDomain(domainName) return api.createDomain(domain)
} }
// GetNameservers returns the nameservers for a domain. // GetNameservers returns the nameservers for a domain.

6
providers/exoscale/exoscaleProvider.go
View File

@ -74,9 +74,9 @@ func init() {
providers.RegisterDomainServiceProviderType("EXOSCALE", fns, features) providers.RegisterDomainServiceProviderType("EXOSCALE", fns, features)
} }
// EnsureDomainExists returns an error if domain doesn't exist. // EnsureZoneExists creates a zone if it does not exist
func (c *exoscaleProvider) EnsureDomainExists(domainName string) error { func (c *exoscaleProvider) EnsureZoneExists(domain string) error {
_, err := c.findDomainByName(domainName) _, err := c.findDomainByName(domain)
return err return err
} }

2
providers/gcloud/gcloudProvider.go
View File

@ -327,7 +327,7 @@ func (g *gcloudProvider) getRecords(domain string) ([]*gdns.ResourceRecordSet, s
return sets, zone.Name, nil return sets, zone.Name, nil
} }
func (g *gcloudProvider) EnsureDomainExists(domain string) error { func (g *gcloudProvider) EnsureZoneExists(domain string) error {
z, err := g.getZone(domain) z, err := g.getZone(domain)
if err != nil { if err != nil {
if _, ok := err.(errNoExist); !ok { if _, ok := err.(errNoExist); !ok {

4
providers/gcore/gcoreProvider.go
View File

@ -114,8 +114,8 @@ func (c *gcoreProvider) GetZoneRecords(domain string) (models.Records, error) {
return existingRecords, nil return existingRecords, nil
} }
// EnsureDomainExists returns an error if domain doesn't exist. // EnsureZoneExists creates a zone if it does not exist
func (c *gcoreProvider) EnsureDomainExists(domain string) error { func (c *gcoreProvider) EnsureZoneExists(domain string) error {
zones, err := c.provider.Zones(c.ctx) zones, err := c.provider.Zones(c.ctx)
if err != nil { if err != nil {
return err return err

4
providers/hedns/hednsProvider.go
View File

@ -156,8 +156,8 @@ func (c *hednsProvider) ListZones() ([]string, error) {
return domains, err return domains, err
} }
// EnsureDomainExists creates the domain if it does not exist. // EnsureZoneExists creates a zone if it does not exist
func (c *hednsProvider) EnsureDomainExists(domain string) error { func (c *hednsProvider) EnsureZoneExists(domain string) error {
domains, err := c.ListZones() domains, err := c.ListZones()
if err != nil { if err != nil {
return err return err

4
providers/hetzner/hetznerProvider.go
View File

@ -61,8 +61,8 @@ func New(settings map[string]string, _ json.RawMessage) (providers.DNSServicePro
return api, nil return api, nil
} }
// EnsureDomainExists creates the domain if it does not exist. // EnsureZoneExists creates a zone if it does not exist
func (api *hetznerProvider) EnsureDomainExists(domain string) error { func (api *hetznerProvider) EnsureZoneExists(domain string) error {
domains, err := api.ListZones() domains, err := api.ListZones()
if err != nil { if err != nil {
return err return err

6
providers/hexonet/domains.go
View File

@ -2,10 +2,10 @@ package hexonet
import "fmt" import "fmt"
// EnsureDomainExists returns an error // EnsureZoneExists returns an error
// * if access to dnszone is not allowed (not authorized) or // * if access to dnszone is not allowed (not authorized) or
// * if it doesn't exist and creating it fails // * if it doesn't exist and creating it fails
func (n *HXClient) EnsureDomainExists(domain string) error { func (n *HXClient) EnsureZoneExists(domain string) error {
r := n.client.Request(map[string]interface{}{ r := n.client.Request(map[string]interface{}{
"COMMAND": "StatusDNSZone", "COMMAND": "StatusDNSZone",
"DNSZONE": domain + ".", "DNSZONE": domain + ".",
@ -17,7 +17,7 @@ func (n *HXClient) EnsureDomainExists(domain string) error {
"DNSZONE": domain + ".", "DNSZONE": domain + ".",
}) })
if !r.IsSuccess() { if !r.IsSuccess() {
return n.GetHXApiError("Failed to create not existing zone for domain", domain, r) return n.GetHXApiError("Failed to create not existing zone ", domain, r)
} }
} else if code == 531 { } else if code == 531 {
return n.GetHXApiError("Not authorized to manage dnszone", domain, r) return n.GetHXApiError("Not authorized to manage dnszone", domain, r)

2
providers/hostingde/hostingdeProvider.go
View File

@ -351,7 +351,7 @@ func (hp *hostingdeProvider) GetRegistrarCorrections(dc *models.DomainConfig) ([
return nil, nil return nil, nil
} }
func (hp *hostingdeProvider) EnsureDomainExists(domain string) error { func (hp *hostingdeProvider) EnsureZoneExists(domain string) error {
_, err := hp.getZoneConfig(domain) _, err := hp.getZoneConfig(domain)
if err == errZoneNotFound { if err == errZoneNotFound {
if err := hp.createZone(domain); err != nil { if err := hp.createZone(domain); err != nil {

8
providers/inwx/inwxProvider.go
View File

@ -399,8 +399,8 @@ func (api *inwxAPI) fetchNameserverDomains() error {
return nil return nil
} }
// EnsureDomainExists returns an error if domain does not exist. // EnsureZoneExists creates a zone if it does not exist
func (api *inwxAPI) EnsureDomainExists(domain string) error { func (api *inwxAPI) EnsureZoneExists(domain string) error {
if api.domainIndex == nil { // only pull the data once. if api.domainIndex == nil { // only pull the data once.
if err := api.fetchNameserverDomains(); err != nil { if err := api.fetchNameserverDomains(); err != nil {
return err return err
@ -408,10 +408,10 @@ func (api *inwxAPI) EnsureDomainExists(domain string) error {
} }
if _, ok := api.domainIndex[domain]; ok { if _, ok := api.domainIndex[domain]; ok {
return nil // domain exists. return nil // zone exists.
} }
// creating the domain. // creating the zone.
request := &goinwx.NameserverCreateRequest{ request := &goinwx.NameserverCreateRequest{
Domain: domain, Domain: domain,
Type: "MASTER", Type: "MASTER",

2
providers/ns1/ns1Provider.go
View File

@ -50,7 +50,7 @@ func newProvider(creds map[string]string, meta json.RawMessage) (providers.DNSSe
return &nsone{rest.NewClient(http.DefaultClient, rest.SetAPIKey(creds["api_token"]))}, nil return &nsone{rest.NewClient(http.DefaultClient, rest.SetAPIKey(creds["api_token"]))}, nil
} }
func (n *nsone) EnsureDomainExists(domain string) error { func (n *nsone) EnsureZoneExists(domain string) error {
// This enables the create-domains subcommand // This enables the create-domains subcommand
zone := dns.NewZone(domain) zone := dns.NewZone(domain)

4
providers/oracle/oracleProvider.go
View File

@ -84,8 +84,8 @@ func (o *oracleProvider) ListZones() ([]string, error) {
return zones, nil return zones, nil
} }
// EnsureDomainExists creates the domain if it does not exist. // EnsureZoneExists creates a zone if it does not exist
func (o *oracleProvider) EnsureDomainExists(domain string) error { func (o *oracleProvider) EnsureZoneExists(domain string) error {
ctx, cancel := context.WithTimeout(context.Background(), time.Minute) ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
defer cancel() defer cancel()

6
providers/powerdns/dns.go
View File

@ -131,15 +131,15 @@ func (dsp *powerdnsProvider) GetDomainCorrections(dc *models.DomainConfig) ([]*m
return corrections, nil return corrections, nil
} }
// EnsureDomainExists adds a domain to the DNS service if it does not exist // EnsureZoneExists creates a zone if it does not exist
func (dsp *powerdnsProvider) EnsureDomainExists(domain string) error { func (dsp *powerdnsProvider) EnsureZoneExists(domain string) error {
if _, err := dsp.client.Zones().GetZone(context.Background(), dsp.ServerName, domain+"."); err != nil { if _, err := dsp.client.Zones().GetZone(context.Background(), dsp.ServerName, domain+"."); err != nil {
if e, ok := err.(pdnshttp.ErrUnexpectedStatus); ok { if e, ok := err.(pdnshttp.ErrUnexpectedStatus); ok {
if e.StatusCode != http.StatusNotFound { if e.StatusCode != http.StatusNotFound {
return err return err
} }
} }
} else { // domain seems to be there } else { // zone seems to exist
return nil return nil
} }

8
providers/providers.go
View File

@ -18,10 +18,10 @@ type DNSServiceProvider interface {
models.DNSProvider models.DNSProvider
} }
// DomainCreator should be implemented by providers that have the ability to add domains to an account. the create-domains command // ZoneCreator should be implemented by providers that have the ability to create zones
// can be run to ensure all domains are present before running preview/push. Implement this only if the provider supoprts the `dnscontrol create-domain` command. // (used for automatically creating zones if they don't exist)
type DomainCreator interface { type ZoneCreator interface {
EnsureDomainExists(domain string) error EnsureZoneExists(domain string) error
} }
// ZoneLister should be implemented by providers that have the // ZoneLister should be implemented by providers that have the

2
providers/route53/route53Provider.go
View File

@ -818,7 +818,7 @@ func unescape(s *string) string {
return name return name
} }
func (r *route53Provider) EnsureDomainExists(domain string) error { func (r *route53Provider) EnsureZoneExists(domain string) error {
if err := r.getZones(); err != nil { if err := r.getZones(); err != nil {
return err return err
} }

4
providers/vultr/vultrProvider.go
View File

@ -223,8 +223,8 @@ func (api *vultrProvider) GetNameservers(domain string) ([]*models.Nameserver, e
return models.ToNameservers(defaultNS) return models.ToNameservers(defaultNS)
} }
// EnsureDomainExists adds a domain to the Vutr DNS service if it does not exist // EnsureZoneExists creates a zone if it does not exist
func (api *vultrProvider) EnsureDomainExists(domain string) error { func (api *vultrProvider) EnsureZoneExists(domain string) error {
if ok, err := api.isDomainInAccount(domain); err != nil { if ok, err := api.isDomainInAccount(domain); err != nil {
return err return err
} else if ok { } else if ok {