GCP: mark attached disks for auto delete when deleting instance.

Author: Genevieve L'Esperance

gcp/compute/client.go

@@ -185,6 +185,10 @@ func (c client) ListDisks(zone string) ([]*gcpcompute.Disk, error) {
 	return list, nil
 }
 
+func (c client) SetDiskAutoDelete(zone, instance, disk string) error {
+	return c.wait(c.instances.SetDiskAutoDelete(c.project, zone, instance, true, disk))
+}
+
 func (c client) DeleteDisk(zone, disk string) error {
 	return c.wait(c.disks.Delete(c.project, zone, disk))
 }

gcp/compute/fakes/instances_client.go

@@ -42,6 +42,19 @@ type InstancesClient struct {
 		}
 		Stub func(string) ([]*gcpcompute.Instance, error)
 	}
+	SetDiskAutoDeleteCall struct {
+		sync.Mutex
+		CallCount int
+		Receives  struct {
+			Zone     string
+			Instance string
+			Disk     string
+		}
+		Returns struct {
+			Error error
+		}
+		Stub func(string, string, string) error
+	}
 }
 
 func (f *InstancesClient) DeleteInstance(param1 string, param2 string) error {
@@ -75,3 +88,15 @@ func (f *InstancesClient) ListInstances(param1 string) ([]*gcpcompute.Instance,
 	}
 	return f.ListInstancesCall.Returns.InstanceSlice, f.ListInstancesCall.Returns.Error
 }
+func (f *InstancesClient) SetDiskAutoDelete(param1 string, param2 string, param3 string) error {
+	f.SetDiskAutoDeleteCall.Lock()
+	defer f.SetDiskAutoDeleteCall.Unlock()
+	f.SetDiskAutoDeleteCall.CallCount++
+	f.SetDiskAutoDeleteCall.Receives.Zone = param1
+	f.SetDiskAutoDeleteCall.Receives.Instance = param2
+	f.SetDiskAutoDeleteCall.Receives.Disk = param3
+	if f.SetDiskAutoDeleteCall.Stub != nil {
+		return f.SetDiskAutoDeleteCall.Stub(param1, param2, param3)
+	}
+	return f.SetDiskAutoDeleteCall.Returns.Error
+}

gcp/compute/fakes/target_https_proxies_client.go

@@ -3,7 +3,7 @@ package fakes
 import (
 	"sync"
 
-	gcp "google.golang.org/api/compute/v1"
+	gcpcompute "google.golang.org/api/compute/v1"
 )
 
 type TargetHttpsProxiesClient struct {
@@ -22,10 +22,10 @@ type TargetHttpsProxiesClient struct {
 		sync.Mutex
 		CallCount int
 		Returns   struct {
-			TargetHttpsProxyList *gcp.TargetHttpsProxyList
+			TargetHttpsProxyList *gcpcompute.TargetHttpsProxyList
 			Error                error
 		}
-		Stub func() (*gcp.TargetHttpsProxyList, error)
+		Stub func() (*gcpcompute.TargetHttpsProxyList, error)
 	}
 }
 
@@ -39,7 +39,7 @@ func (f *TargetHttpsProxiesClient) DeleteTargetHttpsProxy(param1 string) error {
 	}
 	return f.DeleteTargetHttpsProxyCall.Returns.Error
 }
