Implement Get Zone for Azure DNS (#631)

* Implement Get Zone for Azure DNS

* Internalize getExistingRecord

docs/_includes/matrix.html

@@ -907,8 +907,8 @@
 		<td class="info">
 			<i class="fa fa-circle-o text-info" aria-hidden="true"></i>
 		</td>
-		<td class="info">
+		<td class="success">
-			<i class="fa fa-circle-o text-info" aria-hidden="true"></i>
+			<i class="fa fa-check text-success" aria-hidden="true"></i>
 		</td>
 		<td class="success">
 			<i class="fa fa-check text-success" aria-hidden="true"></i>

providers/azuredns/azureDnsProvider.go

@@ -62,23 +62,33 @@ var features = providers.DocumentationNotes{
 	providers.CanUseNAPTR:            providers.Cannot(),
 	providers.CanUseSSHFP:            providers.Cannot(),
 	providers.CanUseTLSA:             providers.Cannot(),
-	providers.CanGetZones:            providers.Unimplemented(),
+	providers.CanGetZones:            providers.Can(),
 }
 
 func init() {
 	providers.RegisterDomainServiceProviderType("AZURE_DNS", newAzureDnsDsp, features)
 }
 
-func (a *azureDnsProvider) getZones() error {
+func (a *azureDnsProvider) getExistingZones() (*adns.ZoneListResult, error) {
-	a.zones = make(map[string]*adns.Zone)
-
 	ctx, cancel := context.WithTimeout(context.Background(), 6000*time.Second)
 	defer cancel()
 	zonesIterator, zonesErr := a.zonesClient.ListByResourceGroupComplete(ctx, *a.resourceGroup, to.Int32Ptr(100))
 	if zonesErr != nil {
-		return zonesErr
+		return nil, zonesErr
 	}
 	zonesResult := zonesIterator.Response()
+	return &zonesResult, nil
+}
+
+func (a *azureDnsProvider) getZones() error {
+	a.zones = make(map[string]*adns.Zone)
+
+	zonesResult, err := a.getExistingZones()
+
+	if err != nil {
+		return err
+	}
+
 	for _, z := range *zonesResult.Value {
 		zone := z
 		domain := strings.TrimSuffix(*z.Name, ".")
@@ -111,12 +121,51 @@ func (a *azureDnsProvider) GetNameservers(domain string) ([]*models.Nameserver,
 	return ns, nil
 }
 
+func (a *azureDnsProvider) ListZones() ([]string, error) {
+	zonesResult, err := a.getExistingZones()
+
+	if err != nil {
+		return nil, err
+	}
+
+	var zones []string
+
+	for _, z := range *zonesResult.Value {
+		domain := strings.TrimSuffix(*z.Name, ".")
+		zones = append(zones, domain)
+	}
+
+	return zones, nil
+}
+
 // GetZoneRecords gets the records of a zone and returns them in RecordConfig format.
-func (client *azureDnsProvider) GetZoneRecords(domain string) (models.Records, error) {
+func (a *azureDnsProvider) GetZoneRecords(domain string) (models.Records, error) {
-	return nil, fmt.Errorf("not implemented")
+	existingRecords, _, _, err := a.getExistingRecords(domain)
-	// This enables the get-zones subcommand.
+	if err != nil {
-	// Implement this by extracting the code from GetDomainCorrections into
+		return nil, err
-	// a single function.  For most providers this should be relatively easy.
+	}
+	return existingRecords, nil
+}
+
+func (a *azureDnsProvider) getExistingRecords(domain string) (models.Records, []*adns.RecordSet, string, error) {
+	zone, ok := a.zones[domain]
+	if !ok {
+		return nil, nil, "", errNoExist{domain}
+	}
+	var zoneName string
+	zoneName = *zone.Name
+	records, err := a.fetchRecordSets(zoneName)
+	if err != nil {
+		return nil, nil, "", err
+	}
+
+	var existingRecords models.Records
+	for _, set := range records {
+		existingRecords = append(existingRecords, nativeToRecords(set, zoneName)...)
+	}
+
+	models.PostProcessRecords(existingRecords)
+	return existingRecords, records, zoneName, nil
 }
 
 func (a *azureDnsProvider) GetDomainCorrections(dc *models.DomainConfig) ([]*models.Correction, error) {
@@ -127,24 +176,12 @@ func (a *azureDnsProvider) GetDomainCorrections(dc *models.DomainConfig) ([]*mod
 	}
 
 	var corrections []*models.Correction
-	zone, ok := a.zones[dc.Name]
+
-	if !ok {
+	existingRecords, records, zoneName, err := a.getExistingRecords(dc.Name)
-		return nil, errNoExist{dc.Name}
-	}
-	var zoneName string
-	zoneName = *zone.Name
-	records, err := a.fetchRecordSets(zoneName)
 	if err != nil {
 		return nil, err
 	}
 
-	var existingRecords []*models.RecordConfig
-	for _, set := range records {
-		existingRecords = append(existingRecords, nativeToRecords(set, dc.Name)...)
-	}
-
-	models.PostProcessRecords(existingRecords)
-
 	differ := diff.New(dc)
 	namesToUpdate := differ.ChangedGroups(existingRecords)