use v1 apis instead of beta

compute_operation.go

@@ -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)
 }

config.go

@@ -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 {

resource_compute_backend_service.go

@@ -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
 	}

resource_compute_backend_service_test.go

@@ -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" {

resource_compute_forwarding_rule.go

@@ -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
 	}

resource_compute_forwarding_rule_test.go

@@ -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)
 }

resource_compute_region_backend_service.go

@@ -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

resource_compute_region_backend_service_test.go

@@ -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,6 +259,7 @@ 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" {

resource_storage_object_acl.go

@@ -150,15 +150,8 @@ func resourceStorageObjectAclRead(d *schema.ResourceData, meta interface{}) erro
 		}
 
 		for _, v := range res.Items {
-			role := ""
+			role := v.Role
-			entity := ""
+			entity := v.Entity
-			for key, val := range v.(map[string]interface{}) {
-				if key == "role" {
-					role = val.(string)
-				} else if key == "entity" {
-					entity = val.(string)
-				}
-			}
 			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)