def run(self, vm_id, vm_name, power_onoff, vsphere=None):
"""
Set power state of targetted virtual machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- vsphere: Pre-configured vsphere connection details (config.yaml)
- power_onoff: Desired powerstate.
Returns:
- dict: State true/false
"""
# check I have information to find a VM
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
# convert ids to stubs
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
if not vm:
raise Exception('Error: Unable to find VM')
if power_onoff == "poweroff":
task = vm.PowerOffVM_Task()
elif power_onoff == "poweron":
task = vm.PowerOnVM_Task()
while task.info.state == vim.TaskInfo.State.running:
eventlet.sleep(1)
return {'state': str(task.info.state)}
def run(self, vm_id, vm_name, power_onoff, vsphere=None):
"""
Set power state of targetted virtual machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- vsphere: Pre-configured vsphere connection details (config.yaml)
- power_onoff: Desired powerstate.
Returns:
- dict: State true/false
"""
# check I have information to find a VM
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
# convert ids to stubs
vm = inventory.get_virtualmachine(self.si_content, moid=vm_id, name=vm_name)
if not vm:
raise Exception("Error: Unable to find VM")
if power_onoff == "poweroff":
task = vm.PowerOffVM_Task()
elif power_onoff == "poweron":
task = vm.PowerOnVM_Task()
while task.info.state == vim.TaskInfo.State.running:
eventlet.sleep(1)
return {"state": str(task.info.state)}
def run(self, vm_id, vm_name, cpu_edit, mem_edit, vsphere=None):
"""
Edit CPU and/or Memory allocated to Virtual Machine
Args:
- vm_id: Moid of the virtual machine targetted (vm-xxxx)
- vm_name: Name of Virtual Machine within vsphere
- vsphere: Pre-configured vsphere connection details (config.yaml)
- cpu_edit: Number of vCPUs to allocate
- mem_edit: Ammount of memory to assign (GB)
Returns:
- state: success or failure
"""
# check a means of finding the VM has been provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
spec = vim.vm.ConfigSpec()
if cpu_edit:
spec.numCPUs = cpu_edit
if mem_edit:
spec.memoryMB = mem_edit * 1024
task = vm.ReconfigVM_Task(spec)
self._wait_for_task(task)
return {'state': str(task.info.state)}
def run(self, vm_id, vm_name, datastore_cluster, datastore, disk_size,
provision_type):
# ensure that minimal inputs are provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
spec = vim.vm.ConfigSpec()
hdd_unit_number = self.get_next_unit_number(vm)
ctrl_key = self.get_controller_key(vm)
# Prepare new Disk configuration
disk_changes = []
disk_spec = vim.vm.device.VirtualDeviceSpec()
disk_spec.fileOperation = "create"
disk_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
disk_spec.device = vim.vm.device.VirtualDisk()
disk_spec.device.backing =\
vim.vm.device.VirtualDisk.FlatVer2BackingInfo()
disk_spec.device.backing.diskMode = "persistent"
if provision_type == 'thin':
disk_spec.device.backing.thinProvisioned = True
disk_spec.device.unitNumber = hdd_unit_number
disk_spec.device.capacityInKB = int(disk_size) * 1024 * 1024
disk_spec.device.controllerKey = ctrl_key
# If Datastore Cluster is provided attach Disk via that
if datastore_cluster:
ds_clust_obj = inventory.get_datastore_cluster(
self.si_content, name=datastore_cluster)
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
srm = self.si_content.storageResourceManager
storage_placement_spec = self.get_storage_placement_spec(
ds_clust_obj, vm, spec)
datastores = srm.RecommendDatastores(
storageSpec=storage_placement_spec)
if not datastores.recommendations:
sys.stderr.write('Skipping as No datastore Recommendations')
add_disk_task = srm.ApplyStorageDrsRecommendation_Task(
datastores.recommendations[0].key)
elif datastore:
datastore_obj = inventory.get_datastore(self.si_content,
name=datastore)
disk_spec.device.backing.datastore = datastore_obj
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
add_disk_task = vm.ReconfigVM_Task(spec)
else:
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
add_disk_task = vm.ReconfigVM_Task(spec)
successfully_added_disk = self._wait_for_task(add_disk_task)
return {'state': successfully_added_disk}
def run(self, vm_id, vm_name, vsphere=None):
"""
Retrieve details for given Virtual Machines
Args:
- vm_id: Moid of Virtual Machine to retrieve
- vm_name: Name of Virtual Machine to retrieve
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- string: Path to VM's containing folder ex: /dc.name/folder1/folder2
"""
# check a means of finding the VM has been provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
folder_name = ''
# The parent of a VM is the Folder object that contains that VM
parent = vm.parent
while parent:
folder_name = '/' + parent.name + folder_name
if parent._wsdlName == "Datacenter":
break
parent = parent.parent
return folder_name
def run(self, vm_id, vm_name, vsphere=None):
"""
Gets all the available controllers to be used
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- list: list of SCSI controllers
"""
# VM name or ID given?
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
# Create object for VM
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
controllers = []
for device in vm.config.hardware.device:
if (isinstance(device, vim.vm.device.VirtualSCSIController) or
isinstance(device, vim.vm.device.ParaVirtualSCSIController)):
controllers.append(device)
return json.loads(json.dumps(controllers, cls=MyJSONEncoder))
def run(self, vm_id, vm_name, datastore_cluster,
datastore, disk_size, provision_type):
# ensure that minimal inputs are provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
spec = vim.vm.ConfigSpec()
hdd_unit_number = self.get_next_unit_number(vm)
ctrl_key = self.get_controller_key(vm)
# Prepare new Disk configuration
disk_changes = []
disk_spec = vim.vm.device.VirtualDeviceSpec()
disk_spec.fileOperation = "create"
disk_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
disk_spec.device = vim.vm.device.VirtualDisk()
disk_spec.device.backing =\
vim.vm.device.VirtualDisk.FlatVer2BackingInfo()
disk_spec.device.backing.diskMode = "persistent"
if provision_type == 'thin':
disk_spec.device.backing.thinProvisioned = True
disk_spec.device.unitNumber = hdd_unit_number
disk_spec.device.capacityInKB = int(disk_size) * 1024 * 1024
disk_spec.device.controllerKey = ctrl_key
# If Datastore Cluster is provided attach Disk via that
if datastore_cluster:
ds_clust_obj = inventory.get_datastore_cluster(
self.si_content, name=datastore_cluster)
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
srm = self.si_content.storageResourceManager
storage_placement_spec = self.get_storage_placement_spec(
ds_clust_obj, vm, spec)
datastores = srm.RecommendDatastores(
storageSpec=storage_placement_spec)
if not datastores.recommendations:
sys.stderr.write('Skipping as No datastore Recommendations')
add_disk_task = srm.ApplyStorageDrsRecommendation_Task(
datastores.recommendations[0].key)
elif datastore:
datastore_obj = inventory.get_datastore(self.si_content,
name=datastore)
disk_spec.device.backing.datastore = datastore_obj
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
add_disk_task = vm.ReconfigVM_Task(spec)
else:
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
add_disk_task = vm.ReconfigVM_Task(spec)
successfully_added_disk = self._wait_for_task(add_disk_task)
return {'state': successfully_added_disk}
def run(self, vm_id, vm_name, network_name,
nictype, stayconnected, wakeonlan, vsphere=None):
"""
Add Network Adapter to Virtual Machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- vsphere: Pre-configured vsphere connection details (config.yaml)
- network_name: vsphere network to connect to
- nictype: Nic type to add
- stayconnected: Nic connected on boot
- wakeonlan: Wake on Lan
Returns:
- dict: state true/false
"""
# create object itmes of key components
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
network_obj = inventory.get_network(self.si_content, name=network_name)
vm_reconfig_spec = self.get_vm_reconfig_spec(network_obj,
stayconnected,
nictype,
wakeonlan)
add_vnic_task = vm.ReconfigVM_Task(spec=vm_reconfig_spec)
successfully_added_vnic = self._wait_for_task(add_vnic_task)
return {'state': successfully_added_vnic}
def run(self, vm_id, vm_name, cpu_edit, mem_edit, vsphere=None):
"""
Edit CPU and/or Memory allocated to Virtual Machine
Args:
- vm_id: Moid of the virtual machine targetted (vm-xxxx)
- vm_name: Name of Virtual Machine within vsphere
- vsphere: Pre-configured vsphere connection details (config.yaml)
- cpu_edit: Number of vCPUs to allocate
- mem_edit: Ammount of memory to assign (GB)
Returns:
- state: success or failure
"""
# check a means of finding the VM has been provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
spec = vim.vm.ConfigSpec()
if cpu_edit:
spec.numCPUs = cpu_edit
if mem_edit:
spec.memoryMB = mem_edit * 1024
task = vm.ReconfigVM_Task(spec)
self._wait_for_task(task)
return {'state': str(task.info.state)}
def run(self, vm_name, vm_id, vsphere=None):
"""
Create barebones VM (CPU/RAM/Graphics)
Args:
- vm_name: Name of Virtual Machine to detach ISO from
- vm_id: ID of Virtual Machine to detach ISO from
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- dict: vm moid of newly created vm
"""
# Setup Identifiers for objects
self.establish_connection(vsphere)
# checkinputs.vm_storage(datastore_cluster, datastore)
checkinputs.one_of_two_strings(vm_name, vm_id,
"Virtual Machine Name or ID")
vm_obj = inventory.get_virtualmachine(self.si_content, name=vm_name)
if vm_obj:
cdrom_number = 1
cdrom_prefix_label = 'CD/DVD drive '
cdrom_label = cdrom_prefix_label + str(cdrom_number)
virtual_cdrom_device = None
attached, connected = None, None
for dev in vm_obj.config.hardware.device:
if isinstance(dev, vim.vm.device.VirtualCdrom
) and dev.deviceInfo.label == cdrom_label:
virtual_cdrom_device = dev
if hasattr(dev.backing, 'fileName'):
if dev.backing.fileName:
attached = True
else:
attached = False
if hasattr(dev.connectable, 'connected'):
if dev.connectable.connected == True:
connected = True
else:
connected = False
if not virtual_cdrom_device:
return ({
'connected':
connected,
'attached':
attached,
'msg':
'Virtual {} could not be found.'.format(cdrom_label)
})
return ({'connected': connected, 'attached': attached})
def run(self, vm_id, vm_name, controller_type, scsi_sharing, vsphere=None):
"""
Add SCSI controller to Virtual Machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- controller_type: Type of Controller to add
- scsi_sharing: type of sharing for scsi adapter
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- dict: state true/false
"""
# VM name or ID given?
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
# Create object for VM
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
# Create SCSI Controller Object
configspec = vim.vm.ConfigSpec()
scsictrl = vim.vm.device.VirtualDeviceSpec()
scsictrl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
# Select object type
if controller_type == 'ParaVirtual':
scsictrl.device = vim.vm.device.ParaVirtualSCSIController()
elif controller_type == 'BusLogic':
scsictrl.device = vim.vm.device.VirtualBusLogicController()
elif controller_type == 'LSILogic':
scsictrl.device = vim.vm.device.VirtualLsiLogicController()
elif controller_type == 'LSILogicSAS':
scsictrl.device = vim.vm.device.VirtualLsiLogicSASController()
# Set SCSI Bus Sharing type
if scsi_sharing == 'None':
scsictrl.device.sharedBus = 'noSharing'
elif scsi_sharing == 'Physical':
scsictrl.device.sharedBus = 'physicalSharing'
elif scsi_sharing == 'Virtual':
scsictrl.device.sharedBus = 'virtualSharing'
# Create Task to add to VM
configspec.deviceChange = [scsictrl]
add_ctrl_task = vm.ReconfigVM_Task(configspec)
successfully_added_ctrl = self._wait_for_task(add_ctrl_task)
return {'state': successfully_added_ctrl}
def run(self, vm_id, vm_name, controller_type, scsi_sharing, vsphere=None):
"""
Add SCSI controller to Virtual Machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- controller_type: Type of Controller to add
- scsi_sharing: type of sharing for scsi adapter
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- dict: state true/false
"""
# VM name or ID given?
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
# Create object for VM
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
# Create SCSI Controller Object
configspec = vim.vm.ConfigSpec()
scsictrl = vim.vm.device.VirtualDeviceSpec()
scsictrl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
# Select object type
if controller_type == 'ParaVirtual':
scsictrl.device = vim.vm.device.ParaVirtualSCSIController()
elif controller_type == 'BusLogic':
scsictrl.device = vim.vm.device.VirtualBusLogicController()
elif controller_type == 'LSILogic':
scsictrl.device = vim.vm.device.VirtualLsiLogicController()
elif controller_type == 'LSILogicSAS':
scsictrl.device = vim.vm.device.VirtualLsiLogicSASController()
# Set SCSI Bus Sharing type
if scsi_sharing == 'None':
scsictrl.device.sharedBus = 'noSharing'
elif scsi_sharing == 'Physical':
scsictrl.device.sharedBus = 'physicalSharing'
elif scsi_sharing == 'Virtual':
scsictrl.device.sharedBus = 'virtualSharing'
# Create Task to add to VM
configspec.deviceChange = [scsictrl]
add_ctrl_task = vm.ReconfigVM_Task(configspec)
successfully_added_ctrl = self._wait_for_task(add_ctrl_task)
return {'state': successfully_added_ctrl}
def run(self, vm_id, vm_name, power_onoff):
# check I have information to find a VM
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
# convert ids to stubs
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id, name=vm_name)
if not vm:
raise Exception('Error: Unable to find VM')
if power_onoff == "poweroff":
task = vm.PowerOffVM_Task()
elif power_onoff == "poweron":
task = vm.PowerOnVM_Task()
while task.info.state == vim.TaskInfo.State.running:
eventlet.sleep(1)
return {'state': str(task.info.state)}
def run(self, vm_id, vm_name, power_onoff):
# check I have information to find a VM
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
# convert ids to stubs
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
if not vm:
raise Exception('Error: Unable to find VM')
if power_onoff == "poweroff":
task = vm.PowerOffVM_Task()
elif power_onoff == "poweron":
task = vm.PowerOnVM_Task()
while task.info.state == vim.TaskInfo.State.running:
eventlet.sleep(1)
return {'state': str(task.info.state)}
def run(self, vm_id, vm_name, network_name, nictype, stayconnected,
wakeonlan):
# create object itmes of key components
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
network_obj = inventory.get_network(self.si_content, name=network_name)
vm_reconfig_spec = self.get_vm_reconfig_spec(network_obj,
stayconnected, nictype,
wakeonlan)
add_vnic_task = vm.ReconfigVM_Task(spec=vm_reconfig_spec)
successfully_added_vnic = self._wait_for_task(add_vnic_task)
return {'state': successfully_added_vnic}
def run(self,
vm_id,
vm_name,
network_name,
nictype,
stayconnected,
wakeonlan,
vsphere=None):
"""
Add Network Adapter to Virtual Machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- vsphere: Pre-configured vsphere connection details (config.yaml)
- network_name: vsphere network to connect to
- nictype: Nic type to add
- stayconnected: Nic connected on boot
- wakeonlan: Wake on Lan
Returns:
- dict: state true/false
"""
# create object itmes of key components
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
try:
nettype = "dist"
network_obj = inventory.get_distributedportgroup(self.si_content,
name=network_name)
except:
nettype = "std"
network_obj = inventory.get_network(self.si_content,
name=network_name)
vm_reconfig_spec = self.get_vm_reconfig_spec(network_obj,
stayconnected, nictype,
wakeonlan, nettype)
add_vnic_task = vm.ReconfigVM_Task(spec=vm_reconfig_spec)
successfully_added_vnic = self._wait_for_task(add_vnic_task)
return {'state': successfully_added_vnic}
def run(self, vm_id, vm_name, cpu_edit, mem_edit):
# check a means of finding the VM has been provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
spec = vim.vm.ConfigSpec()
if cpu_edit:
spec.numCPUs = cpu_edit
if mem_edit:
spec.memoryMB = mem_edit * 1024
task = vm.ReconfigVM_Task(spec)
self._wait_for_task(task)
return {'state': str(task.info.state)}
def run(self, vm_id, vm_name, cpu_edit, mem_edit):
# check a means of finding the VM has been provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
spec = vim.vm.ConfigSpec()
if cpu_edit:
spec.numCPUs = cpu_edit
if mem_edit:
spec.memoryMB = mem_edit * 1024
task = vm.ReconfigVM_Task(spec)
self._wait_for_task(task)
return {'state': str(task.info.state)}
def run(self, vm_id, vm_name, network_name,
nictype, stayconnected, wakeonlan):
# create object itmes of key components
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
network_obj = inventory.get_network(self.si_content, name=network_name)
vm_reconfig_spec = self.get_vm_reconfig_spec(network_obj,
stayconnected,
nictype,
wakeonlan)
add_vnic_task = vm.ReconfigVM_Task(spec=vm_reconfig_spec)
successfully_added_vnic = self._wait_for_task(add_vnic_task)
return {'state': successfully_added_vnic}
def run(self, vm_id, vm_name, network_adapter, network_name):
# check means of finding the VM was provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
# convert ids to stubs
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
network_obj = inventory.get_network(self.si_content,
name=network_name)
# find correct NIC
for device in vm.config.hardware.device:
if isinstance(device, vim.vm.device.VirtualEthernetCard)\
and device.deviceInfo.label == network_adapter:
nic = device
# Different test method due to fact that object
# isn't instantiated if not found
try:
nic
except:
raise Exception('Unable to find Network Adapter provided')
# Create object for new Specification
new_spec = vim.vm.device.VirtualDeviceSpec()
new_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit
new_spec.device = nic
# If network name provided assign new network
# Room to expand the following to set additional flags/values
if network_name:
new_spec.device.backing.network = network_obj
new_spec.device.backing.deviceName = network_obj.name
new_spec.device.deviceInfo.summary = network_obj.name
# format changes for config spec update
dev_changes = []
dev_changes.append(new_spec)
spec = vim.vm.ConfigSpec()
spec.deviceChange = dev_changes
task = vm.ReconfigVM_Task(spec)
self._wait_for_task(task)
return {'state': str(task.info.state)}
def run(self, vm_id, vm_name, vsphere=None):
"""
Retrieve MOID of the virtual machine's containing resource pool
Args:
- vm_id: Moid of Virtual Machine to retrieve
- vm_name: Name of Virtual Machine to retrieve
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- string: MOID of the VM's containing resource pool ex: resgroup-10
"""
# check a means of finding the VM has been provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
return vm.resourcePool.config.entity._moId
def run(self, vm_id, vm_name, vsphere=None):
"""
Retrieve a list of network names that the given VM is on
Args:
- vm_id: Moid of Virtual Machine to retrieve
- vm_name: Name of Virtual Machine to retrieve
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- list: network names that the VM is connected to
"""
# check a means of finding the VM has been provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
# return a list of network names that the VM is on
return map(lambda x: x.name, vm.network)
def run(self, vm_id, vm_name, controller_type, scsi_sharing):
# VM name or ID given?
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
# Create object for VM
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
# Create SCSI Controller Object
configspec = vim.vm.ConfigSpec()
scsictrl = vim.vm.device.VirtualDeviceSpec()
scsictrl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
# Select object type
if controller_type == 'ParaVirtual':
scsictrl.device = vim.vm.device.ParaVirtualSCSIController()
elif controller_type == 'BusLogic':
scsictrl.device = vim.vm.device.VirtualBusLogicController()
elif controller_type == 'LSILogic':
scsictrl.device = vim.vm.device.VirtualLsiLogicController()
elif controller_type == 'LSILogicSAS':
scsictrl.device = vim.vm.device.VirtualLsiLogicSASController()
# Set SCSI Bus Sharing type
if scsi_sharing == 'None':
scsictrl.device.sharedBus = 'noSharing'
elif scsi_sharing == 'Physical':
scsictrl.device.sharedBus = 'physicalSharing'
elif scsi_sharing == 'Virtual':
scsictrl.device.sharedBus = 'virtualSharing'
# Create Task to add to VM
configspec.deviceChange = [scsictrl]
add_ctrl_task = vm.ReconfigVM_Task(configspec)
successfully_added_ctrl = self._wait_for_task(add_ctrl_task)
return {'state': successfully_added_ctrl}
def run(self, vm_id, vm_name, controller_type, scsi_sharing):
# VM name or ID given?
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
# Create object for VM
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
# Create SCSI Controller Object
configspec = vim.vm.ConfigSpec()
scsictrl = vim.vm.device.VirtualDeviceSpec()
scsictrl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
# Select object type
if controller_type == 'ParaVirtual':
scsictrl.device = vim.vm.device.ParaVirtualSCSIController()
elif controller_type == 'BusLogic':
scsictrl.device = vim.vm.device.VirtualBusLogicController()
elif controller_type == 'LSILogic':
scsictrl.device = vim.vm.device.VirtualLsiLogicController()
elif controller_type == 'LSILogicSAS':
scsictrl.device = vim.vm.device.VirtualLsiLogicSASController()
# Set SCSI Bus Sharing type
if scsi_sharing == 'None':
scsictrl.device.sharedBus = 'noSharing'
elif scsi_sharing == 'Physical':
scsictrl.device.sharedBus = 'physicalSharing'
elif scsi_sharing == 'Virtual':
scsictrl.device.sharedBus = 'virtualSharing'
# Create Task to add to VM
configspec.deviceChange = [scsictrl]
add_ctrl_task = vm.ReconfigVM_Task(configspec)
successfully_added_ctrl = self._wait_for_task(add_ctrl_task)
return {'state': successfully_added_ctrl}
def run(self, vm_id, vm_name, cluster, vsphere=None):
"""
Migrate VM to specified datastore
Args:
- vm_id: Moid of Virtual Machine to migrate
- vm_name: Name of Virtual Machine to migrate
- cluster: Cluster to which VM needs to be migrated to
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- dict: Success
"""
# ensure that minimal inputs are provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
# Getting RID code from VM name
rid = vm_name[:4]
ds_size_list = []
rp_usage_list = []
dest_hosts = []
foh_hosts = []
cluster_container = inventory.get_managed_entities(self.si_content, vim.ClusterComputeResource)
cluster_list = cluster_container.view
cluster_container.Destroy()
# iterate through clusters
for cl in cluster_list:
if cl.name == cluster:
# Resource Pool
# Checking if there is any failover hosts in the cluster
# adding those to separate list, further it will be comapred
# with hosts that are attached to matched datastore
if hasattr(cl.configuration.dasConfig.admissionControlPolicy, 'failoverHosts'):
for foh in cl.configuration.dasConfig.admissionControlPolicy.failoverHosts:
foh_hosts.append(foh)
for rp in cl.resourcePool.resourcePool:
# Generating list of all available resource pools
# matching RID
if rp.name[:4] == rid:
overallUsage = rp.summary.runtime.memory.overallUsage + rp.summary.runtime.cpu.overallUsage
rp_usage_list.append((rp, overallUsage))
# Datastore
datastores = cl.datastore
# iterate through datastores that
# exists under specified cluster
for datastore in datastores:
ds = datastore.summary
# take datastores that has proper RID
if ds.name[:4] == rid:
# getting hosts that are attached to datastore
# further those will be compared with FOH hosts
for h in datastore.host:
dest_hosts.append(h.key)
ds_size_list.append((ds.datastore, ds.freeSpace))
# If list is empty, no storages found
if len(ds_size_list) == 0:
return (False, {'state': False, 'msg': 'No storages found in cluster {} for rid {}.'.format(cluster, rid)})
ds_to_migrate_to = max(ds_size_list, key = lambda i : i[1])[0]
# Checking target resource pool list
if len(rp_usage_list) == 0:
return (False, {'state': False, 'msg': 'No resource pools found in cluster {} for rid {}.'.format(cluster, rid)})
rp_to_mirgate_to = min(rp_usage_list, key = lambda i : i[1])[0]
# Determing to which host VM should be migrated to
# on destination cluster
ok_hosts = list(set(dest_hosts)^set(foh_hosts))
dest_host = random.choice(ok_hosts)
# Migrate VM only if datastores not matching destination one
if ds_to_migrate_to not in vm.datastore:
# Setting vm relocation specification
vm_relocate_spec = vim.vm.RelocateSpec()
vm_relocate_spec.host = dest_host
vm_relocate_spec.pool = rp_to_mirgate_to
vm_relocate_spec.datastore = ds_to_migrate_to
# Performing actual migration
relocate_vm = vm.Relocate(spec=vm_relocate_spec)
# If VM is already on the same storage
else:
return (False, {'state': False, 'msg': 'VM is on proper datastore, will not migrate.'})
successfully_relocated_vm = self._wait_for_task(relocate_vm)
if successfully_relocated_vm != True:
return (False, {'state': successfully_relocated_vm, 'msg': relocate_vm})
else:
return {
'state': successfully_relocated_vm,
'dest_datastore': ds_to_migrate_to.name,
'dest_cluster': cluster,
'dest_resource_pool': rp_to_mirgate_to.name
}
def run(self, vm_name, vm_id, answer=None, vsphere=None):
"""
Create barebones VM (CPU/RAM/Graphics)
Args:
- vm_name: Name of Virtual Machine to detach ISO from
- vm_id: ID of Virtual Machine to detach ISO from
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- dict: vm moid of newly created vm
"""
# Setup Identifiers for objects
self.establish_connection(vsphere)
result, error = None, None
# checkinputs.vm_storage(datastore_cluster, datastore)
checkinputs.one_of_two_strings(vm_name, vm_id, "Virtual Machine Name or ID")
vm_obj = inventory.get_virtualmachine(self.si_content, name=vm_name)
# Setting answer value
# Answers:
# 0: button.yes
# 1: button.no
if answer:
if answer == "Yes":
qa = str(0)
else:
qa = str(1)
if vm_obj:
dev_changes = []
cdrom_number = 1
cdrom_prefix_label = 'CD/DVD drive '
cdrom_label = cdrom_prefix_label + str(cdrom_number)
virtual_cdrom_device = None
for dev in vm_obj.config.hardware.device:
if isinstance(dev, vim.vm.device.VirtualCdrom) and dev.deviceInfo.label == cdrom_label:
virtual_cdrom_device = dev
#print(dev)
if not virtual_cdrom_device:
error = ('Virtual {} could not be found.'.format(cdrom_label))
virtual_cd_spec = vim.vm.device.VirtualDeviceSpec()
virtual_cd_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit
virtual_cd_spec.device = vim.vm.device.VirtualCdrom()
virtual_cd_spec.device.controllerKey = virtual_cdrom_device.controllerKey
virtual_cd_spec.device.key = virtual_cdrom_device.key
virtual_cd_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
# Adding no CD
virtual_cd_spec.device.backing = vim.vm.device.VirtualCdrom.RemotePassthroughBackingInfo()
# Allowing guest control
virtual_cd_spec.device.connectable.allowGuestControl = True
dev_changes.append(virtual_cd_spec)
spec = vim.vm.ConfigSpec()
spec.deviceChange = dev_changes
remove_iso_task = vm_obj.ReconfigVM_Task(spec)
while remove_iso_task.info.state not in [vim.TaskInfo.State.success, vim.TaskInfo.State.error]:
if vm_obj.runtime.question is not None:
for qm in vm_obj.runtime.question.message:
if qm.id == 'msg.cdromdisconnect.locked':
msg = qm.text
question_id = vm_obj.runtime.question.id
if answer:
if answer == "Yes":
vm_obj.AnswerVM(question_id, qa)
else:
# Answering with No, to leave ISO connected
vm_obj.AnswerVM(question_id, str(1))
# using time.sleep to wait for answer to be applied
time.sleep(5)
#print(remove_iso_task.info.state)
if remove_iso_task.info.state == vim.TaskInfo.State.error:
return (False, {'state': remove_iso_task.info.state, 'msg': msg})
else:
return {'state': remove_iso_task.info.state}
def run(self,
vm_id,
vm_name,
datastore_cluster,
datastore,
disk_size,
provision_type,
vsphere=None):
"""
Add Hard Drive object to Virtual Machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- datastore_cluster: Datastore Cluster to store new hdd files
- datastore: Datastore to put new files in
- disk_size: Sze of HDD in GB
- provisioning_type: Type of Provisioning to use for HDD
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- dict: Success
"""
# ensure that minimal inputs are provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
spec = vim.vm.ConfigSpec()
hdd_unit_number = self.get_next_unit_number(vm)
ctrl_key = self.get_controller_key(vm)
# Prepare new Disk configuration
disk_changes = []
disk_spec = vim.vm.device.VirtualDeviceSpec()
disk_spec.fileOperation = "create"
disk_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
disk_spec.device = vim.vm.device.VirtualDisk()
disk_spec.device.backing =\
vim.vm.device.VirtualDisk.FlatVer2BackingInfo()
disk_spec.device.backing.diskMode = "persistent"
if provision_type == 'thin':
disk_spec.device.backing.thinProvisioned = True
disk_spec.device.unitNumber = hdd_unit_number
disk_spec.device.capacityInKB = int(disk_size) * 1024 * 1024
disk_spec.device.controllerKey = ctrl_key
# If Datastore Cluster is provided attach Disk via that
if datastore_cluster:
ds_clust_obj = inventory.get_datastore_cluster(
self.si_content, name=datastore_cluster)
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
srm = self.si_content.storageResourceManager
storage_placement_spec = self.get_storage_placement_spec(
ds_clust_obj, vm, spec)
datastores = srm.RecommendDatastores(
storageSpec=storage_placement_spec)
if not datastores.recommendations:
sys.stderr.write('Skipping as No datastore Recommendations')
add_disk_task = srm.ApplyStorageDrsRecommendation_Task(
datastores.recommendations[0].key)
elif datastore:
datastore_obj = inventory.get_datastore(self.si_content,
name=datastore)
disk_spec.device.backing.datastore = datastore_obj
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
add_disk_task = vm.ReconfigVM_Task(spec)
else:
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
add_disk_task = vm.ReconfigVM_Task(spec)
successfully_added_disk = self._wait_for_task(add_disk_task)
return {'state': successfully_added_disk}
def run(self, vm_id, vm_name, network_adapter, network_name, vsphere=None):
"""
Edit Network Adapater on Virtual Machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- vsphere: Pre-configured vsphere connection details (config.yaml)
- network_name: Network to attach adapter to
- network_adapter: Name of Adapter to edit
Returns:
- dict: State true/false
"""
# check means of finding the VM was provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
# convert ids to stubs
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
try:
nettype = "dist"
network_obj = inventory.get_distributedportgroup(self.si_content,
name=network_name)
except:
nettype = "std"
network_obj = inventory.get_network(self.si_content,
name=network_name)
# find correct NIC
for device in vm.config.hardware.device:
if isinstance(device, vim.vm.device.VirtualEthernetCard)\
and device.deviceInfo.label == network_adapter:
nic = device
# Different test method due to fact that object
# isn't instantiated if not found
try:
nic
except:
raise Exception('Unable to find Network Adapter provided')
# Create object for new Specification
new_spec = vim.vm.device.VirtualDeviceSpec()
new_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit
new_spec.device = nic
# If network name provided assign new network
# Room to expand the following to set additional flags/values
if network_name:
# Default functionality is to use the
# Distributed Port Group over a standard group
if nettype == "dist":
new_spec.device.backing = \
vim.vm.device.VirtualEthernetCard\
.DistributedVirtualPortBackingInfo()
new_spec.device.backing.port = vim.dvs.PortConnection()
dvs_port_connection = vim.dvs.PortConnection()
dvs_port_connection.portgroupKey = network_obj.key
dvs_port_connection.switchUuid = \
network_obj.config.distributedVirtualSwitch.uuid
new_spec.device.backing = \
vim.vm.device.VirtualEthernetCard\
.DistributedVirtualPortBackingInfo()
new_spec.device.backing.port = dvs_port_connection
else:
new_spec.device.backing = \
vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
new_spec.device.backing.network = network_obj
new_spec.device.backing.deviceName = network_obj.name
# format changes for config spec update
dev_changes = []
dev_changes.append(new_spec)
spec = vim.vm.ConfigSpec()
spec.deviceChange = dev_changes
task = vm.ReconfigVM_Task(spec)
self._wait_for_task(task)
return {'state': str(task.info.state)}
def run(self, vm_id, vm_name, datastore_cluster,
datastore, disk_size, provision_type, vsphere=None):
"""
Add Hard Drive object to Virtual Machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- datastore_cluster: Datastore Cluster to store new hdd files
- datastore: Datastore to put new files in
- disk_size: Sze of HDD in GB
- provisioning_type: Type of Provisioning to use for HDD
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- dict: Success
"""
# ensure that minimal inputs are provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
spec = vim.vm.ConfigSpec()
hdd_unit_number = self.get_next_unit_number(vm)
ctrl_key = self.get_controller_key(vm)
# Prepare new Disk configuration
disk_changes = []
disk_spec = vim.vm.device.VirtualDeviceSpec()
disk_spec.fileOperation = "create"
disk_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
disk_spec.device = vim.vm.device.VirtualDisk()
disk_spec.device.backing =\
vim.vm.device.VirtualDisk.FlatVer2BackingInfo()
disk_spec.device.backing.diskMode = "persistent"
if provision_type == 'thin':
disk_spec.device.backing.thinProvisioned = True
disk_spec.device.unitNumber = hdd_unit_number
disk_spec.device.capacityInKB = int(disk_size) * 1024 * 1024
disk_spec.device.controllerKey = ctrl_key
# If Datastore Cluster is provided attach Disk via that
if datastore_cluster:
ds_clust_obj = inventory.get_datastore_cluster(
self.si_content, name=datastore_cluster)
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
srm = self.si_content.storageResourceManager
storage_placement_spec = self.get_storage_placement_spec(
ds_clust_obj, vm, spec)
datastores = srm.RecommendDatastores(
storageSpec=storage_placement_spec)
if not datastores.recommendations:
sys.stderr.write('Skipping as No datastore Recommendations')
add_disk_task = srm.ApplyStorageDrsRecommendation_Task(
datastores.recommendations[0].key)
elif datastore:
datastore_obj = inventory.get_datastore(self.si_content,
name=datastore)
disk_spec.device.backing.datastore = datastore_obj
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
add_disk_task = vm.ReconfigVM_Task(spec)
else:
disk_changes.append(disk_spec)
spec.deviceChange = disk_changes
add_disk_task = vm.ReconfigVM_Task(spec)
successfully_added_disk = self._wait_for_task(add_disk_task)
return {'state': successfully_added_disk}
def run(self, vm_name, cluster, datastore_cluster, datastore, resourcepool,
cpu_size, ram_size, guestos, version, description):
# Setup Identifiers for objects
si = self.si
si_content = si.RetrieveContent()
# checkinputs.vm_storage(datastore_cluster, datastore)
checkinputs.one_of_two_strings(datastore_cluster, datastore,
"Datastore Cluster or Datastore")
data_center = self.si_content.rootFolder.childEntity[0]
cluster = inventory.get_cluster(self.si_content, name=cluster)
data_store_cluster = inventory.get_datastore_cluster(
self.si_content, name=datastore_cluster)
# data_store = inventory.get_datastore(self.si_content, name=datastore)
target_folder = data_center.vmFolder
# If No Resource Pool issued the Default one for
# the Cluster will be selected.
if resourcepool:
resource_pool = inventory.get_resource_pool(self.si_content,
name=resourcepool)
else:
resource_pool = cluster.resourcePool
# Config created that is required for DS selection
# Config is BareBones, CPU RAM no more.
config = vim.vm.ConfigSpec(name=vm_name,
memoryMB=(ram_size * 1024),
numCPUs=cpu_size,
guestId=guestos,
version=version,
cpuHotAddEnabled=True,
memoryHotAddEnabled=True,
annotation=description)
# if Datastore cluster is provided it will find the
# recommended Datastore to store VM files
if datastore_cluster:
podsel = vim.storageDrs.PodSelectionSpec()
podsel.storagePod = data_store_cluster
storage_spec = vim.storageDrs.StoragePlacementSpec(
type='create',
configSpec=config,
resourcePool=resource_pool,
podSelectionSpec=podsel,
folder=target_folder)
# Create Instance of Storage Resource Manager -
# This is used to identify a Recommended Datastore from a Cluster
srm = si_content.storageResourceManager
results = srm.RecommendDatastores(storageSpec=storage_spec)
rec_ds = results.recommendations[0].action[0]\
.relocateSpec.datastore
datastore_path = '[' + rec_ds.name + '] ' + vm_name
else:
# No Datastore Cluster has been offered so using the D
if datastore:
datastore_path = '[' + datastore + '] ' + vm_name
else:
raise Exception('Error No Storage Data Provided')
# Now Datastore is known the remaining
# of VM Config can be setup and added
vmx_file = vim.vm.FileInfo(logDirectory=None,
snapshotDirectory=None,
suspendDirectory=None,
vmPathName=datastore_path)
config.files = vmx_file
# Create task to Build actual Machine
task = target_folder.CreateVM_Task(config=config, pool=resource_pool)
self._wait_for_task(task)
if task.info.state != vim.TaskInfo.State.success:
raise Exception(task.info.error.msg)
return {'vm_id': task.info.result._moId}
def run(self, vm_name, cluster, datastore_cluster,
datastore, resourcepool, cpu_size, ram_size,
guestos, version, description):
# Setup Identifiers for objects
si = self.si
si_content = si.RetrieveContent()
# checkinputs.vm_storage(datastore_cluster, datastore)
checkinputs.one_of_two_strings(datastore_cluster,
datastore,
"Datastore Cluster or Datastore")
data_center = self.si_content.rootFolder.childEntity[0]
cluster = inventory.get_cluster(self.si_content, name=cluster)
data_store_cluster = inventory.get_datastore_cluster(
self.si_content,
name=datastore_cluster)
# data_store = inventory.get_datastore(self.si_content, name=datastore)
target_folder = data_center.vmFolder
# If No Resource Pool issued the Default one for
# the Cluster will be selected.
if resourcepool:
resource_pool = inventory.get_resource_pool(self.si_content,
name=resourcepool)
else:
resource_pool = cluster.resourcePool
# Config created that is required for DS selection
# Config is BareBones, CPU RAM no more.
config = vim.vm.ConfigSpec(name=vm_name,
memoryMB=(ram_size * 1024),
numCPUs=cpu_size,
guestId=guestos,
version=version,
cpuHotAddEnabled=True,
memoryHotAddEnabled=True,
annotation=description)
# if Datastore cluster is provided it will find the
# recommended Datastore to store VM files
if datastore_cluster:
podsel = vim.storageDrs.PodSelectionSpec()
podsel.storagePod = data_store_cluster
storage_spec = vim.storageDrs.StoragePlacementSpec(
type='create',
configSpec=config,
resourcePool=resource_pool,
podSelectionSpec=podsel,
folder=target_folder)
# Create Instance of Storage Resource Manager -
# This is used to identify a Recommended Datastore from a Cluster
srm = si_content.storageResourceManager
results = srm.RecommendDatastores(storageSpec=storage_spec)
rec_ds = results.recommendations[0].action[0]\
.relocateSpec.datastore
datastore_path = '[' + rec_ds.name + '] ' + vm_name
else:
# No Datastore Cluster has been offered so using the D
if datastore:
datastore_path = '[' + datastore + '] ' + vm_name
else:
raise Exception('Error No Storage Data Provided')
# Now Datastore is known the remaining
# of VM Config can be setup and added
vmx_file = vim.vm.FileInfo(logDirectory=None,
snapshotDirectory=None,
suspendDirectory=None,
vmPathName=datastore_path)
config.files = vmx_file
# Create task to Build actual Machine
task = target_folder.CreateVM_Task(config=config, pool=resource_pool)
self._wait_for_task(task)
if task.info.state != vim.TaskInfo.State.success:
raise Exception(task.info.error.msg)
return {'vm_id': task.info.result._moId}
def run(self, vm_id, vm_name, datastore_cluster, datastore, vsphere=None):
"""
Migrate VM to specified datastore
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- datastore_cluster: Datastore Cluster to store new hdd files
- datastore: Datastore to put new files in
- vsphere: Pre-configured vsphere connection details (config.yaml)
Returns:
- dict: Success
"""
# ensure that minimal inputs are provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
vm = inventory.get_virtualmachine(self.si_content, vm_id, vm_name)
spec = vim.vm.ConfigSpec()
#print(spec)
disk_size = 0
for device in vm.config.hardware.device:
if hasattr(device.backing, 'fileName'):
#print(device)
disk_size += device.capacityInBytes
#disk_size += device.capacityInKB
#print(device.capacityInKB)
###print(disk_size)
# If Datastore Cluster is provided attach Disk via that
#if datastore_cluster:
# ds_clust_obj = inventory.get_datastore_cluster(
# self.si_content, name=datastore_cluster)
# disk_changes.append(disk_spec)
# spec.deviceChange = disk_changes
# srm = self.si_content.storageResourceManager
#
# storage_placement_spec = self.get_storage_placement_spec(
# ds_clust_obj, vm, spec)
# datastores = srm.RecommendDatastores(
# storageSpec=storage_placement_spec)
#
# if not datastores.recommendations:
# sys.stderr.write('Skipping as No datastore Recommendations')
#
# add_disk_task = srm.ApplyStorageDrsRecommendation_Task(
# datastores.recommendations[0].key)
#elif datastore:
if datastore:
datastore_obj = inventory.get_datastore(self.si_content,
name=datastore)
relocate_spec = vim.vm.RelocateSpec(datastore=datastore_obj)
relocate_vm = vm.Relocate(relocate_spec)
summary = datastore_obj.summary
if not disk_size * 2 < summary.freeSpace:
return (False, {
'state':
False,
'msg':
'Datastore %s doesn\'t have enough free space.' %
summary.name
})
else:
return {'state': 'Datastore not provided.'}
successfully_relocated_vm = self._wait_for_task(relocate_vm)
#print(relocate_vm)
#print(successfully_relocated_vm)
if successfully_relocated_vm != True:
return (False, {
'state': successfully_relocated_vm,
'msg': relocate_vm
})
else:
return {'state': successfully_relocated_vm}
def run(self, vm_id, vm_name, network_adapter, network_name, vsphere=None):
"""
Edit Network Adapater on Virtual Machine
Args:
- vm_id: Moid of Virtual Machine to edit
- vm_name: Name of Virtual Machine to edit
- vsphere: Pre-configured vsphere connection details (config.yaml)
- network_name: Network to attach adapter to
- network_adapter: Name of Adapter to edit
Returns:
- dict: State true/false
"""
# check means of finding the VM was provided
checkinputs.one_of_two_strings(vm_id, vm_name, "ID or Name")
self.establish_connection(vsphere)
# convert ids to stubs
vm = inventory.get_virtualmachine(self.si_content,
moid=vm_id,
name=vm_name)
try:
nettype = "dist"
network_obj = inventory.get_distributedportgroup(self.si_content,
name=network_name)
except:
nettype = "std"
network_obj = inventory.get_network(self.si_content,
name=network_name)
# find correct NIC
for device in vm.config.hardware.device:
if isinstance(device, vim.vm.device.VirtualEthernetCard)\
and device.deviceInfo.label == network_adapter:
nic = device
# Different test method due to fact that object
# isn't instantiated if not found
try:
nic
except:
raise Exception('Unable to find Network Adapter provided')
# Create object for new Specification
new_spec = vim.vm.device.VirtualDeviceSpec()
new_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit
new_spec.device = nic
# If network name provided assign new network
# Room to expand the following to set additional flags/values
if network_name:
# Default functionality is to use the
# Distributed Port Group over a standard group
if nettype == "dist":
new_spec.device.backing = \
vim.vm.device.VirtualEthernetCard\
.DistributedVirtualPortBackingInfo()
new_spec.device.backing.port = vim.dvs.PortConnection()
dvs_port_connection = vim.dvs.PortConnection()
dvs_port_connection.portgroupKey = network_obj.key
dvs_port_connection.switchUuid = \
network_obj.config.distributedVirtualSwitch.uuid
new_spec.device.backing = \
vim.vm.device.VirtualEthernetCard\
.DistributedVirtualPortBackingInfo()
new_spec.device.backing.port = dvs_port_connection
else:
new_spec.device.backing = \
vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
new_spec.device.backing.network = network_obj
new_spec.device.backing.deviceName = network_obj.name
# format changes for config spec update
dev_changes = []
dev_changes.append(new_spec)
spec = vim.vm.ConfigSpec()
spec.deviceChange = dev_changes
task = vm.ReconfigVM_Task(spec)
self._wait_for_task(task)
return {'state': str(task.info.state)}
def run(self, vm_name, cluster, datastore_cluster,
datastore, resourcepool, cpu_size, ram_size,
guestos, version, description, vsphere=None):
"""
Create barebones VM (CPU/RAM/Graphics)
Args:
- vm_name: Name of Virtual Machine to create
- vsphere: Pre-configured vsphere connection details (config.yaml)
- description: Short Description of VM and it's purpose
- cpu_size: Number of vCPUs to allocate
- ram_size: Ammount of memory to assign (GB)
- datastore_cluster: name of DataStore Cluster to use for VM Files
- datastore: Individual datastore to put vm files within.
Not needed if datastore_cluster is set
- cluster: Cluster within vsphere to host virtual machine
- version: VM version to set
- guestos: Code for GuestOS that will be installed on this VM
- resourepool: vsphere resource pool to assign new VM to
Returns:
- dict: vm moid of newly created vm
"""
# Setup Identifiers for objects
self.establish_connection(vsphere)
si = self.si
si_content = si.RetrieveContent()
# checkinputs.vm_storage(datastore_cluster, datastore)
checkinputs.one_of_two_strings(datastore_cluster,
datastore,
"Datastore Cluster or Datastore")
data_center = self.si_content.rootFolder.childEntity[0]
cluster = inventory.get_cluster(self.si_content, name=cluster)
data_store_cluster = inventory.get_datastore_cluster(
self.si_content,
name=datastore_cluster)
# data_store = inventory.get_datastore(self.si_content, name=datastore)
target_folder = data_center.vmFolder
# If No Resource Pool issued the Default one for
# the Cluster will be selected.
if resourcepool:
resource_pool = inventory.get_resource_pool(self.si_content,
name=resourcepool)
else:
resource_pool = cluster.resourcePool
# Config created that is required for DS selection
# Config is BareBones, CPU RAM no more.
config = vim.vm.ConfigSpec(name=vm_name,
memoryMB=(ram_size * 1024),
numCPUs=cpu_size,
guestId=guestos,
version=version,
cpuHotAddEnabled=True,
memoryHotAddEnabled=True,
annotation=description)
# if Datastore cluster is provided it will find the
# recommended Datastore to store VM files
if datastore_cluster:
podsel = vim.storageDrs.PodSelectionSpec()
podsel.storagePod = data_store_cluster
storage_spec = vim.storageDrs.StoragePlacementSpec(
type='create',
configSpec=config,
resourcePool=resource_pool,
podSelectionSpec=podsel,
folder=target_folder)
# Create Instance of Storage Resource Manager -
# This is used to identify a Recommended Datastore from a Cluster
srm = si_content.storageResourceManager
results = srm.RecommendDatastores(storageSpec=storage_spec)
rec_ds = results.recommendations[0].action[0]\
.relocateSpec.datastore
datastore_path = '[' + rec_ds.name + '] ' + vm_name
else:
# No Datastore Cluster has been offered so using the D
if datastore:
datastore_path = '[' + datastore + '] ' + vm_name
else:
raise Exception('Error No Storage Data Provided')
# Now Datastore is known the remaining
# of VM Config can be setup and added
vmx_file = vim.vm.FileInfo(logDirectory=None,
snapshotDirectory=None,
suspendDirectory=None,
vmPathName=datastore_path)
config.files = vmx_file
# Create task to Build actual Machine
task = target_folder.CreateVM_Task(config=config, pool=resource_pool)
self._wait_for_task(task)
if task.info.state != vim.TaskInfo.State.success:
raise Exception(task.info.error.msg)
return {'vm_id': task.info.result._moId}
def run(self,
vm_name,
cluster,
datastore_cluster,
datastore,
resourcepool,
cpu_size,
ram_size,
guestos,
version,
description,
vsphere=None):
"""
Create barebones VM (CPU/RAM/Graphics)
Args:
- vm_name: Name of Virtual Machine to create
- vsphere: Pre-configured vsphere connection details (config.yaml)
- description: Short Description of VM and it's purpose
- cpu_size: Number of vCPUs to allocate
- ram_size: Ammount of memory to assign (GB)
- datastore_cluster: name of DataStore Cluster to use for VM Files
- datastore: Individual datastore to put vm files within.
Not needed if datastore_cluster is set
- cluster: Cluster within vsphere to host virtual machine
- version: VM version to set
- guestos: Code for GuestOS that will be installed on this VM
- resourepool: vsphere resource pool to assign new VM to
Returns:
- dict: vm moid of newly created vm
"""
# Setup Identifiers for objects
self.establish_connection(vsphere)
si = self.si
si_content = si.RetrieveContent()
# checkinputs.vm_storage(datastore_cluster, datastore)
checkinputs.one_of_two_strings(datastore_cluster, datastore,
"Datastore Cluster or Datastore")
data_center = self.si_content.rootFolder.childEntity[0]
cluster = inventory.get_cluster(self.si_content, name=cluster)
data_store_cluster = inventory.get_datastore_cluster(
self.si_content, name=datastore_cluster)
# data_store = inventory.get_datastore(self.si_content, name=datastore)
target_folder = data_center.vmFolder
# If No Resource Pool issued the Default one for
# the Cluster will be selected.
if resourcepool:
resource_pool = inventory.get_resource_pool(self.si_content,
name=resourcepool)
else:
resource_pool = cluster.resourcePool
# Config created that is required for DS selection
# Config is BareBones, CPU RAM no more.
config = vim.vm.ConfigSpec(name=vm_name,
memoryMB=(ram_size * 1024),
numCPUs=cpu_size,
guestId=guestos,
version=version,
cpuHotAddEnabled=True,
memoryHotAddEnabled=True,
annotation=description)
# if Datastore cluster is provided it will find the
# recommended Datastore to store VM files
if datastore_cluster:
podsel = vim.storageDrs.PodSelectionSpec()
podsel.storagePod = data_store_cluster
storage_spec = vim.storageDrs.StoragePlacementSpec(
type='create',
configSpec=config,
resourcePool=resource_pool,
podSelectionSpec=podsel,
folder=target_folder)
# Create Instance of Storage Resource Manager -
# This is used to identify a Recommended Datastore from a Cluster
srm = si_content.storageResourceManager
results = srm.RecommendDatastores(storageSpec=storage_spec)
rec_ds = results.recommendations[0].action[0]\
.relocateSpec.datastore
datastore_path = '[' + rec_ds.name + '] ' + vm_name
else:
# No Datastore Cluster has been offered so using the D
if datastore:
datastore_path = '[' + datastore + '] ' + vm_name
else:
raise Exception('Error No Storage Data Provided')
# Now Datastore is known the remaining
# of VM Config can be setup and added
vmx_file = vim.vm.FileInfo(logDirectory=None,
snapshotDirectory=None,
suspendDirectory=None,
vmPathName=datastore_path)
config.files = vmx_file
# Create task to Build actual Machine
task = target_folder.CreateVM_Task(config=config, pool=resource_pool)
self._wait_for_task(task)
if task.info.state != vim.TaskInfo.State.success:
raise Exception(task.info.error.msg)
return {'vm_id': task.info.result._moId}
