def _wait_for_updates(self, version='', max_object_updates=None, max_wait_seconds=None):
try:
if self.__api_version >= "4.1":
request = VI.WaitForUpdatesExRequestMsg()
options = request.new_options()
if max_object_updates is not None:
options.set_element_maxObjectUpdates(max_object_updates)
if max_wait_seconds is not None:
options.set_element_maxWaitSeconds(max_wait_seconds)
request.set_element_options(options)
method = self._proxy.WaitForUpdatesEx
else:
if max_wait_seconds is None:
print 'WaitForUpdates'
request = VI.WaitForUpdatesRequestMsg()
method = self._proxy.WaitForUpdates
else:
print 'CheckForUpdates'
request = VI.CheckForUpdatesRequestMsg()
method = self._proxy.CheckForUpdates
_this = request.new__this(self._do_service_content.PropertyCollector)
_this.set_attribute_type(MORTypes.PropertyCollector)
request.set_element__this(_this)
request.set_element_version(version)
retval = method(request)._returnval
return retval
except (VI.ZSI.FaultException), e:
raise VIApiException(e)
def __read_tasks(self, max_count, next_page):
if not isinstance(max_count, int):
raise VIException("max_count should be an integer",
FaultTypes.PARAMETER_ERROR)
if next_page:
request = VI.ReadNextTasksRequestMsg()
else:
request = VI.ReadPreviousTasksRequestMsg()
_this = request.new__this(self._mor)
_this.set_attribute_type(self._mor.get_attribute_type())
request.set_element__this(_this)
request.set_element_maxCount(max_count)
try:
if next_page:
resp = self._server._proxy.ReadNextTasks(request)._returnval
else:
resp = self._server._proxy.ReadPreviousTasks(
request)._returnval
ret = []
for task in resp:
ret.append(VITask(task.Task, self._server))
except (VI.ZSI.FaultException) as e:
raise VIApiException(e)
return ret
def export(server, vm_obj):
# Request an export
request = VI.ExportVmRequestMsg()
_this = request.new__this(vm_obj._mor)
_this.set_attribute_type(vm_obj._mor.get_attribute_type())
request.set_element__this(_this)
ret = server._proxy.ExportVm(request)
# List of urls to download
mor = ret._returnval
http = VIProperty(connection, ret._returnval)
url = http.info.deviceUrl[0].url
# TODO: actually download them.
# Set to 100%
request = VI.HttpNfcLeaseProgressRequestMsg()
_this = request.new__this(mor)
_this.set_attribute_type(MORTypes.HttpNfcLease)
request.set_element__this(_this)
request.set_element_percent(100)
server._proxy.HttpNfcLeaseProgress(request)
# Completes the request
request = VI.HttpNfcLeaseCompleteRequestMsg()
_this = request.new__this(mor)
_this.set_attribute_type(MORTypes.HttpNfcLease)
request.set_element__this(_this)
server._proxy.HttpNfcLeaseComplete(request)
def __read_events(self, max_count, next_page):
"""
Reads the 'scrollable view' from the current position.
"""
if not isinstance(max_count, int):
raise VIException("max_count should be an integer",
FaultTypes.PARAMETER_ERROR)
if next_page:
request = VI.ReadNextEventsRequestMsg()
else:
request = VI.ReadPreviousEventsRequestMsg()
_this = request.new__this(self._mor)
_this.set_attribute_type(self._mor.get_attribute_type())
request.set_element__this(_this)
request.set_element_maxCount(max_count)
try:
if next_page:
resp = self._server._proxy.ReadNextEvents(request)._returnval
else:
resp = self._server._proxy.ReadPreviousEvents(request)._returnval
ret = []
for event in resp:
ret.append(VIProperty(self._server,event))
except (VI.ZSI.FaultException), e:
raise VIApiException(e)
def delete_vm_by_name(self, name, remove_files=True):
"""
Unregisters a VM and remove it files from the datastore by name.
@name is the VM name.
@remove_files - if True (default) will delete VM files from datastore.
"""
statusLine = ''
success = False
if not self.__logged:
raise VIException("Must call 'connect' before invoking this method", FaultTypes.NOT_CONNECTED)
try:
# Get VM
vm = self.get_vm_by_name(name)
if remove_files:
# Invoke Destroy_Task
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
ret = self._proxy.Destroy_Task(request)._returnval
task = VITask(ret, self)
# Wait for the task to finish
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
statusLine = "VM successfully unregistered and deleted from datastore"
success = True
elif status == task.STATE_ERROR:
statusLine = "Error removing vm: {}".format(task.get_error_message())
success = False
else:
# Invoke UnregisterVMRequestMsg
request = VI.UnregisterVMRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
ret = self._proxy.UnregisterVM(request)
task = VITask(ret, self)
statusLine = "VM successfully unregistered (files still on datastore)"
success = True
except VI.ZSI.FaultException as e:
raise VIApiException(e)
finally:
return success, statusLine
def change_cpu(vminstance=None, cpu_number=None, cpu_core=None):
'''Modify the number and core number of the virtual machine CPU'''
vm_obj = vminstance
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm_obj._mor)
_this.set_attribute_type(vm_obj._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
if cpu_number is not None:
spec.set_element_numCPUs(cpu_number) # This sets CPU config to 2x1 (The two cpus are single-core)
if cpu_core is not None:
spec.set_element_numCoresPerSocket(cpu_core) # This sets CPU config to 1x2 (instead of 2x2) 1 CPU dual-core
request.set_element_spec(spec)
ret = server._proxy.ReconfigVM_Task(request)._returnval
task = VITask(ret, server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
print "VM successfully reconfigured"
return True
elif status == task.STATE_ERROR:
print "Error reconfiguring vm: %s" % task.get_error_message()
return False
server.disconnect()
def reconfig(server, vm, cdrom):
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
dev_change = spec.new_deviceChange()
dev_change.set_element_device(cdrom)
dev_change.set_element_operation('edit')
spec.set_element_deviceChange([dev_change])
request.set_element_spec(spec)
ret = server._proxy.ReconfigVM_Task(request)._returnval
task = VITask(ret, server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
return False
def create_dvswitch(vcenter, datacenter, name, uplinks=2):
"""Create a new DVS."""
switch_folder = pysphere.VIProperty(vcenter, datacenter).networkFolder._obj
request = VI.CreateDVS_TaskRequestMsg()
_this = request.new__this(switch_folder)
_this.set_attribute_type(switch_folder.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
config = spec.new_configSpec()
config.Name = name
uplink_policy = (
VI.ns0.DVSNameArrayUplinkPortPolicy_Def('uplink_policy').pyclass())
uplink_policy.UplinkPortName = [
'Uplink%d' % x for x in range(1, uplinks + 1)
]
config.set_element_uplinkPortPolicy(uplink_policy)
spec.set_element_configSpec(config)
request.set_element_spec(spec)
task = vcenter._proxy.CreateDVS_Task(request)._returnval
vi_task = pysphere.VITask(task, vcenter)
status = vi_task.wait_for_state(
[vi_task.STATE_SUCCESS, vi_task.STATE_ERROR])
if status == vi_task.STATE_ERROR:
raise CreateDvSwitchError(vi_task.get_error_message())
def _build_create_vm_request(target_config, datastore, vm_name, memory,
num_cpus, osid, resource_pool, vmfolder, version):
"""Creates a new VM create request and populates the config field.
Return:
(CreateVM_TaskRequestMsg, CreateVM_TaskRequestMsg.config)
"""
create_vm_request = VI.CreateVM_TaskRequestMsg()
config = create_vm_request.new_config()
config.set_element_version(version)
vmfiles = config.new_files()
vmfiles.set_element_vmPathName(datastore)
config.set_element_files(vmfiles)
config.set_element_name(vm_name)
config.set_element_memoryMB(memory / 1024 / 1024)
config.set_element_numCPUs(num_cpus)
config.set_element_guestId(osid)
config.set_element_firmware('efi')
create_vm_request.set_element_config(config)
# Reference to what vSphere refers to as a 'Folder' that will handle the call
mor = create_vm_request.new__this(vmfolder)
mor.set_attribute_type(vmfolder.get_attribute_type())
create_vm_request.set_element__this(mor)
# Set which resource pool to use
mor = create_vm_request.new_pool(resource_pool)
mor.set_attribute_type(resource_pool.get_attribute_type())
create_vm_request.set_element_pool(mor)
return create_vm_request, config
def query_perf_provider_summary(self, entity):
"""Returns a ProviderSummary object for a ManagedObject for which
performance statistics can be queried. Also indicates whether current or
summary statistics are supported. If the input managed entity is not a
performance provider, an InvalidArgument exception is thrown.
entity [mor]: The ManagedObject for which available performance metrics
are queried.
"""
if not entity:
raise VIException("No Entity specified.",
FaultTypes.PARAMETER_ERROR)
try:
request = VI.QueryPerfProviderSummaryRequestMsg()
mor_qpps = request.new__this(self._mor)
mor_qpps.set_attribute_type(self._mor.get_attribute_type())
request.set_element__this(mor_qpps)
qpps_entity = request.new_entity(entity)
qpps_entity.set_attribute_type(entity.get_attribute_type())
request.set_element_entity(qpps_entity)
qpps = self._server._proxy.QueryPerfProviderSummary(
request)._returnval
return qpps
except (VI.ZSI.FaultException) as e:
raise VIApiException(e)
def delete_instance(self, name=None):
# Check if name is passed, if not extract from vm_json
if not name:
name = self.vm_json.get('name')
# Initialise vcenter handle
vcenter_handle = self.server
try:
vm = vcenter_handle.get_vm_by_name(name)
except Exception:
logger.info('VM %s not present in vCenter. This is OK' % name)
return
# Power off if not already
if not vm.is_powered_off():
vm.power_off()
# Invoke Destroy_Task
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
ret = vcenter_handle._proxy.Destroy_Task(request)._returnval
# Wait for the task to finish
task = VITask(ret, vcenter_handle)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
logger.info('VM %s successfully deleted from disk' % name)
elif status == task.STATE_ERROR:
logger.info('Error removing vm: %s' % task.get_error_message())
def create_folder(viserver, root_folder, new_name):
request = VI.CreateFolderRequestMsg()
_this = request.new__this(root_folder)
_this.set_attribute_type(root_folder.get_attribute_type())
request.set_element__this(_this)
request.set_element_name(new_name)
viserver._proxy.CreateFolder(request)
def delete_vm(vm):
vm_name = vm.get_property('name', from_cache=False)
log("Preparing to delete VM %s..." % vm_name)
vm_status = vm.get_status()
log("VM status: %s" % vm_status)
if vm_status == "POWERED OFF" or vm_status == "POWERING OFF":
log("VM power state: %s" % vm_status)
else:
log("Powering off VM %s..." % vm_name)
vm.power_off()
log("Deleting VM %s..." % vm_name)
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
ret = server._proxy.Destroy_Task(request)._returnval
# Wait for the delete task to finish
task = VITask(ret, server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
log("VM successfully deleted from disk.")
elif status == task.STATE_ERROR:
error_msg = "Error while deleting VM: " + task.get_error_message()
raise Exception(error_msg)
def add_vdisk(self, vminstance, datastore_name, vdisk_size_gb):
'''add disk'''
vdisk_size_kb = vdisk_size_gb * 1024 * 1024
vm = vminstance
# Virtual device node number
Unit_Number = ""
Temp_Number = 1
# find the device to be removed
while True:
dev = [
dev for dev in vm.properties.config.hardware.device
if dev._type == "VirtualDisk" and dev.unitNumber == Temp_Number
]
if len(dev) == 0:
Unit_Number = Temp_Number
break
else:
Temp_Number += 1
continue
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
dc = spec.new_deviceChange()
dc.Operation = "add"
dc.FileOperation = "create"
hd = VI.ns0.VirtualDisk_Def("hd").pyclass()
hd.Key = -100
hd.UnitNumber = Unit_Number
hd.CapacityInKB = vdisk_size_kb
hd.ControllerKey = 1000
backing = VI.ns0.VirtualDiskFlatVer2BackingInfo_Def(
"backing").pyclass()
backing.FileName = "[%s]" % datastore_name
backing.DiskMode = "persistent"
backing.Split = False
backing.WriteThrough = False
backing.ThinProvisioned = False
backing.EagerlyScrub = False
hd.Backing = backing
dc.Device = hd
spec.DeviceChange = [dc]
request.Spec = spec
task = self.s._proxy.ReconfigVM_Task(request)._returnval
vi_task = VITask(task, self.s)
# Wait for task to finis
status = vi_task.wait_for_state(
[vi_task.STATE_SUCCESS, vi_task.STATE_ERROR])
if status == vi_task.STATE_ERROR:
print "ERROR: %s" % (vi_task.STATE_ERROR)
return False
else:
return True
self.s.disconnect()
def enable_vmi(server, vm_obj):
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm_obj._mor)
_this.set_attribute_type(vm_obj._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
device_config_specs = []
media_device = VirtualMachineVMIROM()
media_device.set_element_key(11000)
device_config_spec = spec.new_deviceChange()
device_config_spec.set_element_operation('add')
device_config_spec.set_element_device(media_device)
device_config_specs.append(device_config_spec)
spec.set_element_deviceChange(device_config_specs)
request.set_element_spec(spec)
ret = server._proxy.ReconfigVM_Task(request)._returnval
# Wait for the task to finish
task = VITask(ret, server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status != task.STATE_SUCCESS:
raise HypervisorError("Guest:update %s" % task.get_error_message())
def set_vm_reservation(server,types,vm_name,reservation,level):
vm_mor = server.get_vm_by_name(vm_name)
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm_mor._mor)
_this.set_attribute_type(vm_mor._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
if types == 'cpu':
spec.set_element_numCPUs(reservation)
elif types == 'memory':
spec.set_element_memoryMB(reservation)
request.set_element_spec(spec)
ret = server._proxy.ReconfigVM_Task(request)._returnval
config_result = False
task = VITask(ret, server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
ret = "VM <" + vm_name + "> successfully reconfigured"
config_result = True
elif status == task.STATE_ERROR:
#print "Error reconfiguring vm <" + vm_name + ">: %s" % task.get_error_message()
#print task.get_info()
#print task.get_result()
#print task.get_state()
#print task.info
ret = "Error reconfiguring vm <" + vm_name + ">: %s" % task.get_error_message()
config_result = False
return config_result
def provision_vm(server, vm, vlan, datacenter):
# Set VMs first NIC to the correct label
hardware = pysphere.VIProperty(server, vm).config.hardware
nic = next(
(x._obj for x in hardware.device if x._type in NET_DEVICE_TYPES), None)
if not nic:
raise NicNotFoundError('No NIC found')
# Only vCenter has the correct notion of a datacenter, so if talking to
# an ESXi assume it is called ha-datacenter instead.
dc = datacenter if 'vCenter' in server.get_server_type(
) else 'ha-datacenter'
datacenter_props = _get_datacenter_props(server, dc)
nic.set_element_backing(create_nic_backing(server, vlan, datacenter_props))
# Submit reconfig request
# Copy/paste from pysphere mailinglist
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm)
_this.set_attribute_type(vm.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
dev_change = spec.new_deviceChange()
dev_change.set_element_device(nic)
dev_change.set_element_operation('edit')
spec.set_element_deviceChange([dev_change])
request.set_element_spec(spec)
ret = server._proxy.ReconfigVM_Task(request)._returnval
task = pysphere.VITask(ret, server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if task.get_state() == task.STATE_ERROR:
raise ProvisionVmError(task.get_error_message())
def query_perf_counter(self, counter_id):
"""Retrieves counter information for the list of counter IDs passed in.
counter_id [list]: list of integers containing the counter IDs.
"""
if counter_id:
if not isinstance(counter_id, list):
raise VIException("counter_id must be a list",
FaultTypes.PARAMETER_ERROR)
else:
raise VIException("No counter_id specified.",
FaultTypes.PARAMETER_ERROR)
try:
request = VI.QueryPerfCounterRequestMsg()
mor_qpc = request.new__this(self._mor)
mor_qpc.set_attribute_type(self._mor.get_attribute_type())
request.set_element__this(mor_qpc)
request.set_element_counterId(counter_id)
qpc = self._server._proxy.QueryPerfCounter(request)._returnval
return qpc
except (VI.ZSI.FaultException) as e:
raise VIApiException(e)
def delete_vm(vsphere_client, module, guest, vm, force):
try:
if vm.is_powered_on():
if force:
try:
vm.power_off(sync_run=True)
vm.get_status()
except Exception, e:
module.fail_json(
msg='Failed to shutdown vm %s: %s' % (guest, e))
else:
module.fail_json(
msg='You must use either shut the vm down first or '
'use force ')
# Invoke Destroy_Task
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
ret = vsphere_client._proxy.Destroy_Task(request)._returnval
task = VITask(ret, vsphere_client)
# Wait for the task to finish
status = task.wait_for_state(
[task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_ERROR:
vsphere_client.disconnect()
module.fail_json(msg="Error removing vm: %s %s" %
task.get_error_message())
module.exit_json(changed=True, changes="VM %s deleted" % guest)
def network_config(base_name, vlan_name, connect=True):
vm = conn.get_vm_by_name(base_name)
net_device = []
for dev in vm.properties.config.hardware.device:
if dev._type in [
"VirtualE1000", "VirtualE1000e", "VirtualPCNet32",
"VirtualVmxnet", "VirtualNmxnet2", "VirtualVmxnet3"
]:
net_device.append(dev._obj)
if len(net_device) == 0:
raise Exception("The vm seems to lack a Virtual Nic")
for dev_eth in net_device:
dev_eth.Backing.set_element_deviceName(vlan_name)
dev_eth.Connectable.Connected = connect
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
dev_change = spec.new_deviceChange()
dev_change.set_element_device(dev_eth)
dev_change.set_element_operation('edit')
spec.set_element_deviceChange([dev_change])
request.set_element_spec(spec)
ret = conn._proxy.ReconfigVM_Task(request)._returnval
task = VITask(ret, conn)
#task_status(task)
print 'set vlan %s' % dev_eth.Backing.DeviceName
print 'set eth connected'
def ReconfigureVM(vm, cdrom):
# create a new VM Reconfigure Task
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
# new device change spec
spec = request.new_spec()
dev_change = spec.new_deviceChange()
dev_change.set_element_device(cdrom)
dev_change.set_element_operation("edit")
spec.set_element_deviceChange([dev_change])
request.set_element_spec(spec)
ret = server._proxy.ReconfigVM_Task(request)._returnval
task = VITask(ret, server)
status = task.wait_for_state([task.STATE_SUCCESS,task.STATE_ERROR])
if status == task.STATE_SUCCESS:
print "%s: successfully reconfigured" % vm.properties.name
return True
elif status == task.STATE_ERROR:
print "%s: Error reconfiguring vm"% vm.properties.name
return False
def validate_host(host_name, ovf_descriptor, server):
u"""Analysis OVF file.
@param host_name Host name
@param ovf_descriptor Data in OVF file
@param server Instance of VIServer
@return Result of analysed OVF file.
"""
# Import
from pysphere.resources import VimService_services as VI
hosts = server.get_hosts()
host = [k for k, v in hosts.items() if v == host_name][0]
if not host:
raise ValueError("invalid ESX host name")
ovf_manager = server._do_service_content.OvfManager
request = VI.ValidateHostRequestMsg()
_this = request.new__this(ovf_manager)
_this.set_attribute_type(ovf_manager.get_attribute_type())
request.set_element__this(_this)
request.set_element_ovfDescriptor(ovf_descriptor)
h = request.new_host(host)
h.set_attribute_type(host.get_attribute_type())
request.set_element_host(h)
vhp = request.new_vhp()
vhp.set_element_locale("")
vhp.set_element_deploymentOption("")
request.set_element_vhp(vhp)
return server._proxy.ValidateHost(request)._returnval
def guest_command(serve, machine, program, command): request = VI.StartProgramInGuestRequestMsg() _this = request.new__this(machine._proc_mgr) _this.set_attribute_type(machine._proc_mgr.get_attribute_type()) request.set_element__this(_this) vm = request.new_vm(machine._mor) vm.set_attribute_type(machine._mor.get_attribute_type()) request.set_element_vm(vm) request.set_element_auth(machine._auth_obj) spec = request.new_spec() spec.set_element_programPath(program) spec.set_element_arguments(command) request.set_element_spec(spec) result = serve._proxy.StartProgramInGuest(request)._returnval return result
def add_nic(vm, vcenter, net_label="DEFAULT_LABEL"):
''' Adds a NIC to the host. Returns a VITask object.
@vm: A VIVirtualMachine object.
@vcenter: An authenticated VIServer object.
@net_label: The network label to apply to the NIC.
'''
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
dev_change = spec.new_deviceChange()
dev_change.set_element_operation("add")
# We use a VMXNET3 controller here. Introspect into
# VI.ns0 for all available controller names.
nic_ctlr = VI.ns0.VirtualVmxnet3_Def("nic_ctlr").pyclass()
nic_backing = VI.ns0.VirtualEthernetCardNetworkBackingInfo_Def("nic_backing").pyclass()
nic_backing.set_element_deviceName(net_label)
nic_ctlr.set_element_addressType("generated")
nic_ctlr.set_element_backing(nic_backing)
nic_ctlr.set_element_key(4)
dev_change.set_element_device(nic_ctlr)
spec.set_element_deviceChange([dev_change])
request.set_element_spec(spec)
vcenter._proxy.ReconfigVM_Task(request)
def destroy(self, sync_run=True):
"""
Destroys this object, deleting its contents and removing it from its
parent folder (if any)
* sync_run: (default True), If False does not wait for the task to
finish and returns an instance of a VITask for the user to monitor
its progress
"""
try:
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(self._mor)
_this.set_attribute_type(self._mor.get_attribute_type())
request.set_element__this(_this)
task = self._server._proxy.Destroy_Task(request)._returnval
vi_task = VITask(task, self._server)
if sync_run:
status = vi_task.wait_for_state(
[vi_task.STATE_SUCCESS, vi_task.STATE_ERROR])
if status == vi_task.STATE_ERROR:
raise VIException(vi_task.get_error_message(),
FaultTypes.TASK_ERROR)
return
return vi_task
except (VI.ZSI.FaultException) as e:
raise VIApiException(e)
def rename(self, new_name, sync_run=True):
"""
Renames this managed entity.
* new_name: Any / (slash), \ (backslash), character used in this name
element will be escaped. Similarly, any % (percent) character used
in this name element will be escaped, unless it is used to start an
escape sequence. A slash is escaped as %2F or %2f. A backslash is
escaped as %5C or %5c, and a percent is escaped as %25.
* sync_run: (default True), If False does not wait for the task to
finish and returns an instance of a VITask for the user to monitor
its progress
"""
try:
request = VI.Rename_TaskRequestMsg()
_this = request.new__this(self._mor)
_this.set_attribute_type(self._mor.get_attribute_type())
request.set_element__this(_this)
request.set_element_newName(new_name)
task = self._server._proxy.Rename_Task(request)._returnval
vi_task = VITask(task, self._server)
if sync_run:
status = vi_task.wait_for_state(
[vi_task.STATE_SUCCESS, vi_task.STATE_ERROR])
if status == vi_task.STATE_ERROR:
raise VIException(vi_task.get_error_message(),
FaultTypes.TASK_ERROR)
return
return vi_task
except (VI.ZSI.FaultException) as e:
raise VIApiException(e)
def _create_filter(self, property_names=[],
from_node=None, obj_type='ManagedEntity', partial_updates=True):
"""Creates filter with given parameters and returns its MOR"""
try:
if not from_node:
from_node = self._do_service_content.RootFolder
elif isinstance(from_node, tuple) and len(from_node) == 2:
from_node = VIMor(from_node[0], from_node[1])
elif not VIMor.is_mor(from_node):
raise VIException("from_node must be a MOR object or a "
"(<str> mor_id, <str> mor_type) tuple",
FaultTypes.PARAMETER_ERROR)
request = VI.CreateFilterRequestMsg()
_this = request.new__this(self._do_service_content.PropertyCollector)
_this.set_attribute_type(MORTypes.PropertyCollector)
request.set_element__this(_this)
request.set_element_partialUpdates(partial_updates)
spec = request.new_spec()
propSet = spec.new_propSet()
propSet.set_element_type(obj_type)
propSet.set_element_pathSet(property_names)
spec.set_element_propSet([propSet])
objects_set = self._get_traversal_objects_set(spec, from_node)
spec.set_element_objectSet(objects_set)
request.set_element_spec(spec)
mor = self._proxy.CreateFilter(request)._returnval
return mor
except (VI.ZSI.FaultException), e:
raise VIApiException(e)
def disconnect_nic_from_network(vCenterserver,
username,
password,
datacentername,
vmname,
dvswitch_uuid,
portgroupKey,
network_name="VM Network",
nic_type="vmxnet3",
network_type="standard"):
con = vs_connect(vCenterserver, username, password)
vm_obj = con.get_vm_by_name(vmname, datacenter=datacentername)
#Disconnect 3rd adaptar if its connected to network "VM Network"
#network_name = "VM Network"
device_name = "Network adapter 3"
#Find Virtual Nic device
net_device = None
for dev in vmname.properties.config.hardware.device:
if (dev._type in [
"VirtualE1000", "VirtualE1000e", "VirtualPCNet32",
"VirtualVmxnet", "VirtualNmxnet2", "VirtualVmxnet3"
] and dev.deviceInfo.label == network_name
and dev.deviceInfo.summary == device_name):
net_device = dev._obj
break
if not net_device:
s.disconnect()
raise Exception("The vm seems to lack a Virtual Nic")
#Disconnect the device
net_device.Connectable.Connected = True
#Invoke ReconfigVM_Task
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vmname._mor)
_this.set_attribute_type(vmname._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
dev_change = spec.new_deviceChange()
dev_change.set_element_device(net_device)
dev_change.set_element_operation("edit")
spec.set_element_deviceChange([dev_change])
request.set_element_spec(spec)
ret = s._proxy.ReconfigVM_Task(request)._returnval
#Wait for the task to finish
task = VITask(ret, s)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
print "VM successfully reconfigured"
elif status == task.STATE_ERROR:
print "Error reconfiguring vm:", task.get_error_message()
s.disconnect()
def deleteVm(self, vmName):
"""
Delete the vm from disk according to the name passed as argument
@param vmName: name of the virtual machine to delete
@type vmName: string
@return: True on success, False otherwise
@rtype: boolean
"""
ret = False
if not self.__connected:
return ret
# log message
content = {
'vsphere-host': self.__host,
'cmd': 'delete-vm',
'vm-name': vmName
}
tpl = self.template(name=self.__class__.__name__.upper(),
content=content)
self.logRequest(msg="delete vm", details=tpl)
try:
try:
vm = self.__server.get_vm_by_name(vmName)
except Exception as e:
raise Exception("VM %s not found!" % vmName)
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
r = self.__server._proxy.Destroy_Task(request)._returnval
task = VITask(r, self.__server)
status = task.wait_for_state(
[task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_ERROR:
raise Exception("Error removing vm:", task.get_error_message())
ret = True
content = {
"result": "success",
"cmd": "delete-vm",
'vm-name': vmName
}
tpl = self.template(name=self.__class__.__name__.upper(),
content=content)
self.logResponse(msg="delete vm", details=tpl)
except Exception as e: # log message
content = {"vsphere-error": "%s" % e, "cmd": "delete-vm"}
tpl = self.template(name=self.__class__.__name__.upper(),
content=content)
self.logResponse(msg="delete vm error", details=tpl)
return ret
def register_vm(self, path, name=None, sync_run=True, folder=None,
template=False, resourcepool=None, host=None):
"""Adds an existing virtual machine to the folder.
@path: a datastore path to the virtual machine.
Example "[datastore] path/to/machine.vmx".
@name: the name to be assigned to the virtual machine.
If this parameter is not set, the displayName configuration
parameter of the virtual machine is used.
@sync_run: if True (default) waits for the task to finish, and returns
a VIVirtualMachine instance with the new VM (raises an exception if
the task didn't succeed). If @sync_run is set to False the task is
started and a VITask instance is returned
@folder_name: folder in which to register the virtual machine.
@template: Flag to specify whether or not the virtual machine
should be marked as a template.
@resourcepool: MOR of the resource pool to which the virtual machine should
be attached. If imported as a template, this parameter is not set.
@host: The target host on which the virtual machine will run. This
parameter must specify a host that is a member of the ComputeResource
indirectly specified by the pool. For a stand-alone host or a cluster
with DRS, the parameter can be omitted, and the system selects a default.
"""
if not folder:
folders = self._get_managed_objects(MORTypes.Folder)
folder = [_mor for _mor, _name in folders.iteritems()
if _name == 'vm'][0]
try:
request = VI.RegisterVM_TaskRequestMsg()
_this = request.new__this(folder)
_this.set_attribute_type(folder.get_attribute_type())
request.set_element__this(_this)
request.set_element_path(path)
if name:
request.set_element_name(name)
request.set_element_asTemplate(template)
if resourcepool:
pool = request.new_pool(resourcepool)
pool.set_attribute_type(resourcepool.get_attribute_type())
request.set_element_pool(pool)
if host:
if not VIMor.is_mor(host):
host = VIMor(host, MORTypes.HostSystem)
hs = request.new_host(host)
hs.set_attribute_type(host.get_attribute_type())
request.set_element_host(hs)
task = self._proxy.RegisterVM_Task(request)._returnval
vi_task = VITask(task, self)
if sync_run:
status = vi_task.wait_for_state([vi_task.STATE_SUCCESS,
vi_task.STATE_ERROR])
if status == vi_task.STATE_ERROR:
raise VITaskException(vi_task.info.error)
return
return vi_task
except (VI.ZSI.FaultException), e:
raise VIApiException(e)
