//
// Create creates the VM by
// 1. Generating SSH keys
// 2. Logs in to vSphere and gathers dc, datastore, network, resource pool and
// other information
// 3. Clones the VM template
// 4. Powers on the VM
// 5. Uploads the SSH key bundle
//
// Parameters:
// None
// Returns:
// (error): various errors from vSphere
//
func (d *Driver) Create() error {
var relocateSpec types.VirtualMachineRelocateSpec
log.Infof("Generating SSH Keypair...")
if err := ssh.GenerateSSHKey(d.GetSSHKeyPath()); err != nil {
return err
}
// Create context
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Query the inventory
c, err := d.vsphereLogin(ctx)
if err != nil {
return err
}
defer c.Logout(ctx)
// Create a new finder
f := find.NewFinder(c.Client, true)
dc, err := f.DatacenterOrDefault(ctx, d.Datacenter)
if err != nil {
return err
}
folders, err := dc.Folders(ctx)
if err != nil {
return err
}
folder := folders.VmFolder
f.SetDatacenter(dc)
dss, err := f.DatastoreOrDefault(ctx, d.Datastore)
if err != nil {
return err
}
rp, err := f.ResourcePoolOrDefault(ctx, d.Pool)
if err != nil {
// Pick default Resource Pool for Host System
hs, err := f.HostSystemOrDefault(ctx, d.HostSystem)
if err != nil {
log.Warnf("Unable to find host system ", err)
}
if hs != nil {
rp, err = hs.ResourcePool(ctx)
if err != nil {
return err
}
if hs != nil {
hostref := hs.Reference()
relocateSpec.Host = &hostref
}
} else {
return err
}
}
dcName, err := d.getDatacenterName(dc)
if err != nil {
return err
}
image, err := d.getVMTemplate(d.VMTemplate, dcName, c.Client)
if err != nil {
return err
}
var imageMoRef mo.VirtualMachine
err = image.Properties(ctx, image.Reference(), []string{"parent", "config.template", "resourcePool", "snapshot", "guest.toolsVersionStatus2", "config.guestFullName"}, &imageMoRef)
if err != nil {
return fmt.Errorf("Error reading base VM properties: %s", err)
}
// Create a CloneSpec to clone the VM
datastoreref := dss.Reference()
folderref := folder.Reference()
poolref := rp.Reference()
relocateSpec.Datastore = &datastoreref
relocateSpec.Folder = &folderref
relocateSpec.Pool = &poolref
spec := types.VirtualMachineConfigSpec{
Name: d.MachineName,
GuestId: "otherLinux64Guest",
Files: &types.VirtualMachineFileInfo{VmPathName: fmt.Sprintf("[%s]", dss.Name())},
NumCPUs: d.CPU,
MemoryMB: int64(d.Memory),
}
cloneSpec := types.VirtualMachineCloneSpec{
Config: &spec,
}
if imageMoRef.Snapshot != nil {
relocateSpec.DiskMoveType = "createNewChildDiskBacking"
cloneSpec.Snapshot = imageMoRef.Snapshot.CurrentSnapshot
} else {
return fmt.Errorf("No snapshots for template, cannot use for cloning")
}
if d.Network != "" {
// search for the first network card of the source
devices, err := image.Device(ctx)
if err != nil {
return fmt.Errorf("Error reading base VM devices: %s", err)
}
var card *types.VirtualEthernetCard
for _, device := range devices {
if c, ok := device.(types.BaseVirtualEthernetCard); ok {
card = c.GetVirtualEthernetCard()
break
}
}
if card == nil {
return fmt.Errorf("No network device found for the template.")
}
// get the new backing information
net, err := f.NetworkOrDefault(ctx, d.Network)
if err != nil {
return fmt.Errorf("Network not found: %s", err)
}
backing, err := net.EthernetCardBackingInfo(ctx)
if err != nil {
return fmt.Errorf("Network backing not found: %s", err)
}
netdev, err := object.EthernetCardTypes().CreateEthernetCard("vmxnet3", backing)
if err != nil {
return fmt.Errorf("Failed to create ethernet card: %s", err)
}
//set backing info
card.Backing = netdev.(types.BaseVirtualEthernetCard).GetVirtualEthernetCard().Backing
// prepare virtual device config spec for network card
configSpecs := []types.BaseVirtualDeviceConfigSpec{
&types.VirtualDeviceConfigSpec{
Operation: types.VirtualDeviceConfigSpecOperationEdit,
Device: card,
},
}
relocateSpec.DeviceChange = configSpecs
}
cloneSpec.Location = relocateSpec
task, err := image.Clone(ctx, folder, d.MachineName, cloneSpec)
if err != nil {
return fmt.Errorf("Error cloning vm: %s", err)
}
info, err := task.WaitForResult(ctx, nil)
if err != nil {
return fmt.Errorf("Error cloning vm: %s", err)
}
vmMoRef := info.Result.(types.ManagedObjectReference)
vm := object.NewVirtualMachine(c.Client, vmMoRef)
// Power On the VM
if err := d.Start(); err != nil {
return err
}
// Upload the bundle
return d.uploadBundle(vm.Reference(), ctx, c.Client)
}
func (cmd *clone) cloneVM(ctx context.Context) (*object.Task, error) {
// search for the first network card of the source
devices, err := cmd.VirtualMachine.Device(ctx)
if err != nil {
return nil, err
}
var card *types.VirtualEthernetCard
for _, device := range devices {
if c, ok := device.(types.BaseVirtualEthernetCard); ok {
card = c.GetVirtualEthernetCard()
break
}
}
if card == nil {
return nil, fmt.Errorf("No network device found.")
}
// get the new backing information
dev, err := cmd.NetworkFlag.Device()
if err != nil {
return nil, err
}
//set backing info
card.Backing = dev.(types.BaseVirtualEthernetCard).GetVirtualEthernetCard().Backing
// prepare virtual device config spec for network card
configSpecs := []types.BaseVirtualDeviceConfigSpec{
&types.VirtualDeviceConfigSpec{
Operation: types.VirtualDeviceConfigSpecOperationEdit,
Device: card,
},
}
folderref := cmd.Folder.Reference()
poolref := cmd.ResourcePool.Reference()
relocateSpec := types.VirtualMachineRelocateSpec{
DeviceChange: configSpecs,
Folder: &folderref,
Pool: &poolref,
}
if cmd.HostSystem != nil {
hostref := cmd.HostSystem.Reference()
relocateSpec.Host = &hostref
}
cloneSpec := &types.VirtualMachineCloneSpec{
Location: relocateSpec,
PowerOn: false,
Template: cmd.template,
}
// clone to storage pod
datastoreref := types.ManagedObjectReference{}
if cmd.StoragePod != nil && cmd.Datastore == nil {
storagePod := cmd.StoragePod.Reference()
// Build pod selection spec from config spec
podSelectionSpec := types.StorageDrsPodSelectionSpec{
StoragePod: &storagePod,
}
// Get the virtual machine reference
vmref := cmd.VirtualMachine.Reference()
// Build the placement spec
storagePlacementSpec := types.StoragePlacementSpec{
Folder: &folderref,
Vm: &vmref,
CloneName: cmd.name,
CloneSpec: cloneSpec,
PodSelectionSpec: podSelectionSpec,
Type: string(types.StoragePlacementSpecPlacementTypeClone),
}
// Get the storage placement result
storageResourceManager := object.NewStorageResourceManager(cmd.Client)
result, err := storageResourceManager.RecommendDatastores(ctx, storagePlacementSpec)
if err != nil {
return nil, err
}
// Get the recommendations
recommendations := result.Recommendations
if len(recommendations) == 0 {
return nil, fmt.Errorf("no recommendations")
}
// Get the first recommendation
datastoreref = recommendations[0].Action[0].(*types.StoragePlacementAction).Destination
} else if cmd.StoragePod == nil && cmd.Datastore != nil {
datastoreref = cmd.Datastore.Reference()
} else {
return nil, fmt.Errorf("Please provide either a datastore or a storagepod")
}
// Set the destination datastore
cloneSpec.Location.Datastore = &datastoreref
// Check if vmx already exists
if !cmd.force {
vmxPath := fmt.Sprintf("%s/%s.vmx", cmd.name, cmd.name)
datastore := object.NewDatastore(cmd.Client, datastoreref)
_, err := datastore.Stat(ctx, vmxPath)
if err == nil {
dsPath := cmd.Datastore.Path(vmxPath)
return nil, fmt.Errorf("File %s already exists", dsPath)
}
}
// check if customization specification requested
if len(cmd.customization) > 0 {
// get the customization spec manager
customizationSpecManager := object.NewCustomizationSpecManager(cmd.Client)
// check if customization specification exists
exists, err := customizationSpecManager.DoesCustomizationSpecExist(ctx, cmd.customization)
if err != nil {
return nil, err
}
if exists == false {
return nil, fmt.Errorf("Customization specification %s does not exists.", cmd.customization)
}
// get the customization specification
customSpecItem, err := customizationSpecManager.GetCustomizationSpec(ctx, cmd.customization)
if err != nil {
return nil, err
}
customSpec := customSpecItem.Spec
// set the customization
cloneSpec.Customization = &customSpec
}
// clone virtualmachine
return cmd.VirtualMachine.Clone(ctx, cmd.Folder, cmd.name, *cloneSpec)
}
func resourceVirtualMachineCreate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*vim25.Client)
dc_name := d.Get("datacenter").(string)
if dc_name == "" {
finder := find.NewFinder(client, false)
dc, err := finder.DefaultDatacenter(context.TODO())
if err != nil {
return fmt.Errorf("Error reading default datacenter: %s", err)
}
var dc_mo mo.Datacenter
err = dc.Properties(context.TODO(), dc.Reference(), []string{"name"}, &dc_mo)
if err != nil {
return fmt.Errorf("Error reading datacenter name: %s", err)
}
dc_name = dc_mo.Name
d.Set("datacenter", dc_name)
}
image_name := d.Get("image").(string)
image_ref, err := object.NewSearchIndex(client).FindByInventoryPath(context.TODO(), fmt.Sprintf("%s/vm/%s", dc_name, image_name))
if err != nil {
return fmt.Errorf("Error reading vm: %s", err)
}
if image_ref == nil {
return fmt.Errorf("Cannot find image %s", image_name)
}
image := image_ref.(*object.VirtualMachine)
var image_mo mo.VirtualMachine
err = image.Properties(context.TODO(), image.Reference(), []string{"parent", "config.template", "resourcePool", "snapshot", "guest.toolsVersionStatus2", "config.guestFullName"}, &image_mo)
if err != nil {
return fmt.Errorf("Error reading base VM properties: %s", err)
}
var folder_ref object.Reference
var folder *object.Folder
if d.Get("folder").(string) != "" {
folder_ref, err = object.NewSearchIndex(client).FindByInventoryPath(context.TODO(), fmt.Sprintf("%v/vm/%v", dc_name, d.Get("folder").(string)))
if err != nil {
return fmt.Errorf("Error reading folder: %s", err)
}
if folder_ref == nil {
return fmt.Errorf("Cannot find folder %s", d.Get("folder").(string))
}
folder = folder_ref.(*object.Folder)
} else {
folder = object.NewFolder(client, *image_mo.Parent)
}
host_name := d.Get("host").(string)
if host_name == "" {
if image_mo.Config.Template == true {
return fmt.Errorf("Image is a template, 'host' is a required")
} else {
var pool_mo mo.ResourcePool
err = property.DefaultCollector(client).RetrieveOne(context.TODO(), *image_mo.ResourcePool, []string{"owner"}, &pool_mo)
if err != nil {
return fmt.Errorf("Error reading resource pool of base VM: %s", err)
}
if strings.Contains(pool_mo.Owner.Value, "domain-s") {
var host_mo mo.ComputeResource
err = property.DefaultCollector(client).RetrieveOne(context.TODO(), pool_mo.Owner, []string{"name"}, &host_mo)
if err != nil {
return fmt.Errorf("Error reading host of base VM: %s", err)
}
host_name = host_mo.Name
} else if strings.Contains(pool_mo.Owner.Value, "domain-c") {
var cluster_mo mo.ClusterComputeResource
err = property.DefaultCollector(client).RetrieveOne(context.TODO(), pool_mo.Owner, []string{"name"}, &cluster_mo)
if err != nil {
return fmt.Errorf("Error reading cluster of base VM: %s", err)
}
host_name = cluster_mo.Name
} else {
return fmt.Errorf("Unknown compute resource format of base VM: %s", pool_mo.Owner.Value)
}
}
}
pool_name := d.Get("resource_pool").(string)
pool_ref, err := object.NewSearchIndex(client).FindByInventoryPath(context.TODO(), fmt.Sprintf("%v/host/%v/Resources/%v", dc_name, host_name, pool_name))
if err != nil {
return fmt.Errorf("Error reading resource pool: %s", err)
}
if pool_ref == nil {
return fmt.Errorf("Cannot find resource pool %s", pool_name)
}
var relocateSpec types.VirtualMachineRelocateSpec
var pool_mor types.ManagedObjectReference
pool_mor = pool_ref.Reference()
relocateSpec.Pool = &pool_mor
if d.Get("linked_clone").(bool) {
relocateSpec.DiskMoveType = "createNewChildDiskBacking"
}
var confSpec types.VirtualMachineConfigSpec
if d.Get("cpus") != nil {
confSpec.NumCPUs = d.Get("cpus").(int)
}
if d.Get("memory") != nil {
confSpec.MemoryMB = int64(d.Get("memory").(int))
}
params := d.Get("configuration_parameters").(map[string]interface{})
var ov []types.BaseOptionValue
if len(params) > 0 {
for k, v := range params {
key := k
value := v
o := types.OptionValue{
Key: key,
Value: &value,
}
ov = append(ov, &o)
}
confSpec.ExtraConfig = ov
}
cloneSpec := types.VirtualMachineCloneSpec{
Location: relocateSpec,
Config: &confSpec,
PowerOn: d.Get("power_on").(bool),
}
if d.Get("linked_clone").(bool) {
if image_mo.Snapshot == nil {
return fmt.Errorf("`linked_clone=true`, but image VM has no snapshots")
}
cloneSpec.Snapshot = image_mo.Snapshot.CurrentSnapshot
}
domain := d.Get("domain").(string)
ip_address := d.Get("ip_address").(string)
if domain != "" {
if image_mo.Guest.ToolsVersionStatus2 == "guestToolsNotInstalled" {
return fmt.Errorf("VMware tools are not installed in base VM")
}
if !strings.Contains(image_mo.Config.GuestFullName, "Linux") && !strings.Contains(image_mo.Config.GuestFullName, "CentOS") {
return fmt.Errorf("Guest customization is supported only for Linux. Base image OS is: %s", image_mo.Config.GuestFullName)
}
customizationSpec := types.CustomizationSpec{
GlobalIPSettings: types.CustomizationGlobalIPSettings{},
Identity: &types.CustomizationLinuxPrep{
HostName: &types.CustomizationVirtualMachineName{},
Domain: domain,
},
NicSettingMap: []types.CustomizationAdapterMapping{
{
Adapter: types.CustomizationIPSettings{},
},
},
}
if ip_address != "" {
mask := d.Get("subnet_mask").(string)
if mask == "" {
return fmt.Errorf("'subnet_mask' must be set, if static 'ip_address' is specified")
}
customizationSpec.NicSettingMap[0].Adapter.Ip = &types.CustomizationFixedIp{
IpAddress: ip_address,
}
customizationSpec.NicSettingMap[0].Adapter.SubnetMask = d.Get("subnet_mask").(string)
gateway := d.Get("gateway").(string)
if gateway != "" {
customizationSpec.NicSettingMap[0].Adapter.Gateway = []string{gateway}
}
} else {
customizationSpec.NicSettingMap[0].Adapter.Ip = &types.CustomizationDhcpIpGenerator{}
}
cloneSpec.Customization = &customizationSpec
} else if ip_address != "" {
return fmt.Errorf("'domain' must be set, if static 'ip_address' is specified")
}
task, err := image.Clone(context.TODO(), folder, d.Get("name").(string), cloneSpec)
if err != nil {
return fmt.Errorf("Error clonning vm: %s", err)
}
info, err := task.WaitForResult(context.TODO(), nil)
if err != nil {
return fmt.Errorf("Error clonning vm: %s", err)
}
vm_mor := info.Result.(types.ManagedObjectReference)
d.SetId(vm_mor.Value)
vm := object.NewVirtualMachine(client, vm_mor)
// workaround for https://github.com/vmware/govmomi/issues/218
if ip_address == "" && d.Get("power_on").(bool) {
ip, err := vm.WaitForIP(context.TODO())
if err != nil {
log.Printf("[ERROR] Cannot read ip address: %s", err)
} else {
d.Set("ip_address", ip)
d.SetConnInfo(map[string]string{
"type": "ssh",
"host": ip,
})
}
}
return nil
}