resource aws_cloudfront_function

.changelog/19315.txt

@@ -0,0 +1,11 @@
+```release-note:enhancement
+resource/aws_cloudfront_distribution: Add `function_association` argument
+```
+
+```release-note:new-resource
+aws_cloudfront_function
+```
+
+```release-note:new-data-source
+aws_cloudfront_function
+```

aws/cloudfront_distribution_configuration_structure.go

@@ -223,6 +223,10 @@ func expandCloudFrontDefaultCacheBehavior(m map[string]interface{}) *cloudfront.
 		dcb.LambdaFunctionAssociations = expandLambdaFunctionAssociations(v.(*schema.Set).List())
 	}
 
+	if v, ok := m["function_association"]; ok {
+		dcb.FunctionAssociations = expandFunctionAssociations(v.(*schema.Set).List())
+	}
+
 	if v, ok := m["smooth_streaming"]; ok {
 		dcb.SmoothStreaming = aws.Bool(v.(bool))
 	}
@@ -277,6 +281,10 @@ func expandCacheBehavior(m map[string]interface{}) *cloudfront.CacheBehavior {
 		cb.LambdaFunctionAssociations = expandLambdaFunctionAssociations(v.(*schema.Set).List())
 	}
 
+	if v, ok := m["function_association"]; ok {
+		cb.FunctionAssociations = expandFunctionAssociations(v.(*schema.Set).List())
+	}
+
 	if v, ok := m["smooth_streaming"]; ok {
 		cb.SmoothStreaming = aws.Bool(v.(bool))
 	}
@@ -320,6 +328,9 @@ func flattenCloudFrontDefaultCacheBehavior(dcb *cloudfront.DefaultCacheBehavior)
 	if len(dcb.LambdaFunctionAssociations.Items) > 0 {
 		m["lambda_function_association"] = flattenLambdaFunctionAssociations(dcb.LambdaFunctionAssociations)
 	}
+	if len(dcb.FunctionAssociations.Items) > 0 {
+		m["function_association"] = flattenFunctionAssociations(dcb.FunctionAssociations)
+	}
 	if dcb.MaxTTL != nil {
 		m["max_ttl"] = aws.Int64Value(dcb.MaxTTL)
 	}
@@ -363,6 +374,9 @@ func flattenCacheBehavior(cb *cloudfront.CacheBehavior) map[string]interface{} {
 	if len(cb.LambdaFunctionAssociations.Items) > 0 {
 		m["lambda_function_association"] = flattenLambdaFunctionAssociations(cb.LambdaFunctionAssociations)
 	}
+	if len(cb.FunctionAssociations.Items) > 0 {
+		m["function_association"] = flattenFunctionAssociations(cb.FunctionAssociations)
+	}
 	if cb.MaxTTL != nil {
 		m["max_ttl"] = int(*cb.MaxTTL)
 	}
@@ -433,6 +447,14 @@ func lambdaFunctionAssociationHash(v interface{}) int {
 	return hashcode.String(buf.String())
 }
 
+func functionAssociationHash(v interface{}) int {
+	var buf bytes.Buffer
+	m := v.(map[string]interface{})
+	buf.WriteString(fmt.Sprintf("%s-", m["event_type"].(string)))
+	buf.WriteString(m["function_arn"].(string))
+	return hashcode.String(buf.String())
+}
+
 func expandLambdaFunctionAssociations(v interface{}) *cloudfront.LambdaFunctionAssociations {
 	if v == nil {
 		return &cloudfront.LambdaFunctionAssociations{
@@ -464,6 +486,34 @@ func expandLambdaFunctionAssociation(lf map[string]interface{}) *cloudfront.Lamb
 	return &lfa
 }
 
+func expandFunctionAssociations(v interface{}) *cloudfront.FunctionAssociations {
+	if v == nil {
+		return &cloudfront.FunctionAssociations{
+			Quantity: aws.Int64(0),
+		}
+	}
+
+	s := v.([]interface{})
+	var fa cloudfront.FunctionAssociations
+	fa.Quantity = aws.Int64(int64(len(s)))
+	fa.Items = make([]*cloudfront.FunctionAssociation, len(s))
+	for i, f := range s {
+		fa.Items[i] = expandFunctionAssociation(f.(map[string]interface{}))
+	}
+	return &fa
+}
+
+func expandFunctionAssociation(f map[string]interface{}) *cloudfront.FunctionAssociation {
+	var fa cloudfront.FunctionAssociation
+	if v, ok := f["event_type"]; ok {
+		fa.EventType = aws.String(v.(string))
+	}
+	if v, ok := f["function_arn"]; ok {
+		fa.FunctionARN = aws.String(v.(string))
+	}
+	return &fa
+}
+
 func flattenLambdaFunctionAssociations(lfa *cloudfront.LambdaFunctionAssociations) *schema.Set {
 	s := schema.NewSet(lambdaFunctionAssociationHash, []interface{}{})
 	for _, v := range lfa.Items {
@@ -482,6 +532,23 @@ func flattenLambdaFunctionAssociation(lfa *cloudfront.LambdaFunctionAssociation)
 	return m
 }
 
+func flattenFunctionAssociations(fa *cloudfront.FunctionAssociations) *schema.Set {
+	s := schema.NewSet(functionAssociationHash, []interface{}{})
+	for _, v := range fa.Items {
+		s.Add(flattenFunctionAssociation(v))
+	}
+	return s
+}
+
+func flattenFunctionAssociation(fa *cloudfront.FunctionAssociation) map[string]interface{} {
+	m := map[string]interface{}{}
+	if fa != nil {
+		m["event_type"] = aws.StringValue(fa.EventType)
+		m["function_arn"] = aws.StringValue(fa.FunctionARN)
+	}
+	return m
+}
+
 func expandForwardedValues(m map[string]interface{}) *cloudfront.ForwardedValues {
 	if len(m) < 1 {
 		return nil

aws/cloudfront_distribution_configuration_structure_test.go

@@ -18,6 +18,7 @@ func defaultCacheBehaviorConf() map[string]interface{} {
 		"min_ttl":                     0,
 		"trusted_signers":             trustedSignersConf(),
 		"lambda_function_association": lambdaFunctionAssociationsConf(),
+		"function_association":        functionAssociationsConf(),
 		"max_ttl":                     31536000,
 		"smooth_streaming":            false,
 		"default_ttl":                 86400,
@@ -51,6 +52,21 @@ func lambdaFunctionAssociationsConf() *schema.Set {
 	return schema.NewSet(lambdaFunctionAssociationHash, x)
 }
 
+func functionAssociationsConf() *schema.Set {
+	x := []interface{}{
+		map[string]interface{}{
+			"event_type":   "viewer-request",
+			"function_arn": "arn:aws:cloudfront::999999999:function/function1", //lintignore:AWSAT003,AWSAT005
+		},
+		map[string]interface{}{
+			"event_type":   "viewer-response",
+			"function_arn": "arn:aws:cloudfront::999999999:function/function2", //lintignore:AWSAT003,AWSAT005
+		},
+	}
+
+	return schema.NewSet(functionAssociationHash, x)
+}
+
 func forwardedValuesConf() map[string]interface{} {
 	return map[string]interface{}{
 		"query_string":            true,
@@ -304,6 +320,9 @@ func TestCloudFrontStructure_expandCloudFrontDefaultCacheBehavior(t *testing.T)
 	if *dcb.LambdaFunctionAssociations.Quantity != 2 {
 		t.Fatalf("Expected LambdaFunctionAssociations to be 2, got %v", *dcb.LambdaFunctionAssociations.Quantity)
 	}
+	if *dcb.FunctionAssociations.Quantity != 2 {
+		t.Fatalf("Expected FunctionAssociations to be 2, got %v", *dcb.FunctionAssociations.Quantity)
+	}
 	if !reflect.DeepEqual(dcb.AllowedMethods.Items, expandStringSet(allowedMethodsConf())) {
 		t.Fatalf("Expected AllowedMethods.Items to be %v, got %v", allowedMethodsConf().List(), dcb.AllowedMethods.Items)
 	}
@@ -391,6 +410,47 @@ func TestCloudFrontStructure_expandlambdaFunctionAssociations_empty(t *testing.T
 	}
 }
 
+func TestCloudFrontStructure_expandFunctionAssociations(t *testing.T) {
+	data := functionAssociationsConf()
+	lfa := expandFunctionAssociations(data.List())
+	if *lfa.Quantity != 2 {
+		t.Fatalf("Expected Quantity to be 2, got %v", *lfa.Quantity)
+	}
+	if len(lfa.Items) != 2 {
+		t.Fatalf("Expected Items to be len 2, got %v", len(lfa.Items))
+	}
+	if et := "viewer-response"; *lfa.Items[0].EventType != et {
+		t.Fatalf("Expected first Item's EventType to be %q, got %q", et, *lfa.Items[0].EventType)
+	}
+	if et := "viewer-request"; *lfa.Items[1].EventType != et {
+		t.Fatalf("Expected second Item's EventType to be %q, got %q", et, *lfa.Items[1].EventType)
+	}
+}
+
+func TestCloudFrontStructure_flattenFunctionAssociations(t *testing.T) {
+	in := functionAssociationsConf()
+	lfa := expandFunctionAssociations(in.List())
+	out := flattenFunctionAssociations(lfa)
+
+	if !reflect.DeepEqual(in.List(), out.List()) {
+		t.Fatalf("Expected out to be %v, got %v", in, out)
+	}
+}
+
+func TestCloudFrontStructure_expandFunctionAssociations_empty(t *testing.T) {
+	data := new(schema.Set)
+	lfa := expandFunctionAssociations(data.List())
+	if *lfa.Quantity != 0 {
+		t.Fatalf("Expected Quantity to be 0, got %v", *lfa.Quantity)
+	}
+	if len(lfa.Items) != 0 {
+		t.Fatalf("Expected Items to be len 0, got %v", len(lfa.Items))
+	}
+	if !reflect.DeepEqual(lfa.Items, []*cloudfront.FunctionAssociation{}) {
+		t.Fatalf("Expected Items to be empty, got %v", lfa.Items)
+	}
+}
+
 func TestCloudFrontStructure_expandForwardedValues(t *testing.T) {
 	data := forwardedValuesConf()
 	fv := expandForwardedValues(data)

aws/data_source_aws_cloudfront_function.go

@@ -0,0 +1,92 @@
+package aws
+
+import (
+	"log"
+	"time"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/aws/aws-sdk-go/service/cloudfront"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceAwsCloudFrontFunction() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceAwsCloudFrontFunctionRead,
+
+		Schema: map[string]*schema.Schema{
+			"code": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"comment": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"runtime": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"status": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"arn": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"etag": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"stage": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"last_modified": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func dataSourceAwsCloudFrontFunctionRead(d *schema.ResourceData, meta interface{}) error {
+	conn := meta.(*AWSClient).cloudfrontconn
+
+	params := &cloudfront.GetFunctionInput{
+		Name: aws.String(d.Get("name").(string)),
+	}
+
+	getFunctionOutput, err := conn.GetFunction(params)
+	if err != nil {
+		return fmt.Errorf("error getting CloudFront Function (%s): %w", d.Get("name").(string), err)
+	}
+
+	d.Set("code", string(getFunctionOutput.FunctionCode))
+
+	describeParams := &cloudfront.DescribeFunctionInput{
+		Name: aws.String(d.Get("name").(string)),
+	}
+
+	describeFunctionOutput, err := conn.DescribeFunction(describeParams)
+	if err != nil {
+		return err
+	}
+
+	d.Set("etag", describeFunctionOutput.ETag)
+	d.Set("arn", describeFunctionOutput.FunctionSummary.FunctionMetadata.FunctionARN)
+	d.Set("last_modified", describeFunctionOutput.FunctionSummary.FunctionMetadata.LastModifiedTime.Format(time.RFC3339))
+	d.Set("stage", describeFunctionOutput.FunctionSummary.FunctionMetadata.Stage)
+	d.Set("comment", describeFunctionOutput.FunctionSummary.FunctionConfig.Comment)
+	d.Set("runtime", describeFunctionOutput.FunctionSummary.FunctionConfig.Runtime)
+	d.Set("status", describeFunctionOutput.FunctionSummary.Status)
+
+	d.SetId(d.Get("name").(string))
+
+	return nil
+}

aws/data_source_aws_cloudfront_function_test.go

@@ -0,0 +1,65 @@
+package aws
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aws/aws-sdk-go/service/cloudfront"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func TestAccDataSourceAWSCloudfrontFunction_basic(t *testing.T) {
+	rName := acctest.RandomWithPrefix("tf-acc-test")
+	dataSourceName := "data.aws_cloudfront_function.test"
+	resourceName := "aws_cloudfront_function.test"
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:   func() { testAccPreCheck(t) },
+		ErrorCheck: testAccErrorCheck(t, cloudfront.EndpointsID),
+		Providers:  testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceAWSCloudfrontFunctionConfigBasic(rName),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					resource.TestCheckResourceAttrPair(dataSourceName, "arn", resourceName, "arn"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "code", resourceName, "code"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "comment", resourceName, "comment"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "last_modified", resourceName, "last_modified"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "name", resourceName, "name"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "runtime", resourceName, "runtime"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "stage", resourceName, "stage"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "status", resourceName, "status"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "etag", resourceName, "etag"),
+				),
+			},
+		},
+	})
+}
+
+func testAccDataSourceAWSCloudfrontFunctionConfigBasic(rName string) string {
+	return fmt.Sprintf(`
+resource "aws_cloudfront_function" "test" {
+  name    = "%s"
+  runtime = "cloudfront-js-1.0"
+  comment = "%s"
+  code    = <<-EOT
+function handler(event) {
+	var response = {
+		statusCode: 302,
+		statusDescription: 'Found',
+		headers: {
+			'cloudfront-functions': { value: 'generated-by-CloudFront-Functions' },
+			'location': { value: 'https://aws.amazon.com/cloudfront/' }
+		}
+	};
+	return response;
+}
+EOT
+}
+
+data "aws_cloudfront_function" "test" {
+  name = aws_cloudfront_function.test.name
+}
+`, rName, rName)
+}

aws/provider.go

@@ -214,6 +214,7 @@ func Provider() *schema.Provider {
 			"aws_cloudformation_type":                        dataSourceAwsCloudFormationType(),
 			"aws_cloudfront_cache_policy":                    dataSourceAwsCloudFrontCachePolicy(),
 			"aws_cloudfront_distribution":                    dataSourceAwsCloudFrontDistribution(),
+			"aws_cloudfront_function":                        dataSourceAwsCloudFrontFunction(),
 			"aws_cloudfront_origin_request_policy":           dataSourceAwsCloudFrontOriginRequestPolicy(),
 			"aws_cloudhsm_v2_cluster":                        dataSourceCloudHsmV2Cluster(),
 			"aws_cloudtrail_service_account":                 dataSourceAwsCloudTrailServiceAccount(),
@@ -521,6 +522,7 @@ func Provider() *schema.Provider {
 			"aws_cloudformation_type":                                 resourceAwsCloudFormationType(),
 			"aws_cloudfront_cache_policy":                             resourceAwsCloudFrontCachePolicy(),
 			"aws_cloudfront_distribution":                             resourceAwsCloudFrontDistribution(),
+			"aws_cloudfront_function":                                 resourceAwsCloudFrontFunction(),
 			"aws_cloudfront_key_group":                                resourceAwsCloudFrontKeyGroup(),
 			"aws_cloudfront_origin_access_identity":                   resourceAwsCloudFrontOriginAccessIdentity(),
 			"aws_cloudfront_origin_request_policy":                    resourceAwsCloudFrontOriginRequestPolicy(),