package vsphere import ( "fmt" "log" "os" "regexp" "testing" "path/filepath" "github.com/hashicorp/terraform/helper/resource" "github.com/hashicorp/terraform/terraform" "github.com/vmware/govmomi" "github.com/vmware/govmomi/find" "github.com/vmware/govmomi/object" "github.com/vmware/govmomi/property" "github.com/vmware/govmomi/vim25/mo" "github.com/vmware/govmomi/vim25/types" "golang.org/x/net/context" ) /////// // Various ENV vars are used to setup these tests. Look for `os.Getenv` /////// // Base setup function to check that a template, and nic information is set // TODO needs some TLC - determine exactly how we want to do this func testBasicPreCheck(t *testing.T) { testAccPreCheck(t) if v := os.Getenv("VSPHERE_TEMPLATE"); v == "" { t.Fatal("env variable VSPHERE_TEMPLATE must be set for acceptance tests") } if v := os.Getenv("VSPHERE_IPV4_GATEWAY"); v == "" { t.Fatal("env variable VSPHERE_IPV4_GATEWAY must be set for acceptance tests") } if v := os.Getenv("VSPHERE_IPV4_ADDRESS"); v == "" { t.Fatal("env variable VSPHERE_IPV4_ADDRESS must be set for acceptance tests") } if v := os.Getenv("VSPHERE_NETWORK_LABEL"); v == "" { t.Fatal("env variable VSPHERE_NETWORK_LABEL must be set for acceptance tests") } } //// // Collects optional env vars used in the tests //// func setupBaseVars() (string, string) { var locationOpt string var datastoreOpt string if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { locationOpt += fmt.Sprintf(" datacenter = \"%s\"\n", v) } if v := os.Getenv("VSPHERE_CLUSTER"); v != "" { locationOpt += fmt.Sprintf(" cluster = \"%s\"\n", v) } if v := os.Getenv("VSPHERE_RESOURCE_POOL"); v != "" { locationOpt += fmt.Sprintf(" resource_pool = \"%s\"\n", v) } if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { datastoreOpt = fmt.Sprintf(" datastore = \"%s\"\n", v) } return locationOpt, datastoreOpt } //// // Structs and funcs used with DHCP data template //// type TestDHCPBodyData struct { template string locationOpt string datastoreOpt string label string } func (body TestDHCPBodyData) parseDHCPTemplateConfigWithTemplate(template string) string { return fmt.Sprintf( template, body.locationOpt, body.label, body.datastoreOpt, body.template, ) } const testAccCheckVSphereTemplate_dhcp = ` %s vcpu = 2 memory = 1024 network_interface { label = "%s" } disk { %s template = "%s" } } ` // replaces data in the above template func (body TestDHCPBodyData) parseDHCPTemplateConfig() string { return fmt.Sprintf( testAccCheckVSphereTemplate_dhcp, body.locationOpt, body.label, body.datastoreOpt, body.template, ) } func (body TestDHCPBodyData) testSprintfDHCPTemplateBodySecondArgDynamic(template string, arg string) string { return fmt.Sprintf( template, body.locationOpt, arg, body.label, body.datastoreOpt, body.template, ) } // returns variables that are used in DHCP tests func setupTemplateFuncDHCPData() TestDHCPBodyData { locationOpt, datastoreOpt := setupBaseVars() data := TestDHCPBodyData{ template: os.Getenv("VSPHERE_TEMPLATE"), label: os.Getenv("VSPHERE_NETWORK_LABEL_DHCP"), locationOpt: locationOpt, datastoreOpt: datastoreOpt, } // log.Printf("[DEBUG] basic vars= %v", data) return data } //// // Structs and funcs used with static ip data templates //// type TemplateBasicBodyVars struct { locationOpt string label string ipv4IpAddress string ipv4Prefix string ipv4Gateway string datastoreOpt string template string } // Takes a base template that has seven "%s" values in it, used by most fixed ip // tests func (body TemplateBasicBodyVars) testSprintfTemplateBody(template string) string { return fmt.Sprintf( template, body.locationOpt, body.label, body.ipv4IpAddress, body.ipv4Prefix, body.ipv4Gateway, body.datastoreOpt, body.template, ) } // setups variables used by fixed ip tests func setupTemplateBasicBodyVars() TemplateBasicBodyVars { locationOpt, datastoreOpt := setupBaseVars() prefix := os.Getenv("VSPHERE_IPV4_PREFIX") if prefix == "" { prefix = "24" } data := TemplateBasicBodyVars{ template: os.Getenv("VSPHERE_TEMPLATE"), ipv4Gateway: os.Getenv("VSPHERE_IPV4_GATEWAY"), label: os.Getenv("VSPHERE_NETWORK_LABEL"), ipv4IpAddress: os.Getenv("VSPHERE_IPV4_ADDRESS"), ipv4Prefix: prefix, locationOpt: locationOpt, datastoreOpt: datastoreOpt, } // log.Printf("[DEBUG] basic vars= %v", data) return data } //// // Basic data to create series of testing functions //// type TestFuncData struct { vm virtualMachine label string vmName string vmResource string numDisks string numCPU string mem string } // returns TestCheckFunc's that are used in many of our tests // mem defaults to 1024 // cpu defaults to 2 // disks defatuls to 1 // vmResource defaults to "terraform-test" // vmName defaults to "vsphere_virtual_machine.foo func (test TestFuncData) testCheckFuncBasic() ( resource.TestCheckFunc, resource.TestCheckFunc, resource.TestCheckFunc, resource.TestCheckFunc, resource.TestCheckFunc, resource.TestCheckFunc, resource.TestCheckFunc, resource.TestCheckFunc) { //log.Printf("[DEBUG] data= %v", test) mem := test.mem if mem == "" { mem = "1024" } cpu := test.numCPU if cpu == "" { cpu = "2" } disks := test.numDisks if disks == "" { disks = "1" } res := test.vmResource if res == "" { res = "terraform-test" } vmName := test.vmName if vmName == "" { vmName = "vsphere_virtual_machine.foo" } return testAccCheckVSphereVirtualMachineExists(vmName, &test.vm), resource.TestCheckResourceAttr(vmName, "name", res), resource.TestCheckResourceAttr(vmName, "vcpu", cpu), resource.TestMatchResourceAttr(vmName, "uuid", regexp.MustCompile("[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}")), resource.TestCheckResourceAttr(vmName, "memory", mem), resource.TestCheckResourceAttr(vmName, "disk.#", disks), resource.TestCheckResourceAttr(vmName, "network_interface.#", "1"), resource.TestCheckResourceAttr(vmName, "network_interface.0.label", test.label) } const testAccCheckVSphereVirtualMachineConfig_really_basic = ` resource "vsphere_virtual_machine" "foo" { name = "terraform-test" ` + testAccTemplateBasicBodyWithEnd // WARNING this is one of the base templates. You change this and you will // be impacting multiple tests const testAccTemplateBasicBody = ` %s vcpu = 2 memory = 1024 network_interface { label = "%s" ipv4_address = "%s" ipv4_prefix_length = %s ipv4_gateway = "%s" } disk { %s template = "%s" iops = 500 } ` const testAccTemplateBasicBodyWithEnd = testAccTemplateBasicBody + ` }` func TestAccVSphereVirtualMachine_basic(t *testing.T) { var vm virtualMachine basic_vars := setupTemplateBasicBodyVars() config := basic_vars.testSprintfTemplateBody(testAccCheckVSphereVirtualMachineConfig_really_basic) log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_really_basic) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testBasicPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: basic_vars.label}.testCheckFuncBasic(), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_debug = ` provider "vsphere" { client_debug = true } ` + testAccCheckVSphereVirtualMachineConfig_really_basic func TestAccVSphereVirtualMachine_client_debug(t *testing.T) { var vm virtualMachine basic_vars := setupTemplateBasicBodyVars() config := basic_vars.testSprintfTemplateBody(testAccCheckVSphereVirtualMachineConfig_debug) log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_debug) log.Printf("[DEBUG] template config= %s", config) test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: basic_vars.label}.testCheckFuncBasic() resource.Test(t, resource.TestCase{ PreCheck: func() { testBasicPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, testAccCheckDebugExists(), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_diskSCSICapacity = ` resource "vsphere_virtual_machine" "scsiCapacity" { name = "terraform-test" ` + testAccTemplateBasicBody + ` disk { size = 1 controller_type = "scsi-paravirtual" name = "one" } disk { size = 1 controller_type = "scsi-paravirtual" name = "two" } disk { size = 1 controller_type = "scsi-paravirtual" name = "three" } disk { size = 1 controller_type = "scsi-paravirtual" name = "four" } disk { size = 1 controller_type = "scsi-paravirtual" name = "five" } disk { size = 1 controller_type = "scsi-paravirtual" name = "six" } disk { size = 1 controller_type = "scsi-paravirtual" name = "seven" } } ` func TestAccVSphereVirtualMachine_diskSCSICapacity(t *testing.T) { var vm virtualMachine basic_vars := setupTemplateBasicBodyVars() config := basic_vars.testSprintfTemplateBody(testAccCheckVSphereVirtualMachineConfig_diskSCSICapacity) vmName := "vsphere_virtual_machine.scsiCapacity" test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: basic_vars.label, vmName: vmName, numDisks: "8"}.testCheckFuncBasic() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_diskSCSICapacity) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_initTypeEager = ` resource "vsphere_virtual_machine" "thickEagerZero" { name = "terraform-test" ` + testAccTemplateBasicBody + ` disk { size = 1 iops = 500 controller_type = "scsi" name = "one" } disk { size = 1 controller_type = "ide" type = "eager_zeroed" name = "two" } } ` func TestAccVSphereVirtualMachine_diskInitTypeEager(t *testing.T) { var vm virtualMachine basic_vars := setupTemplateBasicBodyVars() config := basic_vars.testSprintfTemplateBody(testAccCheckVSphereVirtualMachineConfig_initTypeEager) vmName := "vsphere_virtual_machine.thickEagerZero" test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: basic_vars.label, vmName: vmName, numDisks: "3"}.testCheckFuncBasic() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_initTypeEager) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, // FIXME dynmically calculate the hashes resource.TestCheckResourceAttr(vmName, "disk.294918912.type", "eager_zeroed"), resource.TestCheckResourceAttr(vmName, "disk.294918912.controller_type", "ide"), resource.TestCheckResourceAttr(vmName, "disk.1380467090.controller_type", "scsi"), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_initTypeLazy = ` resource "vsphere_virtual_machine" "lazy" { name = "terraform-test" ` + testAccTemplateBasicBody + ` disk { size = 1 iops = 500 controller_type = "scsi" name = "one" } disk { size = 1 controller_type = "ide" type = "lazy" name = "two" } } ` func TestAccVSphereVirtualMachine_diskInitTypeLazy(t *testing.T) { var vm virtualMachine basic_vars := setupTemplateBasicBodyVars() config := basic_vars.testSprintfTemplateBody(testAccCheckVSphereVirtualMachineConfig_initTypeLazy) vmName := "vsphere_virtual_machine.lazy" test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: basic_vars.label, vmName: vmName, numDisks: "3"}.testCheckFuncBasic() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_initTypeLazy) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, // FIXME dynmically calculate the hashes resource.TestCheckResourceAttr(vmName, "disk.692719290.type", "lazy"), resource.TestCheckResourceAttr(vmName, "disk.692719290.controller_type", "ide"), resource.TestCheckResourceAttr(vmName, "disk.531766495.controller_type", "scsi"), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_dhcp = ` resource "vsphere_virtual_machine" "bar" { name = "terraform-test" ` func TestAccVSphereVirtualMachine_dhcp(t *testing.T) { var vm virtualMachine data := setupTemplateFuncDHCPData() config := testAccCheckVSphereVirtualMachineConfig_dhcp + data.parseDHCPTemplateConfigWithTemplate(testAccCheckVSphereTemplate_dhcp) log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_dhcp+testAccCheckVSphereTemplate_dhcp) log.Printf("[DEBUG] config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: data.label, vmName: "vsphere_virtual_machine.bar"}.testCheckFuncBasic(), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_custom_configs = ` resource "vsphere_virtual_machine" "car" { name = "terraform-test-custom" custom_configuration_parameters { "foo" = "bar" "car" = "ferrari" "num" = 42 } enable_disk_uuid = true ` func TestAccVSphereVirtualMachine_custom_configs(t *testing.T) { var vm virtualMachine data := setupTemplateFuncDHCPData() config := testAccCheckVSphereVirtualMachineConfig_custom_configs + data.parseDHCPTemplateConfigWithTemplate(testAccCheckVSphereTemplate_dhcp) vmName := "vsphere_virtual_machine.car" res := "terraform-test-custom" test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: data.label, vmName: vmName, vmResource: res}.testCheckFuncBasic() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_custom_configs+testAccCheckVSphereTemplate_dhcp) log.Printf("[DEBUG] config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, testAccCheckVSphereVirtualMachineExistsHasCustomConfig(vmName, &vm), resource.TestCheckResourceAttr(vmName, "custom_configuration_parameters.foo", "bar"), resource.TestCheckResourceAttr(vmName, "custom_configuration_parameters.car", "ferrari"), resource.TestCheckResourceAttr(vmName, "custom_configuration_parameters.num", "42"), resource.TestCheckResourceAttr(vmName, "enable_disk_uuid", "true"), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_createInFolder = ` resource "vsphere_virtual_machine" "folder" { name = "terraform-test-folder" folder = "%s" ` func TestAccVSphereVirtualMachine_createInExistingFolder(t *testing.T) { var vm virtualMachine datacenter := os.Getenv("VSPHERE_DATACENTER") folder := "tf_test_cpureateInExistingFolder" data := setupTemplateFuncDHCPData() config := fmt.Sprintf(testAccCheckVSphereVirtualMachineConfig_createInFolder, folder, ) + data.parseDHCPTemplateConfig() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_createInFolder) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: resource.ComposeTestCheckFunc( testAccCheckVSphereVirtualMachineDestroy, removeVSphereFolder(datacenter, folder, ""), ), Steps: []resource.TestStep{ resource.TestStep{ PreConfig: func() { createVSphereFolder(datacenter, folder) }, Config: config, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: data.label, vmName: "vsphere_virtual_machine.folder", vmResource: "terraform-test-folder"}.testCheckFuncBasic(), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_createWithFolder = ` resource "vsphere_folder" "with_folder" { path = "%s" %s } resource "vsphere_virtual_machine" "with_folder" { name = "terraform-test-with-folder" folder = "${vsphere_folder.with_folder.path}" ` func TestAccVSphereVirtualMachine_createWithFolder(t *testing.T) { var vm virtualMachine var folderLocationOpt string var f folder if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { folderLocationOpt = fmt.Sprintf(" datacenter = \"%s\"\n", v) } folder := "tf_test_cpureateWithFolder" data := setupTemplateFuncDHCPData() vmName := "vsphere_virtual_machine.with_folder" test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: data.label, vmName: vmName, vmResource: "terraform-test-with-folder"}.testCheckFuncBasic() config := fmt.Sprintf(testAccCheckVSphereVirtualMachineConfig_createWithFolder, folder, folderLocationOpt, ) + data.parseDHCPTemplateConfig() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_createWithFolder+testAccCheckVSphereTemplate_dhcp) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: resource.ComposeTestCheckFunc( testAccCheckVSphereVirtualMachineDestroy, testAccCheckVSphereFolderDestroy, ), Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, testAccCheckVSphereFolderExists(vmName, &f), resource.TestCheckResourceAttr(vmName, "folder", folder), ), }, }, }) } const testAccCheckVsphereVirtualMachineConfig_cdrom = ` resource "vsphere_virtual_machine" "with_cdrom" { name = "terraform-test-with-cdrom" cdrom { datastore = "%s" path = "%s" } ` func TestAccVSphereVirtualMachine_createWithCdrom(t *testing.T) { var vm virtualMachine // FIXME check that these exist cdromDatastore := os.Getenv("VSPHERE_CDROM_DATASTORE") cdromPath := os.Getenv("VSPHERE_CDROM_PATH") vmName := "vsphere_virtual_machine.with_cdrom" data := setupTemplateFuncDHCPData() test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: data.label, vmName: vmName, vmResource: "terraform-test-with-cdrom"}.testCheckFuncBasic() config := fmt.Sprintf( testAccCheckVsphereVirtualMachineConfig_cdrom, cdromDatastore, cdromPath, ) + data.parseDHCPTemplateConfig() log.Printf("[DEBUG] template= %s", testAccCheckVsphereVirtualMachineConfig_cdrom) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, //resource.TestCheckResourceAttr( // "vsphere_virtual_machine.with_cdrom", "disk.4088143748.template", template), resource.TestCheckResourceAttr(vmName, "cdrom.#", "1"), resource.TestCheckResourceAttr(vmName, "cdrom.0.datastore", cdromDatastore), resource.TestCheckResourceAttr(vmName, "cdrom.0.path", cdromPath), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_withExistingVmdk = ` resource "vsphere_virtual_machine" "with_existing_vmdk" { name = "terraform-test-with-existing-vmdk" %s vcpu = 2 memory = 1024 network_interface { label = "%s" } disk { %s vmdk = "%s" bootable = true } disk { size = 1 iops = 500 name = "one" } } ` func TestAccVSphereVirtualMachine_createWithExistingVmdk(t *testing.T) { var vm virtualMachine vmdk_path := os.Getenv("VSPHERE_VMDK_PATH") data := setupTemplateFuncDHCPData() config := fmt.Sprintf( testAccCheckVSphereVirtualMachineConfig_withExistingVmdk, data.locationOpt, data.label, data.datastoreOpt, vmdk_path, ) log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_withExistingVmdk) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: data.label, vmName: "vsphere_virtual_machine.with_existing_vmdk", vmResource: "terraform-test-with-existing-vmdk", numDisks: "2"}.testCheckFuncBasic(), //resource.TestCheckResourceAttr( // "vsphere_virtual_machine.with_existing_vmdk", "disk.2393891804.vmdk", vmdk_path), //resource.TestCheckResourceAttr( // "vsphere_virtual_machine.with_existing_vmdk", "disk.2393891804.bootable", "true"), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_updateMemory = ` resource "vsphere_virtual_machine" "bar" { name = "terraform-test" %s vcpu = 2 memory = %s network_interface { label = "%s" } disk { %s template = "%s" } } ` func TestAccVSphereVirtualMachine_updateMemory(t *testing.T) { var vm virtualMachine data := setupTemplateFuncDHCPData() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_updateMemory) config := data.testSprintfDHCPTemplateBodySecondArgDynamic(testAccCheckVSphereVirtualMachineConfig_updateMemory, "1024") log.Printf("[DEBUG] template config= %s", config) configUpdate := data.testSprintfDHCPTemplateBodySecondArgDynamic(testAccCheckVSphereVirtualMachineConfig_updateMemory, "2048") log.Printf("[DEBUG] template configUpdate= %s", configUpdate) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: data.label, vmName: "vsphere_virtual_machine.bar"}.testCheckFuncBasic(), ), }, resource.TestStep{ Config: configUpdate, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: data.label, mem: "2048", vmName: "vsphere_virtual_machine.bar"}.testCheckFuncBasic(), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_updateVcpu = ` resource "vsphere_virtual_machine" "bar" { name = "terraform-test" %s vcpu = %s memory = 1024 network_interface { label = "%s" } disk { %s template = "%s" } } ` func TestAccVSphereVirtualMachine_updateVcpu(t *testing.T) { var vm virtualMachine data := setupTemplateFuncDHCPData() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_updateVcpu) config := data.testSprintfDHCPTemplateBodySecondArgDynamic(testAccCheckVSphereVirtualMachineConfig_updateVcpu, "2") log.Printf("[DEBUG] template config= %s", config) configUpdate := data.testSprintfDHCPTemplateBodySecondArgDynamic(testAccCheckVSphereVirtualMachineConfig_updateVcpu, "4") log.Printf("[DEBUG] template configUpdate= %s", configUpdate) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: data.label, vmName: "vsphere_virtual_machine.bar"}.testCheckFuncBasic(), ), }, resource.TestStep{ Config: configUpdate, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: data.label, vmName: "vsphere_virtual_machine.bar", numCPU: "4"}.testCheckFuncBasic(), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_ipv6 = ` resource "vsphere_virtual_machine" "ipv6" { name = "terraform-test-ipv6" %s vcpu = 2 memory = 1024 network_interface { label = "%s" %s ipv6_address = "%s" ipv6_prefix_length = 64 ipv6_gateway = "%s" } disk { %s template = "%s" iops = 500 } disk { size = 1 iops = 500 name = "one" } } ` func TestAccVSphereVirtualMachine_ipv4Andipv6(t *testing.T) { var vm virtualMachine data := setupTemplateBasicBodyVars() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_ipv6) vmName := "vsphere_virtual_machine.ipv6" test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: data.label, vmName: vmName, numDisks: "2", vmResource: "terraform-test-ipv6"}.testCheckFuncBasic() // FIXME test for this or warn?? ipv6Address := os.Getenv("VSPHERE_IPV6_ADDRESS") ipv6Gateway := os.Getenv("VSPHERE_IPV6_GATEWAY") ipv4Settings := fmt.Sprintf(` ipv4_address = "%s" ipv4_prefix_length = %s ipv4_gateway = "%s" `, data.ipv4IpAddress, data.ipv4Prefix, data.ipv4Gateway) config := fmt.Sprintf( testAccCheckVSphereVirtualMachineConfig_ipv6, data.locationOpt, data.label, ipv4Settings, ipv6Address, ipv6Gateway, data.datastoreOpt, data.template, ) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, resource.TestCheckResourceAttr(vmName, "network_interface.0.ipv4_address", data.ipv4IpAddress), resource.TestCheckResourceAttr(vmName, "network_interface.0.ipv4_gateway", data.ipv4Gateway), resource.TestCheckResourceAttr(vmName, "network_interface.0.ipv6_address", ipv6Address), resource.TestCheckResourceAttr(vmName, "network_interface.0.ipv6_gateway", ipv6Gateway), ), }, }, }) } func TestAccVSphereVirtualMachine_ipv6Only(t *testing.T) { var vm virtualMachine data := setupTemplateBasicBodyVars() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_ipv6) vmName := "vsphere_virtual_machine.ipv6" test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: data.label, vmName: vmName, numDisks: "2", vmResource: "terraform-test-ipv6"}.testCheckFuncBasic() // Checks for this will be handled when this code is merged with https://github.com/hashicorp/terraform/pull/7575. ipv6Address := os.Getenv("VSPHERE_IPV6_ADDRESS") ipv6Gateway := os.Getenv("VSPHERE_IPV6_GATEWAY") config := fmt.Sprintf( testAccCheckVSphereVirtualMachineConfig_ipv6, data.locationOpt, data.label, "", ipv6Address, ipv6Gateway, data.datastoreOpt, data.template, ) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, resource.TestCheckResourceAttr(vmName, "network_interface.0.ipv6_address", ipv6Address), resource.TestCheckResourceAttr(vmName, "network_interface.0.ipv6_gateway", ipv6Gateway), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_updateAddDisks = ` resource "vsphere_virtual_machine" "foo" { name = "terraform-test" ` + testAccTemplateBasicBody + ` disk { size = 1 iops = 500 name = "one" %s } disk { size = 1 iops = 500 name = "two" %s } disk { size = 1 iops = 500 name = "three" %s } } ` const testAccCheckVSphereVirtualMachineConfig_basic = ` resource "vsphere_virtual_machine" "foo" { name = "terraform-test" ` + testAccTemplateBasicBody + ` disk { size = 1 iops = 500 name = "one" } } ` func TestAccVSphereVirtualMachine_updateDisks(t *testing.T) { var vm virtualMachine basic_vars := setupTemplateBasicBodyVars() config_basic := basic_vars.testSprintfTemplateBody(testAccCheckVSphereVirtualMachineConfig_basic) log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_basic) log.Printf("[DEBUG] template config= %s", config_basic) config_add := fmt.Sprintf( testAccCheckVSphereVirtualMachineConfig_updateAddDisks, basic_vars.locationOpt, basic_vars.label, basic_vars.ipv4IpAddress, basic_vars.ipv4Prefix, basic_vars.ipv4Gateway, basic_vars.datastoreOpt, basic_vars.template, basic_vars.datastoreOpt, basic_vars.datastoreOpt, basic_vars.datastoreOpt, ) log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_basic) log.Printf("[DEBUG] template config= %s", config_add) config_del := basic_vars.testSprintfTemplateBody(testAccCheckVSphereVirtualMachineConfig_really_basic) log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_really_basic) log.Printf("[DEBUG] template config= %s", config_del) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config_basic, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: basic_vars.label, numDisks: "2"}.testCheckFuncBasic(), ), }, resource.TestStep{ Config: config_add, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: basic_vars.label, numDisks: "4"}.testCheckFuncBasic(), ), }, resource.TestStep{ Config: config_del, Check: resource.ComposeTestCheckFunc( TestFuncData{vm: vm, label: basic_vars.label, numDisks: "1"}.testCheckFuncBasic(), ), }, }, }) } const testAccCheckVSphereVirtualMachineConfig_mac_address = ` resource "vsphere_virtual_machine" "mac_address" { name = "terraform-mac-address" %s vcpu = 2 memory = 1024 network_interface { label = "%s" mac_address = "%s" } disk { %s template = "%s" } } ` // VSPHERE_NETWORK_MAC_ADDRESS needs to be set to run TestAccVSphereVirtualMachine_mac_address // use a basic NIC MAC address like 6:5c:89:2b:a0:64 func testMacPreCheck(t *testing.T) { testBasicPreCheck(t) // TODO should start do parse values to ensure they are correct // for instance // func ParseMAC(s string) (hw HardwareAddr, err error) if v := os.Getenv("VSPHERE_NETWORK_MAC_ADDRESS"); v == "" { t.Fatal("env variable VSPHERE_NETWORK_MAC_ADDRESS must be set for this acceptance test") } } // test new mac address feature func TestAccVSphereVirtualMachine_mac_address(t *testing.T) { var vm virtualMachine data := setupTemplateFuncDHCPData() vmName := "vsphere_virtual_machine.mac_address" macAddress := os.Getenv("VSPHERE_NETWORK_MAC_ADDRESS") log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_mac_address) config := fmt.Sprintf( testAccCheckVSphereVirtualMachineConfig_mac_address, data.locationOpt, data.label, macAddress, data.datastoreOpt, data.template, ) log.Printf("[DEBUG] template config= %s", config) test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: data.label, vmName: vmName, numDisks: "1", vmResource: "terraform-mac-address"}.testCheckFuncBasic() resource.Test(t, resource.TestCase{ PreCheck: func() { testMacPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, resource.TestCheckResourceAttr(vmName, "network_interface.0.mac_address", macAddress), ), }, }, }) } func testAccCheckVSphereVirtualMachineDestroy(s *terraform.State) error { client := testAccProvider.Meta().(*govmomi.Client) finder := find.NewFinder(client.Client, true) for _, rs := range s.RootModule().Resources { if rs.Type != "vsphere_virtual_machine" { continue } dc, err := finder.Datacenter(context.TODO(), rs.Primary.Attributes["datacenter"]) if err != nil { return fmt.Errorf("error %s", err) } dcFolders, err := dc.Folders(context.TODO()) if err != nil { return fmt.Errorf("error %s", err) } folder := dcFolders.VmFolder if len(rs.Primary.Attributes["folder"]) > 0 { si := object.NewSearchIndex(client.Client) folderRef, err := si.FindByInventoryPath( context.TODO(), fmt.Sprintf("%v/vm/%v", rs.Primary.Attributes["datacenter"], rs.Primary.Attributes["folder"])) if err != nil { return err } else if folderRef != nil { folder = folderRef.(*object.Folder) } } v, err := object.NewSearchIndex(client.Client).FindChild(context.TODO(), folder, rs.Primary.Attributes["name"]) if v != nil { return fmt.Errorf("Record still exists") } } return nil } func testAccCheckVSphereVirtualMachineExistsHasCustomConfig(n string, vm *virtualMachine) resource.TestCheckFunc { return func(s *terraform.State) error { rs, ok := s.RootModule().Resources[n] if !ok { return fmt.Errorf("Not found: %s", n) } if rs.Primary.ID == "" { return fmt.Errorf("No ID is set") } client := testAccProvider.Meta().(*govmomi.Client) finder := find.NewFinder(client.Client, true) dc, err := finder.Datacenter(context.TODO(), rs.Primary.Attributes["datacenter"]) if err != nil { return fmt.Errorf("error %s", err) } dcFolders, err := dc.Folders(context.TODO()) if err != nil { return fmt.Errorf("error %s", err) } _, err = object.NewSearchIndex(client.Client).FindChild(context.TODO(), dcFolders.VmFolder, rs.Primary.Attributes["name"]) if err != nil { return fmt.Errorf("error %s", err) } finder = finder.SetDatacenter(dc) instance, err := finder.VirtualMachine(context.TODO(), rs.Primary.Attributes["name"]) if err != nil { return fmt.Errorf("error %s", err) } var mvm mo.VirtualMachine collector := property.DefaultCollector(client.Client) if err := collector.RetrieveOne(context.TODO(), instance.Reference(), []string{"config.extraConfig"}, &mvm); err != nil { return fmt.Errorf("error %s", err) } var configMap = make(map[string]types.AnyType) if mvm.Config != nil && mvm.Config.ExtraConfig != nil && len(mvm.Config.ExtraConfig) > 0 { for _, v := range mvm.Config.ExtraConfig { value := v.GetOptionValue() configMap[value.Key] = value.Value } } else { return fmt.Errorf("error no ExtraConfig") } if configMap["foo"] == nil { return fmt.Errorf("error no ExtraConfig for 'foo'") } if configMap["foo"] != "bar" { return fmt.Errorf("error ExtraConfig 'foo' != bar") } if configMap["car"] == nil { return fmt.Errorf("error no ExtraConfig for 'car'") } if configMap["car"] != "ferrari" { return fmt.Errorf("error ExtraConfig 'car' != ferrari") } if configMap["num"] == nil { return fmt.Errorf("error no ExtraConfig for 'num'") } // todo this should be an int, getting back a string if configMap["num"] != "42" { return fmt.Errorf("error ExtraConfig 'num' != 42") } *vm = virtualMachine{ name: rs.Primary.ID, } return nil } } func testAccCheckDebugExists() resource.TestCheckFunc { return func(s *terraform.State) error { if _, err := os.Stat(filepath.Join(os.Getenv("HOME"), ".govmomi")); os.IsNotExist(err) { return fmt.Errorf("Debug logs not found") } return nil } } func testAccCheckVSphereVirtualMachineExists(n string, vm *virtualMachine) resource.TestCheckFunc { return func(s *terraform.State) error { if n == "" { return fmt.Errorf("No vm name passed in") } if vm == nil { return fmt.Errorf("No vm obj passed in") } rs, ok := s.RootModule().Resources[n] if !ok { return fmt.Errorf("Not found: %s", n) } if rs.Primary.ID == "" { return fmt.Errorf("No ID is set") } client := testAccProvider.Meta().(*govmomi.Client) finder := find.NewFinder(client.Client, true) dc, err := finder.Datacenter(context.TODO(), rs.Primary.Attributes["datacenter"]) if err != nil { return fmt.Errorf("error %s", err) } dcFolders, err := dc.Folders(context.TODO()) if err != nil { return fmt.Errorf("error %s", err) } folder := dcFolders.VmFolder if len(rs.Primary.Attributes["folder"]) > 0 { si := object.NewSearchIndex(client.Client) folderRef, err := si.FindByInventoryPath( context.TODO(), fmt.Sprintf("%v/vm/%v", rs.Primary.Attributes["datacenter"], rs.Primary.Attributes["folder"])) if err != nil { return err } else if folderRef != nil { folder = folderRef.(*object.Folder) } } _, err = object.NewSearchIndex(client.Client).FindChild(context.TODO(), folder, rs.Primary.Attributes["name"]) *vm = virtualMachine{ name: rs.Primary.ID, } return nil } } const testAccCheckVSphereVirtualMachineConfig_keepOnRemove = ` resource "vsphere_virtual_machine" "keep_disk" { name = "terraform-test" ` + testAccTemplateBasicBody + ` disk { size = 1 iops = 500 controller_type = "scsi" name = "one" keep_on_remove = true } } ` func TestAccVSphereVirtualMachine_keepOnRemove(t *testing.T) { var vm virtualMachine basic_vars := setupTemplateBasicBodyVars() config := basic_vars.testSprintfTemplateBody(testAccCheckVSphereVirtualMachineConfig_keepOnRemove) var datastore string if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { datastore = v } var datacenter string if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { datacenter = v } vmName := "vsphere_virtual_machine.keep_disk" test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: basic_vars.label, vmName: vmName, numDisks: "2"}.testCheckFuncBasic() log.Printf("[DEBUG] template= %s", testAccCheckVSphereVirtualMachineConfig_keepOnRemove) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, ), }, resource.TestStep{ Config: " ", Check: checkForDisk(datacenter, datastore, "terraform-test", "one.vmdk", true, true), }, }, }) } const testAccVSphereVirtualMachine_DetachUnknownDisks = ` resource "vsphere_virtual_machine" "detach_unkown_disks" { name = "terraform-test" ` + testAccTemplateBasicBody + ` detach_unknown_disks_on_delete = true disk { size = 1 iops = 500 controller_type = "scsi" name = "one" keep_on_remove = true } disk { size = 2 iops = 500 controller_type = "scsi" name = "two" keep_on_remove = false } disk { size = 3 iops = 500 controller_type = "scsi" name = "three" keep_on_remove = true } } ` func TestAccVSphereVirtualMachine_DetachUnknownDisks(t *testing.T) { var vm virtualMachine basic_vars := setupTemplateBasicBodyVars() config := basic_vars.testSprintfTemplateBody(testAccVSphereVirtualMachine_DetachUnknownDisks) var datastore string if v := os.Getenv("VSPHERE_DATASTORE"); v != "" { datastore = v } var datacenter string if v := os.Getenv("VSPHERE_DATACENTER"); v != "" { datacenter = v } vmName := "vsphere_virtual_machine.detach_unkown_disks" test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label := TestFuncData{vm: vm, label: basic_vars.label, vmName: vmName, numDisks: "4"}.testCheckFuncBasic() log.Printf("[DEBUG] template= %s", testAccVSphereVirtualMachine_DetachUnknownDisks) log.Printf("[DEBUG] template config= %s", config) resource.Test(t, resource.TestCase{ PreCheck: func() { testAccPreCheck(t) }, Providers: testAccProviders, CheckDestroy: testAccCheckVSphereVirtualMachineDestroy, Steps: []resource.TestStep{ resource.TestStep{ Config: config, Check: resource.ComposeTestCheckFunc( test_exists, test_name, test_cpu, test_uuid, test_mem, test_num_disk, test_num_of_nic, test_nic_label, ), }, resource.TestStep{ PreConfig: func() { createAndAttachDisk(t, "terraform-test", 1, datastore, "terraform-test/tf_custom_disk.vmdk", "lazy", "scsi", datacenter) }, Config: " ", Check: resource.ComposeTestCheckFunc( checkForDisk(datacenter, datastore, "terraform-test", "one.vmdk", true, false), checkForDisk(datacenter, datastore, "terraform-test", "two.vmdk", false, false), checkForDisk(datacenter, datastore, "terraform-test", "three.vmdk", true, false), checkForDisk(datacenter, datastore, "terraform-test", "tf_custom_disk.vmdk", true, true), ), }, }, }) } func createAndAttachDisk(t *testing.T, vmName string, size int, datastore string, diskPath string, diskType string, adapterType string, datacenter string) { client := testAccProvider.Meta().(*govmomi.Client) finder := find.NewFinder(client.Client, true) dc, err := finder.Datacenter(context.TODO(), datacenter) if err != nil { log.Printf("[ERROR] finding Datacenter %s: %v", datacenter, err) t.Fail() return } finder = finder.SetDatacenter(dc) ds, err := getDatastore(finder, datastore) if err != nil { log.Printf("[ERROR] getDatastore %s: %v", datastore, err) t.Fail() return } vm, err := finder.VirtualMachine(context.TODO(), vmName) if err != nil { log.Printf("[ERROR] finding VM %s: %v", vmName, err) t.Fail() return } err = addHardDisk(vm, int64(size), int64(0), diskType, ds, diskPath, adapterType) if err != nil { log.Printf("[ERROR] addHardDisk: %v", err) t.Fail() return } } func vmCleanup(dc *object.Datacenter, ds *object.Datastore, vmName string) error { client := testAccProvider.Meta().(*govmomi.Client) fileManager := object.NewFileManager(client.Client) task, err := fileManager.DeleteDatastoreFile(context.TODO(), ds.Path(vmName), dc) if err != nil { log.Printf("[ERROR] checkForDisk - Couldn't delete vm folder '%v': %v", vmName, err) return err } _, err = task.WaitForResult(context.TODO(), nil) if err != nil { log.Printf("[ERROR] checForDisk - Failed while deleting vm folder '%v': %v", vmName, err) return err } return nil } func checkForDisk(datacenter string, datastore string, vmName string, path string, exists bool, cleanup bool) resource.TestCheckFunc { return func(s *terraform.State) error { client := testAccProvider.Meta().(*govmomi.Client) finder := find.NewFinder(client.Client, true) dc, err := getDatacenter(client, datacenter) if err != nil { return err } finder.SetDatacenter(dc) ds, err := finder.Datastore(context.TODO(), datastore) if err != nil { log.Printf("[ERROR] checkForDisk - Couldn't find Datastore '%v': %v", datastore, err) return err } diskPath := vmName + "/" + path _, err = ds.Stat(context.TODO(), diskPath) if err != nil && exists { log.Printf("[ERROR] checkForDisk - Couldn't stat file '%v': %v", diskPath, err) return err } else if err == nil && !exists { errorMessage := fmt.Sprintf("checkForDisk - disk %s still exists", diskPath) err = vmCleanup(dc, ds, vmName) if err != nil { return fmt.Errorf("[ERROR] %s, cleanup also failed: %v", errorMessage, err) } return fmt.Errorf("[ERROR] %s", errorMessage) } if !cleanup || !exists { return nil } err = vmCleanup(dc, ds, vmName) if err != nil { return fmt.Errorf("[ERROR] cleanup failed: %v", err) } return nil } }