New Resource: azurerm_api_management_policy

azurerm/config.go

@@ -131,6 +131,7 @@ type ArmClient struct {
 	apiManagementGroupClient         apimanagement.GroupClient
 	apiManagementGroupUsersClient    apimanagement.GroupUserClient
 	apiManagementLoggerClient        apimanagement.LoggerClient
+	apiManagementPolicyClient        apimanagement.PolicyClient
 	apiManagementProductsClient      apimanagement.ProductClient
 	apiManagementProductApisClient   apimanagement.ProductAPIClient
 	apiManagementProductGroupsClient apimanagement.ProductGroupClient
@@ -518,6 +519,10 @@ func (c *ArmClient) registerApiManagementServiceClients(endpoint, subscriptionId
 	c.configureClient(&serviceClient.Client, auth)
 	c.apiManagementServiceClient = serviceClient
 
+	policyClient := apimanagement.NewPolicyClientWithBaseURI(endpoint, subscriptionId)
+	c.configureClient(&policyClient.Client, auth)
+	c.apiManagementPolicyClient = policyClient
+
 	productsClient := apimanagement.NewProductClientWithBaseURI(endpoint, subscriptionId)
 	c.configureClient(&productsClient.Client, auth)
 	c.apiManagementProductsClient = productsClient

azurerm/helpers/suppress/xml.go

@@ -0,0 +1,47 @@
+package suppress
+
+import (
+	"encoding/xml"
+	"io"
+	"reflect"
+	"strings"
+
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func SuppressXmlDiff(_, old, new string, _ *schema.ResourceData) bool {
+	oldTokens, err := expandXmlTokensFromString(old)
+	if err != nil {
+		return false
+	}
+
+	newTokens, err := expandXmlTokensFromString(new)
+	if err != nil {
+		return false
+	}
+
+	return reflect.DeepEqual(oldTokens, newTokens)
+}
+
+// This function will extract all XML tokens from a string, but ignoring all white-space tokens
+func expandXmlTokensFromString(input string) ([]xml.Token, error) {
+	decoder := xml.NewDecoder(strings.NewReader(input))
+	tokens := make([]xml.Token, 0)
+	for {
+		token, err := decoder.Token()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return nil, err
+		}
+		if chars, ok := token.(xml.CharData); ok {
+			text := string(chars)
+			if strings.TrimSpace(text) == "" {
+				continue
+			}
+		}
+		tokens = append(tokens, xml.CopyToken(token))
+	}
+	return tokens, nil
+}

azurerm/helpers/suppress/xml_test.go

@@ -0,0 +1,81 @@
+package suppress
+
+import "testing"
+
+func TestSuppressXmlDiff(t *testing.T) {
+	cases := []struct {
+		Name     string
+		XmlA     string
+		XmlB     string
+		Suppress bool
+	}{
+		{
+			Name:     "empty",
+			XmlA:     "",
+			XmlB:     "",
+			Suppress: true,
+		},
+		{
+			Name:     "neither are xml",
+			XmlA:     "this is not an xml",
+			XmlB:     "neither is this",
+			Suppress: false,
+		},
+		{
+			Name:     "identical texts",
+			XmlA:     "this is not an xml",
+			XmlB:     "this is not an xml",
+			Suppress: true,
+		},
+		{
+			Name:     "xml vs text",
+			XmlA:     "<r></r>",
+			XmlB:     "this is not an xml",
+			Suppress: false,
+		},
+		{
+			Name:     "text vs xml",
+			XmlA:     "this is not an xml",
+			XmlB:     "<r></r>",
+			Suppress: false,
+		},
+		{
+			Name:     "identical xml",
+			XmlA:     "<r><c></c></r>",
+			XmlB:     "<r><c></c></r>",
+			Suppress: true,
+		},
+		{
+			Name:     "xml with different line endings",
+			XmlA:     "<r>\n<c>\n</c>\n</r>",
+			XmlB:     "<r>\r\n<c>\r\n</c>\r\n</r>",
+			Suppress: true,
+		},
+		{
+			Name:     "xml with different indentations",
+			XmlA:     "<r>\n  <c>\n  </c>\n</r>",
+			XmlB:     "<r>\r\n\t<c>\r\n\t</c>\r\n</r>",
+			Suppress: true,
+		},
+		{
+			Name:     "xml with different quotation marks",
+			XmlA:     "<r><c attr=\"test\"></c></r>",
+			XmlB:     "<r>\r\n\t<c attr='test'>\r\n\t</c>\r\n</r>",
+			Suppress: true,
+		},
+		{
+			Name:     "xml with different spaces",
+			XmlA:     "<r><c   attr = 'test'></c></r>",
+			XmlB:     "<r>\r\n\t<c attr='test'>\r\n\t</c>\r\n</r>",
+			Suppress: true,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.Name, func(t *testing.T) {
+			if SuppressXmlDiff("test", tc.XmlA, tc.XmlB, nil) != tc.Suppress {
+				t.Fatalf("Expected SuppressXmlDiff to return %t for '%q' == '%q'", tc.Suppress, tc.XmlA, tc.XmlB)
+			}
+		})
+	}
+}

azurerm/provider.go

@@ -173,6 +173,7 @@ func Provider() terraform.ResourceProvider {
 			"azurerm_api_management_group":                   resourceArmApiManagementGroup(),
 			"azurerm_api_management_group_user":              resourceArmApiManagementGroupUser(),
 			"azurerm_api_management_logger":                  resourceArmApiManagementLogger(),
+			"azurerm_api_management_policy":                  resourceArmApiManagementPolicy(),
 			"azurerm_api_management_product":                 resourceArmApiManagementProduct(),
 			"azurerm_api_management_product_api":             resourceArmApiManagementProductApi(),
 			"azurerm_api_management_product_group":           resourceArmApiManagementProductGroup(),

azurerm/resource_arm_api_management_policy.go

@@ -0,0 +1,154 @@
+package azurerm
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/Azure/azure-sdk-for-go/services/apimanagement/mgmt/2018-01-01/apimanagement"
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/suppress"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func resourceArmApiManagementPolicy() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceArmApiManagementPolicyCreateUpdate,
+		Read:   resourceArmApiManagementPolicyRead,
+		Update: resourceArmApiManagementPolicyCreateUpdate,
+		Delete: resourceArmApiManagementPolicyDelete,
+
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
+
+		Schema: map[string]*schema.Schema{
+			"resource_group_name": resourceGroupNameSchema(),
+
+			"api_management_name": azure.SchemaApiManagementName(),
+
+			"xml_content": {
+				Type:             schema.TypeString,
+				Optional:         true,
+				DiffSuppressFunc: suppress.SuppressXmlDiff,
+				ConflictsWith:    []string{"xml_link"},
+			},
+
+			"xml_link": {
+				Type:          schema.TypeString,
+				Optional:      true,
+				ConflictsWith: []string{"xml_content"},
+			},
+		},
+	}
+}
+
+func resourceArmApiManagementPolicyCreateUpdate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*ArmClient).apiManagementPolicyClient
+	ctx := meta.(*ArmClient).StopContext
+
+	resourceGroup := d.Get("resource_group_name").(string)
+	serviceName := d.Get("api_management_name").(string)
+
+	if requireResourcesToBeImported {
+		resp, err := client.Get(ctx, resourceGroup, serviceName)
+		if err != nil {
+			if !utils.ResponseWasNotFound(resp.Response) {
+				return fmt.Errorf("Error checking for present of existing Global Policy (API Management Service %q / Resource Group %q): %+v", serviceName, resourceGroup, err)
+			}
+		}
+		if !utils.ResponseWasNotFound(resp.Response) {
+			return tf.ImportAsExistsError("azurerm_api_management_policy", *resp.ID)
+		}
+	}
+
+	xmlContent := d.Get("xml_content").(string)
+	xmlLink := d.Get("xml_link").(string)
+	if xmlContent == "" && xmlLink == "" {
+		return fmt.Errorf("Either `xml_content` or `xml_link` is required")
+	}
+
+	content := xmlContent
+	format := apimanagement.XML
+	if xmlLink != "" {
+		content = xmlLink
+		format = apimanagement.XMLLink
+	}
+
+	parameters := apimanagement.PolicyContract{
+		PolicyContractProperties: &apimanagement.PolicyContractProperties{
+			ContentFormat: format,
+			PolicyContent: utils.String(content),
+		},
+	}
+
+	if _, err := client.CreateOrUpdate(ctx, resourceGroup, serviceName, parameters); err != nil {
+		return fmt.Errorf("Error creating Global Policy (API Management Service %q / Resource Group %q): %+v", serviceName, resourceGroup, err)
+	}
+
+	resp, err := client.Get(ctx, resourceGroup, serviceName)
+	if err != nil {
+		return fmt.Errorf("Error retrieving Global Policy (API Management Service %q / Resource Group %q): %+v", serviceName, resourceGroup, err)
+	}
+	if resp.ID == nil {
+		return fmt.Errorf("Cannot read Global Policy (API Management Service %q / Resource Group %q) ID", serviceName, resourceGroup)
+	}
+	d.SetId(*resp.ID)
+
+	return resourceArmApiManagementPolicyRead(d, meta)
+}
+
+func resourceArmApiManagementPolicyRead(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*ArmClient).apiManagementPolicyClient
+	ctx := meta.(*ArmClient).StopContext
+
+	id, err := parseAzureResourceID(d.Id())
+	if err != nil {
+		return err
+	}
+	resourceGroup := id.ResourceGroup
+	serviceName := id.Path["service"]
+
+	resp, err := client.Get(ctx, resourceGroup, serviceName)
+	if err != nil {
+		if utils.ResponseWasNotFound(resp.Response) {
+			log.Printf("[INFO] Api Management Policy %q does not exist - removing from state", d.Id())
+			d.SetId("")
+			return nil
+		}
+		return fmt.Errorf("Error reading Global Policy (API Management Service %q / Resource Group %q): %+v", serviceName, resourceGroup, err)
+	}
+
+	d.Set("resource_group_name", resourceGroup)
+	d.Set("api_management_name", serviceName)
+	if properties := resp.PolicyContractProperties; properties != nil {
+		d.Set("xml_content", "")
+		d.Set("xml_link", "")
+		if properties.ContentFormat == apimanagement.XML {
+			d.Set("xml_content", properties.PolicyContent)
+		} else if properties.ContentFormat == apimanagement.XMLLink {
+			d.Set("xml_link", properties.PolicyContent)
+		}
+	}
+
+	return nil
+}
+
+func resourceArmApiManagementPolicyDelete(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*ArmClient).apiManagementPolicyClient
+	ctx := meta.(*ArmClient).StopContext
+
+	id, err := parseAzureResourceID(d.Id())
+	if err != nil {
+		return err
+	}
+	resourceGroup := id.ResourceGroup
+	serviceName := id.Path["service"]
+
+	if _, err := client.Delete(ctx, resourceGroup, serviceName, ""); err != nil {
+		return fmt.Errorf("Error deleting Global Policy (API Management Service %q / Resource Group %q): %+v", serviceName, resourceGroup, err)
+	}
+
+	return nil
+}