Add xenorchestra_vm resource argument to opt into graceful termination

Add acceptance tests that verify if graceful termination was successful

docs/resources/vm.md

@@ -128,6 +128,7 @@ $ xo-cli xo.getAllObjects filter='json:{"id": "cf7b5d7d-3cd5-6b7c-5025-5c935c8cd
 * `vga` - (Optional) The video adapter the VM should use. Possible values include std and cirrus.
 * `videoram` - (Optional) The videoram option the VM should use. Possible values include 1, 2, 4, 8, 16
 * `start_delay` - (Optional) Number of seconds the VM should be delayed from starting
+* `use_graceful_termination` - (Optional) If true the VM will be shutdown before it is terminated when destroyed. Defaults to false.
 
 ## Timeouts
 

xoa/internal/mocks.go

@@ -46,3 +46,50 @@ func GetFailToStartAndHaltXOClient(d *schema.ResourceData) (interface{}, error)
 	}
 	return newFailToStartAndHaltClient(config)
 }
+
+// graceful is a mock client used to ensure that HaltVm
+// and StartVm is not called. This is useful for tests that need to ensure that
+// a Vm is modified without rebooting for CPU or memory changes
+type gracefulVmTerminationClient struct {
+	*client.Client
+}
+
+func (c gracefulVmTerminationClient) DeleteVm(id string) error {
+	vm, err := c.GetVm(client.Vm{Id: id})
+
+	if err != nil {
+		return err
+	}
+
+	if vm.PowerState != "Halted" {
+		return errors.New("mock client did not receive a stopped Vm. Graceful termination was bypassed!\n")
+	}
+
+	return c.Client.DeleteVm(id)
+}
+
+func newGracefulVmTerminationClient(config client.Config) (client.XOClient, error) {
+	xoClient, err := client.NewClient(config)
+
+	if err != nil {
+		return nil, err
+	}
+
+	c := xoClient.(*client.Client)
+
+	return &gracefulVmTerminationClient{c}, nil
+}
+
+func GetGracefulVmTerminationClient(d *schema.ResourceData) (interface{}, error) {
+	url := d.Get("url").(string)
+	username := d.Get("username").(string)
+	password := d.Get("password").(string)
+	insecure := d.Get("insecure").(bool)
+	config := client.Config{
+		Url:                url,
+		Username:           username,
+		Password:           password,
+		InsecureSkipVerify: insecure,
+	}
+	return newGracefulVmTerminationClient(config)
+}

xoa/provider_test.go

@@ -10,9 +10,11 @@ import (
 
 var testAccProviders map[string]*schema.Provider
 var testAccFailToStartAndHaltProviders map[string]*schema.Provider
+var testAccGracefulVmTerminationProviders map[string]*schema.Provider
 
 var testAccProvider *schema.Provider
 var testAccFailToStartHaltVmProvider *schema.Provider
+var testAccGracefulVmTerminationProvider *schema.Provider
 
 func init() {
 	testAccProvider = Provider()
@@ -25,6 +27,12 @@ func init() {
 	testAccFailToStartAndHaltProviders = map[string]*schema.Provider{
 		"xenorchestra": testAccFailToStartHaltVmProvider,
 	}
+
+	testAccGracefulVmTerminationProvider = Provider()
+	testAccGracefulVmTerminationProvider.ConfigureFunc = internal.GetGracefulVmTerminationClient
+	testAccGracefulVmTerminationProviders = map[string]*schema.Provider{
+		"xenorchestra": testAccGracefulVmTerminationProvider,
+	}
 }
 
 func testAccPreCheck(t *testing.T) {

xoa/resource_xenorchestra_vm.go

@@ -175,6 +175,11 @@ func resourceVmSchema() map[string]*schema.Schema {
 			Default:  0,
 			Optional: true,
 		},
+		"use_graceful_termination": &schema.Schema{
+			Type:     schema.TypeBool,
+			Default:  false,
+			Optional: true,
+		},
 		// TODO: (#145) Uncomment this once issues with secure_boot have been figured out
 		// "secure_boot": &schema.Schema{
 		// 	Type:     schema.TypeBool,
@@ -832,24 +837,24 @@ func resourceVmUpdate(d *schema.ResourceData, m interface{}) error {
 
 func resourceVmDelete(d *schema.ResourceData, m interface{}) error {
 	c := m.(client.XOClient)
+	gracefulTermination := d.Get("use_graceful_termination").(bool)
+	vmId := d.Id()
 
-	vmReq := client.Vm{
-		Id: d.Id(),
-	}
-
-	vm, err := c.GetVm(vmReq)
-	if err != nil {
-		return err
-	}
-
-	if vm.PowerState == "Running" {
-		err = c.HaltVm(vmReq.Id)
+	if gracefulTermination {
+		vm, err := c.GetVm(client.Vm{Id: vmId})
 		if err != nil {
 			return err
 		}
+
+		if vm.PowerState == "Running" {
+			err = c.HaltVm(vmId)
+			if err != nil {
+				return err
+			}
+		}
 	}
 
-	err = c.DeleteVm(d.Id())
+	err := c.DeleteVm(vmId)
 	if err != nil {
 		return err
 	}

xoa/resource_xenorchestra_vm_test.go

@@ -960,8 +960,30 @@ func TestAccXenorchestraVm_createWithMutipleDisks(t *testing.T) {
 	})
 }
 
+func TestAccXenorchestraVm_gracefulTermination(t *testing.T) {
+	resourceName := "xenorchestra_vm.bar"
+	vmName := fmt.Sprintf("%s - %s", accTestPrefix, t.Name())
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccGracefulVmTerminationProviders,
+		CheckDestroy: testAccCheckXenorchestraVmDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccVmConfigWithGracefulTermination(vmName),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					testAccVmExists(resourceName),
+					resource.TestCheckResourceAttrSet(resourceName, "id")),
+			},
+			{
+				Config:  testAccVmConfigWithGracefulTermination(vmName),
+				Destroy: true,
+			},
+		},
+	})
+}
+
 // Reference: https://github.com/terra-farm/terraform-provider-xenorchestra/pull/212
