2014-08-25 23:23:28 +00:00
|
|
|
package google
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"log"
|
2017-05-19 00:28:16 +00:00
|
|
|
"regexp"
|
2017-05-30 13:16:12 +00:00
|
|
|
"strings"
|
2017-11-10 18:21:14 +00:00
|
|
|
"time"
|
2014-08-25 23:23:28 +00:00
|
|
|
|
|
|
|
"github.com/hashicorp/terraform/helper/schema"
|
2015-03-18 17:10:39 +00:00
|
|
|
"google.golang.org/api/compute/v1"
|
|
|
|
"google.golang.org/api/googleapi"
|
2014-08-25 23:23:28 +00:00
|
|
|
)
|
|
|
|
|
2017-05-19 00:28:16 +00:00
|
|
|
const (
|
|
|
|
computeDiskUserRegexString = "^(?:https://www.googleapis.com/compute/v1/projects/)?([-_a-zA-Z0-9]*)/zones/([-_a-zA-Z0-9]*)/instances/([-_a-zA-Z0-9]*)$"
|
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
computeDiskUserRegex = regexp.MustCompile(computeDiskUserRegexString)
|
|
|
|
)
|
|
|
|
|
2014-08-25 23:23:28 +00:00
|
|
|
func resourceComputeDisk() *schema.Resource {
|
|
|
|
return &schema.Resource{
|
|
|
|
Create: resourceComputeDiskCreate,
|
|
|
|
Read: resourceComputeDiskRead,
|
2017-06-05 17:19:57 +00:00
|
|
|
Update: resourceComputeDiskUpdate,
|
2014-08-25 23:23:28 +00:00
|
|
|
Delete: resourceComputeDiskDelete,
|
2017-05-30 13:16:12 +00:00
|
|
|
Importer: &schema.ResourceImporter{
|
|
|
|
State: schema.ImportStatePassthrough,
|
|
|
|
},
|
2014-08-25 23:23:28 +00:00
|
|
|
|
2017-11-10 18:21:14 +00:00
|
|
|
Timeouts: &schema.ResourceTimeout{
|
|
|
|
Create: schema.DefaultTimeout(5 * time.Minute),
|
|
|
|
Update: schema.DefaultTimeout(5 * time.Minute),
|
|
|
|
Delete: schema.DefaultTimeout(5 * time.Minute),
|
|
|
|
},
|
|
|
|
|
2014-08-25 23:23:28 +00:00
|
|
|
Schema: map[string]*schema.Schema{
|
|
|
|
"name": &schema.Schema{
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Required: true,
|
|
|
|
ForceNew: true,
|
|
|
|
},
|
|
|
|
|
|
|
|
"zone": &schema.Schema{
|
|
|
|
Type: schema.TypeString,
|
2017-12-06 22:30:04 +00:00
|
|
|
Optional: true,
|
2018-01-03 21:18:40 +00:00
|
|
|
Computed: true,
|
2014-08-25 23:23:28 +00:00
|
|
|
ForceNew: true,
|
|
|
|
},
|
|
|
|
|
2017-01-18 13:49:48 +00:00
|
|
|
"disk_encryption_key_raw": &schema.Schema{
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
ForceNew: true,
|
|
|
|
Sensitive: true,
|
|
|
|
},
|
|
|
|
|
|
|
|
"disk_encryption_key_sha256": &schema.Schema{
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Computed: true,
|
|
|
|
},
|
|
|
|
|
2014-08-25 23:23:28 +00:00
|
|
|
"image": &schema.Schema{
|
2017-08-05 19:45:20 +00:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
ForceNew: true,
|
2017-12-21 18:00:35 +00:00
|
|
|
DiffSuppressFunc: diskImageDiffSuppress,
|
2014-08-25 23:23:28 +00:00
|
|
|
},
|
|
|
|
|
2016-04-10 21:34:15 +00:00
|
|
|
"project": &schema.Schema{
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
2017-11-28 00:32:20 +00:00
|
|
|
Computed: true,
|
2016-04-10 21:34:15 +00:00
|
|
|
ForceNew: true,
|
|
|
|
},
|
|
|
|
|
2014-08-25 23:23:28 +00:00
|
|
|
"size": &schema.Schema{
|
|
|
|
Type: schema.TypeInt,
|
|
|
|
Optional: true,
|
2017-06-14 21:31:40 +00:00
|
|
|
Computed: true,
|
2014-08-25 23:23:28 +00:00
|
|
|
},
|
2014-10-07 04:59:09 +00:00
|
|
|
|
2016-04-10 21:34:15 +00:00
|
|
|
"self_link": &schema.Schema{
|
2014-10-10 21:50:35 +00:00
|
|
|
Type: schema.TypeString,
|
2016-04-10 21:34:15 +00:00
|
|
|
Computed: true,
|
2014-10-07 04:59:09 +00:00
|
|
|
},
|
2015-02-10 11:13:55 +00:00
|
|
|
|
2015-04-08 11:21:39 +00:00
|
|
|
"snapshot": &schema.Schema{
|
2017-08-05 19:45:20 +00:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
|
|
|
ForceNew: true,
|
2017-08-05 19:39:30 +00:00
|
|
|
DiffSuppressFunc: linkDiffSuppress,
|
2015-04-08 11:21:39 +00:00
|
|
|
},
|
|
|
|
|
2016-04-10 21:34:15 +00:00
|
|
|
"type": &schema.Schema{
|
2016-04-10 16:59:57 +00:00
|
|
|
Type: schema.TypeString,
|
|
|
|
Optional: true,
|
2017-06-14 21:31:40 +00:00
|
|
|
Default: "pd-standard",
|
2016-04-10 16:59:57 +00:00
|
|
|
ForceNew: true,
|
|
|
|
},
|
2017-08-18 23:10:47 +00:00
|
|
|
|
2017-05-19 00:28:16 +00:00
|
|
|
"users": &schema.Schema{
|
|
|
|
Type: schema.TypeList,
|
|
|
|
Computed: true,
|
|
|
|
Elem: &schema.Schema{Type: schema.TypeString},
|
|
|
|
},
|
2017-08-18 23:10:47 +00:00
|
|
|
|
|
|
|
"labels": &schema.Schema{
|
|
|
|
Type: schema.TypeMap,
|
|
|
|
Optional: true,
|
|
|
|
Elem: &schema.Schema{Type: schema.TypeString},
|
|
|
|
Set: schema.HashString,
|
|
|
|
},
|
|
|
|
|
|
|
|
"label_fingerprint": &schema.Schema{
|
|
|
|
Type: schema.TypeString,
|
|
|
|
Computed: true,
|
|
|
|
},
|
2014-08-25 23:23:28 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func resourceComputeDiskCreate(d *schema.ResourceData, meta interface{}) error {
|
|
|
|
config := meta.(*Config)
|
|
|
|
|
2016-04-10 16:59:57 +00:00
|
|
|
project, err := getProject(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2014-10-07 04:59:09 +00:00
|
|
|
// Get the zone
|
2017-12-06 22:30:04 +00:00
|
|
|
z, err := getZone(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
log.Printf("[DEBUG] Loading zone: %s", z)
|
2014-10-07 04:59:09 +00:00
|
|
|
zone, err := config.clientCompute.Zones.Get(
|
2017-12-06 22:30:04 +00:00
|
|
|
project, z).Do()
|
2014-10-07 04:59:09 +00:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf(
|
2017-12-06 22:30:04 +00:00
|
|
|
"Error loading zone '%s': %s", z, err)
|
2014-10-07 04:59:09 +00:00
|
|
|
}
|
|
|
|
|
2014-08-25 23:23:28 +00:00
|
|
|
// Build the disk parameter
|
|
|
|
disk := &compute.Disk{
|
|
|
|
Name: d.Get("name").(string),
|
|
|
|
SizeGb: int64(d.Get("size").(int)),
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we were given a source image, load that.
|
|
|
|
if v, ok := d.GetOk("image"); ok {
|
2015-01-30 01:00:02 +00:00
|
|
|
log.Printf("[DEBUG] Resolving image name: %s", v.(string))
|
2017-09-27 00:01:52 +00:00
|
|
|
imageUrl, err := resolveImage(config, project, v.(string))
|
2014-08-25 23:23:28 +00:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf(
|
2015-01-30 01:00:02 +00:00
|
|
|
"Error resolving image name '%s': %s",
|
2014-08-25 23:23:28 +00:00
|
|
|
v.(string), err)
|
|
|
|
}
|
|
|
|
|
2015-01-30 01:00:02 +00:00
|
|
|
disk.SourceImage = imageUrl
|
2017-01-24 00:45:06 +00:00
|
|
|
log.Printf("[DEBUG] Image name resolved to: %s", imageUrl)
|
2014-08-25 23:23:28 +00:00
|
|
|
}
|
|
|
|
|
2014-10-07 04:59:09 +00:00
|
|
|
if v, ok := d.GetOk("type"); ok {
|
|
|
|
log.Printf("[DEBUG] Loading disk type: %s", v.(string))
|
2017-09-27 00:01:52 +00:00
|
|
|
diskType, err := readDiskType(config, zone, project, v.(string))
|
2014-10-07 04:59:09 +00:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf(
|
|
|
|
"Error loading disk type '%s': %s",
|
|
|
|
v.(string), err)
|
|
|
|
}
|
|
|
|
|
|
|
|
disk.Type = diskType.SelfLink
|
|
|
|
}
|
|
|
|
|
2015-04-08 11:21:39 +00:00
|
|
|
if v, ok := d.GetOk("snapshot"); ok {
|
|
|
|
snapshotName := v.(string)
|
2017-03-06 21:59:40 +00:00
|
|
|
match, _ := regexp.MatchString("^https://www.googleapis.com/compute", snapshotName)
|
2017-02-27 11:45:36 +00:00
|
|
|
if match {
|
2017-03-06 21:59:40 +00:00
|
|
|
disk.SourceSnapshot = snapshotName
|
2017-02-27 11:45:36 +00:00
|
|
|
} else {
|
2017-03-06 21:59:40 +00:00
|
|
|
log.Printf("[DEBUG] Loading snapshot: %s", snapshotName)
|
|
|
|
snapshotData, err := config.clientCompute.Snapshots.Get(
|
|
|
|
project, snapshotName).Do()
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf(
|
|
|
|
"Error loading snapshot '%s': %s",
|
|
|
|
snapshotName, err)
|
|
|
|
}
|
|
|
|
disk.SourceSnapshot = snapshotData.SelfLink
|
2015-04-08 11:21:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 13:49:48 +00:00
|
|
|
if v, ok := d.GetOk("disk_encryption_key_raw"); ok {
|
|
|
|
disk.DiskEncryptionKey = &compute.CustomerEncryptionKey{}
|
|
|
|
disk.DiskEncryptionKey.RawKey = v.(string)
|
|
|
|
}
|
|
|
|
|
2017-08-18 23:10:47 +00:00
|
|
|
if _, ok := d.GetOk("labels"); ok {
|
|
|
|
disk.Labels = expandLabels(d)
|
|
|
|
}
|
|
|
|
|
2014-08-25 23:23:28 +00:00
|
|
|
op, err := config.clientCompute.Disks.Insert(
|
2017-12-06 22:30:04 +00:00
|
|
|
project, z, disk).Do()
|
2014-08-25 23:23:28 +00:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Error creating disk: %s", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// It probably maybe worked, so store the ID now
|
|
|
|
d.SetId(disk.Name)
|
|
|
|
|
2017-11-10 18:21:14 +00:00
|
|
|
err = computeOperationWaitTime(config.clientCompute, op, project, "Creating Disk", int(d.Timeout(schema.TimeoutCreate).Minutes()))
|
2014-08-26 05:44:27 +00:00
|
|
|
if err != nil {
|
2015-09-24 20:30:12 +00:00
|
|
|
return err
|
2014-08-26 05:44:27 +00:00
|
|
|
}
|
2014-08-25 23:23:28 +00:00
|
|
|
return resourceComputeDiskRead(d, meta)
|
|
|
|
}
|
|
|
|
|
2017-06-05 17:19:57 +00:00
|
|
|
func resourceComputeDiskUpdate(d *schema.ResourceData, meta interface{}) error {
|
|
|
|
config := meta.(*Config)
|
|
|
|
|
|
|
|
project, err := getProject(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-12-06 22:30:04 +00:00
|
|
|
z, err := getZone(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-08-18 23:10:47 +00:00
|
|
|
d.Partial(true)
|
2017-06-05 17:19:57 +00:00
|
|
|
if d.HasChange("size") {
|
|
|
|
rb := &compute.DisksResizeRequest{
|
|
|
|
SizeGb: int64(d.Get("size").(int)),
|
|
|
|
}
|
2017-06-14 21:31:40 +00:00
|
|
|
op, err := config.clientCompute.Disks.Resize(
|
2017-12-06 22:30:04 +00:00
|
|
|
project, z, d.Id(), rb).Do()
|
2017-06-05 17:19:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Error resizing disk: %s", err)
|
|
|
|
}
|
2017-08-18 23:10:47 +00:00
|
|
|
d.SetPartial("size")
|
|
|
|
|
2017-11-10 18:21:14 +00:00
|
|
|
err = computeOperationWaitTime(config.clientCompute, op, project, "Resizing Disk", int(d.Timeout(schema.TimeoutUpdate).Minutes()))
|
2017-06-14 21:31:40 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-06-05 17:19:57 +00:00
|
|
|
}
|
|
|
|
|
2017-08-18 23:10:47 +00:00
|
|
|
if d.HasChange("labels") {
|
|
|
|
zslr := compute.ZoneSetLabelsRequest{
|
|
|
|
Labels: expandLabels(d),
|
|
|
|
LabelFingerprint: d.Get("label_fingerprint").(string),
|
|
|
|
}
|
|
|
|
op, err := config.clientCompute.Disks.SetLabels(
|
2017-12-06 22:30:04 +00:00
|
|
|
project, z, d.Id(), &zslr).Do()
|
2017-08-18 23:10:47 +00:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Error when setting labels: %s", err)
|
|
|
|
}
|
|
|
|
d.SetPartial("labels")
|
|
|
|
|
2017-11-10 18:21:14 +00:00
|
|
|
err = computeOperationWaitTime(config.clientCompute, op, project, "Setting labels on disk", int(d.Timeout(schema.TimeoutUpdate).Minutes()))
|
2017-08-18 23:10:47 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
d.Partial(false)
|
|
|
|
|
2017-06-06 14:44:23 +00:00
|
|
|
return resourceComputeDiskRead(d, meta)
|
2017-06-05 17:19:57 +00:00
|
|
|
}
|
|
|
|
|
2014-08-25 23:23:28 +00:00
|
|
|
func resourceComputeDiskRead(d *schema.ResourceData, meta interface{}) error {
|
|
|
|
config := meta.(*Config)
|
|
|
|
|
2016-04-10 16:59:57 +00:00
|
|
|
project, err := getProject(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-05-30 13:16:12 +00:00
|
|
|
region, err := getRegion(d, config)
|
2014-08-25 23:23:28 +00:00
|
|
|
if err != nil {
|
2017-05-30 13:16:12 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
getDisk := func(zone string) (interface{}, error) {
|
|
|
|
return config.clientCompute.Disks.Get(project, zone, d.Id()).Do()
|
|
|
|
}
|
|
|
|
|
|
|
|
var disk *compute.Disk
|
2017-12-06 22:30:04 +00:00
|
|
|
if zone, _ := getZone(d, config); zone != "" {
|
2017-05-30 13:16:12 +00:00
|
|
|
disk, err = config.clientCompute.Disks.Get(
|
2017-12-06 22:30:04 +00:00
|
|
|
project, zone, d.Id()).Do()
|
2017-05-30 13:16:12 +00:00
|
|
|
if err != nil {
|
|
|
|
return handleNotFoundError(err, d, fmt.Sprintf("Disk %q", d.Get("name").(string)))
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// If the resource was imported, the only info we have is the ID. Try to find the resource
|
|
|
|
// by searching in the region of the project.
|
|
|
|
var resource interface{}
|
|
|
|
resource, err = getZonalResourceFromRegion(getDisk, region, config.clientCompute, project)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
disk = resource.(*compute.Disk)
|
2014-08-25 23:23:28 +00:00
|
|
|
}
|
|
|
|
|
2017-05-30 13:16:12 +00:00
|
|
|
d.Set("name", disk.Name)
|
2015-02-10 11:13:55 +00:00
|
|
|
d.Set("self_link", disk.SelfLink)
|
2018-01-03 21:18:40 +00:00
|
|
|
d.Set("type", GetResourceNameFromSelfLink(disk.Type))
|
|
|
|
d.Set("zone", GetResourceNameFromSelfLink(disk.Zone))
|
2017-05-30 13:16:12 +00:00
|
|
|
d.Set("size", disk.SizeGb)
|
|
|
|
d.Set("users", disk.Users)
|
2017-01-18 13:49:48 +00:00
|
|
|
if disk.DiskEncryptionKey != nil && disk.DiskEncryptionKey.Sha256 != "" {
|
|
|
|
d.Set("disk_encryption_key_sha256", disk.DiskEncryptionKey.Sha256)
|
|
|
|
}
|
2017-07-25 16:13:26 +00:00
|
|
|
|
2017-08-05 19:39:30 +00:00
|
|
|
d.Set("image", disk.SourceImage)
|
2017-06-06 14:44:23 +00:00
|
|
|
d.Set("snapshot", disk.SourceSnapshot)
|
2017-08-18 23:10:47 +00:00
|
|
|
d.Set("labels", disk.Labels)
|
|
|
|
d.Set("label_fingerprint", disk.LabelFingerprint)
|
2017-11-28 00:32:20 +00:00
|
|
|
d.Set("project", project)
|
2015-02-10 11:13:55 +00:00
|
|
|
|
2014-08-25 23:23:28 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func resourceComputeDiskDelete(d *schema.ResourceData, meta interface{}) error {
|
|
|
|
config := meta.(*Config)
|
|
|
|
|
2016-04-10 16:59:57 +00:00
|
|
|
project, err := getProject(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-12-06 22:30:04 +00:00
|
|
|
z, err := getZone(d, config)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-04-10 16:59:57 +00:00
|
|
|
|
2017-05-19 00:28:16 +00:00
|
|
|
// if disks are attached, they must be detached before the disk can be deleted
|
|
|
|
if instances, ok := d.Get("users").([]interface{}); ok {
|
|
|
|
type detachArgs struct{ project, zone, instance, deviceName string }
|
|
|
|
var detachCalls []detachArgs
|
|
|
|
self := d.Get("self_link").(string)
|
|
|
|
for _, instance := range instances {
|
|
|
|
if !computeDiskUserRegex.MatchString(instance.(string)) {
|
|
|
|
return fmt.Errorf("Unknown user %q of disk %q", instance, self)
|
|
|
|
}
|
|
|
|
matches := computeDiskUserRegex.FindStringSubmatch(instance.(string))
|
|
|
|
instanceProject := matches[1]
|
|
|
|
instanceZone := matches[2]
|
|
|
|
instanceName := matches[3]
|
|
|
|
i, err := config.clientCompute.Instances.Get(instanceProject, instanceZone, instanceName).Do()
|
|
|
|
if err != nil {
|
|
|
|
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
|
|
|
|
log.Printf("[WARN] instance %q not found, not bothering to detach disks", instance.(string))
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
return fmt.Errorf("Error retrieving instance %s: %s", instance.(string), err.Error())
|
|
|
|
}
|
|
|
|
for _, disk := range i.Disks {
|
|
|
|
if disk.Source == self {
|
2017-08-10 20:41:27 +00:00
|
|
|
zoneParts := strings.Split(i.Zone, "/")
|
2017-05-19 00:28:16 +00:00
|
|
|
detachCalls = append(detachCalls, detachArgs{
|
|
|
|
project: project,
|
2017-08-10 20:41:27 +00:00
|
|
|
zone: zoneParts[len(zoneParts)-1],
|
2017-05-19 00:28:16 +00:00
|
|
|
instance: i.Name,
|
|
|
|
deviceName: disk.DeviceName,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for _, call := range detachCalls {
|
|
|
|
op, err := config.clientCompute.Instances.DetachDisk(call.project, call.zone, call.instance, call.deviceName).Do()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Error detaching disk %s from instance %s/%s/%s: %s", call.deviceName, call.project,
|
|
|
|
call.zone, call.instance, err.Error())
|
|
|
|
}
|
2017-10-13 22:36:03 +00:00
|
|
|
err = computeOperationWait(config.clientCompute, op, call.project,
|
2017-05-19 00:28:16 +00:00
|
|
|
fmt.Sprintf("Detaching disk from %s/%s/%s", call.project, call.zone, call.instance))
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-26 05:44:27 +00:00
|
|
|
// Delete the disk
|
2014-08-25 23:23:28 +00:00
|
|
|
op, err := config.clientCompute.Disks.Delete(
|
2017-12-06 22:30:04 +00:00
|
|
|
project, z, d.Id()).Do()
|
2014-08-25 23:23:28 +00:00
|
|
|
if err != nil {
|
2016-05-16 18:57:04 +00:00
|
|
|
if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
|
|
|
|
log.Printf("[WARN] Removing Disk %q because it's gone", d.Get("name").(string))
|
|
|
|
// The resource doesn't exist anymore
|
|
|
|
d.SetId("")
|
|
|
|
return nil
|
|
|
|
}
|
2014-08-25 23:23:28 +00:00
|
|
|
return fmt.Errorf("Error deleting disk: %s", err)
|
|
|
|
}
|
|
|
|
|
2017-11-10 18:21:14 +00:00
|
|
|
err = computeOperationWaitTime(config.clientCompute, op, project, "Deleting Disk", int(d.Timeout(schema.TimeoutDelete).Minutes()))
|
2014-08-26 05:44:27 +00:00
|
|
|
if err != nil {
|
2015-09-24 20:30:12 +00:00
|
|
|
return err
|
2014-08-25 23:23:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
d.SetId("")
|
|
|
|
return nil
|
|
|
|
}
|
2017-12-21 18:00:35 +00:00
|
|
|
|
|
|
|
// We cannot suppress the diff for the case when family name is not part of the image name since we can't
|
|
|
|
// make a network call in a DiffSuppressFunc.
|
|
|
|
func diskImageDiffSuppress(_, old, new string, _ *schema.ResourceData) bool {
|
|
|
|
// 'old' is read from the API.
|
|
|
|
// It always has the format 'https://www.googleapis.com/compute/v1/projects/(%s)/global/images/(%s)'
|
|
|
|
matches := resolveImageLink.FindStringSubmatch(old)
|
|
|
|
if matches == nil {
|
|
|
|
// Image read from the API doesn't have the expected format. In practice, it should never happen
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
oldProject := matches[1]
|
|
|
|
oldName := matches[2]
|
|
|
|
|
|
|
|
// Partial or full self link family
|
|
|
|
if resolveImageProjectFamily.MatchString(new) {
|
|
|
|
// Value matches pattern "projects/{project}/global/images/family/{family-name}$"
|
|
|
|
matches := resolveImageProjectFamily.FindStringSubmatch(new)
|
|
|
|
newProject := matches[1]
|
|
|
|
newFamilyName := matches[2]
|
|
|
|
|
|
|
|
return diskImageProjectNameEquals(oldProject, oldName, newProject, newFamilyName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Partial or full self link image
|
|
|
|
if resolveImageProjectImage.MatchString(new) {
|
|
|
|
// Value matches pattern "projects/{project}/global/images/{image-name}$"
|
|
|
|
// or "projects/{project}/global/images/{image-name-latest}$"
|
|
|
|
matches := resolveImageProjectImage.FindStringSubmatch(new)
|
|
|
|
newProject := matches[1]
|
|
|
|
newImageName := matches[2]
|
|
|
|
|
|
|
|
return diskImageProjectNameEquals(oldProject, oldName, newProject, newImageName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Partial link without project family
|
|
|
|
if resolveImageGlobalFamily.MatchString(new) {
|
|
|
|
// Value is "global/images/family/{family-name}"
|
|
|
|
matches := resolveImageGlobalFamily.FindStringSubmatch(new)
|
|
|
|
familyName := matches[1]
|
|
|
|
|
|
|
|
return strings.Contains(oldName, familyName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Partial link without project image
|
|
|
|
if resolveImageGlobalImage.MatchString(new) {
|
|
|
|
// Value is "global/images/family/{image-name}" or "global/images/family/{image-name-latest}"
|
|
|
|
matches := resolveImageGlobalImage.FindStringSubmatch(new)
|
|
|
|
imageName := matches[1]
|
|
|
|
|
|
|
|
return strings.Contains(oldName, imageName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Family shorthand
|
|
|
|
if resolveImageFamilyFamily.MatchString(new) {
|
|
|
|
// Value is "family/{family-name}"
|
|
|
|
matches := resolveImageFamilyFamily.FindStringSubmatch(new)
|
|
|
|
familyName := matches[1]
|
|
|
|
|
|
|
|
return strings.Contains(oldName, familyName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Shorthand for image
|
|
|
|
if resolveImageProjectImageShorthand.MatchString(new) {
|
|
|
|
// Value is "{project}/{image-name}" or "{project}/{image-name-latest}"
|
|
|
|
matches := resolveImageProjectImageShorthand.FindStringSubmatch(new)
|
|
|
|
newProject := matches[1]
|
|
|
|
newName := matches[2]
|
|
|
|
|
|
|
|
return diskImageProjectNameEquals(oldProject, oldName, newProject, newName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Image or family only
|
|
|
|
if strings.Contains(oldName, new) {
|
|
|
|
// Value is "{image-name}" or "{family-name}" or "{image-name-latest}"
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func diskImageProjectNameEquals(project1, name1, project2, name2 string) bool {
|
|
|
|
// Convert short project name to full name
|
|
|
|
// For instance, centos => centos-cloud
|
|
|
|
fullProjectName, ok := imageMap[project2]
|
|
|
|
if ok {
|
|
|
|
project2 = fullProjectName
|
|
|
|
}
|
|
|
|
|
|
|
|
return project1 == project2 && strings.Contains(name1, name2)
|
|
|
|
}
|