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 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 "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 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():
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')
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 create_vm(vm_name='img-stor-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_s')
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():
test_util.test_dsc('Create test vm and check')
vm = test_stub.create_vlan_vm()
test_obj_dict.add_vm(vm)
vm.stop()
r_volume = zstack_volume_header.ZstackTestVolume()
r_volume.set_volume(test_lib.lib_get_root_volume(vm.get_vm()))
r_volume.set_state(volume_header.ATTACHED)
test_util.test_dsc('Create volume template and check')
bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.get_vm())
vol_tmpt = r_volume.create_template([bs_list[0].uuid], 'new_data_template')
test_obj_dict.add_image(vol_tmpt)
test_util.test_dsc('Try to use data vol_tempt to Create VM. ')
vm_option = vm.get_creation_option()
vm_option.set_image_uuid(vol_tmpt.get_image().uuid)
vm2 = zstack_vm_header.ZstackTestVm()
vm2.set_creation_option(vm_option)
try:
vm2.create()
except:
test_util.test_logger('Expected exception, when creating VM by using Data Volume Template as root image')
else:
test_util.test_fail('VM can use data volume template to create VM')
vol_tmpt.delete()
test_obj_dict.rm_image(vol_tmpt)
vm.destroy()
test_util.test_pass('Create VM from Data Volume Template Test 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 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
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 create_vm_with_iso(vm_name, l3_name, session_uuid=None):
img_option = test_util.ImageOption()
img_option.set_name('fake_iso')
root_disk_uuid = test_lib.lib_get_disk_offering_by_name(
os.environ.get('mediumDiskOfferingName')).uuid
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [], \
session_uuid)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
mn_ip = res_ops.query_resource(res_ops.MANAGEMENT_NODE)[0].hostName
img_option.set_url('http://%s:8080/zstack/static/zstack-dvd/ks.cfg' %
(mn_ip))
image_uuid = img_ops.add_iso_template(img_option).uuid
vm_creation_option = test_util.VmOption()
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_root_disk_uuid(root_disk_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_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 = res_ops.get_resource(res_ops.INSTANCE_OFFERING, session_uuid)[0].uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond, session_uuid)[0].uuid
l3net_uuid = res_ops.get_resource(res_ops.L3_NETWORK, session_uuid)[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([l3net_uuid])
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.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_sim')
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_sim_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():
global test_obj_dict
test_util.test_dsc('Create test vm and check')
vm = test_stub.create_vlan_vm()
test_obj_dict.add_vm(vm)
vm.check()
test_util.test_dsc('Create volume and check')
volume = test_stub.create_volume()
vr_vm = test_lib.lib_find_vr_by_vm(vm.vm)[0]
test_vr_vm = zstack_test_vm.ZstackTestVm()
test_vr_vm.vm = vr_vm
test_vr_vm.state = vm_header.RUNNING
volume.attach(vm)
volume.check()
volume.detach()
volume.check()
test_util.test_dsc('Attach volume to VR vm and check')
volume.attach(test_vr_vm)
volume.check()
volume.detach()
volume.check()
volume.delete()
volume.check()
vm.destroy()
test_util.test_pass(
'Create Data Volume for Vlan VirtualRouter Test Success')
def test():
global vm
global test_host
global ps_uuid
global host_ip
global max_attempts
global storagechecker_timeout
allow_ps_list = [inventory.LOCAL_STORAGE_TYPE]
test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list)
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()
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('ls_vm_ha_self_start')
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
ha_ops.set_vm_instance_ha_level(vm.get_vm().uuid, "NeverStop")
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
ps_uuid = ps.uuid
ps_ops.change_primary_storage_state(ps_uuid, 'maintain')
if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail(
'VM is expected to stop when PS change to maintain state')
vm.set_state(vm_header.STOPPED)
vm.check()
ps_ops.change_primary_storage_state(ps_uuid, 'enable')
for i in range(0, 300):
if res_ops.query_resource(res_ops.VM_INSTANCE,
conditions)[0].state == "Running":
break
time.sleep(1)
else:
test_util.test_fail(
"vm has not been changed to running as expected within 300s.")
vm.destroy()
test_util.test_pass(
'Test checking VM ha and none status when force stop vm Success.')
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 = test_lib.lib_get_image_by_name(image_name)
image_uuid = image.uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
datastore_type = vc_ops.get_datastore_type(os.environ['vcenter'])
if datastore_type == 'local':
cond = res_ops.gen_query_conditions('image.uuid', '=', image_uuid)
vcbs = res_ops.query_resource(res_ops.VCENTER_BACKUP_STORAGE, cond)[0]
vcps = vc_ops.lib_get_vcenter_primary_storage_by_name(vcbs.name)
cond = res_ops.gen_query_conditions("name", '=', l3_name)
l3_inv = res_ops.query_resource(res_ops.L3_NETWORK, cond)
for l3_net in l3_inv:
cond = res_ops.gen_query_conditions("uuid", '=',
l3_net.l2NetworkUuid)
l2 = res_ops.query_resource(res_ops.L2_NETWORK, cond)[0]
if l2.attachedClusterUuids == vcps.attachedClusterUuids:
l3_net_uuid = l3_net.uuid
break
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 = 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 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 test():
global origin_interval
global bs_type
test_util.test_dsc('Create test vm and check')
vm1 = test_stub.create_vlan_vm()
#Without this checking, the image (created later) might be not able to get a DHCP IP, when using to create a new vm.
vm1.check()
test_obj_dict.add_vm(vm1)
vm1.stop()
image_creation_option = test_util.ImageOption()
backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm)
image_creation_option.set_backup_storage_uuid_list(
[backup_storage_list[0].uuid])
image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid)
image_creation_option.set_name('test_create_image_template')
bs_type = backup_storage_list[0].type
if bs_type == 'Ceph':
origin_interval = conf_ops.change_global_config(
'ceph', 'imageCache.cleanup.interval', '1')
image = test_image.ZstackTestImage()
image.set_creation_option(image_creation_option)
image.create()
test_obj_dict.add_image(image)
image.check()
test_util.test_dsc('Use new created Image to create a VM')
new_img_uuid = image.image.uuid
vm_creation_option = vm1.get_creation_option()
vm_creation_option.set_image_uuid(new_img_uuid)
vm2 = test_vm.ZstackTestVm()
vm2.set_creation_option(vm_creation_option)
vm2.create()
test_obj_dict.add_vm(vm2)
vm2.check()
vm1.start()
vm1.check()
vm2.destroy()
vm1.destroy()
image.delete()
if bs_type == 'Ceph':
time.sleep(60)
image.check()
if bs_type == 'Ceph':
conf_ops.change_global_config('ceph', 'imageCache.cleanup.interval',
origin_interval)
test_util.test_pass('Create Image Template Test Success')
def test():
global session_uuid
global session_to
global session_mc
vm_num = os.environ.get('ZSTACK_VM_NUM')
if not vm_num:
vm_num = 0
else:
vm_num = int(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('l3PublicNetworkName')
session_uuid = acc_ops.login_as_admin()
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)
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)
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:
vm_creation_option.set_l3_uuids([random.choice(l3s).uuid])
vm.set_creation_option(vm_creation_option)
vm_num -= 1
thread = threading.Thread(target=vm.create)
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)
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 Create():
global session_uuid
global session_to
global session_mc
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)
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('l3PublicNetworkName')
l3 = test_lib.lib_get_l3_by_name(l3_name)
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([l3.uuid])
while vm_num > 0:
check_thread_exception()
vm_name = 'multihost_basic_vm_%s' % 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_vm_wrapper(i, vm_creation_option):
global vms, exec_info
try:
vm = test_vm_header.ZstackTestVm()
vm_creation_option.set_name("vm-%s" % (i))
vm.set_creation_option(vm_creation_option)
vm.create()
ha_ops.set_vm_instance_ha_level(vm.get_vm().uuid, "NeverStop")
vms.append(vm)
except:
exec_info.append("vm-%s" % (i))
def create_vm_wrapper(i, vm_creation_option):
global invs, vms, exec_info
try:
vm = test_vm_header.ZstackTestVm()
vm_creation_option.set_name("vm-%s" %(i))
vm.set_creation_option(vm_creation_option)
inv = vm.create()
vms.append(vm)
except:
exec_info.append("vm-%s" %(i))
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 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_vm(l3_uuid_list, image_uuid, vm_name = None, \
disk_offering_uuids = None, default_l3_uuid = None):
vm_creation_option = test_util.VmOption()
conditions = res_ops.gen_query_conditions('name', '=', os.environ.get('instanceOfferingName_m'))
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
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_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(vm_creation_option=None,
volume_uuids=None,
root_disk_uuid=None,
image_uuid=None,
ps_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
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
cond = res_ops.gen_query_conditions('system', '=', 'false', cond)
l3net_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3VlanNetworkName3')).uuid
if image_uuid:
image_uuid = image_uuid
else:
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond,
session_uuid)[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([l3net_uuid])
vm_creation_option.set_timeout(864000000)
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 ps_uuid:
vm_creation_option.set_ps_uuid(ps_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_ag_vm(vm_creation_option=None,
volume_uuids=None,
root_disk_uuid=None,
image_uuid=None,
affinitygroup_uuid=None,
host_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
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
cond = res_ops.gen_query_conditions('system', '=', 'false', cond)
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond,
session_uuid)[0].uuid
cond = res_ops.gen_query_conditions('category', '!=', 'System')
l3net_uuid = res_ops.query_resource(res_ops.L3_NETWORK, cond,
session_uuid)[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([l3net_uuid])
vm_creation_option.set_host_uuid(host_uuid)
if affinitygroup_uuid:
vm_creation_option.set_system_tags(
["affinityGroupUuid::%s" % affinitygroup_uuid])
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.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_vm(l3_uuid_list, image_uuid, vm_name=None, disk_offering_uuids=None):
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_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)
if vm_name:
vm_name = vm_name + str(time.time())
vm_creation_option.set_name(vm_name)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
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 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 create_vm(l3_uuid_list, image_uuid, vm_name = None, \
disk_offering_uuids = None, default_l3_uuid = None, \
system_tags = None, instance_offering_uuid = None, session_uuid = None):
vm_creation_option = test_util.VmOption()
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_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_name(vm_name)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
vm_creation_option.set_default_l3_uuid(default_l3_uuid)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_session_uuid(session_uuid)
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