-func TestAccXenorchestraVm_shutdownVmIsProperlyTerminated(t *testing.T) {
+func TestAccXenorchestraVm_gracefulTerminationForShutdownVm(t *testing.T) {
 	resourceName := "xenorchestra_vm.bar"
 	vmName := fmt.Sprintf("%s - %s", accTestPrefix, t.Name())
 	shutdownVm := func() {
@@ -982,11 +1004,11 @@ func TestAccXenorchestraVm_shutdownVmIsProperlyTerminated(t *testing.T) {
 	}
 	resource.ParallelTest(t, resource.TestCase{
 		PreCheck:     func() { testAccPreCheck(t) },
-		Providers:    testAccProviders,
+		Providers:    testAccGracefulVmTerminationProviders,
 		CheckDestroy: testAccCheckXenorchestraVmDestroy,
 		Steps: []resource.TestStep{
 			{
-				Config: testAccVmConfig(vmName),
+				Config: testAccVmConfigWithGracefulTermination(vmName),
 				Check: resource.ComposeAggregateTestCheckFunc(
 					testAccVmExists(resourceName),
 					resource.TestCheckResourceAttrSet(resourceName, "id")),
@@ -1706,6 +1728,35 @@ resource "xenorchestra_vm" "bar" {
 `, accDefaultNetwork.NameLabel, accTestPool.Id, vmName, accDefaultSr.Id)
 }
 
+func testAccVmConfigWithGracefulTermination(vmName string) string {
+	return testAccCloudConfigConfig(fmt.Sprintf("vm-template-%s", vmName), "template") + testAccTemplateConfig() + fmt.Sprintf(`
+data "xenorchestra_network" "network" {
+    name_label = "%s"
+    pool_id = "%s"
+}
+
+resource "xenorchestra_vm" "bar" {
+    memory_max = 4295000000
+    cpus  = 1
+    cloud_config = "${xenorchestra_cloud_config.bar.template}"
+    name_label = "%s"
+    name_description = "description"
+    template = "${data.xenorchestra_template.template.id}"
+    network {
+	network_id = "${data.xenorchestra_network.network.id}"
+    }
+
+    disk {
+      sr_id = "%s"
+      name_label = "disk 1"
+      size = 10001317888
+    }
+
+    use_graceful_termination = true
+}
+`, accDefaultNetwork.NameLabel, accTestPool.Id, vmName, accDefaultSr.Id)
+}
+
 func testAccVmConfigPXEBoot(vmName string) string {
 	return testAccCloudConfigConfig(fmt.Sprintf("vm-template-%s", vmName), "template") + testAccNonDefaultTemplateConfig(disklessTestTemplate.NameLabel) + fmt.Sprintf(`
 data "xenorchestra_network" "network" {