From 77a67eb04fa12ed4d807ed35f231462e3c629a47 Mon Sep 17 00:00:00 2001 From: The Magician Date: Fri, 14 Dec 2018 09:37:15 -0800 Subject: [PATCH] Explicitly set TypeSets of nested objects (#2660) --- google/resource_compute_firewall.go | 86 +++++++++++++++------------ google/resource_compute_subnetwork.go | 1 + google/resource_compute_url_map.go | 48 ++++++++------- 3 files changed, 74 insertions(+), 61 deletions(-) diff --git a/google/resource_compute_firewall.go b/google/resource_compute_firewall.go index 7260ec26..cbb40fe0 100644 --- a/google/resource_compute_firewall.go +++ b/google/resource_compute_firewall.go @@ -36,7 +36,7 @@ func resourceComputeFirewallRuleHash(v interface{}) int { // We need to make sure to sort the strings below so that we always // generate the same hash code no matter what is in the set. - if v, ok := m["ports"]; ok { + if v, ok := m["ports"]; ok && v != nil { s := convertStringArr(v.([]interface{})) sort.Strings(s) @@ -81,44 +81,16 @@ func resourceComputeFirewall() *schema.Resource { DiffSuppressFunc: compareSelfLinkOrResourceName, }, "allow": { - Type: schema.TypeSet, - Optional: true, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "protocol": { - Type: schema.TypeString, - Required: true, - }, - "ports": { - Type: schema.TypeList, - Optional: true, - Elem: &schema.Schema{ - Type: schema.TypeString, - }, - }, - }, - }, + Type: schema.TypeSet, + Optional: true, + Elem: computeFirewallAllowSchema(), Set: resourceComputeFirewallRuleHash, ConflictsWith: []string{"deny"}, }, "deny": { - Type: schema.TypeSet, - Optional: true, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "protocol": { - Type: schema.TypeString, - Required: true, - }, - "ports": { - Type: schema.TypeList, - Optional: true, - Elem: &schema.Schema{ - Type: schema.TypeString, - }, - }, - }, - }, + Type: schema.TypeSet, + Optional: true, + Elem: computeFirewallDenySchema(), Set: resourceComputeFirewallRuleHash, ConflictsWith: []string{"allow"}, }, @@ -218,6 +190,42 @@ func resourceComputeFirewall() *schema.Resource { } } +func computeFirewallAllowSchema() *schema.Resource { + return &schema.Resource{ + Schema: map[string]*schema.Schema{ + "protocol": { + Type: schema.TypeString, + Required: true, + }, + "ports": { + Type: schema.TypeList, + Optional: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + }, + } +} + +func computeFirewallDenySchema() *schema.Resource { + return &schema.Resource{ + Schema: map[string]*schema.Schema{ + "protocol": { + Type: schema.TypeString, + Required: true, + }, + "ports": { + Type: schema.TypeList, + Optional: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + }, + }, + } +} + func resourceComputeFirewallCreate(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) @@ -595,14 +603,14 @@ func flattenComputeFirewallAllow(v interface{}, d *schema.ResourceData) interfac return v } l := v.([]interface{}) - transformed := make([]interface{}, 0, len(l)) + transformed := schema.NewSet(resourceComputeFirewallRuleHash, []interface{}{}) for _, raw := range l { original := raw.(map[string]interface{}) if len(original) < 1 { // Do not include empty json objects coming back from the api continue } - transformed = append(transformed, map[string]interface{}{ + transformed.Add(map[string]interface{}{ "protocol": flattenComputeFirewallAllowProtocol(original["IPProtocol"], d), "ports": flattenComputeFirewallAllowPorts(original["ports"], d), }) @@ -626,14 +634,14 @@ func flattenComputeFirewallDeny(v interface{}, d *schema.ResourceData) interface return v } l := v.([]interface{}) - transformed := make([]interface{}, 0, len(l)) + transformed := schema.NewSet(resourceComputeFirewallRuleHash, []interface{}{}) for _, raw := range l { original := raw.(map[string]interface{}) if len(original) < 1 { // Do not include empty json objects coming back from the api continue } - transformed = append(transformed, map[string]interface{}{ + transformed.Add(map[string]interface{}{ "protocol": flattenComputeFirewallDenyProtocol(original["IPProtocol"], d), "ports": flattenComputeFirewallDenyPorts(original["ports"], d), }) diff --git a/google/resource_compute_subnetwork.go b/google/resource_compute_subnetwork.go index cb639658..4628dad0 100644 --- a/google/resource_compute_subnetwork.go +++ b/google/resource_compute_subnetwork.go @@ -159,6 +159,7 @@ func resourceComputeSubnetwork() *schema.Resource { }, } } + func resourceComputeSubnetworkSecondaryIpRangeSetStyleDiff(diff *schema.ResourceDiff, meta interface{}) error { keys := diff.GetChangedKeysPrefix("secondary_ip_range") if len(keys) == 0 { diff --git a/google/resource_compute_url_map.go b/google/resource_compute_url_map.go index 1e1d4715..8f82e8ed 100644 --- a/google/resource_compute_url_map.go +++ b/google/resource_compute_url_map.go @@ -60,26 +60,7 @@ func resourceComputeUrlMap() *schema.Resource { "host_rule": { Type: schema.TypeSet, Optional: true, - Elem: &schema.Resource{ - Schema: map[string]*schema.Schema{ - "hosts": { - Type: schema.TypeSet, - Required: true, - Elem: &schema.Schema{ - Type: schema.TypeString, - }, - Set: schema.HashString, - }, - "path_matcher": { - Type: schema.TypeString, - Required: true, - }, - "description": { - Type: schema.TypeString, - Optional: true, - }, - }, - }, + Elem: computeUrlMapHostRuleSchema(), // Default schema.HashSchema is used. }, "path_matcher": { @@ -175,6 +156,29 @@ func resourceComputeUrlMap() *schema.Resource { } } +func computeUrlMapHostRuleSchema() *schema.Resource { + return &schema.Resource{ + Schema: map[string]*schema.Schema{ + "hosts": { + Type: schema.TypeSet, + Required: true, + Elem: &schema.Schema{ + Type: schema.TypeString, + }, + Set: schema.HashString, + }, + "path_matcher": { + Type: schema.TypeString, + Required: true, + }, + "description": { + Type: schema.TypeString, + Optional: true, + }, + }, + } +} + func resourceComputeUrlMapCreate(d *schema.ResourceData, meta interface{}) error { config := meta.(*Config) @@ -471,14 +475,14 @@ func flattenComputeUrlMapHost_rule(v interface{}, d *schema.ResourceData) interf return v } l := v.([]interface{}) - transformed := make([]interface{}, 0, len(l)) + transformed := schema.NewSet(schema.HashResource(computeUrlMapHostRuleSchema()), []interface{}{}) for _, raw := range l { original := raw.(map[string]interface{}) if len(original) < 1 { // Do not include empty json objects coming back from the api continue } - transformed = append(transformed, map[string]interface{}{ + transformed.Add(map[string]interface{}{ "description": flattenComputeUrlMapHost_ruleDescription(original["description"], d), "hosts": flattenComputeUrlMapHost_ruleHosts(original["hosts"], d), "path_matcher": flattenComputeUrlMapHost_rulePathMatcher(original["pathMatcher"], d),