def destroy(self):
from utils import VM_STATUS
if self.get_state() == VM_STATUS[0]:
self.poweroff()
print 'Destroy vm {}'.format(self.name())
destroy_task = self.vm.Destroy()
task.WaitForTask(task=destroy_task, si=self.si, raiseOnError=False)
def reset(self):
from utils import VM_STATUS
if self.get_state() != VM_STATUS[0]:
print 'VM {} not power on and can not reset.'.format(self.name())
return
print 'Reset vm {}'.format(self.name())
reset_task = self.vm.Reset()
task.WaitForTask(task=reset_task, si=self.si)
def poweroff(self):
from utils import VM_STATUS
if self.get_state() == VM_STATUS[1]:
print 'VM {} already power off.'.format(self.name())
return
print 'Power off vm {}'.format(self.name())
power_task = self.vm.PowerOff()
task.WaitForTask(task=power_task, si=self.si)
def search_file(self, vm_name, file_name):
spec = vim.host.DatastoreBrowser.SearchSpec()
spec.matchPattern = [file_name]
browser = self.ds.browser
search_task = browser.SearchDatastoreSubFolders_Task(
'[{}] {}/'.format(self.name(), vm_name), spec)
task.WaitForTask(task=search_task, si=self.si, raiseOnError=False)
file_list = search_task.info.result[0].file
return False if len(file_list) == 0 else True
def clone(self, name):
relocate_spec = vim.vm.RelocateSpec()
relocate_spec.pool = self.vm.resourcePool
clone_spec = vim.vm.CloneSpec(powerOn=False,
template=False,
location=relocate_spec,
customization=None)
print 'Clone vm {} from {}'.format(name, self.name())
clone_task = self.vm.Clone(self.vm.parent, name, clone_spec)
task.WaitForTask(task=clone_task, si=self.si, raiseOnError=False)
def add_host(self, hostConnectSpec):
"""Adds host to a cluster.
@param hostConnectSpec: vim.host.ConnectSpec
"""
hosttask = self.mor.AddHost_Task(
spec=hostConnectSpec,
asConnected=True)
task.WaitForTask(task=hosttask, si=self.si)
def migrate(self, dest_host, dest_datastore):
# Support change both host and datastore
vm_relocate_spec = vim.vm.RelocateSpec()
vm_relocate_spec.host = dest_host.host_system
vm_relocate_spec.pool = self.vm.resourcePool
vm_relocate_spec.datastore = dest_datastore.ds
print "Migrating {} to datastore {} on destination host {}."\
.format(self.vm.name,
dest_datastore.ds.name,
dest_host.host_system.name)
vmotion_task = self.vm.Relocate(spec=vm_relocate_spec)
task.WaitForTask(task=vmotion_task, si=self.si, raiseOnError=False)
def maintenance(self, action='enter'):
actions = ['enter', 'exit']
action = action.lower()
if action not in actions:
print 'Action {} not support on host {}'\
.format(action, self.host_system.name)
return
print 'Host {} {} maintenance mode.'.format(self.host_system.name,
action)
if action == 'enter':
main_task = self.host_system.EnterMaintenanceMode(0)
else:
main_task = self.host_system.ExitMaintenanceMode(0)
task.WaitForTask(task=main_task, si=self.si, raiseOnError=False)
def reconnect(self, user=None, pwd=None, fingerprint=None):
cnxspec = vim.host.ConnectSpec()
cnxspec.hostName = self.name()
cnxspec.force = True
if user is not None:
cnxspec.userName = user
if pwd is not None:
cnxspec.password = pwd
if fingerprint is not None:
cnxspec.sslThumbprint = fingerprint
reconnectspec = vim.HostSystem.ReconnectSpec()
reconnectspec.syncState = True
print 'Reconnect host {}'.format(self.name())
reconnect_task = self.host_system.ReconnectHost_Task(cnxspec,
reconnectspec)
task.WaitForTask(task=reconnect_task, si=self.si)
def get_log_bundle(self):
def get_all_host_systems():
vmgr = self.si.RetrieveContent().viewManager
invtvw = vmgr.CreateContainerView(
container=self._get_root_folder(),
type=[vim.HostSystem],
recursive=True)
return [h for h in invtvw.view]
content = self.si.RetrieveContent()
dmgr = content.diagnosticManager
generate_task = dmgr.GenerateLogBundles_Task(
includeDefault=True,
host=get_all_host_systems())
task.WaitForTask(generate_task, self.si)
bundles = [b.url.replace("*", self.host)
for b in generate_task.info.result]
return bundles
def add_nic(self, nic_type, net_name, net_type):
devices = []
nicspec = vim.vm.device.VirtualDeviceSpec()
nicspec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
# For now hard code change it to to use string nic_type
nicspec.device = vim.vm.device.VirtualVmxnet3()
nicspec.device.wakeOnLanEnabled = True
nicspec.device.deviceInfo = vim.Description()
# Configuration for DVPortgroups
if net_type == "dvs":
pg_obj = self.get_obj(self.si,
[vim.dvs.DistributedVirtualPortgroup],
net_name)
dvs_port_connection = vim.dvs.PortConnection()
dvs_port_connection.portgroupKey = pg_obj.key
dvs_port_connection.switchUuid = pg_obj.config.\
distributedVirtualSwitch.uuid
nicspec.device.backing = vim.vm.device.VirtualEthernetCard.\
DistributedVirtualPortBackingInfo()
nicspec.device.backing.port = dvs_port_connection
else:
# Configuration for Standard switch port groups
nicspec.device.backing = vim.vm.device.\
VirtualEthernetCard.NetworkBackingInfo()
nicspec.device.backing.network = self.get_obj(self.si,
[vim.Network],
net_name)
nicspec.device.backing.deviceName = net_name
nicspec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nicspec.device.connectable.startConnected = True
nicspec.device.connectable.allowGuestControl = True
devices.append(nicspec)
vmconf = vim.vm.ConfigSpec(deviceChange=devices)
reconfig_task = self.vm.ReconfigVM_Task(vmconf)
task.WaitForTask(task=reconfig_task, si=self.si)
def add_nic(self, network):
"""Add a nic and connect to network.
:param network: Network or DistributedVirtualPortgroup
"""
LOG.info('Add network %s to VM %s' % (network.name, self.name))
devices = []
nicspec = vim.vm.device.VirtualDeviceSpec()
nicspec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
# For now hard code change it to to use string nic_type
nicspec.device = vim.vm.device.VirtualVmxnet3()
nicspec.device.wakeOnLanEnabled = True
nicspec.device.deviceInfo = vim.Description()
net_mor = network.mor
if isinstance(net_mor, vim.dvs.DistributedVirtualPortgroup):
# Configuration for DVPortgroups
dvs_port_connection = vim.dvs.PortConnection()
dvs_port_connection.portgroupKey = net_mor.key
dvs_port_connection.switchUuid = net_mor.config.\
distributedVirtualSwitch.uuid
nicspec.device.backing = vim.vm.device.VirtualEthernetCard.\
DistributedVirtualPortBackingInfo()
nicspec.device.backing.port = dvs_port_connection
else:
# Configuration for Standard switch port groups
nicspec.device.backing = vim.vm.device.\
VirtualEthernetCard.NetworkBackingInfo()
nicspec.device.backing.network = net_mor
nicspec.device.backing.deviceName = net_mor.name
nicspec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nicspec.device.connectable.startConnected = True
nicspec.device.connectable.allowGuestControl = True
devices.append(nicspec)
vmconf = vim.vm.ConfigSpec(deviceChange=devices)
reconfig_task = self.mor.ReconfigVM_Task(vmconf)
task.WaitForTask(task=reconfig_task, si=self.si)
def poweroff(self):
LOG.info('Power off %s' % self.name)
poweroff_task = self.mor.PowerOff(force=True)
task.WaitForTask(task=poweroff_task, si=self.si)
def enable_drs(self, enable=True):
spec = vim.cluster.ConfigSpec(
drsConfig=vim.cluster.DrsConfigInfo(enabled=enable))
rcfg_task = self.mor.ReconfigureCluster_Task(
spec=spec, modify=True)
task.WaitForTask(task=rcfg_task, si=self.si)
def create_dvs(self, spec):
dvs_task = self.mor.networkFolder.CreateDVS_Task(spec)
task.WaitForTask(task=dvs_task, si=self.si)
return DistributedVirtualSwitch(self.si, dvs_task.info.result)
def destroy(self):
destroy_task = self.net.Destroy()
print 'Delete network {}'.format(self.name())
task.WaitForTask(task=destroy_task, si=self.si)
def poweroff(self):
print 'Power off vApp {}'.format(self.name())
poweroff_task = self.vapp.PowerOff(force=True)
task.WaitForTask(task=poweroff_task, si=self.si)
def destroy(self):
destroy_task = self.folder.Destroy()
print 'Delete folder {}'.format(self.name())
task.WaitForTask(task=destroy_task, si=self.si)
def snapshot(self, snap_name):
print 'Take snapshot {} on {}'.format(snap_name, self.name())
snapshot_task = self.vm.CreateSnapshot(snap_name, snap_name, True, True)
task.WaitForTask(task=snapshot_task, si=self.si, raiseOnError=False)
def destroy(self):
print 'Destroy vApp {}'.format(self.name())
destroy_task = self.vapp.Destroy()
task.WaitForTask(task=destroy_task, si=self.si)
def create_dvs(self, spec):
dvs_task = self.dc.networkFolder.CreateDVS_Task(spec)
task.WaitForTask(task=dvs_task, si=self.si)
return self.get_dvs_by_name(spec.configSpec.name)
def poweron(self):
print 'Power on vApp {}'.format(self.name())
poweron_task = self.vapp.PowerOn()
task.WaitForTask(task=poweron_task, si=self.si)
def reboot(self):
print 'Reboot host {}'.format(self.name())
reboot_task = self.host_system.RebootHost_Task(True)
task.WaitForTask(task=reboot_task, si=self.si)
def reconfig_dvs(self, spec):
dvs_config_task = self.dvs.ReconfigureDvs_Task(spec)
task.WaitForTask(task=dvs_config_task, si=self.si)
return dvs_config_task.info.result
def poweron(self):
LOG.info('Power on %s' % self.name)
poweron_task = self.mor.PowerOn()
task.WaitForTask(task=poweron_task, si=self.si)
def shutdown(self):
print 'Shut down host {}'.format(self.name())
shutdown_task = self.host_system.ShutdownHost_Task(True)
task.WaitForTask(task=shutdown_task, si=self.si)
def disconnect(self):
print 'Disconnect host {} from vc cluster'.format(self.name())
disconnect_task = self.host_system.DisconnectHost_Task()
task.WaitForTask(task=disconnect_task, si=self.si)
def _destroy(self):
LOG.info('Destroy %s' % self.name)
destroy_task = self.mor.Destroy()
task.WaitForTask(task=destroy_task, si=self.si)
def add_portgroup(self, spec):
pg_task = self.dvs.AddDVPortgroup_Task([spec])
task.WaitForTask(task=pg_task, si=self.si)
return pg_task.info.result
