2019-04-02 21:32:09 +00:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// *** AUTO GENERATED CODE *** AUTO GENERATED CODE ***
|
|
|
|
//
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// This file is automatically generated by Magic Modules and manual
|
|
|
|
// changes will be clobbered when the file is regenerated.
|
|
|
|
//
|
|
|
|
// Please read more about how to change this file in
|
|
|
|
// .github/CONTRIBUTING.md.
|
|
|
|
//
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
2015-08-20 19:52:30 +00:00
|
|
|
package google
|
|
|
|
|
|
|
|
import (
|
2019-04-04 20:50:31 +00:00
|
|
|
"bytes"
|
2015-08-20 19:52:30 +00:00
|
|
|
"fmt"
|
|
|
|
"log"
|
2019-04-02 21:32:09 +00:00
|
|
|
"reflect"
|
|
|
|
"strconv"
|
|
|
|
"time"
|
2015-08-20 19:52:30 +00:00
|
|
|
|
2018-03-22 16:53:24 +00:00
|
|
|
"github.com/hashicorp/errwrap"
|
2019-04-04 20:50:31 +00:00
|
|
|
"github.com/hashicorp/terraform/helper/hashcode"
|
2015-08-20 19:52:30 +00:00
|
|
|
"github.com/hashicorp/terraform/helper/schema"
|
2019-04-02 21:32:09 +00:00
|
|
|
"github.com/hashicorp/terraform/helper/validation"
|
|
|
|
"google.golang.org/api/compute/v1"
|
2015-08-20 19:52:30 +00:00
|
|
|
)
|
|
|
|
|
2019-04-04 20:50:31 +00:00
|
|
|
func resourceGoogleComputeBackendServiceBackendHash(v interface{}) int {
|
|
|
|
if v == nil {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
var buf bytes.Buffer
|
|
|
|
m := v.(map[string]interface{})
|
|
|
|
log.Printf("[DEBUG] hashing %v", m)
|
|
|
|
|
|
|
|
if group, err := getRelativePath(m["group"].(string)); err != nil {
|
|
|
|
log.Printf("[WARN] Error on retrieving relative path of instance group: %s", err)
|
|
|
|
buf.WriteString(fmt.Sprintf("%s-", m["group"].(string)))
|
|
|
|
} else {
|
|
|
|
buf.WriteString(fmt.Sprintf("%s-", group))
|
|
|
|
}
|
|
|
|
|
|
|
|
if v, ok := m["balancing_mode"]; ok {
|
|
|
|
if v == nil {
|
|
|
|
v = ""
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.WriteString(fmt.Sprintf("%s-", v.(string)))
|
|
|
|
}
|
|
|
|
if v, ok := m["capacity_scaler"]; ok {
|
|
|
|
if v == nil {
|
|
|
|
v = 0.0
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.WriteString(fmt.Sprintf("%f-", v.(float64)))
|
|
|
|
}
|
|
|
|
if v, ok := m["description"]; ok {
|
|
|
|
if v == nil {
|
|
|
|
v = ""
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Printf("[DEBUG] writing description %s", v)
|
|
|
|
buf.WriteString(fmt.Sprintf("%s-", v.(string)))
|
|
|
|
}
|
|
|
|
if v, ok := m["max_rate"]; ok {
|
|
|
|
if v == nil {
|
|
|
|
v = 0
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.WriteString(fmt.Sprintf("%d-", int64(v.(int))))
|
|
|
|
}
|
|
|
|
if v, ok := m["max_rate_per_instance"]; ok {
|
|
|
|
if v == nil {
|
|
|
|
v = 0.0
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.WriteString(fmt.Sprintf("%f-", v.(float64)))
|
|
|
|
}
|
|
|
|
if v, ok := m["max_connections"]; ok {
|
|
|
|
if v == nil {
|
|
|
|
v = 0
|
|
|
|
}
|
|
|
|
|
|
|
|
switch v := v.(type) {
|
|
|
|
case float64:
|
|
|
|
// The Golang JSON library can't tell int values apart from floats,
|
|
|
|
// because MM doesn't give fields strong types. Since another value
|
|
|
|
// in this block was a real float, it assumed this was a float too.
|
|
|
|
// It's not.
|
|
|
|
// Note that math.Round in Go is from float64 -> float64, so it will
|
|
|
|
// be a noop. int(floatVal) truncates extra parts, so if the float64
|
|
|
|
// representation of an int falls below the real value we'll have
|
|
|
|
// the wrong value. eg if 3 was represented as 2.999999, that would
|
|
|
|
// convert to 2. So we add 0.5, ensuring that we'll truncate to the
|
|
|
|
// correct value. This wouldn't remain true if we were far enough
|
|
|
|
// from 0 that we were off by > 0.5, but no float conversion *could*
|
|
|
|
// work correctly in that case. 53-bit floating types as the only
|
|
|
|
// numeric type was not a good idea, thanks Javascript.
|
|
|
|
var vInt int
|
|
|
|
if v < 0 {
|
|
|
|
vInt = int(v - 0.5)
|
|
|
|
} else {
|
|
|
|
vInt = int(v + 0.5)
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Printf("[DEBUG] writing float value %f as integer value %v", v, vInt)
|
|
|
|
buf.WriteString(fmt.Sprintf("%d-", vInt))
|
|
|
|
default:
|
|
|
|
buf.WriteString(fmt.Sprintf("%d-", int64(v.(int))))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if v, ok := m["max_connections_per_instance"]; ok {
|
|
|
|
if v == nil {
|
|
|
|
v = 0
|
|
|
|
}
|
|
|
|
|
|
|
|
switch v := v.(type) {
|
|
|
|
case float64:
|
|
|
|
// The Golang JSON library can't tell int values apart from floats,
|
|
|
|
// because MM doesn't give fields strong types. Since another value
|
|
|
|
// in this block was a real float, it assumed this was a float too.
|
|
|
|
// It's not.
|
|
|
|
// Note that math.Round in Go is from float64 -> float64, so it will
|
|
|
|
// be a noop. int(floatVal) truncates extra parts, so if the float64
|
|
|
|
// representation of an int falls below the real value we'll have
|
|
|
|
// the wrong value. eg if 3 was represented as 2.999999, that would
|
|
|
|
// convert to 2. So we add 0.5, ensuring that we'll truncate to the
|
|
|
|
// correct value. This wouldn't remain true if we were far enough
|
|
|
|
// from 0 that we were off by > 0.5, but no float conversion *could*
|
|
|
|
// work correctly in that case. 53-bit floating types as the only
|
|
|
|
// numeric type was not a good idea, thanks Javascript.
|
|
|
|
var vInt int
|
|
|
|
if v < 0 {
|
|
|
|
vInt = int(v - 0.5)
|
|
|
|
} else {
|
|
|
|
vInt = int(v + 0.5)
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Printf("[DEBUG] writing float value %f as integer value %v", v, vInt)
|
|
|
|
buf.WriteString(fmt.Sprintf("%d-", vInt))
|
|
|
|
default:
|
|
|
|
buf.WriteString(fmt.Sprintf("%d-", int64(v.(int))))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if v, ok := m["max_rate_per_instance"]; ok {
|
|
|
|
if v == nil {
|
|
|
|
v = 0.0
|
|
|
|
}
|
|
|
|
|
|
|
|
buf.WriteString(fmt.Sprintf("%f-", v.(float64)))
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Printf("[DEBUG] computed hash value of %v from %v", hashcode.String(buf.String()), buf.String())
|
|
|
|
return hashcode.String(buf.String())
|
|
|
|
}
|
|
|
|
|
2015-08-20 19:52:30 +00:00
|
|
|
func resourceComputeBackendService() *schema.Resource {
|
|
|
|
return &schema.Resource{
|
|
|
|
Create: resourceComputeBackendServiceCreate,
|
|
|
|
Read: resourceComputeBackendServiceRead,
|
|
|
|
Update: resourceComputeBackendServiceUpdate,
|
|
|
|
Delete: resourceComputeBackendServiceDelete,
|
2019-04-02 21:32:09 +00:00
|
|
|
|
2017-06-14 21:13:52 +00:00
|
|
|
Importer: &schema.ResourceImporter{
|
2019-04-02 21:32:09 +00:00
|
|
|
State: resourceComputeBackendServiceImport,
|
|
|
|
},
|
|
|
|
|
|
|
|
Timeouts: &schema.ResourceTimeout{
|
|
|
|
Create: schema.DefaultTimeout(240 * time.Second),
|
|
|
|
Update: schema.DefaultTimeout(240 * time.Second),
|
|
|
|
Delete: schema.DefaultTimeout(240 * time.Second),
|
2017-06-14 21:13:52 +00:00
|
|
|
},
|
2019-04-02 21:32:09 +00:00
|
|
|
|
2017-10-04 23:49:02 +00:00
|
|
|
SchemaVersion: 1,
|
2015-08-20 19:52:30 +00:00
|
|
|
|
|
|
|
Schema: map[string]*schema.Schema{
|
2018-12-14 20:51:11 +00:00
|
|
|
"health_checks": {
|
2016-04-10 21:34:15 +00:00
|
|
|
Type: schema.TypeSet,
|
2017-06-20 17:26:09 +00:00
|
|
|
Required: true,
|
|
|
|
MinItems: 1,
|
|
|
|
MaxItems: 1,
|
2019-04-02 21:32:09 +00:00
|
|
|
Elem: &schema.Schema{
|
|
|
|
Type: schema.TypeString,
|
|
|
|
},
|
|
|
|
Set: selfLinkRelativePathHash,
|
|
|
|
},
|
|
|
|
"name": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Required: true,
|
|
|
|
ForceNew: true,
|
2016-04-10 21:34:15 +00:00
|
|
|
},
|
2019-03-29 22:12:51 +00:00
|
|
|
"affinity_cookie_ttl_sec": {
|
|
|
|
Type: schema.TypeInt,
|
2017-10-31 23:27:03 +00:00
|
|
|
Optional: true,
|
|
|
|
},
|
2018-12-14 20:51:11 +00:00
|
|
|
"backend": {
|
2017-10-31 23:27:03 +00:00
|
|
|
Type: schema.TypeSet,
|
|
|
|
Optional: true,
|
2019-03-29 22:12:51 +00:00
|
|
|
Elem: computeBackendServiceBackendSchema(),
|
2019-04-02 21:32:09 +00:00
|
|
|
Set: resourceGoogleComputeBackendServiceBackendHash,
|
2015-08-20 19:52:30 +00:00
|
|
|
},
|
2018-12-14 20:51:11 +00:00
|
|
|
"cdn_policy": {
|
2018-03-16 17:50:32 +00:00
|
|
|
Type: schema.TypeList,
|
2018-03-16 20:56:27 +00:00
|
|
|
Computed: true,
|
2019-04-02 21:32:09 +00:00
|
|
|
Optional: true,
|
2018-03-16 17:50:32 +00:00
|
|
|
MaxItems: 1,
|
|
|
|
Elem: &schema.Resource{
|
|
|
|
Schema: map[string]*schema.Schema{
|
2018-12-14 20:51:11 +00:00
|
|
|
"cache_key_policy": {
|
2018-03-16 17:50:32 +00:00
|
|
|
Type: schema.TypeList,
|
|
|
|
Optional: true,
|
|
|
|
MaxItems: 1,
|
|
|
|
Elem: &schema.Resource{
|
|
|
|
Schema: map[string]*schema.Schema{
|
2018-12-14 20:51:11 +00:00
|
|
|
"include_host": {
|
2018-03-16 17:50:32 +00:00
|
|
|
Type: schema.TypeBool,
|
|
|
|
Optional: true,
|
|
|
|
},
|
2018-12-14 20:51:11 +00:00
|
|
|
"include_protocol": {
|
2018-03-16 17:50:32 +00:00
|
|
|
Type: schema.TypeBool,
|
|
|
|
Optional: true,
|
|
|
|
},
|
2018-12-14 20:51:11 +00:00
|
|
|
"include_query_string": {
|
2018-03-16 17:50:32 +00:00
|
|
|
Type: schema.TypeBool,
|
|
|
|
Optional: true,
|
|
|
|
},
|
2018-12-14 20:51:11 +00:00
|
|
|
"query_string_blacklist": {
|
2019-04-02 21:32:09 +00:00
|
|
|
Type: schema.TypeSet,
|
|
|
|
Optional: true,
|
|
|
|
Elem: &schema.Schema{
|
|
|
|
Type: schema.TypeString,
|
|
|
|
},
|
|
|
|
Set: schema.HashString,
|
2018-03-16 17:50:32 +00:00
|
|
|
},
|
2018-12-14 20:51:11 +00:00
|
|
|
"query_string_whitelist": {
|
2019-04-02 21:32:09 +00:00
|
|
|
Type: schema.TypeSet,
|
|
|
|
Optional: true,
|
|
|
|
Elem: &schema.Schema{
|
|
|
|
Type: schema.TypeString,
|
|
|
|
},
|
|
|
|
Set: schema.HashString,
|
2018-03-16 17:50:32 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2019-04-04 20:50:31 +00:00
|
|
|
"signed_url_cache_max_age_sec": {
|
|
|
|
Type: schema.TypeInt,
|
|
|
|
Optional: true,
|
|
|
|
Default: 3600,
|
|
|
|
},
|
2018-03-16 17:50:32 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2019-03-29 22:12:51 +00:00
|
|
|
"connection_draining_timeout_sec": {
|
|
|
|
Type: schema.TypeInt,
|
|
|
|
Optional: true,
|
|
|
|
Default: 300,
|
|
|
|
},
|
|
|
|
|
2018-12-14 20:51:11 +00:00
|
|
|
"description": {
|
2015-08-20 19:52:30 +00:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
},
|
2018-12-14 20:51:11 +00:00
|
|
|
"enable_cdn": {
|
2016-07-28 20:38:09 +00:00
|
|
|
Type: schema.TypeBool,
|
|
|
|
Optional: true,
|
2015-08-20 19:52:30 +00:00
|
|
|
},
|
2019-03-29 22:12:51 +00:00
|
|
|
"iap": {
|
|
|
|
Type: schema.TypeList,
|
2015-08-20 19:52:30 +00:00
|
|
|
Optional: true,
|
2019-03-29 22:12:51 +00:00
|
|
|
MaxItems: 1,
|
|
|
|
Elem: &schema.Resource{
|
|
|
|
Schema: map[string]*schema.Schema{
|
|
|
|
"oauth2_client_id": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Required: true,
|
|
|
|
},
|
|
|
|
"oauth2_client_secret": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Required: true,
|
|
|
|
Sensitive: true,
|
|
|
|
},
|
|
|
|
"oauth2_client_secret_sha256": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Computed: true,
|
|
|
|
Sensitive: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2015-08-20 19:52:30 +00:00
|
|
|
},
|
2019-04-04 20:50:31 +00:00
|
|
|
"load_balancing_scheme": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
ValidateFunc: validation.StringInSlice([]string{"INTERNAL", "EXTERNAL", ""}, false),
|
|
|
|
Default: "EXTERNAL",
|
|
|
|
},
|
2019-03-29 22:12:51 +00:00
|
|
|
"port_name": {
|
2015-08-20 19:52:30 +00:00
|
|
|
Type: schema.TypeString,
|
2017-11-28 00:32:20 +00:00
|
|
|
Computed: true,
|
2015-08-20 19:52:30 +00:00
|
|
|
Optional: true,
|
|
|
|
},
|
2019-04-02 21:32:09 +00:00
|
|
|
"protocol": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Computed: true,
|
|
|
|
Optional: true,
|
|
|
|
ValidateFunc: validation.StringInSlice([]string{"HTTP", "HTTPS", "TCP", "SSL", ""}, false),
|
2015-08-20 19:52:30 +00:00
|
|
|
},
|
2018-12-14 20:51:11 +00:00
|
|
|
"security_policy": {
|
2018-03-22 16:53:24 +00:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
DiffSuppressFunc: compareSelfLinkOrResourceName,
|
|
|
|
},
|
2019-03-29 22:12:51 +00:00
|
|
|
"session_affinity": {
|
2019-04-02 21:32:09 +00:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Computed: true,
|
|
|
|
Optional: true,
|
|
|
|
ValidateFunc: validation.StringInSlice([]string{"NONE", "CLIENT_IP", "GENERATED_COOKIE", "CLIENT_IP_PROTO", "CLIENT_IP_PORT_PROTO", ""}, false),
|
2015-08-20 19:52:30 +00:00
|
|
|
},
|
2019-03-29 22:12:51 +00:00
|
|
|
"timeout_sec": {
|
|
|
|
Type: schema.TypeInt,
|
2019-04-02 21:32:09 +00:00
|
|
|
Computed: true,
|
2019-03-29 22:12:51 +00:00
|
|
|
Optional: true,
|
2019-04-02 21:32:09 +00:00
|
|
|
},
|
|
|
|
"creation_timestamp": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Computed: true,
|
|
|
|
},
|
|
|
|
"fingerprint": {
|
|
|
|
Type: schema.TypeString,
|
2019-03-29 22:12:51 +00:00
|
|
|
Computed: true,
|
|
|
|
},
|
|
|
|
"project": {
|
2016-11-27 19:12:56 +00:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
Computed: true,
|
2019-03-29 22:12:51 +00:00
|
|
|
ForceNew: true,
|
2016-11-27 19:12:56 +00:00
|
|
|
},
|
2019-03-29 22:12:51 +00:00
|
|
|
"self_link": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Computed: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func computeBackendServiceBackendSchema() *schema.Resource {
|
|
|
|
return &schema.Resource{
|
|
|
|
Schema: map[string]*schema.Schema{
|
|
|
|
"balancing_mode": {
|
2019-04-02 21:32:09 +00:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
ValidateFunc: validation.StringInSlice([]string{"UTILIZATION", "RATE", "CONNECTION", ""}, false),
|
|
|
|
Default: "UTILIZATION",
|
2019-03-29 22:12:51 +00:00
|
|
|
},
|
|
|
|
"capacity_scaler": {
|
|
|
|
Type: schema.TypeFloat,
|
|
|
|
Optional: true,
|
2019-04-02 21:32:09 +00:00
|
|
|
Default: 1.0,
|
2019-03-29 22:12:51 +00:00
|
|
|
},
|
|
|
|
"description": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
},
|
2019-04-02 21:32:09 +00:00
|
|
|
"group": {
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
DiffSuppressFunc: compareSelfLinkRelativePaths,
|
|
|
|
},
|
|
|
|
"max_connections": {
|
2018-12-22 00:54:17 +00:00
|
|
|
Type: schema.TypeInt,
|
|
|
|
Optional: true,
|
|
|
|
},
|
2019-04-02 21:32:09 +00:00
|
|
|
"max_connections_per_instance": {
|
|
|
|
Type: schema.TypeInt,
|
2019-03-29 22:12:51 +00:00
|
|
|
Optional: true,
|
|
|
|
},
|
2019-04-02 21:32:09 +00:00
|
|
|
"max_rate": {
|
2016-04-10 21:34:15 +00:00
|
|
|
Type: schema.TypeInt,
|
2016-04-10 16:59:57 +00:00
|
|
|
Optional: true,
|
|
|
|
},
|
2019-04-02 21:32:09 +00:00
|
|
|
"max_rate_per_instance": {
|
|
|
|
Type: schema.TypeFloat,
|
2017-06-07 22:17:49 +00:00
|
|
|
Optional: true,
|
2019-03-29 22:12:51 +00:00
|
|
|
},
|
|
|
|
"max_utilization": {
|
|
|
|
Type: schema.TypeFloat,
|
|
|
|
Optional: true,
|
|
|
|
Default: 0.8,
|
2017-06-07 22:17:49 +00:00
|
|
|
},
|
2015-08-20 19:52:30 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func resourceComputeBackendServiceCreate(d *schema.ResourceData, meta interface{}) error {
|
|
|
|
config := meta.(*Config)
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
obj := make(map[string]interface{})
|
|
|
|
affinityCookieTtlSecProp, err := expandComputeBackendServiceAffinityCookieTtlSec(d.Get("affinity_cookie_ttl_sec"), d, config)
|
2017-10-12 16:21:35 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2019-04-02 21:32:09 +00:00
|
|
|
} else if v, ok := d.GetOkExists("affinity_cookie_ttl_sec"); !isEmptyValue(reflect.ValueOf(affinityCookieTtlSecProp)) && (ok || !reflect.DeepEqual(v, affinityCookieTtlSecProp)) {
|
|
|
|
obj["affinityCookieTtlSec"] = affinityCookieTtlSecProp
|
|
|
|
}
|
|
|
|
backendsProp, err := expandComputeBackendServiceBackend(d.Get("backend"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("backend"); !isEmptyValue(reflect.ValueOf(backendsProp)) && (ok || !reflect.DeepEqual(v, backendsProp)) {
|
|
|
|
obj["backends"] = backendsProp
|
|
|
|
}
|
|
|
|
cdnPolicyProp, err := expandComputeBackendServiceCdnPolicy(d.Get("cdn_policy"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("cdn_policy"); !isEmptyValue(reflect.ValueOf(cdnPolicyProp)) && (ok || !reflect.DeepEqual(v, cdnPolicyProp)) {
|
|
|
|
obj["cdnPolicy"] = cdnPolicyProp
|
|
|
|
}
|
|
|
|
connectionDrainingProp, err := expandComputeBackendServiceConnectionDraining(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if !isEmptyValue(reflect.ValueOf(connectionDrainingProp)) {
|
|
|
|
obj["connectionDraining"] = connectionDrainingProp
|
|
|
|
}
|
|
|
|
fingerprintProp, err := expandComputeBackendServiceFingerprint(d.Get("fingerprint"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("fingerprint"); !isEmptyValue(reflect.ValueOf(fingerprintProp)) && (ok || !reflect.DeepEqual(v, fingerprintProp)) {
|
|
|
|
obj["fingerprint"] = fingerprintProp
|
|
|
|
}
|
|
|
|
descriptionProp, err := expandComputeBackendServiceDescription(d.Get("description"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("description"); !isEmptyValue(reflect.ValueOf(descriptionProp)) && (ok || !reflect.DeepEqual(v, descriptionProp)) {
|
|
|
|
obj["description"] = descriptionProp
|
|
|
|
}
|
|
|
|
enableCDNProp, err := expandComputeBackendServiceEnableCDN(d.Get("enable_cdn"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("enable_cdn"); !isEmptyValue(reflect.ValueOf(enableCDNProp)) && (ok || !reflect.DeepEqual(v, enableCDNProp)) {
|
|
|
|
obj["enableCDN"] = enableCDNProp
|
|
|
|
}
|
|
|
|
healthChecksProp, err := expandComputeBackendServiceHealthChecks(d.Get("health_checks"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("health_checks"); !isEmptyValue(reflect.ValueOf(healthChecksProp)) && (ok || !reflect.DeepEqual(v, healthChecksProp)) {
|
|
|
|
obj["healthChecks"] = healthChecksProp
|
|
|
|
}
|
|
|
|
iapProp, err := expandComputeBackendServiceIap(d.Get("iap"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("iap"); ok || !reflect.DeepEqual(v, iapProp) {
|
|
|
|
obj["iap"] = iapProp
|
|
|
|
}
|
2019-04-04 20:50:31 +00:00
|
|
|
loadBalancingSchemeProp, err := expandComputeBackendServiceLoadBalancingScheme(d.Get("load_balancing_scheme"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("load_balancing_scheme"); !isEmptyValue(reflect.ValueOf(loadBalancingSchemeProp)) && (ok || !reflect.DeepEqual(v, loadBalancingSchemeProp)) {
|
|
|
|
obj["loadBalancingScheme"] = loadBalancingSchemeProp
|
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
nameProp, err := expandComputeBackendServiceName(d.Get("name"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("name"); !isEmptyValue(reflect.ValueOf(nameProp)) && (ok || !reflect.DeepEqual(v, nameProp)) {
|
|
|
|
obj["name"] = nameProp
|
|
|
|
}
|
|
|
|
portNameProp, err := expandComputeBackendServicePortName(d.Get("port_name"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("port_name"); !isEmptyValue(reflect.ValueOf(portNameProp)) && (ok || !reflect.DeepEqual(v, portNameProp)) {
|
|
|
|
obj["portName"] = portNameProp
|
|
|
|
}
|
|
|
|
protocolProp, err := expandComputeBackendServiceProtocol(d.Get("protocol"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("protocol"); !isEmptyValue(reflect.ValueOf(protocolProp)) && (ok || !reflect.DeepEqual(v, protocolProp)) {
|
|
|
|
obj["protocol"] = protocolProp
|
|
|
|
}
|
|
|
|
securityPolicyProp, err := expandComputeBackendServiceSecurityPolicy(d.Get("security_policy"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("security_policy"); !isEmptyValue(reflect.ValueOf(securityPolicyProp)) && (ok || !reflect.DeepEqual(v, securityPolicyProp)) {
|
|
|
|
obj["securityPolicy"] = securityPolicyProp
|
|
|
|
}
|
|
|
|
sessionAffinityProp, err := expandComputeBackendServiceSessionAffinity(d.Get("session_affinity"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("session_affinity"); !isEmptyValue(reflect.ValueOf(sessionAffinityProp)) && (ok || !reflect.DeepEqual(v, sessionAffinityProp)) {
|
|
|
|
obj["sessionAffinity"] = sessionAffinityProp
|
|
|
|
}
|
|
|
|
timeoutSecProp, err := expandComputeBackendServiceTimeoutSec(d.Get("timeout_sec"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("timeout_sec"); !isEmptyValue(reflect.ValueOf(timeoutSecProp)) && (ok || !reflect.DeepEqual(v, timeoutSecProp)) {
|
|
|
|
obj["timeoutSec"] = timeoutSecProp
|
2017-10-12 16:21:35 +00:00
|
|
|
}
|
2017-06-07 22:17:49 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
obj, err = resourceComputeBackendServiceEncoder(d, meta, obj)
|
2016-04-10 16:59:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
url, err := replaceVars(d, config, "https://www.googleapis.com/compute/v1/projects/{{project}}/global/backendServices")
|
2015-08-20 19:52:30 +00:00
|
|
|
if err != nil {
|
2019-04-02 21:32:09 +00:00
|
|
|
return err
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
log.Printf("[DEBUG] Creating new BackendService: %#v", obj)
|
|
|
|
res, err := sendRequestWithTimeout(config, "POST", url, obj, d.Timeout(schema.TimeoutCreate))
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Error creating BackendService: %s", err)
|
|
|
|
}
|
2015-08-20 19:52:30 +00:00
|
|
|
|
2017-05-02 21:01:05 +00:00
|
|
|
// Store the ID now
|
2019-04-02 21:32:09 +00:00
|
|
|
id, err := replaceVars(d, config, "{{name}}")
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Error constructing id: %s", err)
|
|
|
|
}
|
|
|
|
d.SetId(id)
|
|
|
|
|
|
|
|
project, err := getProject(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
op := &compute.Operation{}
|
|
|
|
err = Convert(res, op)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
waitErr := computeOperationWaitTime(
|
|
|
|
config.clientCompute, op, project, "Creating BackendService",
|
|
|
|
int(d.Timeout(schema.TimeoutCreate).Minutes()))
|
2015-08-20 19:52:30 +00:00
|
|
|
|
2017-05-02 21:01:05 +00:00
|
|
|
if waitErr != nil {
|
|
|
|
// The resource didn't actually create
|
|
|
|
d.SetId("")
|
2019-04-02 21:32:09 +00:00
|
|
|
return fmt.Errorf("Error waiting to create BackendService: %s", waitErr)
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
log.Printf("[DEBUG] Finished creating BackendService %q: %#v", d.Id(), res)
|
|
|
|
|
|
|
|
// security_policy isn't set by Create / Update
|
2018-03-22 16:53:24 +00:00
|
|
|
if v, ok := d.GetOk("security_policy"); ok {
|
|
|
|
pol, err := ParseSecurityPolicyFieldValue(v.(string), d, config)
|
2019-02-15 00:00:35 +00:00
|
|
|
if err != nil {
|
|
|
|
return errwrap.Wrapf("Error parsing Backend Service security policy: {{err}}", err)
|
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
op, err := config.clientCompute.BackendServices.SetSecurityPolicy(
|
|
|
|
project, obj["name"].(string), &compute.SecurityPolicyReference{
|
2018-03-22 16:53:24 +00:00
|
|
|
SecurityPolicy: pol.RelativeLink(),
|
|
|
|
}).Do()
|
|
|
|
if err != nil {
|
|
|
|
return errwrap.Wrapf("Error setting Backend Service security policy: {{err}}", err)
|
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
waitErr := computeSharedOperationWait(config.clientCompute, op, project, "Setting Backend Service Security Policy")
|
2018-03-22 16:53:24 +00:00
|
|
|
if waitErr != nil {
|
|
|
|
return waitErr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-20 19:52:30 +00:00
|
|
|
return resourceComputeBackendServiceRead(d, meta)
|
|
|
|
}
|
|
|
|
|
|
|
|
func resourceComputeBackendServiceRead(d *schema.ResourceData, meta interface{}) error {
|
|
|
|
config := meta.(*Config)
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
url, err := replaceVars(d, config, "https://www.googleapis.com/compute/v1/projects/{{project}}/global/backendServices/{{name}}")
|
2016-04-10 16:59:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
res, err := sendRequest(config, "GET", url, nil)
|
2018-05-09 18:24:40 +00:00
|
|
|
if err != nil {
|
2019-04-02 21:32:09 +00:00
|
|
|
return handleNotFoundError(err, d, fmt.Sprintf("ComputeBackendService %q", d.Id()))
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
res, err = resourceComputeBackendServiceDecoder(d, meta, res)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2019-01-23 22:41:55 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
project, err := getProject(d, config)
|
|
|
|
if err != nil {
|
2018-03-16 17:50:32 +00:00
|
|
|
return err
|
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
if err := d.Set("project", project); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := d.Set("affinity_cookie_ttl_sec", flattenComputeBackendServiceAffinityCookieTtlSec(res["affinityCookieTtlSec"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("backend", flattenComputeBackendServiceBackend(res["backends"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("cdn_policy", flattenComputeBackendServiceCdnPolicy(res["cdnPolicy"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if v, ok := res["connectionDraining"].(map[string]interface{}); res["connectionDraining"] != nil && ok {
|
|
|
|
if err := d.Set("connection_draining_timeout_sec", flattenComputeBackendServiceConnectionDrainingConnection_draining_timeout_sec(v["drainingTimeoutSec"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
d.Set("connection_draining_timeout_sec", nil)
|
|
|
|
}
|
|
|
|
if err := d.Set("creation_timestamp", flattenComputeBackendServiceCreationTimestamp(res["creationTimestamp"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("fingerprint", flattenComputeBackendServiceFingerprint(res["fingerprint"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("description", flattenComputeBackendServiceDescription(res["description"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("enable_cdn", flattenComputeBackendServiceEnableCDN(res["enableCDN"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("health_checks", flattenComputeBackendServiceHealthChecks(res["healthChecks"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("iap", flattenComputeBackendServiceIap(res["iap"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
2019-04-04 20:50:31 +00:00
|
|
|
if err := d.Set("load_balancing_scheme", flattenComputeBackendServiceLoadBalancingScheme(res["loadBalancingScheme"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
if err := d.Set("name", flattenComputeBackendServiceName(res["name"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("port_name", flattenComputeBackendServicePortName(res["portName"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("protocol", flattenComputeBackendServiceProtocol(res["protocol"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("security_policy", flattenComputeBackendServiceSecurityPolicy(res["securityPolicy"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("session_affinity", flattenComputeBackendServiceSessionAffinity(res["sessionAffinity"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("timeout_sec", flattenComputeBackendServiceTimeoutSec(res["timeoutSec"], d)); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
|
|
|
if err := d.Set("self_link", ConvertSelfLinkToV1(res["selfLink"].(string))); err != nil {
|
|
|
|
return fmt.Errorf("Error reading BackendService: %s", err)
|
|
|
|
}
|
2015-08-20 19:52:30 +00:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func resourceComputeBackendServiceUpdate(d *schema.ResourceData, meta interface{}) error {
|
|
|
|
config := meta.(*Config)
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
obj := make(map[string]interface{})
|
|
|
|
affinityCookieTtlSecProp, err := expandComputeBackendServiceAffinityCookieTtlSec(d.Get("affinity_cookie_ttl_sec"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("affinity_cookie_ttl_sec"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, affinityCookieTtlSecProp)) {
|
|
|
|
obj["affinityCookieTtlSec"] = affinityCookieTtlSecProp
|
|
|
|
}
|
|
|
|
backendsProp, err := expandComputeBackendServiceBackend(d.Get("backend"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("backend"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, backendsProp)) {
|
|
|
|
obj["backends"] = backendsProp
|
|
|
|
}
|
|
|
|
cdnPolicyProp, err := expandComputeBackendServiceCdnPolicy(d.Get("cdn_policy"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("cdn_policy"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, cdnPolicyProp)) {
|
|
|
|
obj["cdnPolicy"] = cdnPolicyProp
|
|
|
|
}
|
|
|
|
connectionDrainingProp, err := expandComputeBackendServiceConnectionDraining(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if !isEmptyValue(reflect.ValueOf(connectionDrainingProp)) {
|
|
|
|
obj["connectionDraining"] = connectionDrainingProp
|
|
|
|
}
|
|
|
|
fingerprintProp, err := expandComputeBackendServiceFingerprint(d.Get("fingerprint"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("fingerprint"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, fingerprintProp)) {
|
|
|
|
obj["fingerprint"] = fingerprintProp
|
|
|
|
}
|
|
|
|
descriptionProp, err := expandComputeBackendServiceDescription(d.Get("description"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("description"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, descriptionProp)) {
|
|
|
|
obj["description"] = descriptionProp
|
|
|
|
}
|
|
|
|
enableCDNProp, err := expandComputeBackendServiceEnableCDN(d.Get("enable_cdn"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("enable_cdn"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, enableCDNProp)) {
|
|
|
|
obj["enableCDN"] = enableCDNProp
|
|
|
|
}
|
|
|
|
healthChecksProp, err := expandComputeBackendServiceHealthChecks(d.Get("health_checks"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("health_checks"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, healthChecksProp)) {
|
|
|
|
obj["healthChecks"] = healthChecksProp
|
|
|
|
}
|
|
|
|
iapProp, err := expandComputeBackendServiceIap(d.Get("iap"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("iap"); ok || !reflect.DeepEqual(v, iapProp) {
|
|
|
|
obj["iap"] = iapProp
|
|
|
|
}
|
2019-04-04 20:50:31 +00:00
|
|
|
loadBalancingSchemeProp, err := expandComputeBackendServiceLoadBalancingScheme(d.Get("load_balancing_scheme"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("load_balancing_scheme"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, loadBalancingSchemeProp)) {
|
|
|
|
obj["loadBalancingScheme"] = loadBalancingSchemeProp
|
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
nameProp, err := expandComputeBackendServiceName(d.Get("name"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("name"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, nameProp)) {
|
|
|
|
obj["name"] = nameProp
|
|
|
|
}
|
|
|
|
portNameProp, err := expandComputeBackendServicePortName(d.Get("port_name"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("port_name"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, portNameProp)) {
|
|
|
|
obj["portName"] = portNameProp
|
|
|
|
}
|
|
|
|
protocolProp, err := expandComputeBackendServiceProtocol(d.Get("protocol"), d, config)
|
2017-10-12 16:21:35 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2019-04-02 21:32:09 +00:00
|
|
|
} else if v, ok := d.GetOkExists("protocol"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, protocolProp)) {
|
|
|
|
obj["protocol"] = protocolProp
|
|
|
|
}
|
|
|
|
securityPolicyProp, err := expandComputeBackendServiceSecurityPolicy(d.Get("security_policy"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("security_policy"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, securityPolicyProp)) {
|
|
|
|
obj["securityPolicy"] = securityPolicyProp
|
|
|
|
}
|
|
|
|
sessionAffinityProp, err := expandComputeBackendServiceSessionAffinity(d.Get("session_affinity"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("session_affinity"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, sessionAffinityProp)) {
|
|
|
|
obj["sessionAffinity"] = sessionAffinityProp
|
|
|
|
}
|
|
|
|
timeoutSecProp, err := expandComputeBackendServiceTimeoutSec(d.Get("timeout_sec"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if v, ok := d.GetOkExists("timeout_sec"); !isEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, timeoutSecProp)) {
|
|
|
|
obj["timeoutSec"] = timeoutSecProp
|
2017-10-12 16:21:35 +00:00
|
|
|
}
|
2017-09-07 19:56:53 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
obj, err = resourceComputeBackendServiceEncoder(d, meta, obj)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
url, err := replaceVars(d, config, "https://www.googleapis.com/compute/v1/projects/{{project}}/global/backendServices/{{name}}")
|
2016-04-10 16:59:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
log.Printf("[DEBUG] Updating BackendService %q: %#v", d.Id(), obj)
|
|
|
|
res, err := sendRequestWithTimeout(config, "PUT", url, obj, d.Timeout(schema.TimeoutUpdate))
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Error updating BackendService %q: %s", d.Id(), err)
|
|
|
|
}
|
|
|
|
|
|
|
|
project, err := getProject(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
op := &compute.Operation{}
|
|
|
|
err = Convert(res, op)
|
2015-08-20 19:52:30 +00:00
|
|
|
if err != nil {
|
2019-04-02 21:32:09 +00:00
|
|
|
return err
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
err = computeOperationWaitTime(
|
|
|
|
config.clientCompute, op, project, "Updating BackendService",
|
|
|
|
int(d.Timeout(schema.TimeoutUpdate).Minutes()))
|
|
|
|
|
2015-08-20 19:52:30 +00:00
|
|
|
if err != nil {
|
2015-09-24 20:30:12 +00:00
|
|
|
return err
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
// security_policy isn't set by Create / Update
|
|
|
|
if v, ok := d.GetOk("security_policy"); ok {
|
|
|
|
pol, err := ParseSecurityPolicyFieldValue(v.(string), d, config)
|
2018-03-22 16:53:24 +00:00
|
|
|
if err != nil {
|
2019-04-02 21:32:09 +00:00
|
|
|
return errwrap.Wrapf("Error parsing Backend Service security policy: {{err}}", err)
|
2018-03-22 16:53:24 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
op, err := config.clientCompute.BackendServices.SetSecurityPolicy(
|
|
|
|
project, obj["name"].(string), &compute.SecurityPolicyReference{
|
2018-03-22 16:53:24 +00:00
|
|
|
SecurityPolicy: pol.RelativeLink(),
|
|
|
|
}).Do()
|
|
|
|
if err != nil {
|
2019-04-02 21:32:09 +00:00
|
|
|
return errwrap.Wrapf("Error setting Backend Service security policy: {{err}}", err)
|
2018-03-22 16:53:24 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
waitErr := computeSharedOperationWait(config.clientCompute, op, project, "Setting Backend Service Security Policy")
|
2018-03-22 16:53:24 +00:00
|
|
|
if waitErr != nil {
|
|
|
|
return waitErr
|
|
|
|
}
|
|
|
|
}
|
2015-08-20 19:52:30 +00:00
|
|
|
return resourceComputeBackendServiceRead(d, meta)
|
|
|
|
}
|
|
|
|
|
|
|
|
func resourceComputeBackendServiceDelete(d *schema.ResourceData, meta interface{}) error {
|
|
|
|
config := meta.(*Config)
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
url, err := replaceVars(d, config, "https://www.googleapis.com/compute/v1/projects/{{project}}/global/backendServices/{{name}}")
|
2016-04-10 16:59:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
var obj map[string]interface{}
|
|
|
|
log.Printf("[DEBUG] Deleting BackendService %q", d.Id())
|
|
|
|
res, err := sendRequestWithTimeout(config, "DELETE", url, obj, d.Timeout(schema.TimeoutDelete))
|
|
|
|
if err != nil {
|
|
|
|
return handleNotFoundError(err, d, "BackendService")
|
|
|
|
}
|
|
|
|
|
|
|
|
project, err := getProject(d, config)
|
2015-08-20 19:52:30 +00:00
|
|
|
if err != nil {
|
2019-04-02 21:32:09 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
op := &compute.Operation{}
|
|
|
|
err = Convert(res, op)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
err = computeOperationWaitTime(
|
|
|
|
config.clientCompute, op, project, "Deleting BackendService",
|
|
|
|
int(d.Timeout(schema.TimeoutDelete).Minutes()))
|
|
|
|
|
2015-08-20 19:52:30 +00:00
|
|
|
if err != nil {
|
2015-09-24 20:30:12 +00:00
|
|
|
return err
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
log.Printf("[DEBUG] Finished deleting BackendService %q: %#v", d.Id(), res)
|
2015-08-20 19:52:30 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func resourceComputeBackendServiceImport(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
|
|
|
|
config := meta.(*Config)
|
|
|
|
if err := parseImportId([]string{"projects/(?P<project>[^/]+)/global/backendServices/(?P<name>[^/]+)", "(?P<project>[^/]+)/(?P<name>[^/]+)", "(?P<name>[^/]+)"}, d, config); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Replace import id for the resource id
|
|
|
|
id, err := replaceVars(d, config, "{{name}}")
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("Error constructing id: %s", err)
|
|
|
|
}
|
|
|
|
d.SetId(id)
|
|
|
|
|
|
|
|
return []*schema.ResourceData{d}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceAffinityCookieTtlSec(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
// Handles the string fixed64 format
|
|
|
|
if strVal, ok := v.(string); ok {
|
|
|
|
if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
|
|
|
|
return intVal
|
|
|
|
} // let terraform core handle it if we can't convert the string to an int.
|
|
|
|
}
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceBackend(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
if v == nil {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
l := v.([]interface{})
|
|
|
|
transformed := schema.NewSet(resourceGoogleComputeBackendServiceBackendHash, []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.Add(map[string]interface{}{
|
|
|
|
"balancing_mode": flattenComputeBackendServiceBackendBalancingMode(original["balancingMode"], d),
|
|
|
|
"capacity_scaler": flattenComputeBackendServiceBackendCapacityScaler(original["capacityScaler"], d),
|
|
|
|
"description": flattenComputeBackendServiceBackendDescription(original["description"], d),
|
|
|
|
"group": flattenComputeBackendServiceBackendGroup(original["group"], d),
|
|
|
|
"max_connections": flattenComputeBackendServiceBackendMaxConnections(original["maxConnections"], d),
|
|
|
|
"max_connections_per_instance": flattenComputeBackendServiceBackendMaxConnectionsPerInstance(original["maxConnectionsPerInstance"], d),
|
|
|
|
"max_rate": flattenComputeBackendServiceBackendMaxRate(original["maxRate"], d),
|
|
|
|
"max_rate_per_instance": flattenComputeBackendServiceBackendMaxRatePerInstance(original["maxRatePerInstance"], d),
|
|
|
|
"max_utilization": flattenComputeBackendServiceBackendMaxUtilization(original["maxUtilization"], d),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
return transformed
|
|
|
|
}
|
|
|
|
func flattenComputeBackendServiceBackendBalancingMode(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceBackendCapacityScaler(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceBackendDescription(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceBackendGroup(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
if v == nil {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return ConvertSelfLinkToV1(v.(string))
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceBackendMaxConnections(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
// Handles the string fixed64 format
|
|
|
|
if strVal, ok := v.(string); ok {
|
|
|
|
if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
|
|
|
|
return intVal
|
|
|
|
} // let terraform core handle it if we can't convert the string to an int.
|
|
|
|
}
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceBackendMaxConnectionsPerInstance(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
// Handles the string fixed64 format
|
|
|
|
if strVal, ok := v.(string); ok {
|
|
|
|
if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
|
|
|
|
return intVal
|
|
|
|
} // let terraform core handle it if we can't convert the string to an int.
|
|
|
|
}
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceBackendMaxRate(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
// Handles the string fixed64 format
|
|
|
|
if strVal, ok := v.(string); ok {
|
|
|
|
if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
|
|
|
|
return intVal
|
|
|
|
} // let terraform core handle it if we can't convert the string to an int.
|
|
|
|
}
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceBackendMaxRatePerInstance(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceBackendMaxUtilization(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceCdnPolicy(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
if v == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
original := v.(map[string]interface{})
|
|
|
|
if len(original) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
transformed := make(map[string]interface{})
|
|
|
|
transformed["cache_key_policy"] =
|
|
|
|
flattenComputeBackendServiceCdnPolicyCacheKeyPolicy(original["cacheKeyPolicy"], d)
|
2019-04-04 20:50:31 +00:00
|
|
|
transformed["signed_url_cache_max_age_sec"] =
|
|
|
|
flattenComputeBackendServiceCdnPolicySignedUrlCacheMaxAgeSec(original["signedUrlCacheMaxAgeSec"], d)
|
2019-04-02 21:32:09 +00:00
|
|
|
return []interface{}{transformed}
|
|
|
|
}
|
|
|
|
func flattenComputeBackendServiceCdnPolicyCacheKeyPolicy(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
if v == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
original := v.(map[string]interface{})
|
|
|
|
if len(original) == 0 {
|
2018-03-20 22:41:58 +00:00
|
|
|
return nil
|
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
transformed := make(map[string]interface{})
|
|
|
|
transformed["include_host"] =
|
|
|
|
flattenComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeHost(original["includeHost"], d)
|
|
|
|
transformed["include_protocol"] =
|
|
|
|
flattenComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeProtocol(original["includeProtocol"], d)
|
|
|
|
transformed["include_query_string"] =
|
|
|
|
flattenComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeQueryString(original["includeQueryString"], d)
|
|
|
|
transformed["query_string_blacklist"] =
|
|
|
|
flattenComputeBackendServiceCdnPolicyCacheKeyPolicyQueryStringBlacklist(original["queryStringBlacklist"], d)
|
|
|
|
transformed["query_string_whitelist"] =
|
|
|
|
flattenComputeBackendServiceCdnPolicyCacheKeyPolicyQueryStringWhitelist(original["queryStringWhitelist"], d)
|
|
|
|
return []interface{}{transformed}
|
|
|
|
}
|
|
|
|
func flattenComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeHost(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeProtocol(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeQueryString(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceCdnPolicyCacheKeyPolicyQueryStringBlacklist(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
if v == nil {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return schema.NewSet(schema.HashString, v.([]interface{}))
|
|
|
|
}
|
2017-10-31 23:27:03 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func flattenComputeBackendServiceCdnPolicyCacheKeyPolicyQueryStringWhitelist(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
if v == nil {
|
|
|
|
return v
|
2018-10-11 16:37:31 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
return schema.NewSet(schema.HashString, v.([]interface{}))
|
2017-10-31 23:27:03 +00:00
|
|
|
}
|
|
|
|
|
2019-04-04 20:50:31 +00:00
|
|
|
func flattenComputeBackendServiceCdnPolicySignedUrlCacheMaxAgeSec(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
// Handles the string fixed64 format
|
|
|
|
if strVal, ok := v.(string); ok {
|
|
|
|
if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
|
|
|
|
return intVal
|
|
|
|
} // let terraform core handle it if we can't convert the string to an int.
|
|
|
|
}
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func flattenComputeBackendServiceConnectionDrainingConnection_draining_timeout_sec(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
// Handles the string fixed64 format
|
|
|
|
if strVal, ok := v.(string); ok {
|
|
|
|
if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
|
|
|
|
return intVal
|
|
|
|
} // let terraform core handle it if we can't convert the string to an int.
|
2017-10-31 23:27:03 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
return v
|
|
|
|
}
|
2017-10-31 23:27:03 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func flattenComputeBackendServiceCreationTimestamp(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
2017-10-31 23:27:03 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func flattenComputeBackendServiceFingerprint(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
2015-08-20 19:52:30 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func flattenComputeBackendServiceDescription(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
2015-08-20 19:52:30 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func flattenComputeBackendServiceEnableCDN(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceHealthChecks(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
if v == nil {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
return convertAndMapStringArr(v.([]interface{}), ConvertSelfLinkToV1)
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceIap(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
if v == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
original := v.(map[string]interface{})
|
|
|
|
if len(original) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
transformed := make(map[string]interface{})
|
|
|
|
transformed["oauth2_client_id"] =
|
|
|
|
flattenComputeBackendServiceIapOauth2ClientId(original["oauth2ClientId"], d)
|
|
|
|
transformed["oauth2_client_secret"] =
|
|
|
|
flattenComputeBackendServiceIapOauth2ClientSecret(original["oauth2ClientSecret"], d)
|
|
|
|
transformed["oauth2_client_secret_sha256"] =
|
|
|
|
flattenComputeBackendServiceIapOauth2ClientSecretSha256(original["oauth2ClientSecretSha256"], d)
|
|
|
|
return []interface{}{transformed}
|
|
|
|
}
|
|
|
|
func flattenComputeBackendServiceIapOauth2ClientId(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceIapOauth2ClientSecret(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return d.Get("iap.0.oauth2_client_secret")
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceIapOauth2ClientSecretSha256(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2019-04-04 20:50:31 +00:00
|
|
|
func flattenComputeBackendServiceLoadBalancingScheme(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func flattenComputeBackendServiceName(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServicePortName(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceProtocol(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceSecurityPolicy(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceSessionAffinity(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func flattenComputeBackendServiceTimeoutSec(v interface{}, d *schema.ResourceData) interface{} {
|
|
|
|
// Handles the string fixed64 format
|
|
|
|
if strVal, ok := v.(string); ok {
|
|
|
|
if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
|
|
|
|
return intVal
|
|
|
|
} // let terraform core handle it if we can't convert the string to an int.
|
|
|
|
}
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceAffinityCookieTtlSec(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceBackend(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
v = v.(*schema.Set).List()
|
|
|
|
l := v.([]interface{})
|
|
|
|
req := make([]interface{}, 0, len(l))
|
|
|
|
for _, raw := range l {
|
|
|
|
if raw == nil {
|
|
|
|
continue
|
2017-10-12 16:21:35 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
original := raw.(map[string]interface{})
|
|
|
|
transformed := make(map[string]interface{})
|
2017-10-12 16:21:35 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedBalancingMode, err := expandComputeBackendServiceBackendBalancingMode(original["balancing_mode"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedBalancingMode); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["balancingMode"] = transformedBalancingMode
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedCapacityScaler, err := expandComputeBackendServiceBackendCapacityScaler(original["capacity_scaler"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedCapacityScaler); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["capacityScaler"] = transformedCapacityScaler
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
|
|
|
|
transformedDescription, err := expandComputeBackendServiceBackendDescription(original["description"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedDescription); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["description"] = transformedDescription
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
|
|
|
|
transformedGroup, err := expandComputeBackendServiceBackendGroup(original["group"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedGroup); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["group"] = transformedGroup
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
|
|
|
|
transformedMaxConnections, err := expandComputeBackendServiceBackendMaxConnections(original["max_connections"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedMaxConnections); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["maxConnections"] = transformedMaxConnections
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
|
|
|
|
transformedMaxConnectionsPerInstance, err := expandComputeBackendServiceBackendMaxConnectionsPerInstance(original["max_connections_per_instance"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedMaxConnectionsPerInstance); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["maxConnectionsPerInstance"] = transformedMaxConnectionsPerInstance
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
|
|
|
|
transformedMaxRate, err := expandComputeBackendServiceBackendMaxRate(original["max_rate"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedMaxRate); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["maxRate"] = transformedMaxRate
|
2018-04-19 21:00:34 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
|
|
|
|
transformedMaxRatePerInstance, err := expandComputeBackendServiceBackendMaxRatePerInstance(original["max_rate_per_instance"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedMaxRatePerInstance); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["maxRatePerInstance"] = transformedMaxRatePerInstance
|
2018-04-19 21:00:34 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
|
|
|
|
transformedMaxUtilization, err := expandComputeBackendServiceBackendMaxUtilization(original["max_utilization"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedMaxUtilization); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["maxUtilization"] = transformedMaxUtilization
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
req = append(req, transformed)
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
return req, nil
|
|
|
|
}
|
2015-08-20 19:52:30 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceBackendBalancingMode(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceBackendCapacityScaler(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
2015-08-20 19:52:30 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceBackendDescription(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
2015-08-20 19:52:30 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceBackendGroup(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
2019-04-22 18:11:24 +00:00
|
|
|
return v, nil
|
2019-04-02 21:32:09 +00:00
|
|
|
}
|
2015-08-20 19:52:30 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceBackendMaxConnections(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
2015-08-20 19:52:30 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceBackendMaxConnectionsPerInstance(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
2017-09-07 19:56:53 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceBackendMaxRate(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceBackendMaxRatePerInstance(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceBackendMaxUtilization(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceCdnPolicy(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
l := v.([]interface{})
|
|
|
|
if len(l) == 0 || l[0] == nil {
|
|
|
|
return nil, nil
|
2017-10-31 23:27:03 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
raw := l[0]
|
|
|
|
original := raw.(map[string]interface{})
|
|
|
|
transformed := make(map[string]interface{})
|
2017-10-31 23:27:03 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedCacheKeyPolicy, err := expandComputeBackendServiceCdnPolicyCacheKeyPolicy(original["cache_key_policy"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedCacheKeyPolicy); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["cacheKeyPolicy"] = transformedCacheKeyPolicy
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
|
|
|
|
2019-04-04 20:50:31 +00:00
|
|
|
transformedSignedUrlCacheMaxAgeSec, err := expandComputeBackendServiceCdnPolicySignedUrlCacheMaxAgeSec(original["signed_url_cache_max_age_sec"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedSignedUrlCacheMaxAgeSec); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["signedUrlCacheMaxAgeSec"] = transformedSignedUrlCacheMaxAgeSec
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
return transformed, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceCdnPolicyCacheKeyPolicy(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
l := v.([]interface{})
|
|
|
|
if len(l) == 0 || l[0] == nil {
|
|
|
|
return nil, nil
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
raw := l[0]
|
|
|
|
original := raw.(map[string]interface{})
|
|
|
|
transformed := make(map[string]interface{})
|
2017-09-07 19:56:53 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedIncludeHost, err := expandComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeHost(original["include_host"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedIncludeHost); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["includeHost"] = transformedIncludeHost
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedIncludeProtocol, err := expandComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeProtocol(original["include_protocol"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedIncludeProtocol); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["includeProtocol"] = transformedIncludeProtocol
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedIncludeQueryString, err := expandComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeQueryString(original["include_query_string"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedIncludeQueryString); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["includeQueryString"] = transformedIncludeQueryString
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedQueryStringBlacklist, err := expandComputeBackendServiceCdnPolicyCacheKeyPolicyQueryStringBlacklist(original["query_string_blacklist"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedQueryStringBlacklist); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["queryStringBlacklist"] = transformedQueryStringBlacklist
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedQueryStringWhitelist, err := expandComputeBackendServiceCdnPolicyCacheKeyPolicyQueryStringWhitelist(original["query_string_whitelist"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedQueryStringWhitelist); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["queryStringWhitelist"] = transformedQueryStringWhitelist
|
2018-12-22 00:54:17 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
return transformed, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeHost(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeProtocol(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceCdnPolicyCacheKeyPolicyIncludeQueryString(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceCdnPolicyCacheKeyPolicyQueryStringBlacklist(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
v = v.(*schema.Set).List()
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceCdnPolicyCacheKeyPolicyQueryStringWhitelist(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
v = v.(*schema.Set).List()
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
2019-04-04 20:50:31 +00:00
|
|
|
func expandComputeBackendServiceCdnPolicySignedUrlCacheMaxAgeSec(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceConnectionDraining(d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
transformed := make(map[string]interface{})
|
|
|
|
// Note that nesting flattened objects won't work because we don't handle them properly here.
|
|
|
|
transformedConnection_draining_timeout_sec, err := expandComputeBackendServiceConnectionDrainingConnection_draining_timeout_sec(d.Get("connection_draining_timeout_sec"), d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedConnection_draining_timeout_sec); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["drainingTimeoutSec"] = transformedConnection_draining_timeout_sec
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
return transformed, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceConnectionDrainingConnection_draining_timeout_sec(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceFingerprint(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceDescription(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceEnableCDN(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceHealthChecks(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
v = v.(*schema.Set).List()
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceIap(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
l := v.([]interface{})
|
|
|
|
if len(l) == 0 || l[0] == nil {
|
|
|
|
return nil, nil
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
raw := l[0]
|
|
|
|
original := raw.(map[string]interface{})
|
|
|
|
transformed := make(map[string]interface{})
|
2017-09-07 19:56:53 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedOauth2ClientId, err := expandComputeBackendServiceIapOauth2ClientId(original["oauth2_client_id"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedOauth2ClientId); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["oauth2ClientId"] = transformedOauth2ClientId
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedOauth2ClientSecret, err := expandComputeBackendServiceIapOauth2ClientSecret(original["oauth2_client_secret"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else {
|
|
|
|
transformed["oauth2ClientSecret"] = transformedOauth2ClientSecret
|
|
|
|
}
|
2017-09-07 19:56:53 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
transformedOauth2ClientSecretSha256, err := expandComputeBackendServiceIapOauth2ClientSecretSha256(original["oauth2_client_secret_sha256"], d, config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if val := reflect.ValueOf(transformedOauth2ClientSecretSha256); val.IsValid() && !isEmptyValue(val) {
|
|
|
|
transformed["oauth2ClientSecretSha256"] = transformedOauth2ClientSecretSha256
|
2018-03-16 17:50:32 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
return transformed, nil
|
2017-09-07 19:56:53 +00:00
|
|
|
}
|
2018-03-16 17:50:32 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceIapOauth2ClientId(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
2018-03-16 17:50:32 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceIapOauth2ClientSecret(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
2018-03-16 17:50:32 +00:00
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceIapOauth2ClientSecretSha256(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
2019-04-04 20:50:31 +00:00
|
|
|
func expandComputeBackendServiceLoadBalancingScheme(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func expandComputeBackendServiceName(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServicePortName(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceProtocol(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceSecurityPolicy(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceSessionAffinity(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func expandComputeBackendServiceTimeoutSec(v interface{}, d TerraformResourceData, config *Config) (interface{}, error) {
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func resourceComputeBackendServiceEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
// The BackendService API's Update / PUT API is badly formed and behaves like
|
|
|
|
// a PATCH field for at least IAP. When sent a `null` `iap` field, the API
|
|
|
|
// doesn't disable an existing field. To work around this, we need to emulate
|
|
|
|
// the old Terraform behaviour of always sending the block (at both update and
|
|
|
|
// create), and force sending each subfield as empty when the block isn't
|
|
|
|
// present in config.
|
|
|
|
|
|
|
|
iapVal := obj["iap"]
|
|
|
|
if iapVal == nil {
|
|
|
|
data := map[string]interface{}{}
|
|
|
|
data["enabled"] = false
|
|
|
|
data["oauth2ClientId"] = ""
|
|
|
|
data["oauth2ClientSecret"] = ""
|
|
|
|
obj["iap"] = data
|
|
|
|
} else {
|
|
|
|
iap := iapVal.(map[string]interface{})
|
|
|
|
iap["enabled"] = true
|
|
|
|
obj["iap"] = iap
|
2018-03-16 17:50:32 +00:00
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
|
|
|
|
return obj, nil
|
2018-03-16 17:50:32 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
func resourceComputeBackendServiceDecoder(d *schema.ResourceData, meta interface{}, res map[string]interface{}) (map[string]interface{}, error) {
|
|
|
|
// We need to pretend IAP isn't there if it's disabled for Terraform to maintain
|
|
|
|
// BC behaviour with the handwritten resource.
|
|
|
|
v, ok := res["iap"]
|
2019-04-18 21:15:42 +00:00
|
|
|
if !ok || v == nil {
|
|
|
|
delete(res, "iap")
|
|
|
|
return res, nil
|
|
|
|
}
|
2019-04-02 21:32:09 +00:00
|
|
|
m := v.(map[string]interface{})
|
|
|
|
if ok && m["enabled"] == false {
|
|
|
|
delete(res, "iap")
|
2018-03-16 17:50:32 +00:00
|
|
|
}
|
|
|
|
|
2019-04-02 21:32:09 +00:00
|
|
|
return res, nil
|
2018-03-16 17:50:32 +00:00
|
|
|
}
|