provider/fastly: Add support for Cache Settings (hashicorp#6781)

* provider/fastly: Add cache settings

Docs, tests, and implementation for Cache Settings support

Author: catsby

builtin/providers/fastly/resource_fastly_service_v1.go

@@ -21,6 +21,9 @@ func resourceServiceV1() *schema.Resource {
 		Read:   resourceServiceV1Read,
 		Update: resourceServiceV1Update,
 		Delete: resourceServiceV1Delete,
+		Importer: &schema.ResourceImporter{
+			State: schema.ImportStatePassthrough,
+		},
 
 		Schema: map[string]*schema.Schema{
 			"name": &schema.Schema{
@@ -193,6 +196,43 @@ func resourceServiceV1() *schema.Resource {
 				Optional: true,
 			},
 
+			"cache_setting": &schema.Schema{
+				Type:     schema.TypeSet,
+				Optional: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						// required fields
+						"name": &schema.Schema{
+							Type:        schema.TypeString,
+							Required:    true,
+							Description: "A name to refer to this Cache Setting",
+						},
+						"cache_condition": &schema.Schema{
+							Type:        schema.TypeString,
+							Required:    true,
+							Description: "Condition to check if this Cache Setting applies",
+						},
+						"action": &schema.Schema{
+							Type:        schema.TypeString,
+							Optional:    true,
+							Description: "Action to take",
+						},
+						// optional
+						"stale_ttl": &schema.Schema{
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Description: "Max 'Time To Live' for stale (unreachable) objects.",
+							Default:     300,
+						},
+						"ttl": &schema.Schema{
+							Type:        schema.TypeInt,
+							Optional:    true,
+							Description: "The 'Time To Live' for the object",
+						},
+					},
+				},
+			},
+
 			"gzip": &schema.Schema{
 				Type:     schema.TypeSet,
 				Optional: true,
@@ -560,6 +600,7 @@ func resourceServiceV1Update(d *schema.ResourceData, meta interface{}) error {
 		"s3logging",
 		"condition",
 		"request_setting",
+		"cache_setting",
 		"vcl",
 	} {
 		if d.HasChange(v) {
@@ -1020,6 +1061,7 @@ func resourceServiceV1Update(d *schema.ResourceData, meta interface{}) error {
 				}
 			}
 		}
+
 		// Find differences in VCLs
 		if d.HasChange("vcl") {
 			// Note: as above with Gzip and S3 logging, we don't utilize the PUT
@@ -1086,6 +1128,56 @@ func resourceServiceV1Update(d *schema.ResourceData, meta interface{}) error {
 			}
 		}
 
+		// Find differences in Cache Settings
+		if d.HasChange("cache_setting") {
+			oc, nc := d.GetChange("cache_setting")
+			if oc == nil {
+				oc = new(schema.Set)
+			}
+			if nc == nil {
+				nc = new(schema.Set)
+			}
+
+			ocs := oc.(*schema.Set)
+			ncs := nc.(*schema.Set)
+
+			remove := ocs.Difference(ncs).List()
+			add := ncs.Difference(ocs).List()
+
+			// Delete removed Cache Settings
+			for _, dRaw := range remove {
+				df := dRaw.(map[string]interface{})
+				opts := gofastly.DeleteCacheSettingInput{
+					Service: d.Id(),
+					Version: latestVersion,
+					Name:    df["name"].(string),
+				}
+
+				log.Printf("[DEBUG] Fastly Cache Settings removal opts: %#v", opts)
+				err := conn.DeleteCacheSetting(&opts)
+				if err != nil {
+					return err
+				}
+			}
+
+			// POST new Cache Settings
+			for _, dRaw := range add {
+				opts, err := buildCacheSetting(dRaw.(map[string]interface{}))
+				if err != nil {
+					log.Printf("[DEBUG] Error building Cache Setting: %s", err)
+					return err
+				}
+				opts.Service = d.Id()
+				opts.Version = latestVersion
+
+				log.Printf("[DEBUG] Fastly Cache Settings Addition opts: %#v", opts)
+				_, err = conn.CreateCacheSetting(opts)
+				if err != nil {
+					return err
+				}
+			}
+		}
+
 		// validate version
 		log.Printf("[DEBUG] Validating Fastly Service (%s), Version (%s)", d.Id(), latestVersion)
 		valid, msg, err := conn.ValidateVersion(&gofastly.ValidateVersionInput{
@@ -1282,6 +1374,7 @@ func resourceServiceV1Read(d *schema.ResourceData, meta interface{}) error {
 		if err := d.Set("request_setting", rl); err != nil {
 			log.Printf("[WARN] Error setting Request Settings for (%s): %s", d.Id(), err)
 		}
+
 		// refresh VCLs
 		log.Printf("[DEBUG] Refreshing VCLs for (%s)", d.Id())
 		vclList, err := conn.ListVCLs(&gofastly.ListVCLsInput{
@@ -1298,6 +1391,22 @@ func resourceServiceV1Read(d *schema.ResourceData, meta interface{}) error {
 			log.Printf("[WARN] Error setting VCLs for (%s): %s", d.Id(), err)
 		}
 
+		// refresh Cache Settings
+		log.Printf("[DEBUG] Refreshing Cache Settings for (%s)", d.Id())
+		cslList, err := conn.ListCacheSettings(&gofastly.ListCacheSettingsInput{
+			Service: d.Id(),
+			Version: s.ActiveVersion.Number,
+		})
+		if err != nil {
+			return fmt.Errorf("[ERR] Error looking up Cache Settings for (%s), version (%s): %s", d.Id(), s.ActiveVersion.Number, err)
+		}
+
+		csl := flattenCacheSettings(cslList)
+
+		if err := d.Set("cache_setting", csl); err != nil {
+			log.Printf("[WARN] Error setting Cache Settings for (%s): %s", d.Id(), err)
+		}
+
 	} else {
 		log.Printf("[DEBUG] Active Version for Service (%s) is empty, no state to refresh", d.Id())
 	}
@@ -1497,6 +1606,31 @@ func buildHeader(headerMap interface{}) (*gofastly.CreateHeaderInput, error) {
 	return &opts, nil
 }
 
+func buildCacheSetting(cacheMap interface{}) (*gofastly.CreateCacheSettingInput, error) {
+	df := cacheMap.(map[string]interface{})
+	opts := gofastly.CreateCacheSettingInput{
+		Name:           df["name"].(string),
+		StaleTTL:       uint(df["stale_ttl"].(int)),
+		CacheCondition: df["cache_condition"].(string),
+	}
+
+	if v, ok := df["ttl"]; ok {
+		opts.TTL = uint(v.(int))
+	}
+
+	act := strings.ToLower(df["action"].(string))
+	switch act {
+	case "cache":
+		opts.Action = gofastly.CacheSettingActionCache
+	case "pass":
+		opts.Action = gofastly.CacheSettingActionPass
+	case "restart":
+		opts.Action = gofastly.CacheSettingActionRestart
+	}
+
+	return &opts, nil
+}
+
 func flattenGzips(gzipsList []*gofastly.Gzip) []map[string]interface{} {
 	var gl []map[string]interface{}
 	for _, g := range gzipsList {
@@ -1662,6 +1796,32 @@ func buildRequestSetting(requestSettingMap interface{}) (*gofastly.CreateRequest
 
 	return &opts, nil
 }
+
+func flattenCacheSettings(csList []*gofastly.CacheSetting) []map[string]interface{} {
+	var csl []map[string]interface{}
+	for _, cl := range csList {
+		// Convert Cache Settings to a map for saving to state.
+		clMap := map[string]interface{}{
+			"name":            cl.Name,
+			"action":          cl.Action,
+			"cache_condition": cl.CacheCondition,
+			"stale_ttl":       cl.StaleTTL,
+			"ttl":             cl.TTL,
+		}
+
+		// prune any empty values that come from the default string value in structs
+		for k, v := range clMap {
+			if v == "" {
+				delete(clMap, k)
+			}
+		}
+
+		csl = append(csl, clMap)
+	}
+
+	return csl
+}
+
 func flattenVCLs(vclList []*gofastly.VCL) []map[string]interface{} {
 	var vl []map[string]interface{}
 	for _, vcl := range vclList {