azurerm_dns_zone & azurerm_private_dns_zone - support for the soa_record block

azurerm/internal/services/dns/dns_zone_resource.go

@@ -7,10 +7,12 @@ import (
 	"github.com/Azure/azure-sdk-for-go/services/dns/mgmt/2018-05-01/dns"
 	"github.com/hashicorp/go-azure-helpers/response"
 	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/dns/parse"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/dns/validate"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags"
 	azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
@@ -61,13 +63,86 @@ func resourceArmDnsZone() *schema.Resource {
 				Set:      schema.HashString,
 			},
 
+			"soa_record": {
+				Type:     schema.TypeList,
+				MaxItems: 1,
+				Optional: true,
+				Computed: true,
+				ForceNew: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"email": {
+							Type:         schema.TypeString,
+							Required:     true,
+							ValidateFunc: validate.DnsZoneSOARecordEmail,
+						},
+
+						"host_name": {
+							Type:         schema.TypeString,
+							Required:     true,
+							ValidateFunc: validation.StringIsNotEmpty,
+						},
+
+						"expire_time": {
+							Type:         schema.TypeInt,
+							Optional:     true,
+							Default:      2419200,
+							ValidateFunc: validation.IntAtLeast(0),
+						},
+
+						"minimum_ttl": {
+							Type:         schema.TypeInt,
+							Optional:     true,
+							Default:      300,
+							ValidateFunc: validation.IntAtLeast(0),
+						},
+
+						"refresh_time": {
+							Type:         schema.TypeInt,
+							Optional:     true,
+							Default:      3600,
+							ValidateFunc: validation.IntAtLeast(0),
+						},
+
+						"retry_time": {
+							Type:         schema.TypeInt,
+							Optional:     true,
+							Default:      300,
+							ValidateFunc: validation.IntAtLeast(0),
+						},
+
+						"serial_number": {
+							Type:         schema.TypeInt,
+							Optional:     true,
+							Default:      1,
+							ValidateFunc: validation.IntAtLeast(0),
+						},
+
+						"ttl": {
+							Type:         schema.TypeInt,
+							Optional:     true,
+							Default:      3600,
+							ValidateFunc: validation.IntBetween(0, 2147483647),
+						},
+
+						"tags": tags.Schema(),
+
+						"fqdn": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+
 			"tags": tags.Schema(),
 		},
 	}
 }
 
 func resourceArmDnsZoneCreateUpdate(d *schema.ResourceData, meta interface{}) error {
 	client := meta.(*clients.Client).Dns.ZonesClient
+	recordSetsClient := meta.(*clients.Client).Dns.RecordSetsClient
 	ctx, cancel := timeouts.ForCreateUpdate(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
@@ -106,6 +181,21 @@ func resourceArmDnsZoneCreateUpdate(d *schema.ResourceData, meta interface{}) er
 		return fmt.Errorf("Error retrieving DNS Zone %q (Resource Group %q): %s", name, resGroup, err)
 	}
 
+	if v, ok := d.GetOk("soa_record"); ok {
+		soaRecord := v.([]interface{})[0].(map[string]interface{})
+		rsParameters := dns.RecordSet{
+			RecordSetProperties: &dns.RecordSetProperties{
+				TTL:       utils.Int64(int64(soaRecord["ttl"].(int))),
+				Metadata:  tags.Expand(soaRecord["tags"].(map[string]interface{})),
+				SoaRecord: expandArmDNSZoneSOARecord(soaRecord),
+			},
+		}
+
+		if _, err := recordSetsClient.CreateOrUpdate(ctx, resGroup, name, "@", dns.SOA, rsParameters, etag, ifNoneMatch); err != nil {
+			return fmt.Errorf("creating/updating DNS SOA Record @ (Zone %q / Resource Group %q): %s", name, resGroup, err)
+		}
+	}
+
 	if resp.ID == nil {
 		return fmt.Errorf("Cannot read DNS Zone %q (Resource Group %q) ID", name, resGroup)
 	}
@@ -117,6 +207,7 @@ func resourceArmDnsZoneCreateUpdate(d *schema.ResourceData, meta interface{}) er
 
 func resourceArmDnsZoneRead(d *schema.ResourceData, meta interface{}) error {
 	zonesClient := meta.(*clients.Client).Dns.ZonesClient
+	recordSetsClient := meta.(*clients.Client).Dns.RecordSetsClient
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
@@ -148,6 +239,15 @@ func resourceArmDnsZoneRead(d *schema.ResourceData, meta interface{}) error {
 		return err
 	}
 
+	rsResp, err := recordSetsClient.Get(ctx, id.ResourceGroup, id.Name, "@", dns.SOA)
+	if err != nil {
+		return fmt.Errorf("reading DNS SOA record @: %v", err)
+	}
+
+	if err := d.Set("soa_record", flattenArmDNSZoneSOARecord(&rsResp)); err != nil {
+		return fmt.Errorf("setting `soa_record`: %+v", err)
+	}
+
 	return tags.FlattenAndSet(d, resp.Tags)
 }
 
@@ -179,3 +279,88 @@ func resourceArmDnsZoneDelete(d *schema.ResourceData, meta interface{}) error {
 
 	return nil
 }
+
+func expandArmDNSZoneSOARecord(input map[string]interface{}) *dns.SoaRecord {
+	return &dns.SoaRecord{
+		Email:        utils.String(input["email"].(string)),
+		Host:         utils.String(input["host_name"].(string)),
+		ExpireTime:   utils.Int64(int64(input["expire_time"].(int))),
+		MinimumTTL:   utils.Int64(int64(input["minimum_ttl"].(int))),
+		RefreshTime:  utils.Int64(int64(input["refresh_time"].(int))),
+		RetryTime:    utils.Int64(int64(input["retry_time"].(int))),
+		SerialNumber: utils.Int64(int64(input["serial_number"].(int))),
+	}
+}
+
+func flattenArmDNSZoneSOARecord(input *dns.RecordSet) []interface{} {
+	if input == nil {
+		return make([]interface{}, 0)
+	}
+
+	ttl := 0
+	if input.TTL != nil {
+		ttl = int(*input.TTL)
+	}
+
+	metaData := make(map[string]interface{})
+	if input.Metadata != nil {
+		metaData = tags.Flatten(input.Metadata)
+	}
+
+	fqdn := ""
+	if input.Fqdn != nil {
+		fqdn = *input.Fqdn
+	}
+
+	email := ""
+	hostName := ""
+	expireTime := 0
+	minimumTTL := 0
+	refreshTime := 0
+	retryTime := 0
+	serialNumber := 0
+	if input.SoaRecord != nil {
+		if input.SoaRecord.Email != nil {
+			email = *input.SoaRecord.Email
+		}
+
+		if input.SoaRecord.Host != nil {
+			hostName = *input.SoaRecord.Host
+		}
+
+		if input.SoaRecord.ExpireTime != nil {
+			expireTime = int(*input.SoaRecord.ExpireTime)
+		}
+
+		if input.SoaRecord.MinimumTTL != nil {
+			minimumTTL = int(*input.SoaRecord.MinimumTTL)
+		}
+
+		if input.SoaRecord.RefreshTime != nil {
+			refreshTime = int(*input.SoaRecord.RefreshTime)
+		}
+
+		if input.SoaRecord.RetryTime != nil {
+			retryTime = int(*input.SoaRecord.RetryTime)
+		}
+
+		if input.SoaRecord.SerialNumber != nil {
+			serialNumber = int(*input.SoaRecord.SerialNumber)
+		}
+	}
+
+	return []interface{}{
+		map[string]interface{}{
+			"email":         email,
+			"host_name":     hostName,
+			"expire_time":   expireTime,
+			"minimum_ttl":   minimumTTL,
+			"refresh_time":  refreshTime,
+			"retry_time":    retryTime,
+			"serial_number": serialNumber,
+			"ttl":           ttl,
+			"tags":          metaData,
+			"fqdn":          fqdn,
+		},
+	}
+}

azurerm/internal/services/dns/tests/dns_zone_resource_test.go

@@ -80,6 +80,25 @@ func TestAccAzureRMDnsZone_withTags(t *testing.T) {
 	})
 }
 
