def test():
test_util.test_dsc('Test Change VM Image In Multihosts Env')
global vm
image = test_lib.lib_get_image_by_name("centos")
vm = test_stub.create_vm(image_uuid=image.uuid)
last_l3network_uuid = test_lib.lib_get_l3s_uuid_by_vm(vm.get_vm())
last_primarystorage_uuid = test_lib.lib_get_root_volume(vm.get_vm()).primaryStorageUuid
last_host_uuid = test_lib.lib_get_vm_last_host(vm.get_vm()).uuid
image_uuid = test_lib.lib_get_image_by_name("image_for_sg_test").uuid
vm_uuid = vm.get_vm().uuid
host_ops.change_host_state(host_uuid = last_host_uuid, state = 'disable')
vm_ops.stop_vm(vm_uuid)
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
#Disable vm's host.If ps is shared storage,the vm will be started on another host that meets the conditions and the operation of changing vm image will success.
if ps.type != 'LocalStorage':
vm_ops.change_vm_image(vm_uuid,image_uuid)
vm_ops.start_vm(vm_uuid)
#check whether the network config has changed
l3network_uuid_after = test_lib.lib_get_l3s_uuid_by_vm(vm.get_vm())
if l3network_uuid_after != last_l3network_uuid:
test_util.test_fail('Change VM Image Failed.The Network config has changed.')
#check whether primarystorage has changed
primarystorage_uuid_after = test_lib.lib_get_root_volume(vm.get_vm()).primaryStorageUuid
if primarystorage_uuid_after != last_primarystorage_uuid:
test_util.test_fail('Change VM Image Failed.Primarystorage has changed.')
vm.destroy()
test_util.test_pass('Change Vm Image Test Success In Multihosts Env Success')
#Disable vm's host.If ps is local storage,the operation of changing vm image will fail.
else:
try:
vm_ops.change_vm_image(vm_uuid, image_uuid)
except:
test_util.test_pass('Change Vm Image Test Success In Multihosts Env Success')
test_util.test_fail('Test Change VM Image In Multihosts Env Success Failed')
def test():
ps_inv = res_ops.query_resource(res_ops.PRIMARY_STORAGE)
ceph_ps = [ps for ps in ps_inv if ps.type == 'Ceph']
if not ceph_ps:
test_util.test_skip('Skip test as there is not Ceph primary storage')
flavor = case_flavor[os.getenv('CASE_FLAVOR')]
if flavor['shared_vm']:
multi_ps.create_vm(image_name="ttylinux", ps_type="SharedBlock")
else:
multi_ps.create_vm(image_name="ttylinux", ps_type="Ceph")
multi_ps.create_data_volume(vms=multi_ps.vm, ps_type='SharedBlock')
multi_ps.create_data_volume(vms= multi_ps.vm, ps_type='Ceph')
vm = multi_ps.vm[0]
last_data_volumes_uuids = []
last_data_volumes = test_lib.lib_get_data_volumes(vm.get_vm())
for data_volume in last_data_volumes:
last_data_volumes_uuids.append(data_volume.uuid)
last_l3network_uuid = test_lib.lib_get_l3s_uuid_by_vm(vm.get_vm())
last_primarystorage_uuid = test_lib.lib_get_root_volume(vm.get_vm()).primaryStorageUuid
vm.stop()
if flavor['imagestore_bs']:
image_uuid = test_lib.lib_get_image_by_name("image_for_sg_test", bs_type="ImageStoreBackupStorage").uuid
else:
image_uuid = test_lib.lib_get_image_by_name("image_for_sg_test", bs_type="Ceph").uuid
vm_ops.change_vm_image(vm.get_vm().uuid, image_uuid)
vm.start()
vm.update()
#check whether the vm is running successfully
if not test_lib.lib_wait_target_up(vm.get_vm().vmNics[0].ip, 22, 1200):
test_util.test_fail('VM:%s is not startup in 1200 seconds.' % vm.get_vm().uuid)
#check whether data volumes attached to the vm has changed
now_data_volumes_uuids = []
now_data_volumes = test_lib.lib_get_data_volumes(vm.get_vm())
for data_volume in now_data_volumes:
now_data_volumes_uuids.append(data_volume.uuid)
if set(last_data_volumes_uuids) != set(now_data_volumes_uuids):
test_util.test_fail('Change Vm Image Failed.Data volumes changed.')
#check whether the network config has changed
now_l3network_uuid = test_lib.lib_get_l3s_uuid_by_vm(vm.get_vm())
if now_l3network_uuid != last_l3network_uuid:
test_util.test_fail('Change VM Image Failed.The Network config has changed.')
#check whether primarystorage has changed
now_primarystorage_uuid = test_lib.lib_get_root_volume(vm.get_vm()).primaryStorageUuid
if now_primarystorage_uuid != last_primarystorage_uuid:
test_util.test_fail('Change VM Image Failed.Primarystorage has changed.')
test_util.test_pass('Change Vm Image Test Success')
def test():
test_util.test_dsc('''Will mainly doing random test for all kinds of snapshot operations. VM, Volume and Image operations will also be tested. If reach 1 hour successful running condition, testing will success and quit. SG actions, and VIP actions are removed in this robot test.
VM resources: a special Utility vm is required to do volume attach/detach operation.
''')
target_running_vm = 4
public_l3 = test_lib.lib_get_l3_by_name(os.environ.get('l3PublicNetworkName'))
vm_create_option = test_util.VmOption()
#image has to use virtual router image, as it needs to do port checking
vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
utility_vm_create_option = test_util.VmOption()
utility_vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
l3_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetworkName1')).uuid
utility_vm_create_option.set_l3_uuids([l3_uuid])
priority_actions = test_state.TestAction.snapshot_actions * 4
utility_vm = test_lib.lib_create_vm(utility_vm_create_option)
test_dict.add_utility_vm(utility_vm)
if os.environ.get('ZSTACK_SIMULATOR') != "yes":
utility_vm.check()
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.vip_actions + \
test_state.TestAction.image_actions + \
test_state.TestAction.sg_actions + \
[ test_state.TestAction.create_volume ])
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_utility_vm(utility_vm)
robot_test_obj.set_random_type(action_select.fair_strategy)
rounds = 1
current_time = time.time()
timeout_time = current_time + 3600
while time.time() <= timeout_time:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial: 1 hour.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Snapshots Robot Test Success')
def test():
test_util.test_dsc('''
Will doing random test for VIP operations, including VIP create/delete, PF create/attach/detach/remove, EIP create/attach/detach/remove. VM operations will also be tested. If reach max 4 coexisting running vm, testing will success and quit. SG actions, Volume actions and Image actions are removed in this robot test.
VM resources: VIP testing needs at least 3 VRs are running.
''')
target_running_vm = 4
public_l3 = test_lib.lib_get_l3_by_name(os.environ.get('l3PublicNetworkName'))
vm_create_option = test_util.VmOption()
#image has to use virtual router image, as it needs to do port checking
vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
priority_actions = test_state.TestAction.snapshot_actions * 4
utility_vm_create_option = test_util.VmOption()
utility_vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
l3_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetworkName1')).uuid
utility_vm_create_option.set_l3_uuids([l3_uuid])
utility_vm = test_lib.lib_create_vm(utility_vm_create_option)
test_dict.add_utility_vm(utility_vm)
if os.environ.get('ZSTACK_SIMULATOR') != "yes":
utility_vm.check()
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.vip_actions + \
test_state.TestAction.image_actions + \
test_state.TestAction.sg_actions + \
[test_state.TestAction.create_volume])
robot_test_obj.set_public_l3(public_l3)
robot_test_obj.set_utility_vm(utility_vm)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Snapshots Robot Test Success')
def test():
global curr_deploy_conf
global l2_name2
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up l3
l3_1 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name1)[0]
l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name2)[0]
l2_2 = res_ops.get_resource(res_ops.L2_NETWORK, \
uuid = l3_2.l2NetworkUuid)[0]
l2_name2 = l2_2.name
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_l3_uuids([l3_1.uuid, l3_2.uuid])
cluster1_name = os.environ.get('clusterName2')
cluster1 = res_ops.get_resource(res_ops.CLUSTER, name = cluster1_name)[0]
vm_creation_option.set_cluster_uuid(cluster1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
test_util.test_dsc('Delete l2_2')
net_ops.delete_l2(l2_2.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm1.set_state(vm_header.STOPPED)
vm1.check()
test_util.test_dsc('start vm again. vm should remove the deleted l2')
vm1.start()
net_ops.add_l2_resource(curr_deploy_conf, l2_name = l2_name2)
#update l3_2, since it is readded.
l3_2 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name2)[0]
vm_creation_option.set_l3_uuids([l3_1.uuid, l3_2.uuid])
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
#check vm1 vm2 status.
vm1.check()
if not len(vm1.get_vm().vmNics) == 1:
test_util.test_fail('vm1 vmNics still have L3: %s, even if it is deleted' % l3_2.uuid)
vm2.check()
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete L2 Test Success')
def test():
global vm
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_name('multihost_basic_vm')
for i in range(1, 10):
vm_creation_option.set_cpu_num(random.choice(VM_CPU))
vm_creation_option.set_memory_size(random.choice(VM_MEM))
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
vm_uuid = vm.get_vm()['uuid']
vm.check()
time.sleep(30)
prometheus_test(vm_uuid)
vm.destroy()
vm.expunge()
time.sleep(30)
def test():
global vm
vip_s_vm_cfg_lst = test_stub.get_s_vm_cfg_lst_vip_bind(test_lib.all_scenario_config, test_lib.scenario_file)
if len(vip_s_vm_cfg_lst) != 1:
test_util.test_fail('vip has been running on %d host(s)' % len(vip_s_vm_cfg_lst))
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_name('multihost_basic_vm')
for i in range(1, 10):
vm_creation_option.set_cpu_num(random.choice(VM_CPU))
vm_creation_option.set_memory_size(random.choice(VM_MEM))
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
vm.check()
test_util.test_logger('===path%s===\n%s' % (i, random_operations(vm)))
#vm.expunge()
time.sleep(5)
test_util.test_pass('VM Life Cycle Test Success')
def test():
test_util.test_dsc('Test VM online change instance offering')
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_net_list = [l3_net_uuid]
vm = test_stub.create_vm(l3_net_list, image_uuid, 'online_chg_offering_vm', system_tags=['instanceOfferingOnlinechange::true'])
test_obj_dict.add_vm(vm)
vm.check()
cpuNum = 1
cpuSpeed = 222
memorySize = 666 * 1024 * 1024
new_offering = test_lib.lib_create_instance_offering(cpuNum = cpuNum,\
cpuSpeed = cpuSpeed, memorySize = memorySize)
test_obj_dict.add_instance_offering(new_offering)
new_offering_uuid = new_offering.uuid
vm.change_instance_offering(new_offering_uuid)
vm.check()
test_lib.lib_execute_command_in_vm(vm.get_vm(), 'ls -d /sys/devices/system/cpu/cpu*')
test_lib.lib_execute_command_in_vm(vm.get_vm(), 'ls -d /sys/devices/system/memory/memory*')
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def test():
test_util.test_dsc('''
Test Description:
Will create 1 VM with 3 l3 networks. 1 l3_network is not using VR; 1 l3_network is using novlan VR; 1 l3_network is using vlan VR.
Resource required:
Need support 3 VMs (1 test VM + 2 VR VMs) existing at the same time.
This test required a special image, which was configed with at least 3 enabled NICs (e.g. eth0, eth1, eth2).
''')
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_net_list = [l3_net_uuid]
l3_name = os.environ.get('l3VlanNetworkName3')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_net_list.append(l3_net_uuid)
l3_name = os.environ.get('l3VlanNetworkName4')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_net_list.append(l3_net_uuid)
vm = test_stub.create_vm(l3_net_list, image_uuid, '3_l3_vm')
test_obj_dict.add_vm(vm)
vm.check()
if len(vm.vm.vmNics) == 3:
test_util.test_logger("Find 3 expected Nics in new created VM.")
else:
test_util.test_fail("New create VM doesn't not have 3 Nics. It only have %s" % len(vm.get_vm().vmNics))
vm.destroy()
test_util.test_pass('Create 1 VM with 3 l3_network (1 vlan VR, 1 novlan VR and 1 no VR L3network) successfully.')
def test():
global vm
testHosts = test_lib.lib_get_all_hosts_from_plan()
for host in testHosts:
node_ip = host.managementIp_
print str(node_ip)+" is host.managementIp_"
break
host_username = "******"
host_password = "******"
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multihost_basic_vm')
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
cmd = "zstack-ctl setenv ZSTACK_HOME=/usr/local/zstacktest/apache-tomcat/webapps/zstack/; zstack-ctl dump_mysql --file-name mysql_dump"
rsp = test_lib.lib_execute_ssh_cmd(node_ip, host_username, host_password, cmd, 180)
dump_file = rsp.split()[-1]
cmd = "mysqldump -uroot -pzstack.mysql.password -A -r /tmp/mysql_before_restore.dump"
rsp = test_lib.lib_execute_ssh_cmd(node_ip, host_username, host_password, cmd, 180)
vm.check()
cmd = "zstack-ctl restore_mysql -f %s --mysql-root-password %s"%(dump_file, host_password)
rsp = test_lib.lib_execute_ssh_cmd(node_ip, host_username, host_password, cmd, 180)
cmd = '''mysql -uroot -pzstack.mysql.password -D zstack -e "delete from VmInstanceVO where uuid='%s';"''' % (vm.get_vm().uuid)
rsp = test_lib.lib_execute_ssh_cmd(node_ip, host_username, host_password, cmd, 180)
cmd = "mysqldump -uroot -pzstack.mysql.password -A -r /tmp/mysql_after_restore.dump"
rsp = test_lib.lib_execute_ssh_cmd(node_ip, host_username, host_password, cmd, 180)
cmd = "zstack-ctl start"
rsp = test_lib.lib_execute_ssh_cmd(node_ip, host_username, host_password, cmd, 180)
#cmd = "diff /tmp/mysql_before_restore.dump /tmp/mysql_after_restore.dump |wc -l"
#rsp = test_lib.lib_execute_ssh_cmd(node_ip, host_username, host_password, cmd, 180)
#diff mysql dump alway has 4 or 8 lines difference because the dump time is different.
#and sometime here has 12 lines difference,So we suppose the when the different lines
# more than 12, Restore mysql db failed.
#if int(rsp.rstrip()) > 12:
# test_util.test_fail('Restore Mysql Failed')
vm.destroy()
test_util.test_pass('Restore Mysql Success')
def prepare_host_with_different_cpu_scenario():
"""
Prepare vms in hosts
"""
global pre_vms
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3NoVlanNetworkName1')
#l3_name = os.environ.get('l3PublicNetworkName')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
#instance_offering_uuid = new_offering.uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
ps_uuid = res_ops.query_resource(res_ops.PRIMARY_STORAGE)[0].uuid
hosts = test_lib.lib_find_hosts_by_ps_uuid(ps_uuid)
host_id = 0
for host, max_vm_num in zip(hosts,[2,3,1,2]):
host_id +=1
for i in range(max_vm_num):
print "host_id=%s; i=%s" %(host_id, i)
vm_creation_option.set_name('pre-create-vm-%s-%s' %(host_id, i))
vm = test_vm_header.ZstackTestVm()
vm_creation_option.set_host_uuid(host.uuid)
vm.set_creation_option(vm_creation_option)
vm.create()
pre_vms.append(vm)
def create_vm(vm_name = 'vm_for_baremetal', image_name = None, \
l3_name = None, instance_offering_uuid = None, \
host_uuid = None, disk_offering_uuid = None, cluster_uuid = None, \
system_tags = None, password = None, session_uuid = None):
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
if not image_name:
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('scenl3VPCNetworkName1')
l3_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
vm_creation_option = test_util.VmOption()
vm_creation_option.set_name(vm_name)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_l3_uuids([l3_uuid])
if cluster_uuid:
vm_creation_option.set_cluster_uuid(cluster_uuid)
if system_tags:
vm_creation_option.set_system_tags(system_tags)
if disk_offering_uuid:
vm_creation_option.set_data_disk_uuids(disk_offering_uuid)
if password:
vm_creation_option.set_root_password(password)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
img_option = test_util.ImageOption()
UEFI_image_url = os.environ.get('imageUrl_linux_UEFI')
image_name = os.environ.get('imageName_linux_UEFI')
img_option.set_name(image_name)
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [], None)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
img_option.set_format('qcow2')
img_option.set_url(UEFI_image_url)
img_option.set_system_tags("bootMode::UEFI")
image_inv = img_ops.add_root_volume_template(img_option)
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
test_obj_dict.add_image(image)
vm = test_stub.create_vm(image_name = os.environ.get('imageName_linux_UEFI'))
test_obj_dict.add_vm(vm)
vm.check()
vm_ip = vm.get_vm().vmNics[0].ip
retcode = subprocess.call(["ping", "-c","4",vm_ip])
if retcode != 0:
test_util.test_fail('Create VM Test linux UEFI failed.')
else:
test_util.test_pass('Create VM Test linux UEFI Success.')
vm.destroy()
test_util.test_pass('Create VM Test linux UEFI Success')
def test():
test_util.test_dsc('Test VM online change instance offering')
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_net_list = [l3_net_uuid]
vm = test_stub.create_vm(l3_net_list, image_uuid, 'online_chg_offering_vm', system_tags=['instanceOfferingOnlinechange::true'])
test_obj_dict.add_vm(vm)
vm.check()
cpuNum = 2
memorySize = 666 * 1024 * 1024
new_offering = test_lib.lib_create_instance_offering(cpuNum = cpuNum,\
memorySize = memorySize)
test_obj_dict.add_instance_offering(new_offering)
new_offering_uuid = new_offering.uuid
new_offering2 = test_lib.lib_create_instance_offering(cpuNum = cpuNum,\
memorySize = memorySize)
test_obj_dict.add_instance_offering(new_offering2)
new_offering_uuid2 = new_offering2.uuid
vm.change_instance_offering(new_offering_uuid)
vm.change_instance_offering(new_offering_uuid2)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def create_vm(vm_name='virt-vm', \
image_name = None, \
l3_name = None, \
instance_offering_uuid = None, \
host_uuid = None, \
disk_offering_uuids=None, system_tags=None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_net')
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
vm_creation_option = test_util.VmOption()
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
if not instance_offering_uuid:
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
global session_uuid
global session_to
global session_mc
vm_num = os.environ.get('ZSTACK_TEST_NUM')
if not vm_num:
vm_num = 0
else:
vm_num = int(vm_num)
test_util.test_logger('ZSTACK_THREAD_THRESHOLD is %d' % thread_threshold)
test_util.test_logger('ZSTACK_TEST_NUM is %d' % vm_num)
org_num = vm_num
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
conditions = res_ops.gen_query_conditions('name', '=', l3_name)
l3_uuid = res_ops.query_resource_with_num(res_ops.L3_NETWORK, conditions, \
session_uuid, start = 0, limit = 1)[0].uuid
vm_creation_option.set_l3_uuids([l3_uuid])
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
session_uuid = acc_ops.login_as_admin()
#change account session timeout.
session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid)
session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid)
vm_creation_option.set_session_uuid(session_uuid)
vm = test_vm_header.ZstackTestVm()
random_name = random.random()
vm_name = 'multihost_basic_vm_%s' % str(random_name)
vm_creation_option.set_name(vm_name)
while vm_num > 0:
check_thread_exception()
vm.set_creation_option(vm_creation_option)
vm_num -= 1
thread = threading.Thread(target=create_vm, args=(vm,))
while threading.active_count() > thread_threshold:
time.sleep(1)
thread.start()
while threading.active_count() > 1:
time.sleep(0.01)
cond = res_ops.gen_query_conditions('name', '=', vm_name)
vms = res_ops.query_resource_count(res_ops.VM_INSTANCE, cond, session_uuid)
con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid)
con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid)
acc_ops.logout(session_uuid)
if vms == org_num:
test_util.test_pass('Create %d VMs Test Success' % org_num)
else:
test_util.test_fail('Create %d VMs Test Failed. Only find %d VMs.' % (org_num, vms))
def test():
image_name = os.environ.get('imageName')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_uuid_list = [l3_net_uuid]
vm_creation_option = test_util.VmOption()
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_name = 'parallel_vm-'
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_l3_uuids(l3_uuid_list)
vm_creation_option.set_image_uuid(image_uuid)
#vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
for i in range(parallel_num):
i = i + 1
vm_creation_option.set_name(vm_name + str(i))
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
test_obj_dict.add_vm(vm)
#vm.destroy()
test_util.test_pass('Parallelly Create 10 VM successfully')
def test():
global vm
vip_s_vm_cfg_lst = test_stub.get_s_vm_cfg_lst_vip_bind(test_lib.all_scenario_config, test_lib.scenario_file)
if len(vip_s_vm_cfg_lst) != 1:
test_util.test_fail('vip has been running on %d host(s)' % len(vip_s_vm_cfg_lst))
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_name('multihost_basic_vm')
for i in range(1, 10):
vm_creation_option.set_cpu_num(random.choice(VM_CPU))
vm_creation_option.set_memory_size(random.choice(VM_MEM))
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
vm_uuid = vm.get_vm()['uuid']
vm.check()
time.sleep(30)
prometheus_test(vm_uuid)
vm.destroy()
vm.expunge()
time.sleep(30)
def create_vm(vm_name='virt-vm', \
image_name = None, \
l3_name = None, \
instance_offering_uuid = None, \
host_uuid = None, \
disk_offering_uuids=None, system_tags=None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_net')
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
vm_creation_option = test_util.VmOption()
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_s')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_uuid_list = [l3_net_uuid]
vm_creation_option = test_util.VmOption()
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_name = '10k_vm-' + str(time.time())
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_l3_uuids(l3_uuid_list)
vm_creation_option.set_image_uuid(image_uuid)
#disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName'))
#disk_offering_uuids = [disk_offering.uuid]
#vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
vm_creation_option.set_name(vm_name)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
test_obj_dict.add_vm(vm)
time.sleep(1)
vm.destroy()
test_util.test_pass('Create/Destroy VM successfully')
def test():
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_uuid_list = [l3_net_uuid]
vm_creation_option = test_util.VmOption()
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
times = 1
vm_name = '24hr_vm-'
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_l3_uuids(l3_uuid_list)
vm_creation_option.set_image_uuid(image_uuid)
#vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
current_time = time.time()
end_time = current_time + duration
while current_time < end_time:
times = times + 1
vm_creation_option.set_name(vm_name + str(times))
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
time.sleep(5)
vm.destroy()
test_util.test_pass('Keep create/destroy %s VMs in 24 hrs pass' % times)
def test():
global vm, host3_uuid
if test_lib.lib_get_ha_enable() != 'true':
test_util.test_skip("vm ha not enabled. Skip test")
conf_ops.change_global_config('ha', 'allow.slibing.cross.clusters', 'true')
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#l3_name = os.environ.get('l3NoVlanNetworkName1')
#l3_name = os.environ.get('l3VlanNetworkName1')
l3_name = os.environ.get('l3PublicNetworkName')
host3_name = os.environ.get('hostName3')
host4_name = os.environ.get('hostName4')
conditions1 = res_ops.gen_query_conditions('name', '=', host3_name)
host3_uuid = res_ops.query_resource(res_ops.HOST, conditions1)[0].uuid
host3_ip = res_ops.query_resource(res_ops.HOST, conditions1)[0].managementIp
conditions2 = res_ops.gen_query_conditions('name', '=', host4_name)
host4_uuid = res_ops.query_resource(res_ops.HOST, conditions2)[0].uuid
host4_ip = res_ops.query_resource(res_ops.HOST, conditions2)[0].managementIp
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multihost_basic_vm')
vm_creation_option.set_host_uuid(host3_uuid)
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
time.sleep(30)
ha_ops.set_vm_instance_ha_level(vm.get_vm().uuid, "NeverStop")
time.sleep(5)
vm.check()
ssh_cmd1 = 'ssh -oStrictHostKeyChecking=no -oCheckHostIP=no -oUserKnownHostsFile=/dev/null %s' % host3_ip
cmd = '%s "poweroff" ' % ssh_cmd1
process_result = test_stub.execute_shell_in_process(cmd, tmp_file)
time.sleep(360)
host3_status = res_ops.query_resource(res_ops.HOST, conditions1)[0].status
if host3_status == "Disconnected":
conditions3 = res_ops.gen_query_conditions('uuid', '=', vm.vm.uuid)
vm_status = res_ops.query_resource(res_ops.VM_INSTANCE, conditions3)[0].state
vm_host_uuid = res_ops.query_resource(res_ops.VM_INSTANCE, conditions3)[0].hostUuid
if vm_status != "Running" or vm_host_uuid != host4_uuid:
test_util.test_fail('Test fail vm status: %s, vm_host_uuid: %s,' %(vm_status, vm_host_uuid))
vm.destroy()
conf_ops.change_global_config('ha', 'allow.slibing.cross.clusters', 'false')
conditions4 = res_ops.gen_query_conditions('vmNics.ip', '=', host3_ip)
vm3_uuid = sce_ops.query_resource(zstack_management_ip, res_ops.VM_INSTANCE, conditions4).inventories[0].uuid
sce_ops.start_vm(zstack_management_ip, vm3_uuid)
test_util.test_pass('VM auto ha across cluster Test Success')
def test():
test_util.test_dsc('''
Will doing random test Security Group operations, including SG create/delete, rule add/remove, vm nics attach/detach. If reach max 4 coexisting running vm, testing will success and quit. Volume actions and Image actions are removed in this robot test.
VM resources: Since SG testing will create target test vm, there might be max 12 running VMs: 4 VR VMs, 4 SG target test VMs and 4 test VMs.
''')
target_running_vm = 4
target_l3s = test_lib.lib_get_limited_l3_network(2, 5)
vr_num = 0
for target_l3 in target_l3s:
vr_l3_uuid = target_l3.uuid
vrs = test_lib.lib_find_vr_by_l3_uuid(vr_l3_uuid)
temp_vm = None
if not vrs:
#create temp_vm for getting its vr for test pf_vm portforwarding
vm_create_option = test_util.VmOption()
vm_create_option.set_l3_uuids([vr_l3_uuid])
temp_vm = test_lib.lib_create_vm(vm_create_option)
test_dict.add_vm(temp_vm)
#we only need temp_vm's VR
temp_vm.destroy()
test_dict.rm_vm(temp_vm)
vr_num += 1
#VIP testing need 3 VRs
if vr_num > 2:
break
vm_create_option = test_util.VmOption()
#image has to use network test image, as it needs to do port checking
vm_create_option.set_image_uuid(test_lib.lib_get_image_by_name(img_name=os.environ.get('imageName_net')).uuid)
priority_actions = [test_state.TestAction.sg_rule_operations]*2
priority_action_obj = action_select.ActionPriority()
priority_action_obj.add_priority_action_list(priority_actions)
test_util.test_dsc('Random Test Begin. Test target: 4 coexisting running VM (not include VR and SG target test VMs.).')
robot_test_obj = test_util.Robot_Test_Object()
robot_test_obj.set_test_dict(test_dict)
robot_test_obj.set_vm_creation_option(vm_create_option)
robot_test_obj.set_priority_actions(priority_action_obj)
robot_test_obj.set_exclusive_actions_list(\
test_state.TestAction.volume_actions \
+ test_state.TestAction.image_actions \
+ test_state.TestAction.vip_actions \
+ test_state.TestAction.snapshot_actions)
rounds = 1
while len(test_dict.get_vm_list(vm_header.RUNNING)) < target_running_vm:
test_util.test_dsc('New round %s starts: random operation pickup.' % rounds)
test_lib.lib_vm_random_operation(robot_test_obj)
test_util.test_dsc('===============Round %s finished. Begin status checking.================' % rounds)
rounds += 1
test_lib.lib_robot_status_check(test_dict)
test_util.test_dsc('Reach test pass exit criterial.')
test_lib.lib_robot_cleanup(test_dict)
test_util.test_pass('Create random VM Test Success')
def test():
global vms
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3NoVlanNetworkName1')
#l3_name = os.environ.get('l3PublicNetworkName')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
cpuNum = 5
#cpuSpeed = 16
#memorySize = 536870912
memorySize = 134217728
name = 'vm-offering-allocator-strategy'
new_offering_option = test_util.InstanceOfferingOption()
new_offering_option.set_cpuNum(cpuNum)
#new_offering_option.set_cpuSpeed(cpuSpeed)
new_offering_option.set_memorySize(memorySize)
new_offering_option.set_name(name)
new_offering = vm_ops.create_instance_offering(new_offering_option)
test_obj_dict.add_instance_offering(new_offering)
#conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
#instance_offering_inv = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0]
#instance_offering_uuid = instance_offering_inv.uuid
instance_offering_uuid = new_offering.uuid
each_vm_cpu_consume = cpuNum
vm_creation_option = test_util.VmOption()
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_timeout(600000)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
#create different cpu usage of hosts scenario
prepare_host_with_different_cpu_scenario()
#Notice here we are using the same network for both parallel vm and precondition
#In this way, we don't need to care about the cpu cost for newly created vr.
#If must compute vr we need to check vr existed in l3 network:
#vrs = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)
ps_uuid = res_ops.query_resource(res_ops.PRIMARY_STORAGE)[0].uuid
vm_num = compute_total_vm_num_based_on_ps(ps_uuid, each_vm_cpu_consume)
#trigger vm create
for i in range(vm_num):
t = threading.Thread(target=create_vm_wrapper, args=(i, vm_creation_option))
ts.append(t)
t.start()
for t in ts:
t.join()
check_threads_exception()
#clean the prepare scenario
clean_host_with_different_cpu_scenario()
clean_parallel_created_vm()
test_util.test_pass('Create VM Test Success')
def Create(vm_name_prefix):
global session_uuid
global session_to
global session_mc
session_uuid = None
session_to = None
session_mc = None
vm_num = os.environ.get('ZSTACK_TEST_NUM')
if not vm_num:
vm_num = 1000
else:
vm_num = int(vm_num)
test_util.test_logger('ZSTACK_THREAD_THRESHOLD is %d' % thread_threshold)
test_util.test_logger('ZSTACK_TEST_NUM is %d' % vm_num)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
cond = res_ops.gen_query_conditions('category', '=', 'Private')
l3net_uuid = res_ops.query_resource(res_ops.L3_NETWORK, cond, session_uuid)[0].uuid
l3s = test_lib.lib_get_l3s()
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
#change account session timeout.
session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid)
session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid)
session_uuid = acc_ops.login_as_admin()
vm_creation_option.set_session_uuid(session_uuid)
vm = test_vm_header.ZstackTestVm()
vm_creation_option.set_l3_uuids([l3net_uuid])
while vm_num > 0:
check_thread_exception()
vm_name = '%s_%s' % (vm_name_prefix, str(vm_num))
vm_creation_option.set_name(vm_name)
vm.set_creation_option(vm_creation_option)
vm_num -= 1
thread = threading.Thread(target=create_vm, args=(vm,))
while threading.active_count() > thread_threshold:
time.sleep(1)
thread.start()
while threading.active_count() > 1:
time.sleep(0.05)
cond = res_ops.gen_query_conditions('name', '=', vm_name)
vms = res_ops.query_resource_count(res_ops.VM_INSTANCE, cond, session_uuid)
con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid)
con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid)
acc_ops.logout(session_uuid)
def create_user_vlan_vm(l3_name=None, disk_offering_uuids=None):
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('l3NoVlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
return create_vm([l3_net_uuid], image_uuid, 'user_vlan_vm', disk_offering_uuids)
def create_specified_ps_vm(l3_name=None, ps_uuid=None, session_uuid = None):
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('l3NoVlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
return create_vm([l3_net_uuid], image_uuid, 'user_vlan_vm', session_uuid = session_uuid, ps_uuid = ps_uuid)
def create_user_vlan_vm(l3_name=None, disk_offering_uuids=None, session_uuid=None):
image_name = os.environ.get("imageName_net")
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get("l3NoVlanNetworkName1")
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
return create_vm([l3_net_uuid], image_uuid, "user_vlan_vm", disk_offering_uuids, session_uuid=session_uuid)
def create_vlan_vm(image_name, l3_name=None, disk_offering_uuids=None):
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
return create_vm([l3_net_uuid], image_uuid, 'zs_install_%s' % image_name, \
disk_offering_uuids)
def test():
global vm
global host_uuid
global host_ip
global max_attempts
global storagechecker_timeout
allow_ps_list = [inventory.NFS_PRIMARY_STORAGE_TYPE]
test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list)
test_stub.skip_if_not_storage_network_separate(test_lib.all_scenario_config)
if test_lib.lib_get_ha_enable() != 'true':
test_util.test_skip("vm ha not enabled. Skip test")
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
test_lib.clean_up_all_vr()
mn_ip = res_ops.query_resource(res_ops.MANAGEMENT_NODE)[0].hostName
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
conditions = res_ops.gen_query_conditions('state', '=', 'Enabled')
conditions = res_ops.gen_query_conditions('status', '=', 'Connected', conditions)
conditions = res_ops.gen_query_conditions('managementIp', '!=', mn_ip, conditions)
host_uuid = res_ops.query_resource(res_ops.HOST, conditions)[0].uuid
vm_creation_option.set_host_uuid(host_uuid)
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multihost_basic_vm')
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
vr_hosts = test_stub.get_host_has_vr()
mn_hosts = test_stub.get_host_has_mn()
nfs_hosts = test_stub.get_host_has_nfs()
if not test_stub.ensure_vm_not_on(vm.get_vm().uuid, vm.get_vm().hostUuid, vr_hosts+mn_hosts+nfs_hosts):
test_util.test_fail("Not find out a suitable host")
#vm.check()
host_ip = test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp
test_util.test_logger("host %s is disconnecting" %(host_ip))
ha_ops.set_vm_instance_ha_level(vm.get_vm().uuid, "NeverStop")
#test_stub.down_host_network(host_ip, test_lib.all_scenario_config)
host_username = os.environ.get('hostUsername')
host_password = os.environ.get('hostPassword')
t = test_stub.async_exec_ifconfig_nic_down_up(1200, host_ip, host_username, host_password, "zsn1")
vm.destroy()
test_util.test_pass('Test VM ha change to running within 300s Success')
def create_vlan_vm(l3_name=None, disk_offering_uuids=None, system_tags=None, session_uuid = None, instance_offering_uuid = None):
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
return create_vm([l3_net_uuid], image_uuid, 'vlan_vm', \
disk_offering_uuids, system_tags=system_tags, \
instance_offering_uuid = instance_offering_uuid,
session_uuid = session_uuid)
def create_vlan_vm(l3_name=None, disk_offering_uuids=None):
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
#cluster_name = os.environ.get('clusterName')
#cond = res_ops.gen_query_conditions('name', '=', cluster_name)
#cluster_uuid = res_ops.query_resource(res_ops.CLUSTER, cond)[0].uuid
return create_vm([l3_net_uuid], image_uuid, 'vlan_vm', disk_offering_uuids)
def test():
test_util.test_dsc('Test Change VM Image In Multihosts Env')
global vm
image = test_lib.lib_get_image_by_name("centos")
vm = test_stub.create_vm(image_uuid=image.uuid)
last_l3network_uuid = test_lib.lib_get_l3s_uuid_by_vm(vm.get_vm())
last_primarystorage_uuid = test_lib.lib_get_root_volume(
vm.get_vm()).primaryStorageUuid
last_host_uuid = test_lib.lib_get_vm_last_host(vm.get_vm()).uuid
image_uuid = test_lib.lib_get_image_by_name("image_for_sg_test").uuid
vm_uuid = vm.get_vm().uuid
host_ops.change_host_state(host_uuid=last_host_uuid, state='disable')
vm_ops.stop_vm(vm_uuid)
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
#Disable vm's host.If ps is shared storage,the vm will be started on another host that meets the conditions and the operation of changing vm image will success.
if ps.type != 'LocalStorage':
vm_ops.change_vm_image(vm_uuid, image_uuid)
vm_ops.start_vm(vm_uuid)
#check whether the network config has changed
l3network_uuid_after = test_lib.lib_get_l3s_uuid_by_vm(vm.get_vm())
if l3network_uuid_after != last_l3network_uuid:
test_util.test_fail(
'Change VM Image Failed.The Network config has changed.')
#check whether primarystorage has changed
primarystorage_uuid_after = test_lib.lib_get_root_volume(
vm.get_vm()).primaryStorageUuid
if primarystorage_uuid_after != last_primarystorage_uuid:
test_util.test_fail(
'Change VM Image Failed.Primarystorage has changed.')
vm.destroy()
test_util.test_pass(
'Change Vm Image Test Success In Multihosts Env Success')
#Disable vm's host.If ps is local storage,the operation of changing vm image will fail.
else:
try:
vm_ops.change_vm_image(vm_uuid, image_uuid)
except:
test_util.test_pass(
'Change Vm Image Test Success In Multihosts Env Success')
test_util.test_fail(
'Test Change VM Image In Multihosts Env Success Failed')
def create_specified_ps_vm(l3_name=None, ps_uuid=None, session_uuid=None):
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('l3NoVlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
return create_vm([l3_net_uuid],
image_uuid,
'user_vlan_vm',
session_uuid=session_uuid,
ps_uuid=ps_uuid)
def test():
test_util.test_dsc('''
Test Description:
Will create 1 test VM with 1 NIC firstly.
Then will attach a new NIC to VM with different L3 Network.
''')
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_net_list = [l3_net_uuid]
l3_name = os.environ.get('l3VlanNetworkName3')
l3_net_uuid2 = test_lib.lib_get_l3_by_name(l3_name).uuid
vm = test_stub.create_vm(l3_net_list, image_uuid, 'attach_nic_vm', \
default_l3_uuid = l3_net_uuid)
test_obj_dict.add_vm(vm)
#vm.check()
#change static IP need to stop VM firstly.
vm.stop()
vm.add_nic(l3_net_uuid2)
ip_address2 = net_ops.get_free_ip(l3_net_uuid2)[0].ip
static_ip_system_tag2 = test_lib.lib_create_vm_static_ip_tag(\
l3_net_uuid2, \
ip_address2)
tag_ops.create_system_tag('VmInstanceVO', vm.get_vm().uuid, \
static_ip_system_tag2)
vm.start()
attached_nic = test_lib.lib_get_vm_last_nic(vm.get_vm())
if l3_net_uuid2 != attached_nic.l3NetworkUuid:
test_util.test_fail(
"After attach a nic, VM:%s last nic is not belong l3: %s" %
(vm.get_vm().uuid, l3_net_uuid2))
test_lib.lib_restart_vm_network(vm.get_vm())
if attached_nic.ip != ip_address2:
test_util.test_fail('new added NIC ip address:%s is not static ip: %s' \
% (attached_nic.ip, ip_address2))
vm.check()
vm.remove_nic(attached_nic.uuid)
attached_nic = test_lib.lib_get_vm_last_nic(vm.get_vm())
if l3_net_uuid != attached_nic.l3NetworkUuid:
test_util.test_fail(
"After detached NIC, VM:%s only nic is not belong l3: %s" %
(vm.get_vm().uuid, l3_net_uuid2))
vm.destroy()
test_util.test_pass('Test Attach Nic to VM successfully.')
def test():
global vms
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3NoVlanNetworkName1')
#l3_name = os.environ.get('l3PublicNetworkName')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
cpuNum = 1
cpuSpeed = 8
memorySize = 536870912
name = 'vm-offering-allocator-strategy'
new_offering_option = test_util.InstanceOfferingOption()
new_offering_option.set_cpuNum(cpuNum)
new_offering_option.set_cpuSpeed(cpuSpeed)
new_offering_option.set_memorySize(memorySize)
new_offering_option.set_name(name)
new_offering = vm_ops.create_instance_offering(new_offering_option)
test_obj_dict.add_instance_offering(new_offering)
#conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
#instance_offering_inv = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0]
#instance_offering_uuid = instance_offering_inv.uuid
instance_offering_uuid = new_offering.uuid
each_vm_mem_consume = memorySize
vm_creation_option = test_util.VmOption()
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
#create different mem usage of hosts scenario
prepare_host_with_different_mem_scenario()
ps_uuid = res_ops.query_resource(res_ops.PRIMARY_STORAGE)[0].uuid
vm_num = compute_total_vm_num_based_on_ps(ps_uuid, each_vm_mem_consume)
#trigger vm create
for i in range(vm_num):
t = threading.Thread(target=create_vm_wrapper,
args=(i, vm_creation_option))
ts.append(t)
t.start()
for t in ts:
t.join()
check_threads_exception()
#clean the prepare scenario
clean_host_with_different_mem_scenario()
clean_parallel_created_vm()
test_util.test_pass('Create VM Test Success')
def create_sg_vm(l3_name=None, disk_offering_uuids=None):
'''
SG test need more network commands in guest. So it needs VR image.
'''
image_name = os.environ.get('virtualRouterImageName')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
#l3_name = 'guestL3VlanNetwork1'
l3_name = os.environ.get('l3VlanNetworkName_1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
return create_vm([l3_net_uuid], image_uuid, 'vlan_vm', disk_offering_uuids)
def test():
import uuid
account_name = uuid.uuid1().get_hex()
account_pass = uuid.uuid1().get_hex()
account_pass = hashlib.sha512(account_name).hexdigest()
test_account = acc_ops.create_normal_account(account_name,account_pass)
global vm
bs_cond = res_ops.gen_query_conditions("status", '=', "Connected")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, None, fields=['uuid'])
if not bss:
test_util.test_skip("not find available backup storage. Skip test")
test_util.test_dsc('Test change vm image with quota limited')
test_account_uuid = test_account.uuid
#set normal account's storage capacity as 4G
acc_ops.update_quota(test_account.uuid,"volume.capacity","4294967296")
test_account_session = acc_ops.login_by_account(account_name,account_pass)
test_stub.share_admin_resource([test_account_uuid])
vm = test_stub.create_vm(session_uuid = test_account_session)
vm.check()
image_option = test_util.ImageOption()
image_option.set_name('8G')
image_option.set_format('qcow2')
image_option.set_url(os.environ.get('imageServer')+"/diskimages/CentOS-7-x86_64-Cloudinit-8G-official.qcow2")
image_option.set_backup_storage_uuid_list([bss[0].uuid])
new_image = zstack_image_header.ZstackTestImage()
new_image.set_creation_option(image_option)
new_image.add_root_volume_template()
test_stub.share_admin_resource([test_account_uuid])
vm.stop(session_uuid = test_account_session)
image_uuid = test_lib.lib_get_image_by_name("8G").uuid
try:
vm_ops.change_vm_image(vm.get_vm().uuid,image_uuid,session_uuid = test_account_session)
except:
acc_ops.delete_account(test_account_uuid)
img_ops.delete_image(test_lib.lib_get_image_by_name('8G').uuid)
test_util.test_pass('Change Vm Image With Limited Storage Quota Test Success ')
test_util.test_fail('Overstep the limit of storage capacity')
def test():
iam2_ops.clean_iam2_enviroment()
global project_uuid,platform_admin_uuid,virtual_id_uuid
#create project
project_name = 'test_project'
project_uuid = iam2_ops.create_iam2_project(project_name).uuid
#create virtual id
platform_admin_name = 'username'
platform_admin_password = '******'
platform_admin_uuid = iam2_ops.create_iam2_virtual_id(platform_admin_name, platform_admin_password).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo', 'password').uuid
#create platform admin
iam2_ops.add_iam2_virtual_ids_to_project([platform_admin_uuid],project_uuid)
attributes = [{"name": "__PlatformAdmin__", "value": project_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(platform_admin_uuid, attributes)
#login in project by platform admin
platform_admin_session_uuid = iam2_ops.login_iam2_virtual_id(platform_admin_name, platform_admin_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name, session_uuid=platform_admin_session_uuid).uuid
#create ticket
ticket_name = 'ticket_1'
session_uuid = project_login_uuid
api_name='org.zstack.header.vm.APICreateVmInstanceMsg'
request_name='create-vm-ticket'
executeTimes=1
account_system_type='iam2'
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid =res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
image_name = os.environ.get('imageName_s')
image_uuid=test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_network_uuids=test_lib.lib_get_l3_by_name(l3_name).uuid
api_body={"name":"vm","instanceOfferingUuid":instance_offering_uuid,"imageUuid":image_uuid,"l3NetworkUuids":[l3_network_uuids]}
try:
ticket= ticket_ops.create_ticket(ticket_name,request_name,api_body,api_name,executeTimes,account_system_type,virtual_id_uuid,project_uuid,session_uuid)
test_util.test_fail("can't create ticket by platform admin ")
except:
test_util.test_logger("create ticket fail by platform admin ")
#query ticket
try:
cond= res_ops.gen_query_conditions('uuid','=', ticket.uuid)
ticket_list = res_ops.query_resource(res_ops.TICKET,cond)
test_util.test_fail("can't query ticket by platform admin ")
except:
test_util.test_pass('success test iam2 ticket by platform admin')
def create_vm_with_random_offering(vm_name,
image_name=None,
l3_name=None,
session_uuid=None,
instance_offering_uuid=None,
host_uuid=None,
disk_offering_uuids=None,
root_password=None,
ps_uuid=None,
system_tags=None):
if image_name:
imagename = os.environ.get(image_name)
else:
imagename = os.environ.get("imageName_net")
image_uuid = test_lib.lib_get_image_by_name(imagename).uuid
if l3_name:
l3name = os.environ.get(l3_name)
l3_net_uuid = test_lib.lib_get_l3_by_name(l3name).uuid
else:
l3_net_uuid = random.choice(res_ops.get_resource(
res_ops.L3_NETWORK)).uuid
if not instance_offering_uuid:
conf = res_ops.gen_query_conditions('type', '=', 'UserVM')
instance_offering_uuid = random.choice(
res_ops.query_resource(res_ops.INSTANCE_OFFERING, conf)).uuid
vm_creation_option = test_util.VmOption()
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name(vm_name)
if system_tags:
vm_creation_option.set_system_tags(system_tags)
if disk_offering_uuids:
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
if root_password:
vm_creation_option.set_root_password(root_password)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
if ps_uuid:
vm_creation_option.set_ps_uuid(ps_uuid)
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
test_util.test_dsc('Test Change VM Image Function')
global vm
image_uuid = test_lib.lib_get_image_by_name("centos").uuid
vm = test_stub.create_vm(image_uuid = image_uuid)
vm_uuid = vm.get_vm().uuid
image_uuid = test_lib.lib_get_image_by_name("image_for_sg_test").uuid
imagelist = vm_ops.get_image_candidates_for_vm_to_change(vm_uuid)
for image in imagelist.inventories:
#check whether the image is an iso
if image.format == "iso" or image.url.endswith('.iso') or image.mediaType == 'ISO':
test_util.test_fail("iso cannot be chose.")
#check whether the image is a vr image
if image.system == "true":
test_util.test_fail("vr image cannot be chose.")
#test change vm image when vm is running
try:
vm_ops.change_vm_image(vm_uuid,image_uuid)
except:
vm.destroy()
vm.expunge()
test_util.test_pass('Neg Test Change VM Image Function Success')
test_util.test_fail('Neg Test Change VM Image Function Failed')
def test():
global l2_net_uuid
global cluster_uuid
global vm
cluster1 = res_ops.get_resource(res_ops.CLUSTER)[0]
cluster2 = res_ops.get_resource(res_ops.CLUSTER)[1]
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l2_net_uuid = test_lib.lib_get_l3_by_name(l3_name).l2NetworkUuid
l2_net_type = res_ops.get_resource(res_ops.L2_NETWORK, uuid=l2_net_uuid)[0].type
test_util.test_logger("l2_network.type@@:%s" %(l2_net_type))
if l2_net_type == "VxlanNetwork":
test_util.test_skip("Vxlan network not support detach l2 network, therefore, skip the test")
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_cluster_uuid(cluster1.uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multicluster_basic_vm')
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
vm2 = test_vm_header.ZstackTestVm()
vm_creation_option.set_cluster_uuid(cluster2.uuid)
vm2.set_creation_option(vm_creation_option)
vm2.create()
vrs = test_lib.lib_find_vr_by_l3_uuid(l3_net_uuid)
if len(vrs) == 0:
test_util.test_skip("skip the test for non vr")
vr = vrs[0]
cluster_uuid = vr.clusterUuid
net_ops.detach_l2(l2_net_uuid, cluster_uuid)
vrs = test_lib.lib_find_vr_by_l3_uuid(l3_net_uuid)
if len(vrs) == 0:
test_util.test_skip("skip the test for non vr")
vr = vrs[0]
if vr.clusterUuid == cluster_uuid:
test_util.test_logger('vr is expected to migrate to another cluster')
vm.destroy()
vm2.destroy()
net_ops.attach_l2(l2_net_uuid, cluster_uuid)
test_util.test_pass('Create detach l2 from clsuter vr migrate Test Success')
def create_vm(vm_name, image_name, l3_name):
vm_creation_option = test_util.VmOption()
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name(vm_name)
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_lb_vm(l3_name=None, disk_offering_uuids=None, session_uuid=None):
'''
Load Balance VM will only use L3VlanNetworkName6
'''
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('l3VlanNetworkName6')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
return create_vm([l3_net_uuid],
image_uuid,
'vlan_lb_vm',
disk_offering_uuids,
session_uuid=session_uuid)
def test():
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3NoVlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
vm = test_stub.create_vm([l3_net_uuid], image_uuid, 'user_vlan_vm_s')
test_obj_dict.add_vm(vm)
vm.check()
vm.stop()
vm.reinit()
vm.update()
vm.check()
vm.destroy()
test_util.test_pass('Re-init VM Test Success')
def create_other_vm(l3_name=None, disk_offering_uuids=None, session_uuid=None):
'''
Create other platform type vm.
'''
image_name = os.environ.get('imageName_other')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
#l3_name = 'guestL3VlanNetwork1'
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
return create_vm([l3_net_uuid],
image_uuid,
'other_vm',
disk_offering_uuids,
session_uuid=session_uuid)
def test():
test_util.test_dsc('''
Test Description:
Will create 1 test VM with 1 NIC firstly.
Then Stop the VM.
Then attach a new NIC to Stopped VM with different L3 Network.
Then start the VM and check the network.
The reboot the VM and check the network again.
''')
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_net_list = [l3_net_uuid]
l3_name = os.environ.get('l3VlanNetworkName5')
l3_net_uuid2 = test_lib.lib_get_l3_by_name(l3_name).uuid
vm = test_stub.create_vm(l3_net_list, image_uuid, 'attach_nic_vm', \
default_l3_uuid = l3_net_uuid)
test_obj_dict.add_vm(vm)
vm.stop()
vm.add_nic(l3_net_uuid2)
attached_nic = test_lib.lib_get_vm_last_nic(vm.get_vm())
if l3_net_uuid2 != attached_nic.l3NetworkUuid:
test_util.test_fail(
"After attach a nic, VM:%s last nic is not belong l3: %s" %
(vm.get_vm().uuid, l3_net_uuid2))
vm.start()
import time
time.sleep(15)
vm.remove_nic(attached_nic.uuid)
vm.add_nic(l3_net_uuid2)
attached_nic = test_lib.lib_get_vm_last_nic(vm.get_vm())
if l3_net_uuid2 != attached_nic.l3NetworkUuid:
test_util.test_fail(
"After attach a nic, VM:%s last nic is not belong l3: %s" %
(vm.get_vm().uuid, l3_net_uuid2))
vm.reboot()
vm.check()
vm.destroy()
test_util.test_pass('Test Attach Nic with VM reboot action successfully.')
def test():
global image_obj
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_inv = test_lib.lib_get_image_by_name(image_name)
image_uuid = image_inv.uuid
image_crt_opt = test_util.ImageOption()
image_crt_opt.set_name(image_inv.name)
image_crt_opt.set_url(image_inv.url)
image_crt_opt.set_format(image_inv.format)
image_crt_opt.set_system(image_inv.system)
image_crt_opt.set_mediaType(image_inv.mediaType)
image_crt_opt.set_guest_os_type(image_inv.type)
bss = image_inv.backupStorageRefs
bss_uuids = []
for bs in bss:
bss_uuids.append(bs.backupStorageUuid)
image_crt_opt.set_backup_storage_uuid_list(bss_uuids)
image_obj.set_creation_option(image_crt_opt)
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING,
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
test_util.test_dsc('delete image')
img_ops.delete_image(image_uuid)
#in bug, when destroy vm after delete related image, destroy vm will fail
test_util.test_dsc('destroy vm')
vm1.destroy()
test_obj_dict.rm_vm(vm1)
test_util.test_dsc('add image back')
image_obj.add_root_volume_template()
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Image Test Success')
def create_vm():
global vm
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3PublicNetworkName')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('vm_'+ ''.join(map(lambda xx:(hex(ord(xx))[2:]),os.urandom(8))))
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
test_util.test_dsc('Test VM online change instance offering')
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
l3_net_list = [l3_net_uuid]
cpuNum = 2
cpuSpeed = 222
memorySize = 666 * 1024 * 1024
new_offering = test_lib.lib_create_instance_offering(cpuNum = cpuNum,\
cpuSpeed = cpuSpeed, memorySize = memorySize)
test_obj_dict.add_instance_offering(new_offering)
new_offering_uuid = new_offering.uuid
vm = test_stub.create_vm(
l3_net_list,
image_uuid,
'online_chg_offering_vm',
instance_offering_uuid=new_offering_uuid,
system_tags=['instanceOfferingOnlinechange::true'])
test_obj_dict.add_vm(vm)
cpuNum = 1
memorySize = 222 * 1024 * 1024
new_offering2 = test_lib.lib_create_instance_offering(cpuNum = cpuNum,\
cpuSpeed = cpuSpeed, memorySize = memorySize)
test_obj_dict.add_instance_offering(new_offering2)
new_offering_uuid2 = new_offering2.uuid
vm.change_instance_offering(new_offering_uuid2)
cpuNum = 1
memorySize = 444 * 1024 * 1024
new_offering3 = test_lib.lib_create_instance_offering(cpuNum = cpuNum,\
cpuSpeed = cpuSpeed, memorySize = memorySize)
test_obj_dict.add_instance_offering(new_offering3)
new_offering_uuid3 = new_offering3.uuid
vm.change_instance_offering(new_offering_uuid3)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('VM online change instance offering Test Pass')
def create_instance_vm(image_name, instance_offering_uuid, l3_name=None, disk_offering_uuids = None, default_l3_uuid = None):
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
vm_name = 'zs_install_%s' % image_name
vm_creation_option = test_util.VmOption()
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
vm_creation_option.set_default_l3_uuid(default_l3_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_vm_ticket(virtual_id_uuid,
project_uuid,
session_uuid,
name=None,
request_name=None,
execute_times=None,
instance_offering_uuid=None,
image_uuid=None,
l3_network_uuid=None):
if not instance_offering_uuid:
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(
res_ops.INSTANCE_OFFERING, conditions)[0].uuid
if not image_uuid:
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_network_uuid:
l3_name = os.environ.get('l3VlanNetworkName1')
l3_network_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
api_body = {
"name": "vm",
"instanceOfferingUuid": instance_offering_uuid,
"imageUuid": image_uuid,
"l3NetworkUuids": [l3_network_uuid]
}
api_name = 'org.zstack.header.vm.APICreateVmInstanceMsg'
if not execute_times:
execute_times = 1
if not name:
name = 'ticket_for_test'
if not request_name:
request_name = 'create-vm-ticket'
account_system_type = 'iam2'
ticket = ticket_ops.create_ticket(name,
request_name,
api_body,
api_name,
execute_times,
account_system_type,
virtual_id_uuid,
project_uuid,
session_uuid=session_uuid)
return ticket
def create_vm_in_vcenter(vm_name='vcenter-vm', \
image_name = None, \
l3_name = None, \
instance_offering_uuid = None, \
host_uuid = None, \
disk_offering_uuids=None, system_tags=None, \
timeout = 1200000, \
root_password=None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_net')
elif os.environ.get(image_name):
image_name = os.environ.get(image_name)
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
instance_offering_name).uuid
vm_creation_option = test_util.VmOption()
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
vm_creation_option.set_timeout(timeout)
if root_password:
vm_creation_option.set_root_password(root_password)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def prepare_host_with_different_cpu_scenario():
"""
Prepare vms in hosts
"""
global pre_vms
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3NoVlanNetworkName1')
#l3_name = os.environ.get('l3PublicNetworkName')
cpuNum = 6
cpuSpeed = 16
memorySize = 134217728
name = 'vm-offering-pre-cond'
new_offering_option = test_util.InstanceOfferingOption()
new_offering_option.set_cpuNum(cpuNum)
new_offering_option.set_cpuSpeed(cpuSpeed)
new_offering_option.set_memorySize(memorySize)
new_offering_option.set_name(name)
new_offering = vm_ops.create_instance_offering(new_offering_option)
test_obj_dict.add_instance_offering(new_offering)
instance_offering_uuid = new_offering.uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
ps_uuid = res_ops.query_resource(res_ops.PRIMARY_STORAGE)[0].uuid
hosts = test_lib.lib_find_hosts_by_ps_uuid(ps_uuid)
host_id = 0
for host, max_vm_num in zip(hosts,[3,3,3,3]):
host_id +=1
for i in range(max_vm_num):
print "host_id=%s; i=%s" %(host_id, i)
vm_creation_option.set_name('pre-create-vm-%s-%s' %(host_id, i))
vm = test_vm_header.ZstackTestVm()
vm_creation_option.set_host_uuid(host.uuid)
vm.set_creation_option(vm_creation_option)
vm.create()
pre_vms.append(vm)
def test():
global curr_deploy_conf
global l3_1
l3_1 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name1)[0]
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING,
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_l3_uuids([l3_1.uuid])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
test_util.test_dsc('Delete l3_1')
net_ops.delete_l3(l3_1.uuid)
#Since 0.8, delete L3 won't delete VM. It will just detach L3 nic.
#test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED)
#test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED)
#vm1.set_state(vm_header.DESTROYED)
#vm2.set_state(vm_header.DESTROYED)
vm1.check()
vm2.check()
net_ops.add_l3_resource(curr_deploy_conf, l3_name=l3_1.name)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete L3 Test 2 Success')
def test():
global host_config
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up host1
host1 = res_ops.get_resource(res_ops.HOST, name=host1_name)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING,
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_host_uuid(host1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm1.stop()
host_config.set_name(host1_name)
host_config.set_cluster_uuid(host1.clusterUuid)
host_config.set_management_ip(host1.managementIp)
host_config.set_username(os.environ.get('hostUsername'))
host_config.set_password(os.environ.get('hostPassword'))
test_util.test_dsc('delete host')
host_ops.delete_host(host1.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm1.check()
host_ops.add_kvm_host(host_config)
test_util.test_dsc('start vm on host, after readd it.')
vm1.start()
vm1.check()
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Host Test Success')
def test():
vm = test_stub.create_vr_vm('vm_imagecache', 'imageName_net', 'l3VlanNetwork3')
test_obj_dict.add_vm(vm)
vm.check()
host = test_lib.lib_find_host_by_vm(vm.get_vm())
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
image = test_lib.lib_get_image_by_name(os.environ.get('imageName_net'))
if ps.type == inventory.LOCAL_STORAGE_TYPE or ps.type == inventory.NFS_PRIMARY_STORAGE_TYPE or ps.type == 'SharedMountPoint':
image_cache_path = "%s/imagecache/template/%s/" % (ps.mountPath, image.uuid)
imagecache_file_size = int(test_lib.lib_get_file_size(host, image_cache_path))
image_actual_size = int(image.actualSize)
if imagecache_file_size < image.actualSize*0.99 or imagecache_file_size > image.actualSize*1.01:
test_util.test_fail('image cache size (%s) not match image actual size(%s)' % (imagecache_file_size, image_actual_size))
else:
test_util.test_skip("Skip test when primary storage is not local or NFS")
# elif ps.type == inventory.CEPH_PRIMARY_STORAGE_TYPE:
test_lib.lib_error_cleanup(test_obj_dict)
test_util.test_pass('imagecache cleanup Pass.')
def create_vm(vm_name = 'vm1', image_name = None, \
l3_name = None, instance_offering_uuid = None, \
host_uuid = None, disk_offering_uuid = None, \
system_tags = None, password = None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_s')
if not l3_name:
l3_name1 = os.environ.get('l3PublicNetworkName')
l3_name2 = os.environ.get('l3VlanNetworkName1')
l3_name3 = os.environ.get('l3VlanNetworkName3')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_uuid1 = test_lib.lib_get_l3_by_name(l3_name1).uuid
l3_uuid2 = test_lib.lib_get_l3_by_name(l3_name2).uuid
l3_uuid3 = test_lib.lib_get_l3_by_name(l3_name3).uuid
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
vm_creation_option = test_util.VmOption()
vm_creation_option.set_l3_uuids([l3_uuid1, l3_uuid2, l3_uuid3])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuid)
if password:
vm_creation_option.set_root_password(password)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
global vm
bs_cond = res_ops.gen_query_conditions('status', '=', 'Connected')
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE,
bs_cond,
None,
fields=['uuid'])
if not bss:
test_util.test_skip("not find availbale backup storage.Skip test")
#add iso
image_option_iso = test_util.ImageOption()
image_option_iso.set_name('vm-iso')
image_option_iso.set_format('iso')
image_option_iso.set_mediaType('RootVolumeTemplate')
image_option_iso.set_url("http://iso/CentOS-x86_64-7.2-Minimal.iso")
image_option_iso.set_backup_storage_uuid_list([bss[0].uuid])
new_image = zstack_image_header.ZstackTestImage()
new_image.set_creation_option(image_option_iso)
new_image.add_root_volume_template()
#add sshkeyimage
image_option_sshkey = test_util.ImageOption()
image_option_sshkey.set_name('sshkeyimage')
image_option_sshkey.set_format('qcow2')
image_option_sshkey.set_mediaType('RootVolumeTemplate')
image_option_sshkey.set_url("http://zstack-cloudinit.img")
image_option_sshkey.set_backup_storage_uuid_list([bss[0].uuid])
new_image = zstack_image_header.ZstackTestImage()
new_image.set_creation_option(image_option_sshkey)
new_image.add_root_volume_template()
image_name = os.environ.get('imageName3')
centosimage_uuid = test_lib.lib_get_image_by_name(image_name).uuid
running_vm = test_stub.create_vm(image_uuid=centosimage_uuid)
stopped_vm = test_stub.create_vm(image_uuid=centosimage_uuid)
scheduler_vm = test_stub.create_vm(image_uuid=centosimage_uuid)
running_vm_operations(running_vm, bss)
stopped_vm_operations(stopped_vm, bss)
scheduler_vm_operations(scheduler_vm, bss)
def create_arm_vm(vm_creation_option=None,
volume_uuids=None,
root_disk_uuid=None,
image_uuid=None,
session_uuid=None):
if not vm_creation_option:
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
image_name = os.environ.get('imageName_arm')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
conditions = res_ops.gen_query_conditions('name', '=', 'arm_cluster')
cluster_uuid = res_ops.query_resource(res_ops.CLUSTER,
conditions)[0].uuid
vm_creation_option = test_util.VmOption()
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_cluster_uuid(cluster_uuid)
vm_creation_option.set_name("arm_test_vm")
if volume_uuids:
if isinstance(volume_uuids, list):
vm_creation_option.set_data_disk_uuids(volume_uuids)
else:
test_util.test_fail('volume_uuids type: %s is not "list".' %
type(volume_uuids))
if root_disk_uuid:
vm_creation_option.set_root_disk_uuid(root_disk_uuid)
if image_uuid:
vm_creation_option.set_image_uuid(image_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
