def relocate_vm(self, vm_name, host_dest, datastore_dest):
self.logger.info('Perform relocate_vm')
try:
vm = self.get_obj([vim.VirtualMachine], vm_name)
self.srchost = vm.runtime.host.name
self.srcdatastore = vm.datastore[0].info.name
# Create Relocate Spec
spec = vim.VirtualMachineRelocateSpec()
# Find destination host
destination_host = self.get_obj([vim.HostSystem], host_dest)
spec.host = destination_host
# Find destination Resource pool
resource_pool = destination_host.parent.resourcePool
spec.pool = resource_pool
# collect disks belong to the VM
template_disks = self.collect_template_disks(vm)
datastore_dest_id = self.get_obj([vim.Datastore], datastore_dest)
spec.datastore = datastore_dest_id
spec.disk = self.construct_locator(template_disks,
datastore_dest_id)
task = vm.RelocateVM_Task(spec)
return (self.wait_for_task(task))
except Exception as e:
self.logger.error('Failed in relocate_vm: ' + str(e))
self.logger.exception('')
return False
self.logger.info('Finished relocate_vm')
def relocate_vm(si, args):
content = si.RetrieveContent()
vm = get_vm(si, args.get('uuid'))
priority = get_priority(args.get('priority'))
spec = vim.VirtualMachineRelocateSpec() # type: ignore
spec.folder = search_for_obj(content, [vim.Folder], args.get('folder'))
spec.host = search_for_obj(content, [vim.HostSystem], args.get('host'))
spec.pool = search_for_obj(content, [vim.ResourcePool], args.get('pool')) # type: ignore
datastore = search_for_obj(content, [vim.Datastore], args.get('datastore'))
if datastore:
spec.datastore = datastore
spec.disks = create_rellocation_locator_spec(vm, datastore)
task = vm.RelocateVM_Task(spec, priority)
wait_for_tasks(si, [task])
if task.info.state == 'success':
return {
'ContentsFormat': formats['json'],
'Type': entryTypes['note'],
'Contents': {},
'ReadableContentsFormat': formats['text'],
'HumanReadable': 'Virtual Machine was relocated successfully.',
'EntryContext': {}
}
elif task.info.state == 'error':
raise Exception('Error occurred while trying to relocate VM.')
def migrationVM(content, vminfo, vm, score, resourcepool):
relocate_spec = vim.VirtualMachineRelocateSpec()
relocate_spec.pool = resourcepool
if score == 1:
host = get_host_by_name(content, vminfo['targethost'])
if not host:
print "[ERROR] not found host"
return
relocate_spec.host = host
elif score == 2:
datastore = get_ds_by_name(content, vminfo['targetdatastore'])
if not datastore:
print "[ERROR] not found datastore"
return
relocate_spec.datastore = datastore
elif score == 3:
host = get_host_by_name(content, vminfo['targethost'])
if not host:
print "[ERROR] not found host"
return
relocate_spec.host = host
datastore = get_ds_by_name(content, vminfo['targetdatastore'])
if not datastore:
print "[ERROR] not found datastore"
return
relocate_spec.datastore = datastore
else:
print "[ERROR] you must write target host or datastore"
return
# run migration
task = vm.Relocate(relocate_spec)
wait_for_task(task)
def cloneToTemplate(VM, dstFolder, dstDatastore):
backup_snapshot = takeSnapshot(VM)
if not (backup_snapshot):
logging.warning("Error taking snapshot of virtual machine \"" +
VM.name + "\"")
return None
else:
spec = vim.VirtualMachineCloneSpec()
location = vim.VirtualMachineRelocateSpec()
location.folder = dstFolder
location.datastore = dstDatastore
spec.location = location
spec.snapshot = backup_snapshot
spec.template = True
spec.memory = False
task = VM.CloneVM_Task(name=VM.name + "_Backup_" +
(datetime.today()).strftime("%Y-%m-%d_%H-%M"),
spec=spec,
folder=dstFolder)
if trackTask(task):
logging.info("Successfull backup of VM " + VM.name +
", deleting Snapshot")
deleteSnapshot(backup_snapshot)
deleteOldBackups(VM, 2, dstFolder)
else:
logging.warning("Something gone wrong with coping VM \"" +
VM.name + "\". Deleting made snapshot.")
deleteSnapshot(backup_snapshot)
def clone_vm( content, template, vm_name, si, datastore_name, resource_pool):
datacenter = get_obj( content, [vim.Datacenter], None)
destfolder = datacenter.vmFolder
if datastore_name:
datastore = get_obj( content, [vim.Datastore], datastore_name)
else:
objview = content.viewManager.CreateContainerView( content.rootFolder, [vim.HostSystem], True)
esxi_hosts = objview.view
for esxi_host in esxi_hosts:
if esxi_host.name == resource_pool:
storage_system = esxi_host.configManager.storageSystem
host_file_sys_vol_mount_info = storage_system.fileSystemVolumeInfo.mountInfo
datastore = host_file_sys_vol_mount_info[0].volume.name
datastore = get_obj( content, [vim.Datastore], datastore)
break
cluster = get_obj(content, [vim.ClusterComputeResource], None)
host_dest = resource_pool;
if resource_pool:
resource_pool = get_obj(content, [vim.ResourcePool], resource_pool)
else:
resource_pool = cluster.resourcePool
vmconf = vim.vm.ConfigSpec()
destination_host = get_obj(content, [vim.HostSystem], host_dest)
relospec = vim.VirtualMachineRelocateSpec()
relospec.pool = destination_host.parent.resourcePool
relospec.datastore = datastore
clonespec = vim.vm.CloneSpec()
clonespec.location = relospec
print("cloning VM...")
task = template.Clone( folder = destfolder, name = vm_name, spec = clonespec)
wait_for_task(task)
def relocate_vm(vm_name, content, host_dest, datastore_dest=None):
"""
This method relocates vm to the host_dest across
datacenters, clusters, datastores managed by a Vcenter
Args:
vm_name:
content:
host_dest:
datastore_dest:
Returns:
"""
relocation_status = False
message = "relocate_vm passed"
try:
vm = get_object(content, [vim.VirtualMachine], vm_name)
current_host = vm.runtime.host.name
print("vmotion_vm current_host:" + current_host)
# Create Relocate Spec
spec = vim.VirtualMachineRelocateSpec()
# Check whether compute vmotion required and construct spec accordingly
if host_dest is not None:
if current_host == host_dest:
raise Exception("WARNING:: destination_host can not equal "
"current_host")
# Find destination host
destination_host = get_object(content, [vim.HostSystem], host_dest)
print("vmotion_vm destination_host:" + str(destination_host))
spec.host = destination_host
# Find destination Resource pool
resource_pool = destination_host.parent.resourcePool
print("vmotion_vm resource_pool:" + str(resource_pool))
spec.pool = resource_pool
# Check whether storage vmotion required and construct spec accordingly
if datastore_dest is not None:
# collect disks belong to the VM
template_disks = collect_template_disks(vm)
datastore_dest_id = get_object(content, [vim.Datastore],
datastore_dest)
spec.datastore = datastore_dest_id
spec.disk = construct_locator(template_disks, datastore_dest_id)
print("relocate_vm spec:" + str(spec))
task = vm.RelocateVM_Task(spec)
while task.info.state == vim.TaskInfo.State.running:
continue
relocation_status = True
except Exception as e:
message = "relocate_vm failed for vm:" + vm_name \
+ " with error:" + str(e)
print(message)
return relocation_status, message
def DeployVmFn(Properties):
task = Properties['task']
params = getParameters(task['Parameters'])
opStatus = {}
# ===========================================================================
# Connect to Vcenter
# ===========================================================================
si = connectVcenter(Properties)
obj = getObjRef(si.content, vim.VirtualMachine, params['Template'])
destination_host = getObjRef(si.content, vim.HostSystem, params['Host'])
dc = getObjRef(si.content, vim.Datacenter, params['Datacenter'])
cluster = getObjRef(si.content, vim.ClusterComputeResource, params['Cluster'])
if obj is None:
msg = "A object named " + params['Template'] + " could not be found"
updateFailedTaskList(task['TaskName'], params, msg, opStatus)
elif destination_host is None:
msg = "A object named " + params['Host'] + " could not be found"
updateFailedTaskList(task['TaskName'], params, msg, opStatus)
elif dc is None:
msg = "A object named " + params['Datacenter'] + " could not be found"
updateFailedTaskList(task['TaskName'], params, msg, opStatus)
elif cluster is None:
msg = "A object named " + params['Cluster'] + " could not be found"
updateFailedTaskList(task['TaskName'], params, msg, opStatus)
else:
try:
print(" Deploying the VM %s" % obj.name)
rs = vim.VirtualMachineRelocateSpec()
cs = vim.VirtualMachineCloneSpec()
target_folder = dc.vmFolder
rs.host = destination_host
rs.pool = cluster.resourcePool
cs.location = rs
cs.powerOn = False
print ("Deploy initiated...")
WaitForTask(obj.CloneVM_Task(target_folder, params['VmName'], cs))
print(" Virtual Machine %s has been Deployed successfully" % params['VmName'])
opStatus['ObjectName'] = getObjName(obj)
opStatus['Status'] = 'Passed'
except Exception as e:
updateFailedTaskList(task['TaskName'], params, e.msg, opStatus)
# ===========================================================================
# Disconnect Vcenter
# ===========================================================================
Disconnect(si)
return opStatus
def buildVmotionSpec(self, vm, dest_host, dest_datastore):
spec = vim.VirtualMachineRelocateSpec()
destination_host = self.getHost(dest_host)
destination_ds = self.getDatastore(dest_datastore)
spec.host = destination_host
spec.pool = destination_host.parent.resourcePool
spec.datastore = destination_ds
template_disks = self.collect_template_disks(vm)
spec.disk = self.construct_locator(template_disks, destination_ds)
return spec
def vmotion_inside_bb(self, openstack_obj, big_vm_name_uuid,
free_node_name, data):
# details about vm and free node
vm = self.find_server(big_vm_name_uuid)
# if vm not found on vcenter return
vhost = self.get_object_by_name(vim.HostSystem, free_node_name)
log.info(
"INFO: vmotion of instance uuid %s started to target node %s",
big_vm_name_uuid, free_node_name)
# capture the status of server
# check metadata and lock if exist
loc_check = openstack_obj.api.compute.get_server(big_vm_name_uuid)
# if vm not found on vcenter return
log.info("INFO: instance uuid %s lock status %s", big_vm_name_uuid,
loc_check['is_locked'])
# setting metadata and lock for nanny
openstack_obj.api.compute.set_server_metadata(big_vm_name_uuid,
nanny_metadata=data)
openstack_obj.api.compute.lock_server(big_vm_name_uuid)
loc_check = openstack_obj.api.compute.get_server(big_vm_name_uuid)
log.info("INFO: instance uuid %s lock status set by nanny %s",
big_vm_name_uuid, loc_check['is_locked'])
# actual vmotion step
spec = vim.VirtualMachineRelocateSpec()
spec.host = vhost
task = vm.RelocateVM_Task(spec)
try:
state = WaitForTask(task, si=self.api)
except Exception as e:
log.error(
"ERROR: failed to relocate big vm %s to target node %s with error message =>%s",
str(big_vm_name_uuid), str(free_node_name), str(e.msg))
state = "Vmotion_failed"
else:
log.info(
"INFO: vmotion done big vm %s to target node %s and state %s",
str(big_vm_name_uuid), str(free_node_name), str(state))
# if result failed through alert
# unlock the server and unset nanny metadata
openstack_obj.api.compute.unlock_server(big_vm_name_uuid)
openstack_obj.api.compute.delete_server_metadata(
big_vm_name_uuid, ['nanny_metadata'])
# check unlock succesfully done
unloc_check = openstack_obj.api.compute.get_server(big_vm_name_uuid)
log.info("INFO: instance uuid %s unlock status %s done",
big_vm_name_uuid, unloc_check['is_locked'])
return state
def main():
# connection for vm
nanny_metadata_handle = "nanny_big_vm_handle"
openstack_obj = OpenstackHelper(os.getenv('REGION'), os.getenv('OS_USER_DOMAIN_NAME'),
os.getenv('OS_PROJECT_DOMAIN_NAME'),os.getenv('OS_PROJECT_NAME'),
os.getenv('OS_USERNAME'), os.getenv('OS_PASSWORD'))
vc = VCenterHelper(host=os.getenv('VM_BALANCE_VCHOST'),user=os.getenv('VM_BALANCE_VCUSER'),password=os.getenv('VM_BALANCE_VCPASSWORD'))
big_vm_name_uuid = input("Enter BIG VM Instance UUID: ")
# details about vm and free node
vm = vc.find_server(big_vm_name_uuid)
free_node_name = input("Enter Free Node name like(node*-bb*.cc.*-*-*.cloud.sap):")
vhost = vc.get_object_by_name(vim.HostSystem,free_node_name)
log.info("INFO: vmotion of instance uuid %s started to target node %s",big_vm_name_uuid,free_node_name)
# capture the status of server
# check metadata and lock if exist
loc_check = openstack_obj.api.compute.get_server(big_vm_name_uuid)
log.info("INFO: instance uuid %s lock status %s", big_vm_name_uuid, loc_check['is_locked'])
# setting metadata and lock for nanny
metadata_check = openstack_obj.api.compute.set_server_metadata(big_vm_name_uuid, nanny_metadata=nanny_metadata_handle)
loc = openstack_obj.api.compute.lock_server(big_vm_name_uuid)
loc_check = openstack_obj.api.compute.get_server(big_vm_name_uuid)
log.info("INFO: instance uuid %s lock status set by nanny %s", big_vm_name_uuid, loc_check['is_locked'])
# actual vmotion step
spec = vim.VirtualMachineRelocateSpec()
spec.host = vhost
task = vm.RelocateVM_Task(spec)
try:
state = WaitForTask(task,si=vc.api)
except Exception as e:
logging.error("ERROR: failed to relocate big vm %s to target node %s with error message =>%s",
str(big_vm_name_uuid),str(free_node_name),str(e.msg))
state = "VMotion_failed"
else:
log.info("INFO: vmotion done big vm %s to target node %s and state %s",str(big_vm_name_uuid),str(free_node_name),str(state))
# if result failed through alert
# unlock the server and unset nanny metadata
unloc = openstack_obj.api.compute.unlock_server(big_vm_name_uuid)
metadata_check = openstack_obj.api.compute.delete_server_metadata(big_vm_name_uuid,['nanny_metadata'])
# check unlock succesfully done
unloc_check = openstack_obj.api.compute.get_server(big_vm_name_uuid)
log.info("INFO: instance uuid %s unlock status %s done", big_vm_name_uuid, unloc_check['is_locked'])
return state
def do_a_vmotion(vm_obj, host, pingaddr, verbose=False):
"""
do one repetition of a vmotion.
Ping the pingaddr,
migrate the vm
Ping the pingaddr
raising exceptions on any failure
vm_obj - vm object
host - host object
pingaddr - the dns or ip to ping.
"""
spec = vim.VirtualMachineRelocateSpec()
spec.host = host
if verbose:
print('*** Preparing to move VM: ' + vm_obj.name +
' to host: %s' % host.name)
if ping(pingaddr):
if verbose:
print('*** We have initial pings - moving to host: %s' % host.name)
print('*** VMotion to host %s now' % host.name)
task = vm_obj.RelocateVM_Task(spec)
else:
raise Exception('Pre-VMotion Ping Failed')
if wait_for_task(task, verbose):
if verbose:
print("*** VMotion succeeded")
else:
raise Exception("VMotion task failed")
if verbose:
print("*** Sleeping 5 seconds to let things settle.")
time.sleep(5)
if ping(pingaddr):
if verbose:
print('*** Success, we have ping post VMotion to %s' % host.name)
else:
raise Exception('Post-VMotion Ping Failed')
def relocate_vm(vm_name, content, host_dest, datastore_dest=None):
relocation_status = False
try:
vm = get_object(content, [vim.VirtualMachine], vm_name)
current_host = vm.runtime.host.name
spec = vim.VirtualMachineRelocateSpec()
if host_dest is not None:
if current_host == host_dest:
raise Exception("WARNING:: destination_host can not equal "
"current_host")
destination_host = get_object(content, [vim.HostSystem], host_dest)
spec.host = destination_host
target_esx_host = destination_host.parent.resourcePool
spec.pool = target_esx_host
if datastore_dest is not None:
template_disks = collect_template_disks(vm)
datastore_dest_id = get_object(content, [vim.Datastore],
datastore_dest)
spec.datastore = datastore_dest_id
spec.disk = construct_locator(template_disks, datastore_dest_id)
else:
objview = content.viewManager.CreateContainerView(
content.rootFolder, [vim.HostSystem], True)
esxi_hosts = objview.view
objview.Destroy()
for esxi_host in esxi_hosts:
if esxi_host.name == host_dest:
storage_system = esxi_host.configManager.storageSystem
host_file_sys_vol_mount_info = storage_system.fileSystemVolumeInfo.mountInfo
datastore = host_file_sys_vol_mount_info[0].volume.name
datastore = get_object(content, [vim.Datastore], datastore)
template_disks = collect_template_disks(vm)
spec.datastore = datastore
spec.disk = construct_locator(template_disks, datastore)
break
task = vm.RelocateVM_Task(spec)
wait_for_task(task)
except Exception as e:
print(
"Relocation failed for vm:", vm_name, " with error:", str(e),
".\nHost or VM doesn't exist or Vm is already in the mentioned host."
)
return -1
def clone(
content,
template,
name,
pool,
folder,
datastore,
):
vm_mor = get_object(content, vim.VirtualMachine, template)
if vm_mor is None:
logger.error(u'VirtualMachine %s not found' % template)
return None
pool_mor = get_object(content, vim.ResourcePool, pool)
if pool_mor is None:
logger.error(u'ResourcePoll %s not found' % pool)
return None
folder_mor = get_object(content, vim.Folder, folder)
if folder_mor is None:
loggeer.error(u'Folder %s not found' % folder)
return None
datastore_mor = get_object(content, vim.Datastore, datastore)
if datastore_mor is None:
logger.error(u'Datastore %s not found' % datastore)
return None
r_spec = vim.VirtualMachineRelocateSpec()
c_spec = vim.VirtualMachineCloneSpec()
r_spec.pool = pool_mor
r_spec.datastore = datastore_mor
c_spec.location = r_spec
c_spec.powerOn = True
# TODO: zvazit alternativne riesenie cez metodu vm_mor.Clone
return vm_mor.CloneVM_Task(name=name, folder=folder_mor, spec=c_spec)
def v_motion_handler(logger, si, template_vm, host_mor, ds_mor):
"""
Will handle the thread handling migration of virtual machine and run post processing
"""
#time.sleep(10) # Sleep Introduced to trigger Host Collection Stats
if ds_mor is None:
logger.info("No Datastore specified. Doing only Compute vMotion")
try:
vm_name = template_vm.name
vm_relocate_spec = vim.VirtualMachineRelocateSpec()
vm_relocate_spec.host = host_mor
resource_pool = host_mor.parent.resourcePool
vm_relocate_spec.pool = resource_pool
if ds_mor:
template_disks = Propertycollector.collect_template_disks(
template_vm)
vm_relocate_spec.datastore = ds_mor
vm_relocate_spec.disk = Propertycollector.construct_locator(
template_disks, ds_mor)
print("VM %s Host %s DS %s" % (template_vm, host_mor, ds_mor))
logger.info("Initiating Migration of %s" % vm_name)
task = template_vm.RelocateVM_Task(vm_relocate_spec)
#task_results.append(task_pool.apply_async(TaskAnalyzer.Analyze,(logger,si,vm_name,task)))
TaskAnalyzer.Analyze(logger, si, vm_name, task)
except vmodl.MethodFault, e:
logger.error("Caught vmodl fault: %s" % e.msg)
def main():
global dc_to_check, dc_limit, dc_target, bad_stor_exist, dc_dest, vm_to
if args.verbose:
sys.stdout.write("Connect to VMWare ... ")
sys.stdout.flush()
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
if args.disable_ssl_verification:
context.verify_mode = ssl.CERT_NONE
si = SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=args.port,
sslContext=context)
# disconnect vc
atexit.register(Disconnect, si)
if args.verbose:
print "Connected!"
content = si.RetrieveContent()
datacenter = content.rootFolder.childEntity[0]
datastores = datacenter.datastore
if args.name:
dc_to_check = args.name
if args.target:
dc_target = args.target
if args.destination:
dc_dest = args.destination
if args.limit:
dc_limit = int(args.limit)
#ds_collect(datastores)
ds_list = []
need_free = 0
for ds in datastores:
if dc_to_check in ds.summary.name:
ds_list.append(ds)
if args.verbose:
print "Found %s" % ds.summary.name
for i, ds in enumerate(ds_list):
need_perc = dc_limit - (
(ds.summary.freeSpace * 100) / ds.summary.capacity) + 1
need_free = (ds.summary.capacity / 100) * need_perc
if (need_perc > 0):
print "%s need to free %s" % (ds.summary.name,
sizeof_fmt(need_free))
bad_stor_exist = True
# now try to find stor with free space
for n, vl in enumerate(ds_list):
# calculate, how many space left if we push
c = vl.summary.freeSpace - need_free
p = (c * 100) / vl.summary.capacity
if (p > dc_limit):
if args.verbose:
print "%s will have %s%% free. good" % (
vl.summary.name, p)
if dc_dest in vl.summary.name:
ds_from.append(ds)
ds_to.append(vl)
ds_to_free.append(p)
if args.verbose:
print "Can move %s -> %s" % (ds.summary.name,
vl.summary.name)
else:
if args.verbose:
print "Cannot %s /> %s (banned by destination)" % (
ds.summary.name, vl.summary.name)
else:
if args.verbose:
print "%s not suitable %s%%<%s%% bad" % (
vl.summary.name, p, dc_limit)
# ok, now we need to collect VM files
if bad_stor_exist == True:
print "Found %s possible relocations" % len(ds_from)
if len(ds_from) == 0:
print "ALERT! Lack of space. Do handjob quickly ..."
return # noting to do
# ok, lets choice which stor
ch_n = 0
ch_p = 0
for i, fr in enumerate(ds_from):
print "Can migrate %s -> %s" % (fr.summary.name,
ds_to[i].summary.name)
if ds_to_free[i] > ch_p:
ch_n = i
ch_p = ds_to_free[i]
print "OK, lets move from %s to %s (%s%% free will be after move)" % (
ds_from[ch_n].summary.name, ds_to[ch_n].summary.name, ch_p)
# now select VM to move.
print "Try to find possible VM to move"
np = dc_limit - ((ds_from[ch_n].summary.freeSpace * 100) /
ds_from[ch_n].summary.capacity) + 1
nf = (ds_from[ch_n].summary.capacity / 100) * np
for i, vm in enumerate(ds_from[ch_n].vm):
s = 0
for t in vm.layoutEx.file:
s = s + t.size
if dc_target in vm.summary.config.name:
if args.verbose:
print "Can take %s (%s)" % (vm.summary.config.name,
sizeof_fmt(s))
# collect enougth VM to move
if nf > 0:
vm_to.append(vm)
nf = nf - s
else:
if args.verbose:
print "Cannot take %s (banned by target) %s " % (
vm.summary.config.name, sizeof_fmt(s))
if len(vm_to) == 0:
print "ALERT! Ooops, cannot find VM to move. Abort"
return
for i, vm in enumerate(vm_to):
print "Ok, Final. Move %s from %s to %s " % (
vm.summary.config.name, ds_from[ch_n].summary.name,
ds_to[ch_n].summary.name)
# https://gist.github.com/rgerganov/12fdd2ded8d80f36230f
# vm = vim.VirtualMachine(vm.summary.config.name, si._stub)
disk_key = []
disk_filekey = []
# collect info about key - filekey and grab only one part or pair (vmdk, -flat.vmdk)
for t in vm.layoutEx.disk:
disk_key.append(t.key)
disk_filekey.append(t.chain[0].fileKey[0])
#print "DISK ", t.key, t.chain[0].fileKey[0]
# check disk for moving
for t in vm.layoutEx.file:
#print "Check %s " % t.name
if ds_from[
ch_n].summary.name in t.name: # ok this file on bad store, move
for i, j in enumerate(disk_filekey):
# print "compare %s %s" % (j,t.key)
if j == t.key:
spec = vim.VirtualMachineRelocateSpec()
dsk = vim.VirtualMachineRelocateSpecDiskLocator()
print "Move %s queue" % t.name
dsk.datastore = ds_to[ch_n]
dsk.diskId = disk_key[i]
spec.disk.append(dsk)
task = vm.RelocateVM_Task(spec)
wait_for_task(task)
else:
print "%s already moved" % t.name
else:
print "All look seems to be in order. Have a nice day!"
def _clone(self, destination, resourcepool=None, datastore=None, power_on=True,
sparse=False, template=False, provision_timeout=1800, progress_callback=None,
allowed_datastores=None, cpu=None, ram=None, **kwargs):
"""
Clone this template to a VM
Returns a VMWareVirtualMachine object
"""
try:
vm = self.system.get_vm(destination)
except VMInstanceNotFound:
vm = None
if vm:
raise Exception("VM/template of the name {} already present!".format(destination))
if progress_callback is None:
progress_callback = partial(
self._progress_log_callback, self.logger, self.name, destination)
source_template = self.raw
vm_clone_spec = vim.VirtualMachineCloneSpec()
vm_reloc_spec = vim.VirtualMachineRelocateSpec()
# DATASTORE
if isinstance(datastore, six.string_types):
vm_reloc_spec.datastore = self.system.get_obj(vim.Datastore, name=datastore)
elif isinstance(datastore, vim.Datastore):
vm_reloc_spec.datastore = datastore
elif datastore is None:
if allowed_datastores is not None:
# Pick a datastore by space
vm_reloc_spec.datastore = self._pick_datastore(allowed_datastores)
else:
# Use the same datastore
datastores = source_template.datastore
if isinstance(datastores, (list, tuple)):
vm_reloc_spec.datastore = datastores[0]
else:
vm_reloc_spec.datastore = datastores
else:
raise NotImplementedError("{} not supported for datastore".format(datastore))
progress_callback("Picked datastore `{}`".format(vm_reloc_spec.datastore.name))
# RESOURCE POOL
if isinstance(resourcepool, vim.ResourcePool):
vm_reloc_spec.pool = resourcepool
else:
vm_reloc_spec.pool = self._get_resource_pool(resourcepool)
progress_callback("Picked resource pool `{}`".format(vm_reloc_spec.pool.name))
vm_reloc_spec.host = None
if sparse:
vm_reloc_spec.transform = vim.VirtualMachineRelocateTransformation().sparse
else:
vm_reloc_spec.transform = vim.VirtualMachineRelocateTransformation().flat
vm_clone_spec.powerOn = power_on
vm_clone_spec.template = template
vm_clone_spec.location = vm_reloc_spec
vm_clone_spec.snapshot = None
if cpu is not None:
vm_clone_spec.config.numCPUs = int(cpu)
if ram is not None:
vm_clone_spec.config.memoryMB = int(ram)
try:
folder = source_template.parent.parent.vmParent
except AttributeError:
folder = source_template.parent
progress_callback("Picked folder `{}`".format(folder.name))
task = source_template.CloneVM_Task(folder=folder, name=destination, spec=vm_clone_spec)
def _check(store=[task]):
try:
if hasattr(store[0].info, 'progress') and store[0].info.progress is not None:
progress_callback("{}/{}%".format(store[0].info.state, store[0].info.progress))
else:
progress_callback("{}".format(store[0].info.state))
except AttributeError:
pass
if store[0].info.state not in {"queued", "running"}:
return True
store[0] = self.system.get_updated_obj(store[0])
return False
wait_for(_check, num_sec=provision_timeout, delay=4)
if task.info.state != 'success':
self.logger.error(
"Clone VM from VM/template '%s' failed: %s",
self.name, get_task_error_message(task)
)
raise VMInstanceNotCloned(destination)
if template:
entity_cls = VMWareTemplate
else:
entity_cls = VMWareVirtualMachine
return entity_cls(system=self.system, name=destination)
def main():
parser = argparse.ArgumentParser(description='vCenter login')
parser.add_argument('-s',
'--host',
required=True,
action='store',
help='vSphere IP')
parser.add_argument('-o',
'--port',
type=int,
default=443,
action='store',
help='vSphere Port')
parser.add_argument('-u',
'--user',
required=True,
action='store',
help='User name')
parser.add_argument('-p',
'--password',
required=True,
action='store',
help='Password')
parser.add_argument('-n',
'--name',
required=True,
action='store',
help='VM name')
parser.add_argument('-q',
'--resourcepool',
required=True,
action='store',
help='ResourcePool name')
parser.add_argument('-d',
'--datastore',
required=False,
action='store',
help='Datastore name')
args = parser.parse_args()
try:
service_instance = connect.SmartConnect(host=args.host,
user=args.user,
pwd=args.password,
port=int(args.port))
atexit.register(connect.Disconnect, service_instance)
content = service_instance.content
objView = content.viewManager.CreateContainerView(
content.rootFolder, [vim.VirtualMachine], True)
vmlist = objView.view
objView.Destroy()
for vm in vmlist:
if vm.name == args.name:
#print vm.name
spec = vim.VirtualMachineRelocateSpec()
for respool in libvmtask.get_vim_objects(
content, vim.ResourcePool):
if respool.name == args.resourcepool:
resourcepool = respool
if not resourcepool:
sys.exit(0)
spec.pool = resourcepool
if args.datastore:
for ds in libvmtask.get_vim_objects(
content, vim.Datastore):
if ds.name == args.datastore:
spec.datastore = ds
#print spec
task = vm.RelocateVM_Task(spec)
libvmtask.WaitForTasks([task], service_instance)
return 0
except vmodl.MethodFault as error:
print("ERROR: " + error.msg)
sys.exit(1)
