resilien
/
terraform
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

use v1 apis instead of beta

This commit is contained in:
Dana Hoffman 2016-11-22 13:14:28 -08:00
parent d319d4099e
commit 39809fca76
9 changed files with 57 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
builtin/providers/google/compute_operation.go
View File

@ -7,7 +7,6 @@ import (
"time"
"github.com/hashicorp/terraform/helper/resource"
computeBeta "google.golang.org/api/compute/v0.beta"
"google.golang.org/api/compute/v1"
)
@ -31,15 +30,6 @@ type ComputeOperationWaiter struct {
Zone string
}
type ComputeOperationWaiterBeta struct {
Service *computeBeta.Service
Op *computeBeta.Operation
Project string
Region string
Type ComputeOperationWaitType
Zone string
}
func (w *ComputeOperationWaiter) RefreshFunc() resource.StateRefreshFunc {
return func() (interface{}, string, error) {
var op *compute.Operation
@ -70,36 +60,6 @@ func (w *ComputeOperationWaiter) RefreshFunc() resource.StateRefreshFunc {
}
}
func (w *ComputeOperationWaiterBeta) RefreshFunc() resource.StateRefreshFunc {
return func() (interface{}, string, error) {
var op *computeBeta.Operation
var err error
switch w.Type {
case ComputeOperationWaitGlobal:
op, err = w.Service.GlobalOperations.Get(
w.Project, w.Op.Name).Do()
case ComputeOperationWaitRegion:
op, err = w.Service.RegionOperations.Get(
w.Project, w.Region, w.Op.Name).Do()
case ComputeOperationWaitZone:
op, err = w.Service.ZoneOperations.Get(
w.Project, w.Zone, w.Op.Name).Do()
default:
return nil, "bad-type", fmt.Errorf(
"Invalid wait type: %#v", w.Type)
}
if err != nil {
return nil, "", err
}
log.Printf("[DEBUG] Got %q when asking for operation %q", op.Status, w.Op.Name)
return op, op.Status, nil
}
}
func (w *ComputeOperationWaiter) Conf() *resource.StateChangeConf {
return &resource.StateChangeConf{
Pending: []string{"PENDING", "RUNNING"},
@ -108,18 +68,9 @@ func (w *ComputeOperationWaiter) Conf() *resource.StateChangeConf {
}
}
func (w *ComputeOperationWaiterBeta) Conf() *resource.StateChangeConf {
return &resource.StateChangeConf{
Pending: []string{"PENDING", "RUNNING"},
Target: []string{"DONE"},
Refresh: w.RefreshFunc(),
}
}
// ComputeOperationError wraps compute.OperationError and implements the
// error interface so it can be returned.
type ComputeOperationError compute.OperationError
type ComputeOperationErrorBeta computeBeta.OperationError
func (e ComputeOperationError) Error() string {
var buf bytes.Buffer
@ -131,16 +82,6 @@ func (e ComputeOperationError) Error() string {
return buf.String()
}
func (e ComputeOperationErrorBeta) Error() string {
var buf bytes.Buffer
for _, err := range e.Errors {
buf.WriteString(err.Message + "\n")
}
return buf.String()
}
func computeOperationWaitGlobal(config *Config, op *compute.Operation, project string, activity string) error {
return computeOperationWaitGlobalTime(config, op, project, activity, 4)
}
@ -170,31 +111,6 @@ func computeOperationWaitGlobalTime(config *Config, op *compute.Operation, proje
return nil
}
func computeOperationWaitGlobalBeta(config *Config, op *computeBeta.Operation, project string, activity string) error {
w := &ComputeOperationWaiterBeta{
Service: config.clientComputeBeta,
Op: op,
Project: project,
Type: ComputeOperationWaitGlobal,
}
state := w.Conf()
state.Delay = 10 * time.Second
state.Timeout = 4 * time.Minute
state.MinTimeout = 2 * time.Second
opRaw, err := state.WaitForState()
if err != nil {
return fmt.Errorf("Error waiting for %s: %s", activity, err)
}
op = opRaw.(*computeBeta.Operation)
if op.Error != nil {
return ComputeOperationErrorBeta(*op.Error)
}
return nil
}
func computeOperationWaitRegion(config *Config, op *compute.Operation, project string, region, activity string) error {
w := &ComputeOperationWaiter{
Service: config.clientCompute,
@ -221,32 +137,6 @@ func computeOperationWaitRegion(config *Config, op *compute.Operation, project s
return nil
}
func computeOperationWaitRegionBeta(config *Config, op *computeBeta.Operation, project string, region, activity string) error {
w := &ComputeOperationWaiterBeta{
Service: config.clientComputeBeta,
Op: op,
Project: project,
Type: ComputeOperationWaitRegion,
Region: region,
}
state := w.Conf()
state.Delay = 10 * time.Second
state.Timeout = 4 * time.Minute
state.MinTimeout = 2 * time.Second
opRaw, err := state.WaitForState()
if err != nil {
return fmt.Errorf("Error waiting for %s: %s", activity, err)
}
op = opRaw.(*computeBeta.Operation)
if op.Error != nil {
return ComputeOperationErrorBeta(*op.Error)
}
return nil
}
func computeOperationWaitZone(config *Config, op *compute.Operation, project string, zone, activity string) error {
return computeOperationWaitZoneTime(config, op, project, zone, 4, activity)
}

9
builtin/providers/google/config.go
View File

@ -14,7 +14,6 @@ import (
"golang.org/x/oauth2/google"
"golang.org/x/oauth2/jwt"
"google.golang.org/api/cloudresourcemanager/v1"
computeBeta "google.golang.org/api/compute/v0.beta"
"google.golang.org/api/compute/v1"
"google.golang.org/api/container/v1"
"google.golang.org/api/dns/v1"
@ -32,7 +31,6 @@ type Config struct {
Region string
clientCompute *compute.Service
clientComputeBeta *computeBeta.Service
clientContainer *container.Service
clientDns *dns.Service
clientPubsub *pubsub.Service
@ -104,13 +102,6 @@ func (c *Config) loadAndValidate() error {
}
c.clientCompute.UserAgent = userAgent
log.Printf("[INFO] Instantiating GCE beta client...")
c.clientComputeBeta, err = computeBeta.New(client)
if err != nil {
return err
}
c.clientComputeBeta.UserAgent = userAgent
log.Printf("[INFO] Instantiating GKE client...")
c.clientContainer, err = container.New(client)
if err != nil {

37
builtin/providers/google/resource_compute_backend_service.go
View File

@ -4,12 +4,11 @@ import (
"bytes"
"fmt"
"log"
"os"
"regexp"
"github.com/hashicorp/terraform/helper/hashcode"
"github.com/hashicorp/terraform/helper/schema"
"google.golang.org/api/compute/v0.beta"
"google.golang.org/api/compute/v1"
"google.golang.org/api/googleapi"
)
@ -100,12 +99,6 @@ func resourceComputeBackendService() *schema.Resource {
Computed: true,
},
"load_balancing_scheme": &schema.Schema{
Type: schema.TypeString,
Optional: true,
ForceNew: true,
},
"port_name": &schema.Schema{
Type: schema.TypeString,
Optional: true,
@ -192,22 +185,13 @@ func resourceComputeBackendServiceCreate(d *schema.ResourceData, meta interface{
service.EnableCDN = v.(bool)
}
if v, ok := d.GetOk("load_balancing_scheme"); ok {
service.LoadBalancingScheme = v.(string)
}
if v, ok := d.GetOk("region"); ok {
service.Region = v.(string)
}
project, err := getProject(d, config)
if err != nil {
return err
}
fmt.Fprintf(os.Stderr, "[DEBUG] Creating new Backend Service: %#v", service)
log.Printf("[DEBUG] Creating new Backend Service: %#v", service)
op, err := config.clientComputeBeta.BackendServices.Insert(
op, err := config.clientCompute.BackendServices.Insert(
project, &service).Do()
if err != nil {
return fmt.Errorf("Error creating backend service: %s", err)
@ -217,7 +201,7 @@ func resourceComputeBackendServiceCreate(d *schema.ResourceData, meta interface{
d.SetId(service.Name)
err = computeOperationWaitGlobalBeta(config, op, project, "Creating Backend Service")
err = computeOperationWaitGlobal(config, op, project, "Creating Backend Service")
if err != nil {
return err
}
@ -233,7 +217,7 @@ func resourceComputeBackendServiceRead(d *schema.ResourceData, meta interface{})
return err
}
service, err := config.clientComputeBeta.BackendServices.Get(
service, err := config.clientCompute.BackendServices.Get(
project, d.Id()).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
@ -254,7 +238,6 @@ func resourceComputeBackendServiceRead(d *schema.ResourceData, meta interface{})
d.Set("session_affinity", service.SessionAffinity)
d.Set("timeout_sec", service.TimeoutSec)
d.Set("fingerprint", service.Fingerprint)
d.Set("load_balancing_scheme", service.LoadBalancingScheme)
d.Set("self_link", service.SelfLink)
d.Set("backend", flattenBackends(service.Backends))
@ -304,16 +287,12 @@ func resourceComputeBackendServiceUpdate(d *schema.ResourceData, meta interface{
service.SessionAffinity = d.Get("session_affinity").(string)
}
if v, ok := d.GetOk("load_balancing_scheme"); ok {
service.LoadBalancingScheme = v.(string)
}
if d.HasChange("enable_cdn") {
service.EnableCDN = d.Get("enable_cdn").(bool)
}
log.Printf("[DEBUG] Updating existing Backend Service %q: %#v", d.Id(), service)
op, err := config.clientComputeBeta.BackendServices.Update(
op, err := config.clientCompute.BackendServices.Update(
project, d.Id(), &service).Do()
if err != nil {
return fmt.Errorf("Error updating backend service: %s", err)
@ -321,7 +300,7 @@ func resourceComputeBackendServiceUpdate(d *schema.ResourceData, meta interface{
d.SetId(service.Name)
err = computeOperationWaitGlobalBeta(config, op, project, "Updating Backend Service")
err = computeOperationWaitGlobal(config, op, project, "Updating Backend Service")
if err != nil {
return err
}
@ -338,13 +317,13 @@ func resourceComputeBackendServiceDelete(d *schema.ResourceData, meta interface{
}
log.Printf("[DEBUG] Deleting backend service %s", d.Id())
op, err := config.clientComputeBeta.BackendServices.Delete(
op, err := config.clientCompute.BackendServices.Delete(
project, d.Id()).Do()
if err != nil {
return fmt.Errorf("Error deleting backend service: %s", err)
}
err = computeOperationWaitGlobalBeta(config, op, project, "Deleting Backend Service")
err = computeOperationWaitGlobal(config, op, project, "Deleting Backend Service")
if err != nil {
return err
}

55
builtin/providers/google/resource_compute_backend_service_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/terraform"
"google.golang.org/api/compute/v0.beta"
"google.golang.org/api/compute/v1"
)
func TestAccComputeBackendService_basic(t *testing.T) {
@ -122,7 +122,7 @@ func testAccCheckComputeBackendServiceDestroy(s *terraform.State) error {
continue
}
_, err := config.clientComputeBeta.BackendServices.Get(
_, err := config.clientCompute.BackendServices.Get(
config.Project, rs.Primary.ID).Do()
if err == nil {
return fmt.Errorf("Backend service still exists")
@ -145,7 +145,7 @@ func testAccCheckComputeBackendServiceExists(n string, svc *compute.BackendServi
config := testAccProvider.Meta().(*Config)
found, err := config.clientComputeBeta.BackendServices.Get(
found, err := config.clientCompute.BackendServices.Get(
config.Project, rs.Primary.ID).Do()
if err != nil {
return err
@ -221,39 +221,11 @@ func TestAccComputeBackendService_withSessionAffinity(t *testing.T) {
}
}
func TestAccComputeBackendService_withInternalLoadBalancing(t *testing.T) {
serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(10))
var svc compute.BackendService
// config := testAccProvider.Meta().(*Config)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckComputeBackendServiceDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeBackendService_withInternalLoadBalancing(
serviceName, checkName, "us-central1"),
Check: resource.ComposeTestCheckFunc(
testAccCheckComputeBackendServiceExists(
"google_compute_backend_service.foobar", &svc),
),
},
},
})
if svc.LoadBalancingScheme != "INTERNAL" {
t.Errorf("Expected LoadBalancingScheme == INTERNAL, got %q", svc.EnableCDN)
}
}
func testAccComputeBackendService_basic(serviceName, checkName string) string {
return fmt.Sprintf(`
resource "google_compute_backend_service" "foobar" {
name = "%s"
health_checks = ["${google_compute_http_health_check.zero.name}"]
health_checks = ["${google_compute_http_health_check.zero.self_link}"]
}
resource "google_compute_http_health_check" "zero" {
@ -282,25 +254,6 @@ resource "google_compute_http_health_check" "zero" {
`, serviceName, checkName)
}
func testAccComputeBackendService_withInternalLoadBalancing(serviceName, checkName, region string) string {
return fmt.Sprintf(`
resource "google_compute_backend_service" "foobar" {
name = "%s"
health_checks = ["${google_compute_http_health_check.zero.self_link}"]
load_balancing_scheme = "INTERNAL"
region = "%s"
}
resource "google_compute_http_health_check" "zero" {
name = "%s"
request_path = "/"
check_interval_sec = 1
timeout_sec = 1
}
`, serviceName, region, checkName)
}
func testAccComputeBackendService_basicModified(serviceName, checkOne, checkTwo string) string {
return fmt.Sprintf(`
resource "google_compute_backend_service" "foobar" {

33
builtin/providers/google/resource_compute_forwarding_rule.go
View File

@ -5,7 +5,7 @@ import (
"log"
"github.com/hashicorp/terraform/helper/schema"
"google.golang.org/api/compute/v0.beta"
"google.golang.org/api/compute/v1"
"google.golang.org/api/googleapi"
)
@ -69,6 +69,7 @@ func resourceComputeForwardingRule() *schema.Resource {
Type: schema.TypeString,
Optional: true,
ForceNew: true,
Computed: true,
},
"port_range": &schema.Schema{
@ -77,6 +78,13 @@ func resourceComputeForwardingRule() *schema.Resource {
ForceNew: true,
},
"ports": &schema.Schema{
Type: schema.TypeSet,
Elem: &schema.Schema{Type: schema.TypeString},
Optional: true,
Set: schema.HashString,
},
"project": &schema.Schema{
Type: schema.TypeString,
Optional: true,
@ -100,6 +108,7 @@ func resourceComputeForwardingRule() *schema.Resource {
Type: schema.TypeString,
Optional: true,
ForceNew: true,
Computed: true,
},
},
}
@ -118,6 +127,12 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
return err
}
ps := d.Get("ports").(*schema.Set).List()
ports := make([]string, 0, len(ps))
for _, v := range ps {
ports = append(ports, v.(string))
}
frule := &compute.ForwardingRule{
BackendService: d.Get("backend_service").(string),
IPAddress: d.Get("ip_address").(string),
@ -127,12 +142,13 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
Name: d.Get("name").(string),
Network: d.Get("network").(string),
PortRange: d.Get("port_range").(string),
Ports: ports,
Subnetwork: d.Get("subnetwork").(string),
Target: d.Get("target").(string),
}
log.Printf("[DEBUG] ForwardingRule insert request: %#v", frule)
op, err := config.clientComputeBeta.ForwardingRules.Insert(
op, err := config.clientCompute.ForwardingRules.Insert(
project, region, frule).Do()
if err != nil {
return fmt.Errorf("Error creating ForwardingRule: %s", err)
@ -141,7 +157,7 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
// It probably maybe worked, so store the ID now
d.SetId(frule.Name)
err = computeOperationWaitRegionBeta(config, op, project, region, "Creating Fowarding Rule")
err = computeOperationWaitRegion(config, op, project, region, "Creating Fowarding Rule")
if err != nil {
return err
}
@ -167,13 +183,13 @@ func resourceComputeForwardingRuleUpdate(d *schema.ResourceData, meta interface{
if d.HasChange("target") {
target_name := d.Get("target").(string)
target_ref := &compute.TargetReference{Target: target_name}
op, err := config.clientComputeBeta.ForwardingRules.SetTarget(
op, err := config.clientCompute.ForwardingRules.SetTarget(
project, region, d.Id(), target_ref).Do()
if err != nil {
return fmt.Errorf("Error updating target: %s", err)
}
err = computeOperationWaitRegionBeta(config, op, project, region, "Updating Forwarding Rule")
err = computeOperationWaitRegion(config, op, project, region, "Updating Forwarding Rule")
if err != nil {
return err
}
@ -199,7 +215,7 @@ func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{})
return err
}
frule, err := config.clientComputeBeta.ForwardingRules.Get(
frule, err := config.clientCompute.ForwardingRules.Get(
project, region, d.Id()).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
@ -220,6 +236,7 @@ func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{})
d.Set("load_balancing_scheme", frule.LoadBalancingScheme)
d.Set("network", frule.Network)
d.Set("port_range", frule.PortRange)
d.Set("ports", frule.Ports)
d.Set("project", project)
d.Set("region", region)
d.Set("subnetwork", frule.Subnetwork)
@ -244,13 +261,13 @@ func resourceComputeForwardingRuleDelete(d *schema.ResourceData, meta interface{
// Delete the ForwardingRule
log.Printf("[DEBUG] ForwardingRule delete request")
op, err := config.clientComputeBeta.ForwardingRules.Delete(
op, err := config.clientCompute.ForwardingRules.Delete(
project, region, d.Id()).Do()
if err != nil {
return fmt.Errorf("Error deleting ForwardingRule: %s", err)
}
err = computeOperationWaitRegionBeta(config, op, project, region, "Deleting Forwarding Rule")
err = computeOperationWaitRegion(config, op, project, region, "Deleting Forwarding Rule")
if err != nil {
return err
}

8
builtin/providers/google/resource_compute_forwarding_rule_test.go
View File

@ -61,7 +61,7 @@ func TestAccComputeForwardingRule_internalLoadBalancing(t *testing.T) {
CheckDestroy: testAccCheckComputeForwardingRuleDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccComputeForwardingRule_internalLoadBalancing(serviceName, checkName, ruleName),
Config: testAccComputeForwardingRule_internalLoadBalancing(serviceName, "us-central1", checkName, ruleName),
Check: resource.ComposeTestCheckFunc(
testAccCheckComputeForwardingRuleExists(
"google_compute_forwarding_rule.foobar"),
@ -154,13 +154,14 @@ resource "google_compute_forwarding_rule" "foobar" {
`, addrName, poolName, ruleName)
}
func testAccComputeForwardingRule_internalLoadBalancing(serviceName, checkName, ruleName string) string {
func testAccComputeForwardingRule_internalLoadBalancing(serviceName, region, checkName, ruleName string) string {
return fmt.Sprintf(`
resource "google_compute_region_backend_service" "foobar-bs" {
name = "%s"
description = "Resource created for Terraform acceptance testing"
health_checks = ["${google_compute_health_check.zero.self_link}"]
load_balancing_scheme = "INTERNAL"
region = "%s"
}
resource "google_compute_health_check" "zero" {
name = "%s"
@ -177,6 +178,7 @@ resource "google_compute_forwarding_rule" "foobar" {
name = "%s"
load_balancing_scheme = "INTERNAL"
backend_service = "${google_compute_region_backend_service.foobar-bs.self_link}"
ports = ["80"]
}
`, serviceName, checkName, ruleName)
`, serviceName, region, checkName, ruleName)
}

73
builtin/providers/google/resource_compute_region_backend_service.go
View File

@ -4,12 +4,11 @@ import (
"bytes"
"fmt"
"log"
"os"
"regexp"
"github.com/hashicorp/terraform/helper/hashcode"
"github.com/hashicorp/terraform/helper/schema"
"google.golang.org/api/compute/v0.beta"
"google.golang.org/api/compute/v1"
"google.golang.org/api/googleapi"
)
@ -196,10 +195,9 @@ func resourceComputeRegionBackendServiceCreate(d *schema.ResourceData, meta inte
return err
}
fmt.Fprintf(os.Stderr, "[DEBUG] Creating new Region Backend Service: %#v", service) // DO NOT SUBMIT
log.Printf("[DEBUG] Creating new Region Backend Service: %#v", service)
op, err := config.clientComputeBeta.RegionBackendServices.Insert(
op, err := config.clientCompute.RegionBackendServices.Insert(
project, region, &service).Do()
if err != nil {
return fmt.Errorf("Error creating backend service: %s", err)
@ -209,7 +207,7 @@ func resourceComputeRegionBackendServiceCreate(d *schema.ResourceData, meta inte
d.SetId(service.Name)
err = computeOperationWaitGlobalBeta(config, op, project, "Creating Backend Service")
err = computeOperationWaitRegion(config, op, project, region, "Creating Region Backend Service")
if err != nil {
return err
}
@ -230,7 +228,7 @@ func resourceComputeRegionBackendServiceRead(d *schema.ResourceData, meta interf
return err
}
service, err := config.clientComputeBeta.RegionBackendServices.Get(
service, err := config.clientCompute.RegionBackendServices.Get(
project, region, d.Id()).Do()
if err != nil {
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
@ -310,7 +308,7 @@ func resourceComputeRegionBackendServiceUpdate(d *schema.ResourceData, meta inte
}
log.Printf("[DEBUG] Updating existing Backend Service %q: %#v", d.Id(), service)
op, err := config.clientComputeBeta.RegionBackendServices.Update(
op, err := config.clientCompute.RegionBackendServices.Update(
project, region, d.Id(), &service).Do()
if err != nil {
return fmt.Errorf("Error updating backend service: %s", err)
@ -318,7 +316,7 @@ func resourceComputeRegionBackendServiceUpdate(d *schema.ResourceData, meta inte
d.SetId(service.Name)
err = computeOperationWaitGlobalBeta(config, op, project, "Updating Backend Service")
err = computeOperationWaitRegion(config, op, project, region, "Updating Backend Service")
if err != nil {
return err
}
@ -340,13 +338,13 @@ func resourceComputeRegionBackendServiceDelete(d *schema.ResourceData, meta inte
}
log.Printf("[DEBUG] Deleting backend service %s", d.Id())
op, err := config.clientComputeBeta.RegionBackendServices.Delete(
op, err := config.clientCompute.RegionBackendServices.Delete(
project, region, d.Id()).Do()
if err != nil {
return fmt.Errorf("Error deleting backend service: %s", err)
}
err = computeOperationWaitGlobalBeta(config, op, project, "Deleting Backend Service")
err = computeOperationWaitRegion(config, op, project, region, "Deleting Backend Service")
if err != nil {
return err
}
@ -355,61 +353,6 @@ func resourceComputeRegionBackendServiceDelete(d *schema.ResourceData, meta inte
return nil
}
// func expandBackends(configured []interface{}) []*compute.Backend {
// backends := make([]*compute.Backend, 0, len(configured))
// for _, raw := range configured {
// data := raw.(map[string]interface{})
// b := compute.Backend{
// Group: data["group"].(string),
// }
// if v, ok := data["balancing_mode"]; ok {
// b.BalancingMode = v.(string)
// }
// if v, ok := data["capacity_scaler"]; ok {
// b.CapacityScaler = v.(float64)
// }
// if v, ok := data["description"]; ok {
// b.Description = v.(string)
// }
// if v, ok := data["max_rate"]; ok {
// b.MaxRate = int64(v.(int))
// }
// if v, ok := data["max_rate_per_instance"]; ok {
// b.MaxRatePerInstance = v.(float64)
// }
// if v, ok := data["max_utilization"]; ok {
// b.MaxUtilization = v.(float64)
// }
// backends = append(backends, &b)
// }
// return backends
// }
// func flattenBackends(backends []*compute.Backend) []map[string]interface{} {
// result := make([]map[string]interface{}, 0, len(backends))
// for _, b := range backends {
// data := make(map[string]interface{})
// data["balancing_mode"] = b.BalancingMode
// data["capacity_scaler"] = b.CapacityScaler
// data["description"] = b.Description
// data["group"] = b.Group
// data["max_rate"] = b.MaxRate
// data["max_rate_per_instance"] = b.MaxRatePerInstance
// data["max_utilization"] = b.MaxUtilization
// result = append(result, data)
// }
// return result
// }
func resourceGoogleComputeRegionBackendServiceBackendHash(v interface{}) int {
if v == nil {
return 0

9
builtin/providers/google/resource_compute_region_backend_service_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/hashicorp/terraform/helper/acctest"
"github.com/hashicorp/terraform/helper/resource"
"github.com/hashicorp/terraform/terraform"
"google.golang.org/api/compute/v0.beta"
"google.golang.org/api/compute/v1"
)
func TestAccComputeRegionBackendService_basic(t *testing.T) {
@ -122,7 +122,7 @@ func testAccCheckComputeRegionBackendServiceDestroy(s *terraform.State) error {
continue
}
_, err := config.clientComputeBeta.RegionBackendServices.Get(
_, err := config.clientCompute.RegionBackendServices.Get(
config.Project, config.Region, rs.Primary.ID).Do()
if err == nil {
return fmt.Errorf("Backend service still exists")
@ -145,7 +145,7 @@ func testAccCheckComputeRegionBackendServiceExists(n string, svc *compute.Backen
config := testAccProvider.Meta().(*Config)
found, err := config.clientComputeBeta.RegionBackendServices.Get(
found, err := config.clientCompute.RegionBackendServices.Get(
config.Project, config.Region, rs.Primary.ID).Do()
if err != nil {
return err
@ -259,13 +259,14 @@ resource "google_compute_region_backend_service" "foobar" {
name = "%s"
health_checks = ["${google_compute_health_check.zero.self_link}"]
load_balancing_scheme = "INTERNAL"
region = "%s"
}
resource "google_compute_health_check" "zero" {
name = "%s"
check_interval_sec = 1
timeout_sec = 1
tcp_health_check {
port = "80"
}

11
builtin/providers/google/resource_storage_object_acl.go
View File

@ -150,15 +150,8 @@ func resourceStorageObjectAclRead(d *schema.ResourceData, meta interface{}) erro
}
for _, v := range res.Items {
role := ""
entity := ""
for key, val := range v.(map[string]interface{}) {
if key == "role" {
role = val.(string)
} else if key == "entity" {
entity = val.(string)
}
}
role := v.Role
entity := v.Entity
if _, in := re_local_map[entity]; in {
role_entity = append(role_entity, fmt.Sprintf("%s:%s", role, entity))
log.Printf("[DEBUG]: saving re %s-%s", role, entity)