+func TestAccAzureRMDnsZone_withSOARecord(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_dns_zone", "test")
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { acceptance.PreCheck(t) },
+		Providers:    acceptance.SupportedProviders,
+		CheckDestroy: testCheckAzureRMDnsZoneDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccAzureRMDnsZone_withSOARecord(data),
+				Check: resource.ComposeTestCheckFunc(
+					testCheckAzureRMDnsZoneExists(data.ResourceName),
+				),
+			},
+			data.ImportStep(),
+		},
+	})
+}
+
 func testCheckAzureRMDnsZoneExists(resourceName string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		client := acceptance.AzureProvider.Meta().(*clients.Client).Dns.ZonesClient
@@ -212,3 +231,36 @@ resource "azurerm_dns_zone" "test" {
 }
 `, data.RandomInteger, data.Locations.Primary, data.RandomInteger)
 }
+
+func testAccAzureRMDnsZone_withSOARecord(data acceptance.TestData) string {
+	return fmt.Sprintf(`
+provider "azurerm" {
+  features {}
+}
+
+resource "azurerm_resource_group" "test" {
+  name     = "acctestRG-DNSZone-%d"
+  location = "%s"
+}
+
+resource "azurerm_dns_zone" "test" {
+  name                = "acctestzone%d.com"
+  resource_group_name = azurerm_resource_group.test.name
+
+  soa_record {
+    email         = "testemail.com"
+    host_name     = "testhost.contoso.com"
+    expire_time   = 2419200
+    minimum_ttl   = 200
+    refresh_time  = 2600
+    retry_time    = 200
+    serial_number = 1
+    ttl           = 100
+
+    tags = {
+      ENv = "Test"
+    }
+  }
+}
+`, data.RandomInteger, data.Locations.Primary, data.RandomInteger)
+}

azurerm/internal/services/dns/validate/dns_zone.go

@@ -0,0 +1,17 @@
+package validate
+
+import (
+	"fmt"
+	"regexp"
+)
+
+func DnsZoneSOARecordEmail(v interface{}, k string) (warnings []string, errors []error) {
+	value := v.(string)
+
+	if !regexp.MustCompile(`^[a-zA-Z\d_-][a-zA-Z\d._-]{0,62}$`).MatchString(value) {
+		errors = append(errors, fmt.Errorf("%q must be between 1 and 63 characters in length and contains only letters, numbers, underscores, dashes and periods", k))
+		return warnings, errors
+	}
+
+	return warnings, errors
+}

azurerm/internal/services/dns/validate/dns_zone_test.go

@@ -0,0 +1,56 @@
+package validate
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDNSZoneSOARecordEmail(t *testing.T) {
+	cases := []struct {
+		Value  string
+		Errors int
+	}{
+		{
+			Value:  "",
+			Errors: 1,
+		},
+		{
+			Value:  "a/b.com",
+			Errors: 1,
+		},
+		{
+			Value:  "a-b.com",
+			Errors: 0,
+		},
+		{
+			Value:  "ab.com",
+			Errors: 0,
+		},
+		{
+			Value:  "terraform.io",
+			Errors: 0,
+		},
+		{
+			Value:  strings.Repeat("s", 62),
+			Errors: 0,
+		},
+		{
+			Value:  strings.Repeat("s", 63),
+			Errors: 0,
+		},
+		{
+			Value:  strings.Repeat("s", 64),
+			Errors: 1,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.Value, func(t *testing.T) {
+			_, errors := DnsZoneSOARecordEmail(tc.Value, "email")
+
+			if len(errors) != tc.Errors {
+				t.Fatalf("Expected DNSZoneSOARecordEmail to return %d error(s) not %d", tc.Errors, len(errors))
+			}
+		})
+	}
+}