def test():
new_offering = test_lib.lib_create_instance_offering(cpuNum = 1,\
cpuSpeed = 111, memorySize = 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(new_offering)
vm = test_stub.create_vm(vm_name='ckvmoffering-c6-64',
image_name="imageName_i_c6",
instance_offering_uuid=new_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
(available_cpu_before, available_memory_before, vm_outer_cpu_before,
vm_outer_mem_before, vm_interal_cpu_before,
vm_interal_mem_before) = test_stub.check_cpu_mem(vm)
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(
vm.get_vm().instanceOfferingUuid)
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum + 1, None)
vm.update()
time.sleep(10)
vm.check()
(available_cpu_after, available_memory_after, vm_outer_cpu_after,
vm_outer_mem_after, vm_interal_cpu_after,
vm_internal_mem_after) = test_stub.check_cpu_mem(vm)
assert available_cpu_before == available_cpu_after + 1
assert available_memory_before == available_memory_after
assert vm_outer_cpu_before == vm_outer_cpu_after - 1
assert vm_outer_mem_before == vm_outer_mem_after
assert vm_interal_cpu_before == vm_interal_cpu_after - 1
assert vm_interal_mem_before == vm_internal_mem_after
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
test_lib.lib_set_vm_numa('true')
vm = test_stub.create_vr_vm('migrate_vm', 'imageName3', 'l3VlanNetwork2')
test_obj_dict.add_vm(vm)
vm.check()
(available_cpu_before, available_memory_before, vm_outer_cpu_before, vm_outer_mem_before,
vm_interal_cpu_before, vm_interal_mem_before) = test_stub.check_cpu_mem(vm)
test_stub.migrate_vm_to_random_host(vm)
vm.check()
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(vm.get_vm().instanceOfferingUuid)
MEMchange = 126*1024*1024
AlignedMemChange = 128*1024*1024
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum + 1, vm_instance_offering.memorySize + MEMchange)
vm.update()
time.sleep(10)
vm.check()
(available_cpu_after, available_memory_after, vm_outer_cpu_after, vm_outer_mem_after,
vm_interal_cpu_after, vm_internal_mem_after) = test_stub.check_cpu_mem(vm)
assert available_cpu_before == available_cpu_after + 1
assert available_memory_after + AlignedMemChange / float(test_lib.lib_get_provision_memory_rate()) in range(available_memory_before-1, available_memory_before+1)
assert vm_outer_cpu_before == vm_outer_cpu_after - 1
assert vm_outer_mem_before == vm_outer_mem_after - AlignedMemChange
assert vm_interal_cpu_before == vm_interal_cpu_after - 1
assert vm_interal_mem_before == vm_internal_mem_after - AlignedMemChange/1024/1024
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering after migration Test Pass')
def test():
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instanc_offering = test_lib.lib_create_instance_offering(cpuNum = 2,
memorySize = 2 * 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(vm_instanc_offering)
test_util.test_dsc("STEP2: Ceate vm and wait until it up for testing")
vm = test_stub.create_vm(vm_name = 'window-telnet', image_name = "imageName_windows",
instance_offering_uuid=vm_instanc_offering.uuid)
test_obj_dict.add_vm(vm)
time.sleep(10)
test_util.test_dsc("STEP3: Hot Plugin CPU and Memory and check capacity")
cpu_change = random.randint(1,5)
mem_change = random.randint(1,500) * 1024 * 1024
with test_stub.CapacityCheckerContext(vm, cpu_change, mem_change, window=True):
vm_ops.update_vm(vm.get_vm().uuid, vm_instanc_offering.cpuNum+cpu_change,
vm_instanc_offering.memorySize+mem_change)
vm.update()
time.sleep(10)
test_util.test_dsc("STEP4: Destroy test object")
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
new_offering = test_lib.lib_create_instance_offering(cpuNum = 1,\
cpuSpeed = 111, memorySize = 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(new_offering)
vm = test_stub.create_vm(vm_name = 'ckvmoffering-c7-64', image_name = "imageName_i_c7", instance_offering_uuid=new_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
(available_cpu_before, available_memory_before, vm_outer_cpu_before, vm_outer_mem_before,
vm_interal_cpu_before, vm_interal_mem_before) = test_stub.check_cpu_mem(vm)
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(vm.get_vm().instanceOfferingUuid)
MEMchange = 64*1024*1024
vm_ops.update_vm(vm.get_vm().uuid, None, vm_instance_offering.memorySize + MEMchange)
vm.update()
time.sleep(10)
test_stub.online_hotplug_cpu_memory(vm)
(available_cpu_after, available_memory_after, vm_outer_cpu_after, vm_outer_mem_after,
vm_interal_cpu_after, vm_internal_mem_after) = test_stub.check_cpu_mem(vm)
AlignedMemChange = 128*1024*1024
assert available_cpu_before == available_cpu_after
#test_util.test_logger("%s %s %s" % (available_memory_before, available_memory_after, MEMchange))
assert available_memory_after + AlignedMemChange / int(test_lib.lib_get_provision_memory_rate()) in range(available_memory_before-1, available_memory_before)
assert vm_outer_cpu_before == vm_outer_cpu_after
assert vm_outer_mem_before == vm_outer_mem_after - AlignedMemChange
assert vm_interal_cpu_before == vm_interal_cpu_after
assert vm_interal_mem_before == vm_internal_mem_after - AlignedMemChange/1024/1024
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instance_offering = test_lib.lib_create_instance_offering(cpuNum = 1,
memorySize = 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(vm_instance_offering)
test_util.test_dsc("STEP2: Ceate vm and wait until it up for testing")
vm = test_stub.create_vm(vm_name = 'ckvmoffering-c6-64', image_name = "imageName_i_c6",
instance_offering_uuid=vm_instance_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
test_util.test_dsc("STEP3: Continuously Hot Plugin CPU and Memory and check capacity")
last_cpu = vm_instance_offering.cpuNum
last_mem = vm_instance_offering.memorySize
cpu_change = 0
mem_change_list = [random.randint(0, 500)*1024*1024 for _ in xrange(8)]
for mem_change in mem_change_list:
with test_stub.CapacityCheckerContext(vm, cpu_change, mem_change) as cc:
vm_ops.update_vm(vm.get_vm().uuid, last_cpu + cpu_change, last_mem + mem_change)
last_cpu += cpu_change
last_mem += cc.mem_aligned_change
vm.update()
test_stub.online_hotplug_cpu_memory(vm)
time.sleep(5)
test_util.test_dsc("STEP4: Destroy test object")
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
flavor = case_flavor[os.environ.get('CASE_FLAVOR')]
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instance_offering = test_lib.lib_create_instance_offering(cpuNum=1, memorySize=1024*1024*1024)
test_obj_dict.add_instance_offering(vm_instance_offering)
test_util.test_dsc("STEP2: Ceate vm and wait until it up for testing image_name : {}".format(flavor['image']))
vm = test_stub.create_vm(vm_name='test_vm', image_name=flavor['image'],
instance_offering_uuid=vm_instance_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
cpu_change = random.randint(1, 5) if flavor['add_cpu'] else 0
mem_change = random.randint(1, 500)*1024*1024 if flavor['add_memory'] else 0
test_util.test_dsc("STEP3: Hot Plugin CPU: {} and Memory: {} and check capacity".format(cpu_change, mem_change))
with test_stub.CapacityCheckerContext(vm, cpu_change, mem_change):
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum+cpu_change,
vm_instance_offering.memorySize+mem_change)
vm.update()
if flavor['need_online']:
test_stub.online_hotplug_cpu_memory(vm)
time.sleep(10)
test_util.test_dsc("STEP4: Destroy test object")
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def testmethod():
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instance_offering = test_lib.lib_create_instance_offering(
cpuNum=1, memorySize=1024 * 1024 * 1024)
tbj.add_instance_offering(vm_instance_offering)
test_util.test_dsc("STEP2: Ceate vm and wait until it up for testing")
vm = create_vm(vm_name='test_vm',
image_name=test_image_name,
instance_offering_uuid=vm_instance_offering.uuid)
tbj.add_vm(vm)
vm.check()
cpu_change = random.randint(1, 5) if add_cpu else 0
mem_change = random.randint(1, 500) * 1024 * 1024 if add_memory else 0
test_util.test_dsc(
"STEP3: Hot Plugin CPU: {} and Memory: {} and check capacity".
format(cpu_change, mem_change))
with CapacityCheckerContext(vm, cpu_change, mem_change):
vm_ops.update_vm(vm.get_vm().uuid,
vm_instance_offering.cpuNum + cpu_change,
vm_instance_offering.memorySize + mem_change)
vm.update()
if need_online:
online_hotplug_cpu_memory(vm)
time.sleep(10)
test_util.test_dsc("STEP4: Destroy test object")
test_lib.lib_error_cleanup(tbj)
test_util.test_pass('VM online change instance offering Test Pass')
def testmethod():
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instance_offering = test_lib.lib_create_instance_offering(cpuNum=1, memorySize=1024*1024*1024)
tbj.add_instance_offering(vm_instance_offering)
test_util.test_dsc("STEP2: Ceate vm and wait until it up for testing")
vm = create_vm(vm_name='test_vm', image_name = test_image_name,
instance_offering_uuid=vm_instance_offering.uuid)
tbj.add_vm(vm)
vm.check()
cpu_change = random.randint(1, 5) if add_cpu else 0
mem_change = random.randint(1, 500)*1024*1024 if add_memory else 0
test_util.test_dsc("STEP3: Hot Plugin CPU: {} and Memory: {} and check capacity".format(cpu_change, mem_change))
with CapacityCheckerContext(vm, cpu_change, mem_change):
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum+cpu_change,
vm_instance_offering.memorySize+mem_change)
vm.update()
if need_online:
online_hotplug_cpu_memory(vm)
time.sleep(10)
test_util.test_dsc("STEP4: Destroy test object")
test_lib.lib_error_cleanup(tbj)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instanc_offering = test_lib.lib_create_instance_offering(cpuNum = 2,
memorySize = 2 * 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(vm_instanc_offering)
test_util.test_dsc("STEP2: Ceate vm and wait until it up for testing")
vm = test_stub.create_vm(vm_name = 'window-telnet', image_name = "imageName_windows",
instance_offering_uuid=vm_instanc_offering.uuid)
test_obj_dict.add_vm(vm)
time.sleep(10)
test_util.test_dsc("STEP3: Hot Plugin CPU and Memory and check capacity")
cpu_change = random.randint(1,5)
mem_change = random.randint(1,500) * 1024 * 1024
with test_stub.CapacityCheckerContext(vm, cpu_change, mem_change, window=True):
# wait for 90s to ensure all the windows services up
time.sleep(90)
vm_ops.update_vm(vm.get_vm().uuid, vm_instanc_offering.cpuNum+cpu_change,
vm_instanc_offering.memorySize+mem_change)
vm.update()
time.sleep(10)
test_util.test_dsc("STEP4: Destroy test object")
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
test_util.test_dsc('Test update instance offering')
vm = test_stub.create_basic_vm()
vm.stop()
instance_offering = test_lib.lib_get_instance_offering_by_uuid(vm.get_vm().instanceOfferingUuid)
test_obj_dict.add_vm(vm)
vm_ops.update_vm(vm.get_vm().uuid, instance_offering.cpuNum * 2, None)
vm_ops.update_vm(vm.get_vm().uuid, None, instance_offering.memorySize * 2)
vm.update()
if (vm.get_vm().cpuNum != instance_offering.cpuNum * 2):
test_util.test_fail("cpuNum change is expected to change")
if (vm.get_vm().memorySize != instance_offering.memorySize * 2):
test_util.test_fail("memorySize change is expected to change")
vm.start()
if (vm.get_vm().cpuNum != instance_offering.cpuNum * 2):
test_util.test_fail("cpuNum change is expected to take effect after Vm restart")
if (vm.get_vm().memorySize != instance_offering.memorySize * 2):
test_util.test_fail("memorySize change is expected to take effect after Vm restart")
vm.check()
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Test update instance cpu memory Pass')
def update_cpu_mem(vm):
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(vm.get_vm().instanceOfferingUuid)
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum + CPUchange,
vm_instance_offering.memorySize + MEMchange)
vm.update()
test_stub.online_hotplug_cpu_memory(vm)
vm.check()
def test():
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instance_offering = test_lib.lib_create_instance_offering(
cpuNum=1, memorySize=1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(vm_instance_offering)
test_util.test_dsc("STEP2: Ceate vm and wait until it up for testing")
vm = test_stub.create_vm(vm_name='ckvmoffering-c7-64',
image_name="imageName_i_c7",
instance_offering_uuid=vm_instance_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
test_util.test_dsc(
"STEP3: Continuously Hot Plugin CPU and Memory and check capacity")
last_cpu = vm_instance_offering.cpuNum
last_mem = vm_instance_offering.memorySize
for _ in xrange(5):
cpu_change = random.randint(1, 5)
mem_change = random.randint(1, 500) * 1024 * 1024
with test_stub.CapacityCheckerContext(vm, cpu_change,
mem_change) as cc:
vm_ops.update_vm(vm.get_vm().uuid, last_cpu + cpu_change,
last_mem + mem_change)
last_cpu += cpu_change
last_mem += cc.mem_aligned_change
vm.update()
test_stub.online_hotplug_cpu_memory(vm)
time.sleep(5)
test_util.test_dsc("STEP4: Destroy test object")
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
test_util.test_dsc('Test update instance offering')
vm = test_stub.create_basic_vm()
instance_offering = test_lib.lib_get_instance_offering_by_uuid(vm.get_vm().instanceOfferingUuid)
test_obj_dict.add_vm(vm)
vm_ops.update_vm(vm.get_vm().uuid, instance_offering.cpuNum * 2, None)
vm_ops.update_vm(vm.get_vm().uuid, None, instance_offering.memorySize * 2)
vm.update()
if (vm.get_vm().cpuNum != instance_offering.cpuNum * 2):
test_util.test_fail("cpuNum is expected to change")
if (vm.get_vm().memorySize != instance_offering.memorySize * 2):
test_util.test_fail("memorySize is expected to change")
vm.stop()
vm.update()
if (vm.get_vm().cpuNum != instance_offering.cpuNum * 2):
test_util.test_fail("cpuNum is expected to change")
if (vm.get_vm().memorySize != instance_offering.memorySize * 2):
test_util.test_fail("memorySize is expected to change")
vm.start()
if (vm.get_vm().cpuNum != instance_offering.cpuNum * 2):
test_util.test_fail("cpuNum change is expected to take effect after Vm restart")
if (vm.get_vm().memorySize != instance_offering.memorySize * 2):
test_util.test_fail("memorySize change is expected to take effect after Vm restart")
vm.check()
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Test update instance cpu memory Pass')
def update_cpu_mem(vm):
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(
vm.get_vm().instanceOfferingUuid)
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum + CPUchange,
vm_instance_offering.memorySize + MEMchange)
vm.update()
test_stub.online_hotplug_cpu_memory(vm)
vm.check()
def test():
new_offering = test_lib.lib_create_instance_offering(cpuNum = 1,\
cpuSpeed = 111, memorySize = 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(new_offering)
vm = test_stub.create_vm(vm_name='ckvmoffering-c6-64',
image_name="imageName_i_c6",
instance_offering_uuid=new_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
mem_aligned_dict = {}
mem_aligned_dict['126'] = 128 * 1024 * 1024
mem_aligned_dict['1'] = 128 * 1024 * 1024
mem_aligned_dict['63'] = 128 * 1024 * 1024
mem_aligned_dict['129'] = 128 * 1024 * 1024
mem_aligned_dict['191'] = 128 * 1024 * 1024
mem_aligned_dict['192'] = 256 * 1024 * 1024
mem_aligned_dict['300'] = 256 * 1024 * 1024
last_mem = new_offering.memorySize
for memory in mem_aligned_dict:
(available_cpu_before, available_memory_before, vm_outer_cpu_before,
vm_outer_mem_before, vm_interal_cpu_before,
vm_interal_mem_before) = test_stub.check_cpu_mem(vm)
vm_ops.update_vm(vm.get_vm().uuid, None,
last_mem + int(memory) * 1024 * 1024)
vm.update()
last_mem += mem_aligned_dict[memory] * 1024 * 1024
(available_cpu_after, available_memory_after, vm_outer_cpu_after,
vm_outer_mem_after, vm_interal_cpu_after,
vm_internal_mem_after) = test_stub.check_cpu_mem(vm)
AlignedMemChange = mem_aligned_dict[memory]
assert available_cpu_before == available_cpu_after
test_util.test_logger("%s %s %s" %
(available_memory_before, available_memory_after,
AlignedMemChange))
assert available_memory_after + AlignedMemChange / int(
test_lib.lib_get_provision_memory_rate()) in range(
available_memory_before - 10, available_memory_before + 10)
assert vm_outer_cpu_before == vm_outer_cpu_after
assert vm_outer_mem_before == vm_outer_mem_after - AlignedMemChange
assert vm_interal_cpu_before == vm_interal_cpu_after
#test_util.test_logger("%s %s %s" % (vm_interal_mem_before, vm_internal_mem_after, MEMchange))
assert vm_interal_mem_before == vm_internal_mem_after - AlignedMemChange / 1024 / 1024
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instance_offering = test_lib.lib_create_instance_offering(
cpuNum=1, memorySize=1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(vm_instance_offering)
test_util.test_dsc("STEP2: Ceate vm and wait until it up for testing")
vm = test_stub.create_vm(vm_name='ckvmoffering-c7-64',
image_name="imageName_i_c7",
instance_offering_uuid=vm_instance_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
test_util.test_dsc("STEP3: Ceate Snapshot of root volume")
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
snapshots = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid)
snapshots.set_utility_vm(vm)
snapshots.create_snapshot('create_root_snapshot1')
snapshot1 = snapshots.get_current_snapshot()
test_util.test_dsc("STEP4: Hot Plugin CPU and Memory and check capacity")
cpu_change = random.randint(1, 5)
mem_change = random.randint(1, 500) * 1024 * 1024
with test_stub.CapacityCheckerContext(vm, cpu_change, mem_change):
vm_ops.update_vm(vm.get_vm().uuid,
vm_instance_offering.cpuNum + cpu_change,
vm_instance_offering.memorySize + mem_change)
vm.update()
test_stub.online_hotplug_cpu_memory(vm)
time.sleep(10)
test_util.test_dsc(
"STEP5: Recover from snapshot make sure CPU memory no change")
with test_stub.CapacityCheckerContext(vm, 0, 0) as cc:
vm.stop()
vm.check()
snapshots.check()
snapshots.use_snapshot(snapshot1)
vm.start()
vm.check()
cc.disable_internal_check = True
test_util.test_dsc("STEP6: Destroy test object")
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
new_offering = test_lib.lib_create_instance_offering(cpuNum = 1,\
cpuSpeed = 111, memorySize = 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(new_offering)
vm = test_stub.create_vm(vm_name='ckvmoffering-c7-64',
image_name="imageName_i_c7",
instance_offering_uuid=new_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
(available_cpu_before, available_memory_before, vm_outer_cpu_before,
vm_outer_mem_before, vm_interal_cpu_before,
vm_interal_mem_before) = test_stub.check_cpu_mem(vm, shutdown=True)
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(
vm.get_vm().instanceOfferingUuid)
MEMchange = 126 * 1024 * 1024
AlignedMemChange = 128 * 1024 * 1024
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum + 1,
vm_instance_offering.memorySize + MEMchange)
vm.update()
time.sleep(10)
vm.check()
vm_ops.stop_vm(vm.get_vm().uuid)
test_stub.wait_for_certain_vm_state(vm, 'stopped')
vm_ops.start_vm(vm.get_vm().uuid)
test_stub.wait_for_certain_vm_state(vm, 'running')
vm.check()
(available_cpu_after, available_memory_after, vm_outer_cpu_after,
vm_outer_mem_after, vm_interal_cpu_after,
vm_internal_mem_after) = test_stub.check_cpu_mem(vm, shutdown=True)
assert available_cpu_before == available_cpu_after + 1
assert available_memory_after + AlignedMemChange / int(
test_lib.lib_get_provision_memory_rate()) in range(
available_memory_before - 1, available_memory_before + 1)
assert vm_outer_cpu_before == vm_outer_cpu_after - 1
assert vm_outer_mem_before == vm_outer_mem_after - AlignedMemChange
assert vm_interal_cpu_before == vm_interal_cpu_after - 1
assert vm_interal_mem_before == vm_internal_mem_after - AlignedMemChange / 1024 / 1024
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instance_offering = test_lib.lib_create_instance_offering(cpuNum = 1,
memorySize = 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(vm_instance_offering)
test_util.test_dsc("STEP2: Ceate vm and wait until it up for testing")
vm = test_stub.create_vm(vm_name = 'ckvmoffering-c7-64', image_name = "imageName_i_c7",
instance_offering_uuid=vm_instance_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
test_util.test_dsc("STEP3: Ceate Snapshot of root volume")
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
snapshots = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid)
snapshots.set_utility_vm(vm)
snapshots.create_snapshot('create_root_snapshot1')
snapshot1 = snapshots.get_current_snapshot()
test_util.test_dsc("STEP4: Hot Plugin CPU and Memory and check capacity")
cpu_change = random.randint(1,5)
mem_change = random.randint(1,500)*1024*1024
with test_stub.CapacityCheckerContext(vm, cpu_change, mem_change):
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum+cpu_change,
vm_instance_offering.memorySize+mem_change)
vm.update()
test_stub.online_hotplug_cpu_memory(vm)
time.sleep(10)
test_util.test_dsc("STEP5: Recover from snapshot make sure CPU memory no change")
with test_stub.CapacityCheckerContext(vm, 0, 0) as cc:
vm.stop()
vm.check()
snapshots.check()
snapshots.use_snapshot(snapshot1)
vm.start()
vm.check()
cc.disable_internal_check = True
test_util.test_dsc("STEP6: Destroy test object")
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
vm = hot_plug_common.create_onlinechange_vm(test_stub, test_obj_dict)
(available_cpu_before, available_memory_before, vm_outer_cpu_before, vm_outer_mem_before,
vm_interal_cpu_before, vm_interal_mem_before) = hot_plug_common.check_cpu_mem(vm)
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(vm.get_vm().instanceOfferingUuid)
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum + 1, None)
vm.update()
time.sleep(10)
(available_cpu_after, available_memory_after, vm_outer_cpu_after, vm_outer_mem_after,
vm_interal_cpu_after, vm_internal_mem_after) = hot_plug_common.check_cpu_mem(vm)
assert available_cpu_before == available_cpu_after + 1
assert available_memory_before == available_memory_after
assert vm_outer_cpu_before == vm_outer_cpu_after - 1
assert vm_outer_mem_before == vm_outer_mem_after
assert vm_interal_cpu_before == vm_interal_cpu_after - 1
assert vm_interal_mem_before == vm_internal_mem_after
def test():
new_offering = test_lib.lib_create_instance_offering(cpuNum = 1,\
cpuSpeed = 111, memorySize = 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(new_offering)
vm = test_stub.create_vm(vm_name='ckvmoffering-c7-64',
image_name="imageName_i_c7",
instance_offering_uuid=new_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
last_cpu = new_offering.cpuNum
last_mem = new_offering.memorySize
for x in xrange(5):
(available_cpu_before, available_memory_before, vm_outer_cpu_before,
vm_outer_mem_before, vm_interal_cpu_before,
vm_interal_mem_before) = test_stub.check_cpu_mem(vm)
MEMchange = 126 * 1024 * 1024
AlignedMemChange = 128 * 1024 * 1024
vm_ops.update_vm(vm.get_vm().uuid, last_cpu + 2, last_mem + MEMchange)
last_cpu += 2
last_mem += MEMchange
vm.update()
time.sleep(10)
test_stub.online_hotplug_cpu_memory(vm)
vm.check()
(available_cpu_after, available_memory_after, vm_outer_cpu_after,
vm_outer_mem_after, vm_interal_cpu_after,
vm_internal_mem_after) = test_stub.check_cpu_mem(vm)
assert available_cpu_before == available_cpu_after + 2
assert available_memory_after + AlignedMemChange / int(
test_lib.lib_get_provision_memory_rate()) in range(
available_memory_before - 1, available_memory_before + 1)
assert vm_outer_cpu_before == vm_outer_cpu_after - 2
assert vm_outer_mem_before == vm_outer_mem_after - AlignedMemChange
assert vm_interal_cpu_before == vm_interal_cpu_after - 2
assert vm_interal_mem_before == vm_internal_mem_after - AlignedMemChange / 1024 / 1024
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
test_lib.lib_set_vm_numa('true')
vm = test_stub.create_vr_vm('migrate_vm', 'imageName3', 'l3VlanNetwork2')
test_obj_dict.add_vm(vm)
vm.check()
(available_cpu_before, available_memory_before, vm_outer_cpu_before,
vm_outer_mem_before, vm_interal_cpu_before,
vm_interal_mem_before) = test_stub.check_cpu_mem(vm)
test_stub.migrate_vm_to_random_host(vm)
vm.check()
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(
vm.get_vm().instanceOfferingUuid)
MEMchange = 126 * 1024 * 1024
AlignedMemChange = 128 * 1024 * 1024
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum + 1,
vm_instance_offering.memorySize + MEMchange)
vm.update()
time.sleep(10)
vm.check()
(available_cpu_after, available_memory_after, vm_outer_cpu_after,
vm_outer_mem_after, vm_interal_cpu_after,
vm_internal_mem_after) = test_stub.check_cpu_mem(vm)
assert available_cpu_before == available_cpu_after + 1
assert available_memory_after + AlignedMemChange / float(
test_lib.lib_get_provision_memory_rate()) in range(
available_memory_before - 1, available_memory_before + 1)
assert vm_outer_cpu_before == vm_outer_cpu_after - 1
assert vm_outer_mem_before == vm_outer_mem_after - AlignedMemChange
assert vm_interal_cpu_before == vm_interal_cpu_after - 1
assert vm_interal_mem_before == vm_internal_mem_after - AlignedMemChange / 1024 / 1024
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass(
'VM online change instance offering after migration Test Pass')
def test():
vm = hot_plug_common.create_onlinechange_vm(test_stub, test_obj_dict)
(available_cpu_before, available_memory_before, vm_outer_cpu_before,
vm_outer_mem_before, vm_interal_cpu_before,
vm_interal_mem_before) = hot_plug_common.check_cpu_mem(vm)
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(
vm.get_vm().instanceOfferingUuid)
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum + 1, None)
vm.update()
time.sleep(10)
(available_cpu_after, available_memory_after, vm_outer_cpu_after,
vm_outer_mem_after, vm_interal_cpu_after,
vm_internal_mem_after) = hot_plug_common.check_cpu_mem(vm)
assert available_cpu_before == available_cpu_after + 1
assert available_memory_before == available_memory_after
assert vm_outer_cpu_before == vm_outer_cpu_after - 1
assert vm_outer_mem_before == vm_outer_mem_after
assert vm_interal_cpu_before == vm_interal_cpu_after - 1
assert vm_interal_mem_before == vm_internal_mem_after
def test():
new_offering = test_lib.lib_create_instance_offering(cpuNum = 1,\
memorySize = 1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(new_offering)
vm = test_stub.create_vm(vm_name = 'ckvmoffering-c7-64', image_name = "imageName_i_c7", instance_offering_uuid=new_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
(available_cpu_before, available_memory_before, vm_outer_cpu_before, vm_outer_mem_before,
vm_interal_cpu_before, vm_interal_mem_before) = test_stub.check_cpu_mem(vm, shutdown=True)
vm_instance_offering = test_lib.lib_get_instance_offering_by_uuid(vm.get_vm().instanceOfferingUuid)
MEMchange = 126*1024*1024
AlignedMemChange = 128*1024*1024
vm_ops.update_vm(vm.get_vm().uuid, vm_instance_offering.cpuNum + 1, vm_instance_offering.memorySize + MEMchange)
vm.update()
time.sleep(10)
vm.check()
vm_ops.stop_vm(vm.get_vm().uuid)
test_stub.wait_for_certain_vm_state(vm, 'stopped')
vm_ops.start_vm(vm.get_vm().uuid)
test_stub.wait_for_certain_vm_state(vm, 'running')
vm.check()
(available_cpu_after, available_memory_after, vm_outer_cpu_after, vm_outer_mem_after,
vm_interal_cpu_after, vm_internal_mem_after) = test_stub.check_cpu_mem(vm, shutdown=True)
assert available_cpu_before == available_cpu_after + 1
assert available_memory_after + AlignedMemChange / int(test_lib.lib_get_provision_memory_rate()) in range(available_memory_before-1, available_memory_before+1)
assert vm_outer_cpu_before == vm_outer_cpu_after - 1
assert vm_outer_mem_before == vm_outer_mem_after - AlignedMemChange
assert vm_interal_cpu_before == vm_interal_cpu_after - 1
assert vm_interal_mem_before == vm_internal_mem_after - AlignedMemChange/1024/1024
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
new_offering = test_lib.lib_create_instance_offering(cpuNum=1,
cpuSpeed=111,
memorySize=1024 *
1024 * 1024)
test_obj_dict.add_instance_offering(new_offering)
vm = test_stub.create_vm(vm_name='ckvmoffering-u12-64',
image_name="imageName_i_u12",
instance_offering_uuid=new_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
last_cpu = new_offering.cpuNum
for _ in xrange(5):
(available_cpu_before, available_memory_before, vm_outer_cpu_before,
vm_outer_mem_before, vm_interal_cpu_before,
vm_interal_mem_before) = test_stub.check_cpu_mem(vm)
vm_ops.update_vm(vm.get_vm().uuid, last_cpu + 1, None)
last_cpu += 1
vm.update()
test_stub.online_hotplug_cpu_memory(vm)
vm.check()
(available_cpu_after, available_memory_after, vm_outer_cpu_after,
vm_outer_mem_after, vm_interal_cpu_after,
vm_internal_mem_after) = test_stub.check_cpu_mem(vm)
assert available_cpu_before == available_cpu_after + 1
assert available_memory_before == available_memory_after
assert vm_outer_cpu_before == vm_outer_cpu_after - 1
assert vm_outer_mem_before == vm_outer_mem_after
assert vm_interal_cpu_before == vm_interal_cpu_after - 1
assert vm_interal_mem_before == vm_internal_mem_after
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
flavor = case_flavor[os.environ.get('CASE_FLAVOR')]
test_util.test_dsc("STEP1: Ceate vm instance offering")
vm_instance_offering = test_lib.lib_create_instance_offering(
cpuNum=1, memorySize=1024 * 1024 * 1024)
test_obj_dict.add_instance_offering(vm_instance_offering)
test_util.test_dsc(
"STEP2: Ceate vm and wait until it up for testing image_name : {}".
format(flavor['image']))
vm = test_stub.create_vm(vm_name='test_vm',
image_name=flavor['image'],
instance_offering_uuid=vm_instance_offering.uuid)
test_obj_dict.add_vm(vm)
vm.check()
cpu_change = random.randint(1, 5) if flavor['add_cpu'] else 0
mem_change = random.randint(
1, 500) * 1024 * 1024 if flavor['add_memory'] else 0
test_util.test_dsc(
"STEP3: Hot Plugin CPU: {} and Memory: {} and check capacity".format(
cpu_change, mem_change))
with test_stub.CapacityCheckerContext(vm, cpu_change, mem_change):
vm_ops.update_vm(vm.get_vm().uuid,
vm_instance_offering.cpuNum + cpu_change,
vm_instance_offering.memorySize + mem_change)
vm.update()
if flavor['need_online']:
test_stub.online_hotplug_cpu_memory(vm)
time.sleep(10)
test_util.test_dsc("STEP4: Destroy test object")
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def set_iso_first(self, iso_uuid, vm_uuid=None):
if not vm_uuid:
vm_uuid = self.vm1.vm.uuid
system_tags = ['iso::%s::0' % iso_uuid]
vm_ops.update_vm(vm_uuid, system_tags=system_tags)
def running_vm_operations(vm,bss):
numa = config_ops.get_global_config_value('vm', 'numa')
live_migration = config_ops.get_global_config_value('localStoragePrimaryStorage','liveMigrationWithStorage.allow')
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
vm_uuid = vm.get_vm().uuid
#change vm's instanceoffering
if numa == 'false':
try:
vm_ops.update_vm(vm_uuic,2,2048*1024*1024)
test_util.test_fail('Test Fail.Cannot change instanceoffering of running vm when NUMA is false')
except:
config_ops.change_global_config('vm','numa','true')
vm_ops.reboot_vm(vm_uuid)
vm_ops.update_vm(vm_uuid,2,2048*1024*1024)
#Change vm's status;set ha level/stop/del ha level/reboot/pause/resume/force stop
ha_ops.set_vm_instance_ha_level(vm_uuid,'NeverStop')
vm_ops.stop_vm(vm_uuid)
ha_ops.del_vm_instance_ha_level(vm_uuid)
vm_ops.stop_vm(vm_uuid)
vm_ops.start_vm(vm_uuid)
vm_ops.reboot_vm(vm_uuid)
vm_ops.suspend_vm(vm_uuid)
vm_ops.resume_vm(vm_uuid)
vm_ops.stop_vm(vm_uuid,'cold')
vm_ops.start_vm(vm_uuid)
#clone vms
vm_ops.clone_vm(vm_uuid,['vm-1','vm-2','vm-3'],'InstantStart')
#migrate
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
migrate_host_uuids = []
if candidate_hosts == None:
pass
else:
for host in candidate_hosts.inventories:
migrate_host_uuids.append(host.uuid)
if ps.type == 'LocalStorage':
if live_migration == 'false':
try:
vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
test_util.test_fail('Test Fail.Cannot migrate localstorage vm when liveMigrationWithStorage is false.' )
except:
config_ops.change_global_config('localStoragePrimaryStorage','liveMigrationWithStorage.allow','true')
else:
vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
else:
vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
#change vm's password(qga)
try:
vm_ops.change_vm_password(vm_uuid,'root','testpassword')
test_util.test_fail('Test Fail.Cannot change vm password when qga is disabled.')
except:
vm_ops.set_vm_qga_enable(vm_uuid)
vm_ops.change_vm_password(vm_uuid,'root','testpassword')
vm_ops.set_vm_qga_disable(vm_uuid)
#snapshot operations
sp_option = test_util.SnapshotOption()
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
test_util.test_logger('rootvolumerunning:%s' % root_volume_uuid)
sp_option.set_volume_uuid(root_volume_uuid)
sp = vol_ops.create_snapshot(sp_option)
vm_ops.stop_vm(vm_uuid)
vol_ops.use_snapshot(sp.uuid)
vm_ops.start_vm(vm_uuid)
vol_ops.delete_snapshot(sp.uuid)
common_operations(vm,bss,'running')
vm_ops.destroy_vm(vm_uuid)
vm_ops.recover_vm(vm_uuid)
vm_ops.start_vm(vm_uuid)
vm.destroy()
vm.expunge()
def stopped_vm_operations(vm,bss):
vm_uuid = vm.get_vm().uuid
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
vm_ops.stop_vm(vm_uuid)
#Change vm's instanceoffering
vm_ops.update_vm(vm_uuid,2,2048*1024*1024)
#Change vm's status
ha_ops.set_vm_instance_ha_level(vm_uuid,'neverstop')
vm_ops.stop_vm(vm_uuid)
ha_ops.del_vm_instance_ha_level(vm_uuid)
vm_ops.stop_vm(vm_uuid)
if ps.type != 'LocalStorage':
target_host_uuid = test_lib.lib_find_random_host(vm.get_vm()).uuid
if target_host_uuid != None:
vm_ops.start_vm_with_target_host(vm_uuid,target_host_uuid)
#vm_ops.stop_vm(vm_uuid)
vm_ops.destroy_vm(vm_uuid)
vm_ops.recover_vm(vm_uuid)
vm_ops.reinit_vm(vm_uuid)
#clone
vm_ops.clone_vm(vm_uuid,['vm-1','vm-2','vm-3'],'InstantStart')
#migrate
vm_ops.start_vm(vm_uuid)
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
vm_ops.stop_vm(vm_uuid)
migrate_host_uuids = []
if candidate_hosts != None:
for host in candidate_hosts.inventories:
migrate_host_uuids.append(host.uuid)
if ps.type == 'LocalStorage':
vol_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid
#vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
vol_ops.migrate_volume(vol_uuid, migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
#resize root volume
vol_size = test_lib.lib_get_root_volume(vm.get_vm()).size
vol_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid
set_size = 1024*1024*1024*5
vol_ops.resize_volume(vol_uuid, set_size)
vm.update()
vol_size_after = test_lib.lib_get_root_volume(vm.get_vm()).size
if set_size != vol_size_after:
test_util.test_fail('Resize Root Volume failed, size = %s' % vol_size_after)
test_util.test_logger('resize vm success')
#storage migrate
#change vm image
image_list = vm_ops.get_image_candidates_for_vm_to_change(vm_uuid)
image_uuids = []
for image in image_list.inventories:
image_uuids.append(image.uuid)
vm_ops.change_vm_image(vm_uuid,image_uuids[0])
vm.update()
#update vm nic mac
nic_uuid = vm.get_vm().vmNics[0].uuid
mac = 'fa:4c:ee:9a:76:00'
vm_ops.update_vm_nic_mac(nic_uuid,mac)
#set/del static ip
l3network_uuid = test_lib.lib_get_l3_uuid_by_nic(nic_uuid)
vm_ops.change_vm_static_ip(vm_uuid, l3network_uuid, vm.get_vm().vmNics[0].ip)
vm_ops.delete_vm_static_ip(vm_uuid, l3network_uuid)
#snapshot operations
sp_option = test_util.SnapshotOption()
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
sp_option.set_volume_uuid(root_volume_uuid)
sp = vol_ops.create_snapshot(sp_option)
vol_ops.use_snapshot(sp.uuid)
vol_ops.delete_snapshot(sp.uuid)
common_operations(vm,bss,'stopped')
vm.destroy()
vm.expunge()
def running_vm_operations(vm, bss):
numa = config_ops.get_global_config_value('vm', 'numa')
live_migration = config_ops.get_global_config_value(
'localStoragePrimaryStorage', 'liveMigrationWithStorage.allow')
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
vm_uuid = vm.get_vm().uuid
#change vm's instanceoffering
if numa == 'false':
try:
vm_ops.update_vm(vm_uuic, 2, 2048 * 1024 * 1024)
test_util.test_fail(
'Test Fail.Cannot change instanceoffering of running vm when NUMA is false'
)
except:
config_ops.change_global_config('vm', 'numa', 'true')
vm_ops.reboot_vm(vm_uuid)
vm_ops.update_vm(vm_uuid, 2, 2048 * 1024 * 1024)
#Change vm's status;set ha level/stop/del ha level/reboot/pause/resume/force stop
ha_ops.set_vm_instance_ha_level(vm_uuid, 'neverstop')
vm_ops.stop_vm(vm_uuid)
ha_ops.del_vm_instance_ha_level(vm_uuid)
vm_ops.stop_vm(vm_uuid)
vm_ops.start_vm(vm_uuid)
vm_ops.reboot_vm(vm_uuid)
vm_ops.suspend_vm(vm_uuid)
vm_ops.resume_vm(vm_uuid)
vm_ops.stop_vm(vm_uuid, 'cold')
vm_ops.start_vm(vm_uuid)
#clone vms
vm_ops.clone_vm(vm_uuid, ['vm-1', 'vm-2', 'vm-3'], 'InstantStart')
#migrate
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
migrate_host_uuids = []
if candidate_hosts == None:
pass
else:
for host in candidate_hosts.inventories:
migrate_host_uuids.append(host.uuid)
if ps.type == 'LocalStorage':
if live_migration == 'false':
try:
vm_ops.migrate_vm(vm_uuid, migrate_host_uuids[0])
test_util.test_fail(
'Test Fail.Cannot migrate localstorage vm when liveMigrationWithStorage is false.'
)
except:
config_ops.change_global_config(
'localStoragePrimaryStorage',
'liveMigrationWithStorage.allow', 'true')
else:
vm_ops.migrate_vm(vm_uuid, migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
else:
vm_ops.migrate_vm(vm_uuid, migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
#change vm's password(qga)
try:
vm_ops.change_vm_password(vm_uuid, 'root', 'testpassword')
test_util.test_fail(
'Test Fail.Cannot change vm password when qga is disabled.')
except:
vm_ops.set_vm_qga_enable(vm_uuid)
vm_ops.change_vm_password(vm_uuid, 'root', 'testpassword')
vm_ops.set_vm_qga_disable(vm_uuid)
#snapshot operations
sp_option = test_util.SnapshotOption()
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
test_util.test_logger('rootvolumerunning:%s' % root_volume_uuid)
sp_option.set_volume_uuid(root_volume_uuid)
sp = vol_ops.create_snapshot(sp_option)
vm_ops.stop_vm(vm_uuid)
vol_ops.use_snapshot(sp.uuid)
vm_ops.start_vm(vm_uuid)
vol_ops.delete_snapshot(sp.uuid)
common_operations(vm, bss, 'running')
vm_ops.destroy_vm(vm_uuid)
vm_ops.recover_vm(vm_uuid)
vm_ops.start_vm(vm_uuid)
vm.destroy()
vm.expunge()
def stopped_vm_operations(vm, bss):
vm_uuid = vm.get_vm().uuid
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
vm_ops.stop_vm(vm_uuid)
#Change vm's instanceoffering
vm_ops.update_vm(vm_uuid, 2, 2048 * 1024 * 1024)
#Change vm's status
ha_ops.set_vm_instance_ha_level(vm_uuid, 'neverstop')
vm_ops.stop_vm(vm_uuid)
ha_ops.del_vm_instance_ha_level(vm_uuid)
vm_ops.stop_vm(vm_uuid)
if ps.type != 'LocalStorage':
target_host_uuid = test_lib.lib_find_random_host(vm.get_vm()).uuid
if target_host_uuid != None:
vm_ops.start_vm_with_target_host(vm_uuid, target_host_uuid)
#vm_ops.stop_vm(vm_uuid)
vm_ops.destroy_vm(vm_uuid)
vm_ops.recover_vm(vm_uuid)
vm_ops.reinit_vm(vm_uuid)
#clone
vm_ops.clone_vm(vm_uuid, ['vm-1', 'vm-2', 'vm-3'], 'InstantStart')
#migrate
vm_ops.start_vm(vm_uuid)
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
vm_ops.stop_vm(vm_uuid)
migrate_host_uuids = []
if candidate_hosts != None:
for host in candidate_hosts.inventories:
migrate_host_uuids.append(host.uuid)
if ps.type == 'LocalStorage':
vol_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid
#vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
vol_ops.migrate_volume(vol_uuid, migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
#resize root volume
vol_size = test_lib.lib_get_root_volume(vm.get_vm()).size
vol_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid
set_size = 1024 * 1024 * 1024 * 5
vol_ops.resize_volume(vol_uuid, set_size)
vm.update()
vol_size_after = test_lib.lib_get_root_volume(vm.get_vm()).size
if set_size != vol_size_after:
test_util.test_fail('Resize Root Volume failed, size = %s' %
vol_size_after)
test_util.test_logger('resize vm success')
#storage migrate
#change vm image
image_list = vm_ops.get_image_candidates_for_vm_to_change(vm_uuid)
image_uuids = []
for image in image_list.inventories:
image_uuids.append(image.uuid)
vm_ops.change_vm_image(vm_uuid, image_uuids[0])
vm.update()
#update vm nic mac
nic_uuid = vm.get_vm().vmNics[0].uuid
mac = 'fa:4c:ee:9a:76:00'
vm_ops.update_vm_nic_mac(nic_uuid, mac)
#set/del static ip
l3network_uuid = test_lib.lib_get_l3_uuid_by_nic(nic_uuid)
vm_ops.change_vm_static_ip(vm_uuid, l3network_uuid,
vm.get_vm().vmNics[0].ip)
vm_ops.delete_vm_static_ip(vm_uuid, l3network_uuid)
#snapshot operations
sp_option = test_util.SnapshotOption()
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
sp_option.set_volume_uuid(root_volume_uuid)
sp = vol_ops.create_snapshot(sp_option)
vol_ops.use_snapshot(sp.uuid)
vol_ops.delete_snapshot(sp.uuid)
common_operations(vm, bss, 'stopped')
vm.destroy()
vm.expunge()
