Add keepalive to compute router (#5760) (#4089)

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/5760.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+compute: added support for `keepalive_interval` to `google_compute_router.bgp`
+```

google-beta/resource_compute_router.go

@@ -142,6 +142,16 @@ CIDR-formatted string.`,
 								},
 							},
 						},
+						"keepalive_interval": {
+							Type:     schema.TypeInt,
+							Optional: true,
+							Description: `The interval in seconds between BGP keepalive messages that are sent to the peer.
+Hold time is three times the interval at which keepalive messages are sent, and the hold time is the
+maximum number of seconds allowed to elapse between successive keepalive messages that BGP receives from a peer.
+BGP will use the smaller of either the local hold time value or the peer's hold time value as the hold time for
+the BGP connection between the two peers. If set, this value must be between 20 and 60. The default is 20.`,
+							Default: 20,
+						},
 					},
 				},
 			},
@@ -523,6 +533,8 @@ func flattenComputeRouterBgp(v interface{}, d *schema.ResourceData, config *Conf
 		flattenComputeRouterBgpAdvertisedGroups(original["advertisedGroups"], d, config)
 	transformed["advertised_ip_ranges"] =
 		flattenComputeRouterBgpAdvertisedIpRanges(original["advertisedIpRanges"], d, config)
+	transformed["keepalive_interval"] =
+		flattenComputeRouterBgpKeepaliveInterval(original["keepaliveInterval"], d, config)
 	return []interface{}{transformed}
 }
 func flattenComputeRouterBgpAsn(v interface{}, d *schema.ResourceData, config *Config) interface{} {
@@ -577,6 +589,23 @@ func flattenComputeRouterBgpAdvertisedIpRangesDescription(v interface{}, d *sche
 	return v
 }
 
+func flattenComputeRouterBgpKeepaliveInterval(v interface{}, d *schema.ResourceData, config *Config) interface{} {
+	// Handles the string fixed64 format
+	if strVal, ok := v.(string); ok {
+		if intVal, err := stringToFixed64(strVal); err == nil {
+			return intVal
+		}
+	}
+
+	// number values are represented as float64
+	if floatVal, ok := v.(float64); ok {
+		intVal := int(floatVal)
+		return intVal
+	}
+
+	return v // let terraform core handle it otherwise
+}
+
 func flattenComputeRouterEncryptedInterconnectRouter(v interface{}, d *schema.ResourceData, config *Config) interface{} {
 	return v
 }
@@ -641,6 +670,13 @@ func expandComputeRouterBgp(v interface{}, d TerraformResourceData, config *Conf
 		transformed["advertisedIpRanges"] = transformedAdvertisedIpRanges
 	}
 
+	transformedKeepaliveInterval, err := expandComputeRouterBgpKeepaliveInterval(original["keepalive_interval"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedKeepaliveInterval); val.IsValid() && !isEmptyValue(val) {
+		transformed["keepaliveInterval"] = transformedKeepaliveInterval
+	}
+
 	return transformed, nil
 }
 
@@ -693,6 +729,10 @@ func expandComputeRouterBgpAdvertisedIpRangesDescription(v interface{}, d Terraf
 	return v, nil
 }
 
+func expandComputeRouterBgpKeepaliveInterval(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeRouterEncryptedInterconnectRouter(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
 	return v, nil
 }

google-beta/resource_compute_router_test.go

@@ -222,6 +222,7 @@ resource "google_compute_router" "foobar" {
     advertised_ip_ranges {
       range = "6.7.0.0/16"
     }
+    keepalive_interval = 25
   }
 }
 `, routerName, routerName)

website/docs/r/compute_router.html.markdown

@@ -163,6 +163,14 @@ The following arguments are supported:
   Leave this field blank to advertise no custom IP ranges.
   Structure is [documented below](#nested_advertised_ip_ranges).
 
+* `keepalive_interval` -
+  (Optional)
+  The interval in seconds between BGP keepalive messages that are sent to the peer.
+  Hold time is three times the interval at which keepalive messages are sent, and the hold time is the
+  maximum number of seconds allowed to elapse between successive keepalive messages that BGP receives from a peer.
+  BGP will use the smaller of either the local hold time value or the peer's hold time value as the hold time for
+  the BGP connection between the two peers. If set, this value must be between 20 and 60. The default is 20.
+
 
 <a name="nested_advertised_ip_ranges"></a>The `advertised_ip_ranges` block supports: