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