def get_vm_by_name(self, name, datacenter=None):
"""
Returns an instance of VIVirtualMachine. Where its name matches @name.
The VM is searched throughout all the datacenters, unless the name or
MOR of the datacenter the VM belongs to is provided. The first instance
matching @name is returned.
NOTE: As names might be duplicated is recommended to use get_vm_by_path
instead.
"""
if not self.__logged:
raise VIException(
"Must call 'connect' before invoking this method",
FaultTypes.NOT_CONNECTED)
try:
nodes = [None]
if datacenter and VIMor.is_mor(datacenter):
nodes = [datacenter]
elif datacenter:
dc = self.get_datacenters()
nodes = [k for k, v in dc.iteritems() if v == datacenter]
for node in nodes:
vms = self._get_managed_objects(MORTypes.VirtualMachine,
from_mor=node)
for k, v in vms.iteritems():
if v == name:
return VIVirtualMachine(self, k)
except (VI.ZSI.FaultException), e:
raise VIApiException(e)
def get_vm_by_uuid(server, guest_id):
request = VI.FindByUuidRequestMsg()
mor_search_index = request.new__this(
server._do_service_content.SearchIndex)
mor_search_index.set_attribute_type('SearchIndex')
request.set_element__this(mor_search_index)
request.set_element_uuid(guest_id)
request.set_element_vmSearch(True)
vm = server._proxy.FindByUuid(request)._returnval
if vm is not None:
return VIVirtualMachine(server, vm)
def clone(self, hostname, template, clone_name):
'''
cloneVM clones a vm based on a previous vm:
**to clone based on a template see deployVM
vm_name is the name of the new vm
clone_vm is what you are cloning from
'''
vm_name = self.vm_json.get('name')
if template == "server":
clname = "ServerTemplate"
cluster_name = "TestNet"
elif template == "test":
clname = "TestingTemplate"
cluster_name = "TestNet"
elif template == "se":
clname = "SETemplate"
cluster_name = "TestNet"
elif template == "controller":
clname = "ControllerTemplate"
cluster_name = "TestNet"
elif template == "unittest":
clname = "jenkins-clone-unit-test"
cluster_name = "TestNet"
all_vms = self.server._get_managed_objects(MORTypes.VirtualMachine,
from_mor=None)
vm = None
target_name = clname
for mor, name in all_vms.iteritems():
if name == target_name:
vm = VIVirtualMachine(self.server, mor)
break
if not vm:
raise Exception("VM template not found")
resource_pool = "/Resources"
cluster = [
k for k, v in self.server.get_clusters().items()
if v == cluster_name
][0]
rpmor = [
k for k, v in self.server.get_resource_pools(
from_mor=cluster).items() if v == resource_pool
][0]
try:
logger.info("Starting Clone operation \n")
vm.clone(clone_name, resourcepool=rpmor)
logger.info(
"Clone Successful, please check vmware in about 20 minutes to see it."
)
except VIException:
logger.info("VI Exception")
def deploy(self, cluster_name, template_name, new_vm):
'''
deployVM is similar to a clone, but based off of a template
Arguments:
cluster_name: e.g.: TestNet
template_name: template you wish to clone from, e.g.: apache-template
new_vm: name of the new vm
'''
# like clone but only based off of a template. clone can only work with
# a vm
s = self.server
# find all vms that are templates
all_vms = s._get_managed_objects(MORTypes.VirtualMachine,
from_mor=None)
# you can filter from cluster, datacenter, host, etc by setting
# 'from_mor' parameter to a managed object reference
vm = None
target_name = template_name
for mor, name in all_vms.iteritems():
if name == target_name:
vm = VIVirtualMachine(s, mor)
break
if not vm:
raise Exception("VM Template Not found")
resource_pool = "/Resources"
cluster = [
k for k, v in s.get_clusters().items() if v == cluster_name
][0]
rpmor = [
k for k, v in s.get_resource_pools(from_mor=cluster).items()
if v == resource_pool
][0]
vm_name = new_vm
try:
test_exist = s.get_vm_by_name(name, self.datacenter)
except VIException:
test_exist = None
if test_exist is None:
logger.info('ERROR: %s already exists' % vm_name)
else:
clone = vm.clone(new_vm, resourcepool=rpmor)
logger.info("Cloned! Powering on now")
clone.power_on()
logger.info("Powered on")
return clone
def _get_vm_for_uuid(self, uuid, datacenter=None):
"""
Retrieve VM for the provided UUID.
:type uuid: ``str``
"""
server = self.connection.client
dc_list = []
if datacenter and VIMor.is_mor(datacenter):
dc_list.append(datacenter)
else:
dc = server.get_datacenters()
if datacenter:
dc_list = [k for k, v in dc.iteritems() if v == datacenter]
else:
dc_list = list(dc.iterkeys())
for mor_dc in dc_list:
request = VI.FindByUuidRequestMsg()
search_index = server._do_service_content.SearchIndex
mor_search_index = request.new__this(search_index)
mor_search_index.set_attribute_type(MORTypes.SearchIndex)
request.set_element__this(mor_search_index)
mor_datacenter = request.new_datacenter(mor_dc)
mor_datacenter.set_attribute_type(MORTypes.Datacenter)
request.set_element_datacenter(mor_datacenter)
request.set_element_vmSearch(True)
request.set_element_uuid(uuid)
try:
# pylint: disable=no-member
vm = server._proxy.FindByUuid(request)._returnval
# pylint: enable=no-member
except VI.ZSI.FaultException:
pass
else:
if vm:
return VIVirtualMachine(server, vm)
return None
def get_vm_by_path(self, path, datacenter=None):
"""Returns an instance of VIVirtualMachine. Where its path matches
@path. The VM is searched througout all the datacenters, unless the
name or MOR of the datacenter the VM belongs to is provided."""
if not self.__logged:
raise VIException(
"Must call 'connect' before invoking this method",
FaultTypes.NOT_CONNECTED)
try:
dc_list = []
if datacenter and VIMor.is_mor(datacenter):
dc_list.append(datacenter)
else:
dc = self.get_datacenters()
if datacenter:
dc_list = [k for k, v in dc.items() if v == datacenter]
else:
dc_list = list(dc.keys())
for mor_dc in dc_list:
request = VI.FindByDatastorePathRequestMsg()
mor_search_index = request.new__this(
self._do_service_content.SearchIndex)
mor_search_index.set_attribute_type(MORTypes.SearchIndex)
request.set_element__this(mor_search_index)
mor_datacenter = request.new_datacenter(mor_dc)
mor_datacenter.set_attribute_type(MORTypes.Datacenter)
request.set_element_datacenter(mor_datacenter)
request.set_element_path(path)
try:
vm = self._proxy.FindByDatastorePath(request)._returnval
except VI.ZSI.FaultException:
pass
else:
if vm:
return VIVirtualMachine(self, vm)
except (VI.ZSI.FaultException) as e:
raise VIApiException(e)
raise VIException("Could not find a VM with path '%s'" % path,
FaultTypes.OBJECT_NOT_FOUND)
dc_properties = VIProperty(server, dc_mor)
hostFolder_mor = dc_properties.hostFolder._obj
# Get ComputeResource MOR for target host
cr_mor = __get_computeresource_mor(server, hostFolder_mor, host_mor)
# Get ComputeResource properties
crprops = VIProperty(server, cr_mor)
# Get ResourcePool MOR
rp_mor = crprops.resourcePool._obj
template_mor = __get_template_by_name(server, 'template2')
vm = VIVirtualMachine(server, template_mor)
folder = None
folders = server._retrieve_properties_traversal(
property_names=['name', 'childEntity'],
obj_type=MORTypes.Folder)
folder_mor = None
for f in folders:
fname = ""
children = []
for prop in f.PropSet:
if prop.Name == "name":
fname = prop.Val
elif prop.Name == "childEntity":