Add azurerm_key_vault_certificate_issuer

azurerm/helpers/azure/key_vault.go

@@ -27,9 +27,9 @@ func GetKeyVaultBaseUrlFromID(ctx context.Context, client *keyvault.VaultsClient
 	resp, err := client.Get(ctx, resourceGroup, vaultName)
 	if err != nil {
 		if utils.ResponseWasNotFound(resp.Response) {
-			return "", fmt.Errorf("Error unable to find KeyVault %q (Resource Group %q): %+v", vaultName, resourceGroup, err)
+			return "", fmt.Errorf("failed to find KeyVault %q (Resource Group %q): %+v", vaultName, resourceGroup, err)
 		}
-		return "", fmt.Errorf("Error making Read request on KeyVault %q (Resource Group %q): %+v", vaultName, resourceGroup, err)
+		return "", fmt.Errorf("failed to make Read request on KeyVault %q (Resource Group %q): %+v", vaultName, resourceGroup, err)
 	}
 
 	if resp.Properties == nil || resp.Properties.VaultURI == nil {
@@ -42,7 +42,7 @@ func GetKeyVaultBaseUrlFromID(ctx context.Context, client *keyvault.VaultsClient
 func GetKeyVaultIDFromBaseUrl(ctx context.Context, client *keyvault.VaultsClient, keyVaultUrl string) (*string, error) {
 	list, err := client.ListComplete(ctx, utils.Int32(1000))
 	if err != nil {
-		return nil, fmt.Errorf("Error GetKeyVaultId unable to list Key Vaults %v", err)
+		return nil, fmt.Errorf("failed to list Key Vaults %v", err)
 	}
 
 	for list.NotDone() {
@@ -54,7 +54,7 @@ func GetKeyVaultIDFromBaseUrl(ctx context.Context, client *keyvault.VaultsClient
 
 		vid, err := ParseAzureResourceID(*v.ID)
 		if err != nil {
-			return nil, fmt.Errorf("Error parsing ID for Key Vault URI %q: %s", *v.ID, err)
+			return nil, fmt.Errorf("failed to parse ID for Key Vault URI %q: %s", *v.ID, err)
 		}
 		resourceGroup := vid.ResourceGroup
 		name := vid.Path["vaults"]
@@ -64,11 +64,11 @@ func GetKeyVaultIDFromBaseUrl(ctx context.Context, client *keyvault.VaultsClient
 		if err != nil {
 			if utils.ResponseWasNotFound(get.Response) {
 				if e := list.NextWithContext(ctx); e != nil {
-					return nil, fmt.Errorf("Error getting next vault on KeyVault url %q : %+v", keyVaultUrl, err)
+					return nil, fmt.Errorf("failed to get next vault on KeyVault url %q : %+v", keyVaultUrl, err)
 				}
 				continue
 			}
-			return nil, fmt.Errorf("Error making Read request on KeyVault %q (Resource Group %q): %+v", name, resourceGroup, err)
+			return nil, fmt.Errorf("failed to make Read request on KeyVault %q (Resource Group %q): %+v", name, resourceGroup, err)
 		}
 
 		if get.ID == nil || get.Properties == nil || get.Properties.VaultURI == nil {
@@ -80,7 +80,7 @@ func GetKeyVaultIDFromBaseUrl(ctx context.Context, client *keyvault.VaultsClient
 		}
 
 		if e := list.NextWithContext(ctx); e != nil {
-			return nil, fmt.Errorf("Error getting next vault on KeyVault url %q : %+v", keyVaultUrl, err)
+			return nil, fmt.Errorf("failed to get next vault on KeyVault url %q : %+v", keyVaultUrl, err)
 		}
 	}
 
@@ -109,7 +109,7 @@ func KeyVaultExists(ctx context.Context, client *keyvault.VaultsClient, keyVault
 		if utils.ResponseWasNotFound(resp.Response) {
 			return false, nil
 		}
-		return false, fmt.Errorf("Error making Read request on KeyVault %q (Resource Group %q): %+v", vaultName, resourceGroup, err)
+		return false, fmt.Errorf("failed to make Read request on KeyVault %q (Resource Group %q): %+v", vaultName, resourceGroup, err)
 	}
 
 	if resp.Properties == nil || resp.Properties.VaultURI == nil {

azurerm/internal/services/keyvault/key_vault_certificate_issuer_data_source.go

@@ -0,0 +1,118 @@
+package keyvault
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/keyvault/validate"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func dataSourceArmKeyVaultCertificateIssuer() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceArmKeyVaultCertificateIssuerRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read: schema.DefaultTimeout(5 * time.Minute),
+		},
+
+		Schema: map[string]*schema.Schema{
+			"key_vault_id": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: azure.ValidateResourceID,
+			},
+
+			"name": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ValidateFunc: validate.KeyVaultCertificateIssuerName,
+			},
+
+			"provider_name": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"account_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"org_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"admin": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"email_address": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"first_name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"last_name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"phone": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func dataSourceArmKeyVaultCertificateIssuerRead(d *schema.ResourceData, meta interface{}) error {
+	vaultClient := meta.(*clients.Client).KeyVault.VaultsClient
+	client := meta.(*clients.Client).KeyVault.ManagementClient
+	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	name := d.Get("name").(string)
+	keyVaultId := d.Get("key_vault_id").(string)
+
+	keyVaultBaseUri, err := azure.GetKeyVaultBaseUrlFromID(ctx, vaultClient, keyVaultId)
+	if err != nil {
+		return fmt.Errorf("failed to look up Certificate Issuer %q, vault id %q: %+v", name, keyVaultId, err)
+	}
+
+	resp, err := client.GetCertificateIssuer(ctx, keyVaultBaseUri, name)
+	if err != nil {
+		if utils.ResponseWasNotFound(resp.Response) {
+			return fmt.Errorf("KeyVault Certificate Issuer %q (KeyVault URI %q) does not exist", name, keyVaultBaseUri)
+		}
+		return fmt.Errorf("failed making Read request on Azure KeyVault Certificate Issuer %s: %+v", name, err)
+	}
+	if resp.ID == nil || *resp.ID == "" {
+		return fmt.Errorf("failure reading Key Vault Certificate Issuer ID for %q", name)
+	}
+	d.SetId(*resp.ID)
+
+	d.Set("provider_name", resp.Provider)
+	if resp.OrganizationDetails != nil {
+		if resp.OrganizationDetails.ID != nil {
+			d.Set("org_id", resp.OrganizationDetails.ID)
+		}
+		d.Set("admin", flattenKeyVaultCertificateIssuerAdmins(resp.OrganizationDetails.AdminDetails))
+	}
+	if resp.Credentials != nil && resp.Credentials.AccountID != nil {
+		d.Set("account_id", resp.Credentials.AccountID)
+	}
+
+	return nil
+}