Import for compute_address now requires region/name. Changed the ID format.

google/resource_compute_address.go

@@ -6,6 +6,13 @@ import (
 
 	"github.com/hashicorp/terraform/helper/schema"
 	"google.golang.org/api/compute/v1"
+	"regexp"
+	"strings"
+)
+
+var (
+	computeAddressIdTemplate = "projects/%s/regions/%s/addresses/%s"
+	computeAddressLinkRegex  = regexp.MustCompile("projects/(.*)/regions/(.*)/addresses/(.*)$")
 )
 
 func resourceComputeAddress() *schema.Resource {
@@ -14,8 +21,12 @@ func resourceComputeAddress() *schema.Resource {
 		Read:   resourceComputeAddressRead,
 		Delete: resourceComputeAddressDelete,
 		Importer: &schema.ResourceImporter{
-			State: schema.ImportStatePassthrough,
+			State: resourceComputeAddressImportState,
 		},
+
+		SchemaVersion: 1,
+		MigrateState:  resourceComputeAddressMigrateState,
+
 		Schema: map[string]*schema.Schema{
 			"name": &schema.Schema{
 				Type:     schema.TypeString,
@@ -37,6 +48,7 @@ func resourceComputeAddress() *schema.Resource {
 			"region": &schema.Schema{
 				Type:     schema.TypeString,
 				Optional: true,
+				Computed: true,
 				ForceNew: true,
 			},
 
@@ -70,7 +82,11 @@ func resourceComputeAddressCreate(d *schema.ResourceData, meta interface{}) erro
 	}
 
 	// It probably maybe worked, so store the ID now
-	d.SetId(addr.Name)
+	d.SetId(computeAddressId{
+		Project: project,
+		Region:  region,
+		Name:    addr.Name,
+	}.canonicalId())
 
 	err = computeOperationWait(config, op, project, "Creating Address")
 	if err != nil {
@@ -83,55 +99,107 @@ func resourceComputeAddressCreate(d *schema.ResourceData, meta interface{}) erro
 func resourceComputeAddressRead(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 
-	region, err := getRegion(d, config)
+	addressId, err := parseComputeAddressId(d.Id(), config)
 	if err != nil {
 		return err
 	}
 
-	project, err := getProject(d, config)
-	if err != nil {
-		return err
-	}
+	log.Println("[rosbo] resourceComputeAddressRead", addressId)
 
 	addr, err := config.clientCompute.Addresses.Get(
-		project, region, d.Id()).Do()
+		addressId.Project, addressId.Region, addressId.Name).Do()
 	if err != nil {
 		return handleNotFoundError(err, d, fmt.Sprintf("Address %q", d.Get("name").(string)))
 	}
 
 	d.Set("address", addr.Address)
 	d.Set("self_link", addr.SelfLink)
 	d.Set("name", addr.Name)
+	d.Set("region", addr.Region)
 
 	return nil
 }
 
 func resourceComputeAddressDelete(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 
-	region, err := getRegion(d, config)
-	if err != nil {
-		return err
-	}
-
-	project, err := getProject(d, config)
+	addressId, err := parseComputeAddressId(d.Id(), config)
 	if err != nil {
 		return err
 	}
 
 	// Delete the address
 	log.Printf("[DEBUG] address delete request")
 	op, err := config.clientCompute.Addresses.Delete(
-		project, region, d.Id()).Do()
+		addressId.Project, addressId.Region, addressId.Name).Do()
 	if err != nil {
 		return fmt.Errorf("Error deleting address: %s", err)
 	}
 
-	err = computeOperationWait(config, op, project, "Deleting Address")
+	err = computeOperationWait(config, op, addressId.Project, "Deleting Address")
 	if err != nil {
 		return err
 	}
 
 	d.SetId("")
 	return nil
 }
+
+func resourceComputeAddressImportState(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
+	config := meta.(*Config)
+
+	addressId, err := parseComputeAddressId(d.Id(), config)
+	if err != nil {
+		return nil, err
+	}
+
+	d.SetId(addressId.canonicalId())
+
+	return []*schema.ResourceData{d}, nil
+}
+
+type computeAddressId struct {
+	Project string
+	Region  string
+	Name    string
+}
+
+func (s computeAddressId) canonicalId() string {
+	return fmt.Sprintf(computeAddressIdTemplate, s.Project, s.Region, s.Name)
+}
+
+func parseComputeAddressId(id string, config *Config) (*computeAddressId, error) {
+	var parts []string
+	if computeAddressLinkRegex.MatchString(id) {
+		parts = computeAddressLinkRegex.FindStringSubmatch(id)
+
+		return &computeAddressId{
+			Project: parts[1],
+			Region:  parts[2],
+			Name:    parts[3],
+		}, nil
+	} else {
+		parts = strings.Split(id, "/")
+	}
+
+	if len(parts) == 3 {
+		return &computeAddressId{
+			Project: parts[0],
+			Region:  parts[1],
+			Name:    parts[2],
+		}, nil
+	} else if len(parts) == 2 {
+		// Project is optional.
+		if config.Project == "" {
+			return nil, fmt.Errorf("Invalid compute address id. The default project for the provider must be set.")
+		}
+
+		return &computeAddressId{
+			Project: config.Project,
+			Region:  parts[0],
+			Name:    parts[1],
+		}, nil
+	}
+
+	return nil, fmt.Errorf("Invalid compute address id. Expecting resource link or {project}/{region}/{name} format.")
+}

google/resource_compute_address_migrate.go

@@ -0,0 +1,48 @@
+package google
+
+import (
+	"fmt"
+	"github.com/hashicorp/terraform/terraform"
+	"log"
+)
+
+func resourceComputeAddressMigrateState(v int, is *terraform.InstanceState, meta interface{}) (*terraform.InstanceState, error) {
+	if is.Empty() {
+		log.Println("[DEBUG] Empty InstanceState; nothing to migrate.")
+		return is, nil
+	}
+
+	switch v {
+	case 0:
+		log.Println("[INFO] Found Container Node Pool State v0; migrating to v1")
+		return migrateComputeAddressV0toV1(is, meta)
+	default:
+		return is, fmt.Errorf("Unexpected schema version: %d", v)
+	}
+}
+
+func migrateComputeAddressV0toV1(is *terraform.InstanceState, meta interface{}) (*terraform.InstanceState, error) {
+	log.Printf("[DEBUG] Attributes before migration: %#v", is.Attributes)
+	log.Printf("[DEBUG] ID before migration: %s", is.ID)
+
+	config := meta.(*Config)
+
+	project, err := getProjectFromInstanceState(is, config)
+	if err != nil {
+		return is, err
+	}
+
+	region, err := getRegionFromInstanceState(is, config)
+	if err != nil {
+		return is, err
+	}
+
+	is.ID = computeAddressId{
+		Project: project,
+		Region:  region,
+		Name:    is.Attributes["name"],
+	}.canonicalId()
+
+	log.Printf("[DEBUG] ID after migration: %s", is.ID)
+	return is, nil
+}

google/resource_compute_address_migrate_test.go

@@ -0,0 +1,65 @@
+package google
+
+import (
+	"github.com/hashicorp/terraform/terraform"
+	"testing"
+)
+
+func TestComputeAddressMigrateState(t *testing.T) {
+	cases := map[string]struct {
+		StateVersion int
+		Attributes   map[string]string
+		ExpectedId   string
+		Meta         interface{}
+	}{
+		"update id from name to region/name": {
+			StateVersion: 0,
+			Attributes: map[string]string{
+				"name": "address-1",
+			},
+			ExpectedId: "projects/gcp-project/regions/us-central1/addresses/address-1",
+			Meta:       &Config{Region: "us-central1", Project: "gcp-project"},
+		},
+	}
+
+	for tn, tc := range cases {
+		is := &terraform.InstanceState{
+			ID:         tc.Attributes["name"],
+			Attributes: tc.Attributes,
+		}
+
+		is, err := resourceComputeAddressMigrateState(tc.StateVersion, is, tc.Meta)
+
+		if err != nil {
+			t.Fatalf("bad: %s, err: %#v", tn, err)
+		}
+
+		if is.ID != tc.ExpectedId {
+			t.Fatalf("Id should be set to `%s` but is `%s`", tc.ExpectedId, is.ID)
+		}
+	}
+}
+
+func TestComputeAddressMigrateState_empty(t *testing.T) {
+	var is *terraform.InstanceState
+	var meta *Config
+
+	// should handle nil
+	is, err := resourceComputeAddressMigrateState(0, is, meta)
+
+	if err != nil {
+		t.Fatalf("err: %#v", err)
+	}
+
+	if is != nil {
+		t.Fatalf("expected nil instancestate, got: %#v", is)
+	}
+
+	// should handle non-nil but empty
+	is = &terraform.InstanceState{}
+	is, err = resourceComputeAddressMigrateState(0, is, meta)
+
+	if err != nil {
+		t.Fatalf("err: %#v", err)
+	}
+}

google/resource_compute_address_test.go

@@ -10,6 +10,64 @@ import (
 	"google.golang.org/api/compute/v1"
 )
 
+// Unit tests
+
+func TestComputeAddressIdParsing(t *testing.T) {
+	cases := map[string]struct {
+		ImportId            string
+		ExpectedError       bool
+		ExpectedCanonicalId string
+		Config              *Config
+	}{
+		"id is a full self link": {
+			ImportId:            "https://www.googleapis.com/compute/v1/projects/test-project/regions/us-central1/addresses/test-address",
+			ExpectedError:       false,
+			ExpectedCanonicalId: "projects/test-project/regions/us-central1/addresses/test-address",
+		},
+		"id is a partial self link": {
+			ImportId:            "projects/test-project/regions/us-central1/addresses/test-address",
+			ExpectedError:       false,
+			ExpectedCanonicalId: "projects/test-project/regions/us-central1/addresses/test-address",
+		},
+		"id is project/region/address": {
+			ImportId:            "test-project/us-central1/test-address",
+			ExpectedError:       false,
+			ExpectedCanonicalId: "projects/test-project/regions/us-central1/addresses/test-address",
+		},
+		"id is region/address": {
+			ImportId:            "us-central1/test-address",
+			ExpectedError:       false,
+			ExpectedCanonicalId: "projects/default-project/regions/us-central1/addresses/test-address",
+			Config:              &Config{Project: "default-project"},
+		},
+		"id has invalid format": {
+			ImportId:      "invalid",
+			ExpectedError: true,
+		},
+	}
+
+	for tn, tc := range cases {
+		addressId, err := parseComputeAddressId(tc.ImportId, tc.Config)
+
+		if tc.ExpectedError && err == nil {
+			t.Fatalf("bad: %s, expected an error", tn)
+		}
+
+		if err != nil {
+			if tc.ExpectedError {
+				continue
+			}
+			t.Fatalf("bad: %s, err: %#v", tn, err)
+		}
+
+		if addressId.canonicalId() != tc.ExpectedCanonicalId {
+			t.Fatalf("bad: %s, expected canonical id to be `%s` but is `%s`", tn, tc.ExpectedCanonicalId, addressId.canonicalId())
+		}
+	}
+}
+
+// Acceptance tests
+
 func TestAccComputeAddress_basic(t *testing.T) {
 	var addr compute.Address
 
@@ -37,8 +95,10 @@ func testAccCheckComputeAddressDestroy(s *terraform.State) error {
 			continue
 		}
 
-		_, err := config.clientCompute.Addresses.Get(
-			config.Project, config.Region, rs.Primary.ID).Do()
+		addressId, err := parseComputeAddressId(rs.Primary.ID, nil)
+
+		_, err = config.clientCompute.Addresses.Get(
+			config.Project, addressId.Region, addressId.Name).Do()
 		if err == nil {
 			return fmt.Errorf("Address still exists")
 		}
@@ -60,13 +120,15 @@ func testAccCheckComputeAddressExists(n string, addr *compute.Address) resource.
 
 		config := testAccProvider.Meta().(*Config)
 
+		addressId, err := parseComputeAddressId(rs.Primary.ID, nil)
+
 		found, err := config.clientCompute.Addresses.Get(
-			config.Project, config.Region, rs.Primary.ID).Do()
+			config.Project, addressId.Region, addressId.Name).Do()
 		if err != nil {
 			return err
 		}
 
-		if found.Name != rs.Primary.ID {
+		if found.Name != addressId.Name {
 			return fmt.Errorf("Addr not found")
 		}