-func (f *TargetHttpsProxiesClient) ListTargetHttpsProxies() (*gcp.TargetHttpsProxyList, error) {
+func (f *TargetHttpsProxiesClient) ListTargetHttpsProxies() (*gcpcompute.TargetHttpsProxyList, error) {
 	f.ListTargetHttpsProxiesCall.Lock()
 	defer f.ListTargetHttpsProxiesCall.Unlock()
 	f.ListTargetHttpsProxiesCall.CallCount++

gcp/compute/instance.go

@@ -12,9 +12,10 @@ type Instance struct {
 	name        string
 	clearerName string
 	zone        string
+	diskNames   []string
 }
 
-func NewInstance(client instancesClient, name, zone string, tags *gcpcompute.Tags, networkInterfaces []*gcpcompute.NetworkInterface) Instance {
+func NewInstance(client instancesClient, name, zone string, tags *gcpcompute.Tags, networkInterfaces []*gcpcompute.NetworkInterface, disks []*gcpcompute.AttachedDisk) Instance {
 	clearerName := name
 
 	extra := []string{}
@@ -35,17 +36,29 @@ func NewInstance(client instancesClient, name, zone string, tags *gcpcompute.Tag
 		clearerName = fmt.Sprintf("%s (%s)", name, strings.Join(extra, ", "))
 	}
 
+	diskNames := []string{}
+	for _, d := range disks {
+		diskNames = append(diskNames, d.DeviceName)
+	}
+
 	return Instance{
 		client:      client,
 		name:        name,
 		clearerName: clearerName,
 		zone:        zone,
+		diskNames:   diskNames,
 	}
 }
 
 func (i Instance) Delete() error {
-	err := i.client.DeleteInstance(i.zone, i.name)
+	for _, d := range i.diskNames {
+		err := i.client.SetDiskAutoDelete(i.zone, i.name, d)
+		if err != nil {
+			return fmt.Errorf("Set Disk Auto Delete: %s", err)
+		}
+	}
 
+	err := i.client.DeleteInstance(i.zone, i.name)
 	if err != nil {
 		return fmt.Errorf("Delete: %s", err)
 	}

gcp/compute/instance_test.go

@@ -27,11 +27,12 @@ var _ = Describe("Instance", func() {
 		name = "banana"
 		zone = "zone"
 		networkInterfaces = []*gcpcompute.NetworkInterface{{Network: "https://www.googleapis.com/compute/v1/projects/id/global/networks/kiwi-network"}}
+		disks := []*gcpcompute.AttachedDisk{}
 		tags = &gcpcompute.Tags{Items: []string{"tag-1"}}
 
 		client.GetNetworkNameCall.Returns.Name = "kiwi-network"
 
-		instance = compute.NewInstance(client, name, zone, tags, networkInterfaces)
+		instance = compute.NewInstance(client, name, zone, tags, networkInterfaces, disks)
 	})
 
 	Describe("Delete", func() {
@@ -44,6 +45,24 @@ var _ = Describe("Instance", func() {
 			Expect(client.DeleteInstanceCall.Receives.Zone).To(Equal(zone))
 		})
 
+		Context("when there are attached disks", func() {
+			BeforeEach(func() {
+				disks := []*gcpcompute.AttachedDisk{{DeviceName: "yogurt"}}
+				instance = compute.NewInstance(client, name, zone, tags, networkInterfaces, disks)
+			})
+			It("marks all with auto_delete true", func() {
+				err := instance.Delete()
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(client.SetDiskAutoDeleteCall.CallCount).To(Equal(1))
+				Expect(client.SetDiskAutoDeleteCall.Receives.Instance).To(Equal(name))
+				Expect(client.SetDiskAutoDeleteCall.Receives.Zone).To(Equal(zone))
+				Expect(client.SetDiskAutoDeleteCall.Receives.Disk).To(Equal("yogurt"))
+
+				Expect(client.DeleteInstanceCall.CallCount).To(Equal(1))
+			})
+		})
+
 		Context("when the client fails to delete", func() {
 			BeforeEach(func() {
 				client.DeleteInstanceCall.Returns.Error = errors.New("the-error")

gcp/compute/instances.go

@@ -13,6 +13,8 @@ type instancesClient interface {
 	GetNetworkName(url string) (name string)
 	ListInstances(zone string) ([]*gcpcompute.Instance, error)
 	DeleteInstance(zone, instance string) error
+
+	SetDiskAutoDelete(zone, instance, disk string) error
 }
 
 type Instances struct {
@@ -43,7 +45,7 @@ func (i Instances) List(filter string) ([]common.Deletable, error) {
 
 	var resources []common.Deletable
 	for _, instance := range instances {
-		resource := NewInstance(i.client, instance.Name, i.zones[instance.Zone], instance.Tags, instance.NetworkInterfaces)
+		resource := NewInstance(i.client, instance.Name, i.zones[instance.Zone], instance.Tags, instance.NetworkInterfaces, instance.Disks)
 
 		if !strings.Contains(resource.Name(), filter) {
 			continue