def _cleanup_previous_checking_point(self): if not self.get_utility_vm(): return if not self.get_target_volume(): return test_util.test_logger('cleanup checking point files for target volume: %s' % self.get_target_volume()) volume_obj = self.get_target_volume() volume = volume_obj.get_volume() if volume.type == 'Root': test_util.test_logger('Can not add checking point file for Root Volume: %s, since it can not be detached and reattached to utility vm for checking.' % volume.uuid) return volume_vm = volume_obj.get_target_vm() #check if volume has been attached to the living VM. if volume_obj.get_state() == volume_header.ATTACHED: if volume_vm.get_state() == vm_header.STOPPED or \ volume_vm.get_state() == vm_header.RUNNING: #test_util.test_logger('volume has been attached to living VM.') volume_obj.detach() volume_obj.attach(self.utility_vm) self._remove_checking_file() volume_obj.detach() volume_obj.attach(volume_vm) return volume_obj.attach(self.utility_vm) self._remove_checking_file() volume_obj.detach()
def test(): global test_obj_dict, bs, ps #judge whether BS is imagestore bs = res_ops.query_resource(res_ops.BACKUP_STORAGE) for i in bs: if i.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break else: test_util.test_skip('Skip test on non-imagestore') #judge whether PS is SharedBlock ps = res_ops.query_resource(res_ops.PRIMARY_STORAGE) for i in ps: if i.type in ['SharedBlock', 'AliyunNAS']: test_util.test_skip('Skip test on SharedBlock and PS') image_name = os.environ.get('imageName_s') l3_name = os.environ.get('l3PublicNetworkName') vm = test_stub.create_vm("test_vm", image_name, l3_name) #vm.check() test_obj_dict.add_vm(vm) new_vm = vm.clone(['test_vm_clone_with_on_data_volume'], full=True)[0] test_obj_dict.add_vm(new_vm) volumes_number = len(test_lib.lib_get_all_volumes(new_vm.vm)) if volumes_number != 1: test_util.test_fail('Did not find 1 volumes for [vm:] %s. But we assigned 1 data volume when create the vm. We only catch %s volumes' % (new_vm.vm.uuid, volumes_number)) else: test_util.test_logger('Find 1 volumes for [vm:] %s.' % new_vm.vm.uuid) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Test clone vm with one data volume Success')
def delete_scheduler(uuid, session_uuid = None): action = api_actions.DeleteSchedulerAction() action.uuid = uuid test_util.action_logger('Delete [Scheduler:] %s' % uuid) evt = account_operations.execute_action_with_session(action, session_uuid) test_util.test_logger('[Scheduler:] %s is deleted.' % uuid) return evt
def add_checking_point(self): volume_obj = self.get_target_volume() volume = volume_obj.get_volume() if volume.type == 'Root': test_util.test_logger('Can not add checking point file for Root Volume: %s, since it can not be detached and reattached to utility vm for checking.' % volume.uuid) return volume_vm = volume_obj.get_target_vm() #check if volume has been attached to the living VM. if volume_obj.get_state() == volume_header.ATTACHED: if volume_vm.get_state() == vm_header.STOPPED or \ volume_vm.get_state() == vm_header.RUNNING: test_util.test_logger('volume has been attached to living VM.') volume_obj.detach() volume_obj.attach(self.utility_vm) #add checking point self._create_checking_file() volume_obj.detach() volume_obj.attach(volume_vm) return volume_obj.attach(self.utility_vm) #add_checking_point self._create_checking_file() volume_obj.detach()
def test(): global bs_username, bs_hostname, bs_password, bs_name, bs_username, bs_url, bs_sshport global new_image file_path = test_stub.gen_license('woodpecker', '*****@*****.**', '1', 'Prepaid', '1', '') test_stub.load_license(file_path) issued_date = test_stub.get_license_info().issuedDate expired_date = test_stub.license_date_cal(issued_date, 86400 * 1) test_stub.check_license("*****@*****.**", 1, None, False, 'Paid', issued_date=issued_date, expired_date=expired_date) test_util.test_logger('create zone and add the bs of the imagestore') node_uuid = res_ops.query_resource(res_ops.MANAGEMENT_NODE)[0].uuid test_stub.create_zone() zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid bs_name = 'BS1' bs_hostname = os.environ.get('node1Ip') bs_username = os.environ.get('nodeUserName') bs_password = os.environ.get('nodePassword') bs_url = '/zstack_bs' bs_sshport = '22' test_stub.create_image_store_backup_storage(bs_name, bs_hostname, bs_username, bs_password, bs_url, bs_sshport) bs_uuid = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0].uuid test_stub.reload_default_license() test_util.test_logger('Check default community license') #test_stub.check_license(None, None, 2147483647, False, 'Community') try: bs_ops.reconnect_backup_storage(bs_uuid) except Exception, e: if "commercial" in str(e): test_util.test_pass('test reconnect bs failed, An operation failed, details: commercial license is required to use ImageStore.')
def _add_zone(zone, zone_duplication): action = api_actions.CreateZoneAction() action.sessionUuid = session_uuid if zone_duplication == 0: action.name = zone.name_ action.description = zone.description__ else: action.name = generate_dup_name(zone.name_, zone_duplication, 'z') action.description = generate_dup_name(zone.description__, zone_duplication, 'zone') try: evt = action.run() test_util.test_logger(jsonobject.dumps(evt)) zinv = evt.inventory except: exc_info.append(sys.exc_info()) if xmlobject.has_element(zone, 'backupStorageRef'): for ref in xmlobject.safe_list(zone.backupStorageRef): bss = res_ops.get_resource(res_ops.BACKUP_STORAGE, session_uuid, name=ref.text_) bs = get_first_item_from_list(bss, 'Backup Storage', ref.text_, 'attach backup storage to zone') action = api_actions.AttachBackupStorageToZoneAction() action.sessionUuid = session_uuid action.backupStorageUuid = bs.uuid action.zoneUuid = zinv.uuid try: evt = action.run() test_util.test_logger(jsonobject.dumps(evt)) except: exc_info.append(sys.exc_info())
def vm_op_test(vm, op): test_util.test_logger(vm.vm.name + "-------" + op) ops = { "VM_TEST_STOP": stop, "VM_TEST_REBOOT": reboot, "VM_TEST_NONE": do_nothing, "VM_TEST_MIGRATE": migrate, "VM_TEST_SNAPSHOT": create_snapshot, "VM_TEST_CREATE_IMG": create_image, "VM_TEST_RESIZE_RVOL": resize_rvol, "RVOL_DEL_SNAPSHOT": delete_snapshot, "VM_TEST_CHANGE_OS": change_os, "VM_TEST_RESET": reset, "VM_TEST_BACKUP": back_up, "VM_TEST_REVERT_BACKUP": revert_backup, "VM_TEST_REVERT_VM_BACKUP": revert_vm_backup, "VM_TEST_BACKUP_IMAGE": backup_image, "DVOL_TEST_SNAPSHOT": create_dvol_snapshot, "DVOL_DEL_SNAPSHOT": delete_dvol_snapshot, "DVOL_TEST_CREATE_IMG": create_dvol_image, "DVOL_TEST_RESIZE": resize_dvol, "DVOL_BACKUP": dvol_back_up, "DVOL_TEST_BACKUP_IMAGE": dvol_backup_image, "CREATE_ATTACH_VOLUME": create_attach_volume } ops[op](vm)
def add_zone_resource(deploy_config, zone_name): session_uuid = acc_ops.login_as_admin() try: test_util.test_dsc('-------add zone operation-------') dep_ops.add_zone(deploy_config, session_uuid, zone_name = zone_name) test_util.test_dsc('-------add l2 operation-------') dep_ops.add_l2_network(deploy_config, session_uuid, \ zone_name = zone_name) test_util.test_dsc('-------add primary stroage operation-------') dep_ops.add_primary_storage(deploy_config, session_uuid, \ zone_name = zone_name) test_util.test_dsc('-------add cluster operation-------') dep_ops.add_cluster(deploy_config, session_uuid, \ zone_name = zone_name) test_util.test_dsc('-------add host operation-------') dep_ops.add_host(deploy_config, session_uuid, \ zone_name = zone_name) test_util.test_dsc('-------add l3 operation-------') dep_ops.add_l3_network(deploy_config, session_uuid, \ zone_name = zone_name) test_util.test_dsc('-------add virtual router offering operation-------') dep_ops.add_virtual_router(deploy_config, session_uuid, \ zone_name = zone_name) zone = res_ops.get_resource(res_ops.ZONE, session_uuid, \ name = zone_name)[0] except Exception as e: test_util.test_logger('[Error] zstack deployment meets exception when adding zone resource .') traceback.print_exc(file=sys.stdout) raise e finally: acc_ops.logout(session_uuid) test_util.action_logger('Complete add zone resources for [uuid:] %s' \ % zone.uuid)
def deploy_initial_database(deploy_config): operations = [ add_backup_storage, add_zone, add_l2_network, add_primary_storage, add_cluster, add_host, add_l3_network, add_image, add_disk_offering, add_instance_offering, add_virtual_router ] for operation in operations: session_uuid = account_operations.login_as_admin() try: operation(deploy_config, session_uuid) except Exception as e: test_util.test_logger('[Error] zstack deployment meets exception when doing: %s . The real exception are:.' % operation.__name__) print('----------------------Exception Reason------------------------') traceback.print_exc(file=sys.stdout) print('-------------------------Reason End---------------------------\n') raise e finally: account_operations.logout(session_uuid) test_util.test_logger('[Done] zstack initial database was created successfully.')
def test(): ag1 = ag_ops.create_affinity_group(name="ag1", policy="antiHard") vm1 = test_stub.create_ag_vm(affinitygroup_uuid=ag1.uuid) test_obj_dict.add_vm(vm1) vm2 = test_stub.create_ag_vm(affinitygroup_uuid=ag1.uuid) test_obj_dict.add_vm(vm2) assert vm1.get_vm().hostUuid != vm2.get_vm().hostUuid vm3 = test_stub.create_ag_vm(affinitygroup_uuid=ag1.uuid) test_obj_dict.add_vm(vm3) assert vm1.get_vm().hostUuid != vm3.get_vm().hostUuid assert vm2.get_vm().hostUuid != vm3.get_vm().hostUuid try: vm4 = None vm4 = test_stub.create_ag_vm(affinitygroup_uuid=ag1.uuid) except: if not vm4: test_util.test_logger("vm4 isn't created as expected") finally: if vm4: test_util.test_fail("Test Fail, vm4 [uuid:%s] is not expected to be created" % vm4.get_vm().uuid) test_lib.lib_error_cleanup(test_obj_dict) ag_ops.delete_affinity_group(ag1.uuid) test_util.test_pass("Affinity Group antiHard policy pass")
def test(): global vm global vip_s_vm_cfg_lst 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)) test_util.test_logger("disconnect host [%s]" % (vip_s_vm_cfg_lst[0].ip_)) #test_stub.down_host_network(vip_s_vm_cfg_lst[0].ip_, test_lib.all_scenario_config) test_stub.exec_zsha2_demote(vip_s_vm_cfg_lst[0].ip_, "root", "password") time.sleep(5) expected_vip_s_vm_cfg_lst_ip = test_stub.get_expected_vip_s_vm_cfg_lst_after_switch(test_lib.all_scenario_config, test_lib.scenario_file, vip_s_vm_cfg_lst[0].ip_) if not test_stub.check_if_vip_is_on_host(test_lib.all_scenario_config, test_lib.scenario_file, expected_vip_s_vm_cfg_lst_ip): test_util.test_fail("find vip should drift on ip %s, but is not on it." %(expected_vip_s_vm_cfg_lst_ip)) vip_s_vm_cfg_lst_new = 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_new) != 1: test_util.test_fail('vip has been running on %d host(s)' % len(vip_s_vm_cfg_lst_new)) test_stub.wrapper_of_wait_for_management_server_start(600) test_stub.ensure_hosts_connected(exclude_host=[vip_s_vm_cfg_lst[0]]) test_stub.ensure_bss_connected() test_stub.ensure_pss_connected() vm = test_stub.create_basic_vm() vm.check() vm.destroy() test_util.test_pass('Create VM Test Success')
def detach_l3(nic_uuid, session_uuid = None): action = api_actions.DetachL3NetworkFromVmAction() action.vmNicUuid = nic_uuid test_util.action_logger('[Detach L3 Network Nic]: %s' % nic_uuid) evt = acc_ops.execute_action_with_session(action, session_uuid) test_util.test_logger('[L3 Network Nic]: %s has been detached'% nic_uuid) return evt.inventory
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_inv test_util.test_dsc('Create test vm to test zstack upgrade by -u.') image_name = os.environ.get('imageName_i_c7_z_1.9') #iso_path = os.environ.get('iso_path') zstack_latest_version = os.environ.get('zstackLatestVersion') zstack_latest_path = os.environ.get('zstackLatestInstaller') vm_name = os.environ.get('vmName') #upgrade_script_path = os.environ.get('upgradeScript') vm_inv = test_stub.create_vm_scenario(image_name, vm_name) vm_ip = vm_inv.vmNics[0].ip test_lib.lib_wait_target_up(vm_ip, 22) test_stub.make_ssh_no_password(vm_ip, tmp_file) test_util.test_logger('Update MN IP') test_stub.update_mn_hostname(vm_ip, tmp_file) test_stub.update_mn_ip(vm_ip, tmp_file) test_stub.start_mn(vm_ip, tmp_file) test_stub.check_installation(vm_ip, tmp_file) test_util.test_logger('Upgrade zstack to latest with repo') #test_stub.update_iso(vm_ip, tmp_file, iso_path, upgrade_script_path) test_stub.update_repo(vm_ip, tmp_file) test_stub.upgrade_zstack(vm_ip, zstack_latest_path, tmp_file) test_stub.check_zstack_version(vm_ip, tmp_file, zstack_latest_version) test_stub.start_mn(vm_ip, tmp_file) test_stub.check_mn_running(vm_ip, tmp_file) test_stub.check_installation(vm_ip, tmp_file) os.system('rm -f %s' % tmp_file) test_stub.destroy_vm_scenario(vm_inv.uuid) test_util.test_pass('ZStack upgrade Test Success')
def test(): h1_name = os.environ.get("hostName") cond = res_ops.gen_query_conditions('name', '=', h1_name) h1 = res_ops.query_resource(res_ops.HOST, cond) ag1 = ag_ops.create_affinity_group(name="ag1", policy="antiHard") vm1 = test_stub.create_ag_vm(host_uuid=h1[0].uuid) assert vm1.get_vm().hostUuid == h1[0].uuid test_obj_dict.add_vm(vm1) new_vm = vm1.clone(names=["clone-vm1", "clone-vm2", "clone-vm3"], systemtag=["affinityGroupUuid::%s" % ag1.uuid]) test_obj_dict.add_vm(new_vm[0]) test_obj_dict.add_vm(new_vm[1]) test_obj_dict.add_vm(new_vm[2]) vmuuids = [] ag = test_lib.lib_get_affinity_group_by_name(name="ag1") for usage in ag.usages: vmuuids.append(usage.resourceUuid) assert new_vm[0].get_vm().uuid in vmuuids assert new_vm[1].get_vm().uuid in vmuuids assert new_vm[2].get_vm().uuid in vmuuids assert len(vmuuids) == 3 try: ag_ops.add_vm_to_affinity_group(ag1.uuid, vm1.get_vm().uuid) except: test_util.test_logger("vm1 is not expected to add into affinity group [uuid: %s]" % ag1.uuid) vmuuids = [] ag = test_lib.lib_get_affinity_group_by_name(name="ag1") for usage in ag.usages: vmuuids.append(usage.resourceUuid) assert vm1.get_vm().uuid not in vmuuids test_lib.lib_error_cleanup(test_obj_dict) ag_ops.delete_affinity_group(ag1.uuid) test_util.test_pass("Affinity Group antiHard policy pass")
def test(): if os.environ.get('ZSTACK_SIMULATOR') == "yes": if os.environ.get('WOODPECKER_PARALLEL') != None and os.environ.get('WOODPECKER_PARALLEL') == '0': destroy_initial_database() deploy_operations.deploy_initial_database(test_lib.deploy_config, test_lib.all_scenario_config, test_lib.scenario_file) else: test_util.test_logger('Skip case setup since parallel testing')
def test_scp_vm_inbound_speed(vm_inv, bandwidth): ''' bandwidth unit is KB ''' timeout = TEST_TIME + 30 vm_ip = vm_inv.vmNics[0].ip file_size = bandwidth * TEST_TIME seek_size = file_size / 1024 - 1 cmd = 'dd if=/dev/zero of=%s bs=1M count=1 seek=%d' \ % (test_file, seek_size) os.system(cmd) cmd = 'scp -oStrictHostKeyChecking=no -oCheckHostIP=no -oUserKnownHostsFile=/dev/null %s %s:/dev/null' \ % (test_file, vm_ip) start_time = time.time() if execute_shell_in_process(cmd, timeout) != 0: test_util.test_fail('scp test file failed') end_time = time.time() os.system('rm -f %s' % test_file) scp_time = end_time - start_time if scp_time < TEST_TIME: test_util.test_fail('network inbound QOS test file failed, since the scp time: %d is smaller than the expected test time: %d. It means the bandwidth limitation: %d KB/s is not effect. ' % (scp_time, TEST_TIME, bandwidth)) else: test_util.test_logger('network inbound QOS test file pass, since the scp time: %d is bigger than the expected test time: %d. It means the bandwidth limitation: %d KB/s is effect. ' % (scp_time, TEST_TIME, bandwidth)) return True
def check(self): super(zstack_kvm_lbl_checker, self).check() self.vm_nic_uuids = self.lbl.get_vm_nics_uuid() self.algorithm = self.lbl.get_algorithm() self.vm_list = [] self.vm_ip_test_dict = {} for vm_nic_uuid in self.vm_nic_uuids: vm = test_lib.lib_get_vm_by_nic(vm_nic_uuid) if vm.state == 'Running': nic_ip = test_lib.lib_get_nic_by_uuid(vm_nic_uuid).ip self.vm_ip_test_dict[nic_ip] = 0 self.vm_list.append(vm) if not self.vm_list: test_util.test_logger('There is not living vm for load balancer test') return self.judge(False) cond = res_ops.gen_query_conditions('listeners.uuid', '=', self.lbl_uuid) vip_uuid = res_ops.query_resource(res_ops.LOAD_BALANCER, cond)[0].vipUuid cond = res_ops.gen_query_conditions('uuid', '=', vip_uuid) self.vip_ip = res_ops.query_resource(res_ops.VIP, cond)[0].ip if not len(self.vm_list) > 1: self.do_so_check() return if self.algorithm == lb_header.LB_ALGORITHM_RR: self.do_rr_check() elif self.algorithm == lb_header.LB_ALGORITHM_LC: #self.do_lc_check() #If not consider long connection, leastconn is same as round robin. self.do_rr_check() elif self.algorithm == lb_header.LB_ALGORITHM_SO: self.do_so_check()
def cleanup_none_vm_volumes_violently(): session_uuid = acc_ops.login_as_admin() try: priSto_host_list = {} result = res_ops.get_resource(res_ops.VOLUME, session_uuid) for volume in result: if not volume.installPath: continue volume_path = os.path.dirname(volume.installPath) # VM volume has been cleanup in destroy_vm_and_storage_violently() if not volume.hasattr("vmInstanceUuid"): pri_sto_uuid = volume.primaryStorageUuid if priSto_host_list.has_key(pri_sto_uuid): host_ip = priSto_host_list[pri_sto_uuid] else: # TODO: need to add multi hosts, if primary storage is local storage. host = _get_host_from_primary_storage(pri_sto_uuid, session_uuid) host_ip = host.managementIp priSto_host_list[pri_sto_uuid] = host_ip thread = threading.Thread(target=_delete_file, args=(host_ip, volume_path)) thread.start() while threading.active_count() > 1: time.sleep(0.1) except Exception as e: test_util.test_logger("cleanup volumes violently meet exception") traceback.print_exc(file=sys.stdout) raise e finally: acc_ops.logout(session_uuid)
def get_host(content, name=None): from pyVmomi import vim host = get_obj(content, [vim.HostSystem], name=name) if isinstance(host, list): test_util.test_logger("do not find host named %s, now return all host" % name) return host return [host]
def get_vm(content, name=None): from pyVmomi import vim vm = get_obj(content, [vim.VirtualMachine], name=name) if isinstance(vm, list): test_util.test_logger("do not find vm named %s, now return all vm" % name) return vm return [vm]
def get_datacenter(content, name=None): from pyVmomi import vim dc = get_obj(content, [vim.Datacenter], name=name) if isinstance(dc, list): test_util.test_logger("do not find datacenter named %s, now return all datacenter" % name) return dc return [dc]
def create_checker(self, test_obj): kvm_volume_checker_chain = checker_header.CheckerChain() checker_dict = {} if test_obj.state == volume_header.CREATED: checker_dict[db_checker.zstack_volume_db_checker] = True checker_dict[volume_checker.zstack_kvm_volume_file_checker] = False elif test_obj.state == volume_header.ATTACHED: checker_dict[db_checker.zstack_volume_db_checker] = True checker_dict[volume_checker.zstack_kvm_volume_file_checker] = True if not test_obj.target_vm.state == vm_header.DESTROYED: checker_dict[db_checker.zstack_volume_attach_db_checker] = True if test_obj.target_vm.state == vm_header.RUNNING: checker_dict[volume_checker.zstack_kvm_volume_attach_checker] = True else: checker_dict[db_checker.zstack_volume_attach_db_checker] = False elif test_obj.state == volume_header.DETACHED: checker_dict[db_checker.zstack_volume_db_checker] = True checker_dict[db_checker.zstack_volume_attach_db_checker] = False checker_dict[volume_checker.zstack_kvm_volume_attach_checker] = False checker_dict[volume_checker.zstack_kvm_volume_file_checker] = True elif test_obj.state == volume_header.DELETED: test_util.test_logger('volume has been deleted: %s' % test_obj.volume.uuid) checker_dict[db_checker.zstack_volume_db_checker] = False checker_dict[volume_checker.zstack_kvm_volume_file_checker] = False kvm_volume_checker_chain.add_checker_dict(checker_dict, test_obj) return kvm_volume_checker_chain
def check_nfs(self, volume, volume_installPath): host = test_lib.lib_get_volume_object_host(self.test_obj) if not host: test_util.test_logger('Check result: can not find Host, who is belonged to same Zone Uuid of [volume uuid: ] %s. Can not check volume file existence' % volume.uuid) return self.judge(False) self.check_file_exist(volume, volume_installPath, host)
def dump_zstack_deployment_config(deployConfig = None): ''' deployConfig is the original zstack config. We need this conifg to set username/password, as they are not get from ZStack API will return an xmlobject ''' if not deployConfig: deployConfig = xmlobject.XmlObject('fake') root_xml = etree.Element("deployerConfig") session_uuid = account_operations.login_as_admin() try: add_nodes_config(root_xml, deployConfig.nodes__, session_uuid) add_sftp_backup_stroage_config(root_xml, \ deployConfig.backupStorages__, session_uuid) add_instance_offering_config(root_xml, session_uuid) add_disk_offering_config(root_xml, session_uuid) add_image_config(root_xml, deployConfig.images__, session_uuid) add_zone_config(root_xml, deployConfig.zones, session_uuid) except Exception as e: test_util.test_logger('[Error] export zstack deployment configuration meets exception.') traceback.print_exc(file=sys.stdout) raise e finally: account_operations.logout(session_uuid) return root_xml
def check(self): super(zstack_kvm_vm_snat_checker, self).check() vm = self.test_obj.vm test_lib.lib_install_testagent_to_vr(vm) host = test_lib.lib_get_vm_host(vm) vm_cmd_result = None vr_vms = test_lib.lib_find_vr_by_vm(vm) test_lib.lib_set_vm_host_l2_ip(vm) for vr_vm in vr_vms: test_util.test_logger("Begin to check [vm:] %s SNAT" % vm.uuid) nic = test_lib.lib_get_vm_nic_by_vr(vm, vr_vm) if not 'SNAT' in test_lib.lib_get_l3_service_type(nic.l3NetworkUuid): test_util.test_logger("Skip [VR:] %s, since it doesn't provide SNAT service" % vr_vm.uuid) continue ping_target = test_lib.test_config.pingTestTarget.text_ #Check if there is a SG rule to block ICMP checking if test_lib.lib_is_sg_rule_exist(nic.uuid, None, None, inventory.EGRESS): if not test_lib.lib_is_sg_rule_exist(nic.uuid, inventory.ICMP, ping_target, inventory.EGRESS): test_util.test_warn('Skip SNAT checker: because there is ICMP Egress Rule was assigned to [nic:] %s and the allowed target ip is not %s' % (nic.uuid, ping_target)) return self.judge(self.exp_result) guest_ip = nic.ip vm_command = 'ping -c 5 -W 5 %s >/tmp/ping_result 2>&1; ret=$?; cat /tmp/ping_result; exit $ret' % ping_target vm_cmd_result = test_lib.lib_ssh_vm_cmd_by_agent_with_retry(host.managementIp, nic.ip, test_lib.lib_get_vm_username(vm), test_lib.lib_get_vm_password(vm), vm_command, self.exp_result) if not vm_cmd_result: test_util.test_logger('Checker result: FAIL to ping [target:] %s from [vm:] %s .' % (ping_target, vm.uuid)) if self.exp_result == True: test_util.test_logger("network connection result is not expected pass, will print VR's network configuration:") test_lib.lib_print_vr_network_conf(vr_vm) return self.judge(False) else: test_util.test_logger('Checker result: SUCCEED to ping [target:] %s from [vm:] %s .' % (ping_target, vm.uuid)) return self.judge(True)
def check_detach_l2(pre_cluster_uuid, l2_uuid, vm, is_other_cluster): l2 = res_ops.get_resource(res_ops.L2_NETWORK, uuid = l2_uuid)[0] attached_clusters = l2.attachedClusterUuids if pre_cluster_uuid in attached_clusters: test_util.test_fail('[cluster:] %s is still in [l2:] %s attached list.'\ % (pre_cluster_uuid, l2_uuid)) test_util.test_dsc('start vm again. vm should be started in different cluster, if there has.') if attached_clusters : if not is_other_cluster: test_util.test_fail('There should not be available cluster for [l2:] %s. But catch some.' % l2_uuid) vm.start() new_cluster_uuid = vm.get_vm().clusterUuid if new_cluster_uuid == pre_cluster_uuid : test_util.test_fail('\ VM start on old [cluster]: %s, which is detached by [l2:] %s ' \ % (vm.get_vm().uuid, new_cluster_uuid, l2_uuid)) vm.check() else: if is_other_cluster: test_util.test_fail('There should be available cluster for [l2:] %s. But did not catch.' % l2_uuid) #no cluster is attached with l2. vm will start failure. try: vm.start() except: test_util.test_logger('\ Expected: VM start failed, since there is not cluster is attached to [l2]: %s, \ after [cluster:] %s is detached' % (l2_uuid, pre_cluster_uuid)) else: test_util.test_fail('[vm]: %s is Wrongly started up, since there is\ not cluster is attached with [l2]: %s, after previous detaching ops' % \ (vm.get_vm().uuid, l2_uuid))
def revert_vm_from_backup(group_uuid, session_uuid=None): action = api_actions.RevertVmFromVmBackupAction() action.groupUuid = group_uuid action.timeout = 1800000 evt = account_operations.execute_action_with_session(action, session_uuid) test_util.test_logger('Revert [volume_uuid:] %s ' % group_uuid) return evt.inventory
def _create_checking_file(self): #make fs for volume, if it doesn't exist if not self.parent and not self.child_list: test_lib.lib_mkfs_for_volume(self.target_volume.get_volume().uuid, \ self.utility_vm.get_vm()) import tempfile with tempfile.NamedTemporaryFile() as script: script.write(''' device=/dev/`ls -ltr --file-type /dev | grep disk | awk '{print $NF}' | grep -v '[[:digit:]]' | tail -1`1 mkdir -p %s mount $device %s mkdir -p %s touch %s/%s umount %s ''' % (test_lib.WOODPECKER_MOUNT_POINT, \ test_lib.WOODPECKER_MOUNT_POINT, \ checking_point_folder, checking_point_folder, \ self.checking_point, test_lib.WOODPECKER_MOUNT_POINT)) script.flush() test_lib.lib_execute_shell_script_in_vm(self.utility_vm.get_vm(), script.name) if self.parent: test_util.test_logger('[snapshot:] %s checking file: %s is created.\ Its [parent:] %s' % \ (self.snapshot_option.get_name(), \ self.checking_point, self.parent.get_snapshot().uuid)) else: test_util.test_logger('[snapshot:] %s checking file: %s is created.'% (self.snapshot_option.get_name(), self.checking_point))
def get_cluster(content, name=None): from pyVmomi import vim cluster = get_obj(content, [vim.ClusterComputeResource], name=name) if isinstance(cluster, list): test_util.test_logger("do not find cluster named %s, now return all cluster" % name) return cluster return [cluster]
def test(): global vm global host_uuid global host_ip global max_attempts global storagechecker_timeout if test_lib.lib_get_ha_enable() != 'true': test_util.test_skip("vm ha not enabled. Skip test") max_attempts = test_lib.lib_get_ha_selffencer_maxattempts() test_lib.lib_set_ha_selffencer_maxattempts('12') storagechecker_timeout = test_lib.lib_get_ha_selffencer_storagechecker_timeout() test_lib.lib_set_ha_selffencer_storagechecker_timeout('15') 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_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid vrs = test_lib.lib_find_vr_by_l3_uuid(l3_net_uuid) for vr in vrs: if test_lib.lib_is_vm_running(vr) == True: vm_ops.start_vm(vr.uuid) time.sleep(60) 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', '!=', os.environ.get('hostIp'), 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() #vm.check() host_ip = test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp host_uuid = test_lib.lib_find_host_by_vm(vm.get_vm()).uuid ha_ops.set_vm_instance_ha_level(vm.get_vm().uuid, "NeverStop") l2_network_interface = os.environ.get('l2ManagementNetworkInterface') cmd = "ifdown %s && sleep 180 && ifup %s" % (l2_network_interface, l2_network_interface) host_username = os.environ.get('hostUsername') host_password = os.environ.get('hostPassword') rsp = test_lib.lib_execute_ssh_cmd(host_ip, host_username, host_password, cmd, 180) if rsp: test_util.test_logger("host may have been shutdown") else: test_util.test_fail("host is expected to shutdown after its network down for a while") test_util.test_logger("wait for 600 seconds") time.sleep(600) vm.update() if test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp == host_ip: test_util.test_fail("VM is expected to start running on another host") vm.set_state(vm_header.RUNNING) vm.check() vm.destroy() test_lib.lib_set_ha_selffencer_maxattempts(max_attempts) test_lib.lib_set_ha_selffencer_storagechecker_timeout(storagechecker_timeout) os.system('bash -ex %s %s' % (os.environ.get('hostRecoverScript'), host_ip)) host_ops.reconnect_host(host_uuid) test_util.test_pass('Test VM ha on host failure Success')
def test(): vm = test_stub.create_vlan_vm() #test_obj_dict.add_vm(vm) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break #if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: # break #if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: # break else: vm.destroy() vm.expunge() test_util.test_skip('Not find image store type backup storage.') primary_storage_list = res_ops.query_resource(res_ops.PRIMARY_STORAGE) for ps in primary_storage_list: if ps.type == "SharedBlock" or ps.type == "AliyunNAS": vm.destroy() vm.expunge() test_util.test_skip('The test is not support sharedblock storage.') new_vms = vm.clone(vm_names) for new_vm in new_vms: test_obj_dict.add_vm(new_vm) if len(new_vms) != len(vm_names): test_util.test_fail( 'only %s VMs have been cloned, which is less than required: %s' % (len(new_vms), vm_names)) for new_vm in new_vms: new_vm = new_vm.get_vm() try: vm_names.remove(new_vm.name) test_util.test_logger('VM:%s name: %s is found' % (new_vm.uuid, new_vm.name)) except: test_util.test_fail('%s vm name: %s is not in list: %s' % (new_vm.uuid, new_vm.name, vm_names)) vm.destroy() check_imf2_cmd = "find /|grep imf|grep %s" % ( test_lib.lib_get_root_volume_uuid(vm.get_vm())) host = test_lib.lib_find_host_by_vm(vm.get_vm()) ret, output, stderr = ssh.execute(check_imf2_cmd, host.managementIp, "root", "password", False, 22) test_util.test_logger('expect imf2 exist: %s,%s' % (output, ret)) if ret != 0: test_util.test_fail('imf2 is expected to exist') vm.expunge() ret, output, stderr = ssh.execute(check_imf2_cmd, host.managementIp, "root", "password", False, 22) test_util.test_logger('expect imf2 not exist: %s,%s' % (output, ret)) if ret == 0: test_util.test_fail('imf2 is expected to be deleted') test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Clone VM Test Success')
def deploy_ha_env(scenarioConfig, scenarioFile, deploy_config, config_json, deploy_tool, mn_img): prepare_config_json(scenarioConfig, scenarioFile, deploy_config, config_json) mn_ha_storage_type = sce_ops.get_mn_ha_storage_type(scenarioConfig, scenarioFile, deploy_config) if mn_ha_storage_type == 'ceph': os.system('sed -i s/node/ceph-/g %s' %(config_json)) test_host = get_mn_host(scenarioConfig,scenarioFile)[0] test_host_ip = test_host.ip_ test_host_config = sce_ops.get_scenario_config_vm(test_host.name_, scenarioConfig) host_password = test_host_config.imagePassword_ mn_image_path = "/home/%s/mn.qcow2" % test_host_ip installer_path = "/home/%s/zs-ha" % test_host_ip config_path = "/home/%s/config.json" % test_host_ip ssh.scp_file(config_json, config_path, test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_) ssh.scp_file(mn_img, mn_image_path, test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_) ssh.scp_file(deploy_tool, installer_path, test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_) cmd0 = "chmod a+x %s" % (installer_path) test_util.test_logger("[%s] %s" % (test_host_ip, cmd0)) ssh.execute(cmd0, test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, True, 22) if mn_ha_storage_type == 'ceph': if test_lib.lib_cur_cfg_is_a_and_b(["test-config-vyos-ceph-3-nets-sep.xml"], ["scenario-config-storage-separate-ceph.xml"]): ceph_node_ip = get_host_by_index_in_scenario_file(scenarioConfig, scenarioFile, 0).ip_ mn_image_path = "/home/%s/mn.qcow2" % ceph_node_ip ssh.scp_file(mn_img, mn_image_path, ceph_node_ip, test_host_config.imageUsername_, test_host_config.imagePassword_) cmd0="yum install -y --disablerepo=* --enablerepo=zstack-local qemu-img" test_util.test_logger("[%s] %s" % (ceph_node_ip, cmd0)) ssh.execute(cmd0, ceph_node_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, True, 22) else: ceph_node_ip = test_host_ip cmd1="ceph osd pool create zstack 128" test_util.test_logger("[%s] %s" % (ceph_node_ip, cmd1)) ssh.execute(cmd1, ceph_node_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, True, 22) cmd2="qemu-img convert -f qcow2 -O raw %s rbd:zstack/mnvm.img" % mn_image_path test_util.test_logger("[%s] %s" % (ceph_node_ip, cmd2)) if test_lib.lib_execute_ssh_cmd(ceph_node_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, cmd2, timeout=7200 ) == False: test_util.test_fail("fail to run cmd: %s on %s" %(cmd2, ceph_node_ip)) elif mn_ha_storage_type == 'nfs': prepare_etc_hosts(scenarioConfig, scenarioFile, deploy_config, config_json) cmd1 = "cp %s /storage/mnvm.img" % (mn_image_path) test_util.test_logger("[%s] %s" % (test_host_ip, cmd1)) ssh.execute(cmd1, test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, True, 22) elif mn_ha_storage_type == 'fusionstor': cmd1 = "lichbd pool create zstack -p nbd" test_util.test_logger("[%s] %s" % (test_host_ip, cmd1)) ssh.execute(cmd1, test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, True, 22) cmd2 = "lichbd vol import %s zstack/mnvm.img -p nbd" %(mn_image_path) test_util.test_logger("[%s] %s" % (test_host_ip, cmd2)) ssh.execute(cmd2, test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, True, 22) cmd3 = "lich.inspect --localize /default/zstack/mnvm.img 0" test_util.test_logger("[%s] %s" % (test_host_ip, cmd3)) ssh.execute(cmd3, test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, True, 22) cmd3='%s install -p %s -c %s' % (installer_path, host_password, config_path) test_util.test_logger("[%s] %s" % (test_host_ip, cmd3)) #ssh.execute(cmd3, test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, True, 22) if test_lib.lib_execute_ssh_cmd(test_host_ip, test_host_config.imageUsername_, test_host_config.imagePassword_, cmd3, timeout=3600 ) == False: test_util.test_fail("fail to run cmd: %s on %s" %(cmd3, test_host_ip))
host_list = [] for host in mn_host_list: host_config = sce_ops.get_scenario_config_vm(host.name_, scenarioConfig) cmd = "virsh list | grep -v paused | grep \"ZStack Management Node VM\"" try: if sce_is_sep_pub(): vm_list = test_lib.lib_execute_ssh_cmd(host.managementIp_, host_config.imageUsername_, host_config.imagePassword_,cmd) else: vm_list = test_lib.lib_execute_ssh_cmd(host.ip_, host_config.imageUsername_, host_config.imagePassword_,cmd) if vm_list: host_list.append(host) except Exception, e: test_util.test_logger("@@get host exception@@:%s" %(str(e))) continue test_util.test_logger("@@DEBUG@@: host_list=<%s>" %(str(host_list))) return host_list def get_mn_host(scenarioConfig, scenarioFile): mn_host_list = [] test_util.test_logger("@@DEBUG@@:<scenarioConfig:%s><scenarioFile:%s><scenarioFile is existed: %s>" \ %(str(scenarioConfig), str(scenarioFile), str(os.path.exists(scenarioFile)))) if scenarioConfig == None or scenarioFile == None or not os.path.exists(scenarioFile): return mn_host_list test_util.test_logger("@@DEBUG@@: after config file exist check") for host in xmlobject.safe_list(scenarioConfig.deployerConfig.hosts.host): for vm in xmlobject.safe_list(host.vms.vm): if xmlobject.has_element(vm, 'mnHostRef'): with open(scenarioFile, 'r') as fd:
def test(): global vm global mn_host test_stub.skip_if_scenario_not_multiple_networks() mn_host = test_stub.get_host_by_mn_vm(test_lib.all_scenario_config, test_lib.scenario_file) if len(mn_host) != 1: test_util.test_fail('MN VM is running on %d host(s)' % len(mn_host)) test_util.test_logger( "shutdown host's network [%s] that mn vm is running on" % (mn_host[0].ip_)) test_stub.shutdown_host_network(mn_host[0], test_lib.all_scenario_config, downMagt=True) test_util.test_logger( "wait for 20 seconds to see if management node VM starts on another host" ) time.sleep(20) new_mn_host_ip = test_stub.get_host_by_consul_leader( test_lib.all_scenario_config, test_lib.scenario_file) if new_mn_host_ip == "" or (new_mn_host_ip != mn_host[0].ip_ and new_mn_host_ip != mn_host[0].managementIp_): test_util.test_fail( "management network down, mn host should not changed. Expected on [%s] while is on [%s]" % (mn_host[0].ip_, new_mn_host_ip)) count = 120 while count > 0: new_mn_host = test_stub.get_host_by_mn_vm(test_lib.all_scenario_config, test_lib.scenario_file) if len(new_mn_host) == 1: test_util.test_logger( "management node VM run after its former host down for 120s") break elif len(new_mn_host) > 1: test_util.test_fail( "management node VM runs on more than one host after its former host down" ) time.sleep(5) count -= 1 if len(new_mn_host) == 0: test_util.test_fail( "management node VM does not run after its former host down for 120s" ) elif len(new_mn_host) > 1: test_util.test_fail( "management node VM runs on more than one host after its former host down" ) try: node_ops.wait_for_management_server_start() except: test_util.test_fail( "management node does not recover after its former host's network down" ) test_stub.reopen_host_network(mn_host[0], test_lib.all_scenario_config) test_stub.wait_for_mn_ha_ready(test_lib.all_scenario_config, test_lib.scenario_file) test_stub.ensure_hosts_connected() test_stub.ensure_bss_host_connected_from_sep_net_down( test_lib.scenario_file, test_lib.all_scenario_config, downMagt=True) test_stub.ensure_bss_connected() test_stub.ensure_pss_connected() vm = test_stub.create_basic_vm() vm.check() vm.destroy() test_util.test_pass('Create VM Test Success')
def test(): global vm_inv test_util.test_dsc('Create test vm to test zstack upgrade by -u.') image_name = os.environ.get('imageName_i_c7_z_1.3') iso_path = os.environ.get('iso_path') iso_19_path = os.environ.get('iso_19_path') iso_10_path = os.environ.get('iso_10_path') iso_20_path = os.environ.get('iso_20_path') iso_21_path = os.environ.get('iso_21_path') zstack_latest_version = os.environ.get('zstackLatestVersion') zstack_latest_path = os.environ.get('zstackLatestInstaller') vm_name = os.environ.get('vmName') upgrade_script_path = os.environ.get('upgradeScript') vm_inv = test_stub.create_vm_scenario(image_name, vm_name) vm_ip = vm_inv.vmNics[0].ip test_lib.lib_wait_target_up(vm_ip, 22) test_stub.make_ssh_no_password(vm_ip, tmp_file) test_util.test_dsc('Update MN IP') test_stub.update_mn_hostname(vm_ip, tmp_file) test_stub.update_hosts(vm_ip, tmp_file) test_stub.update_mn_ip(vm_ip, tmp_file) test_stub.reset_rabbitmq_for_13(vm_ip, tmp_file) test_stub.start_mn(vm_ip, tmp_file) test_stub.check_installation(vm_ip, tmp_file) test_stub.update_19_iso(vm_ip, tmp_file, iso_19_path, upgrade_script_path) #pkg_num = 1.4 release_ver = [ '1.4', '1.5', '1.6', '1.7', '1.8', '1.9', '1.10', '2.0.0', '2.1.0', '2.2.0' ] curren_num = float(os.environ.get('releasePkgNum')) #while pkg_num <= curren_num: for pkg_num in release_ver: test_util.test_logger('Upgrade zstack to %s' % pkg_num) #if str(pkg_num) == '1.7': # test_stub.update_19_iso(vm_ip, tmp_file, iso_19_path, upgrade_script_path) if str(pkg_num) == '1.10': test_stub.update_10_iso(vm_ip, tmp_file, iso_10_path, upgrade_script_path) if str(pkg_num) == '2.0.0': test_stub.update_20_iso(vm_ip, tmp_file, iso_20_path, upgrade_script_path) if str(pkg_num) == '2.1.0': test_stub.update_21_iso(vm_ip, tmp_file, iso_21_path, upgrade_script_path) upgrade_pkg = os.environ.get('zstackPkg_%s' % pkg_num) test_stub.upgrade_zstack(vm_ip, upgrade_pkg, tmp_file) test_stub.start_mn(vm_ip, tmp_file) test_stub.check_zstack_version(vm_ip, tmp_file, str(pkg_num)) #test_stub.check_installation(vm_ip, tmp_file) #pkg_num = pkg_num + 0.1 test_util.test_dsc('Upgrade zstack to latest') test_stub.update_iso(vm_ip, tmp_file, iso_path, upgrade_script_path) test_stub.upgrade_zstack(vm_ip, zstack_latest_path, tmp_file) test_stub.start_mn(vm_ip, tmp_file) test_stub.check_zstack_version(vm_ip, tmp_file, zstack_latest_version) test_stub.check_installation(vm_ip, tmp_file) os.system('rm -f %s' % tmp_file) test_stub.destroy_vm_scenario(vm_inv.uuid) test_util.test_pass('ZStack upgrade Test Success')
def test(): global vm global host_uuid global test_host global host_ip global max_attempts global storagechecker_timeout must_ps_list = [inventory.LOCAL_STORAGE_TYPE, 'SharedMountPoint'] test_lib.skip_test_if_any_ps_not_deployed(must_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() #vrs = test_lib.lib_find_vr_by_l3_uuid(l3_net_uuid) #vr_host_ips = [] #for vr in vrs: # vr_host_ips.append(test_lib.lib_find_host_by_vr(vr).managementIp) # if test_lib.lib_is_vm_running(vr) != True: # vm_ops.start_vm(vr.uuid) #time.sleep(60) 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) #for vr_host_ip in vr_host_ips: # conditions = res_ops.gen_query_conditions('managementIp', '=', vr_host_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('ls_vm_ha_self_start') 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") host_uuid = test_lib.lib_find_host_by_vm(vm.get_vm()).uuid test_stub.ensure_all_vrs_on_host(host_uuid) #vrs = test_lib.lib_find_vr_by_l3_uuid(l3_net_uuid) #target_host_uuid = test_lib.lib_find_host_by_vm(vm.get_vm()).uuid #for vr in vrs: # if test_lib.lib_find_host_by_vr(vr).managementIp != test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp: # vm_ops.migrate_vm(vr.uuid, target_host_uuid) #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") host_list = test_stub.get_sce_hosts(test_lib.all_scenario_config, test_lib.scenario_file) for host in host_list: if host.ip_ == host_ip: test_host = host break if not test_host: test_util.test_fail('there is no host with ip %s in scenario file.' % (host_ip)) test_stub.stop_host(test_host, test_lib.all_scenario_config) vm_stop_time = None cond = res_ops.gen_query_conditions('name', '=', 'ls_vm_ha_self_start') cond = res_ops.gen_query_conditions('uuid', '=', vm.vm.uuid, cond) for i in range(0, 240): vm_stop_time = i if res_ops.query_resource(res_ops.VM_INSTANCE, cond)[0].state == "Stopped": test_stub.start_host(test_host, test_lib.all_scenario_config) test_stub.recover_host_vlan(test_host, test_lib.all_scenario_config, test_lib.deploy_config) conditions = res_ops.gen_query_conditions('managementIp', '=', host_ip) kvm_host_uuid = res_ops.query_resource(res_ops.HOST, conditions)[0].uuid host_ops.reconnect_host(kvm_host_uuid) break time.sleep(1) if vm_stop_time is None: vm_stop_time = 240 for i in range(vm_stop_time, 240): if res_ops.query_resource(res_ops.VM_INSTANCE, cond)[0].state == "Starting": break time.sleep(1) else: test_util.test_fail( "vm has not been changed to running as expected within 180s.") vm.destroy() test_util.test_pass( 'Test checking VM ha and none status when force stop vm Success.')
def test(): def test_fail(msg): os.system('rm -f %s' % tmp_file) test_util.test_fail(msg) test_util.test_dsc('Create 2 CentOS7 vms to test zstack installation.') image_name = os.environ.get('imageName_i_c7') vm1 = test_stub.create_vlan_vm(image_name) test_obj_dict.add_vm(vm1) vm2 = test_stub.create_vlan_vm(image_name) test_obj_dict.add_vm(vm2) vm1.check() vm2.check() vm1_inv = vm1.get_vm() vm1_ip = vm1_inv.vmNics[0].ip vm2_inv = vm2.get_vm() vm2_ip = vm2_inv.vmNics[0].ip target_file = '/root/zstack-all-in-one.tgz' test_stub.prepare_test_env(vm1_inv, target_file) ssh_cmd1 = 'ssh -oStrictHostKeyChecking=no -oCheckHostIP=no -oUserKnownHostsFile=/dev/null %s' % vm1_ip test_stub.only_install_zstack(ssh_cmd1, target_file, tmp_file) test_stub.copy_id_dsa(vm1_inv, ssh_cmd1, tmp_file) test_stub.copy_id_dsa_pub(vm1_inv) test_stub.copy_id_dsa_pub(vm2_inv) cmd = '%s "zstack-ctl install_db --host=%s"' % (ssh_cmd1, vm2_ip) process_result = test_stub.execute_shell_in_process(cmd, tmp_file) if process_result != 0: test_fail('zstack install db failed in vm:%s' % vm2_inv.uuid) cmd = '%s "zstack-ctl deploydb --host=%s"' % (ssh_cmd1, vm2_ip) process_result = test_stub.execute_shell_in_process(cmd, tmp_file) if process_result != 0: test_fail('zstack deploy db failed in vm:%s' % vm2_inv.uuid) cmd = '%s "zstack-ctl install_rabbitmq --host=%s"' % (ssh_cmd1, vm1_ip) process_result = test_stub.execute_shell_in_process(cmd, tmp_file) if process_result != 0: test_fail('zstack install rabbitmq failed in vm:%s' % vm1_inv.uuid) cmd = '%s "zstack-ctl install_management_node --host=%s"' % (ssh_cmd1, vm2_ip) process_result = test_stub.execute_shell_in_process(cmd, tmp_file) if process_result != 0: test_fail('zstack install mn failed in vm:%s' % vm2_inv.uuid) cmd = '%s "zstack-ctl install_ui --host=%s"' % (ssh_cmd1, vm2_ip) process_result = test_stub.execute_shell_in_process(cmd, tmp_file) if process_result != 0: test_fail('zstack install ui failed in vm:%s' % vm2_inv.uuid) cmd = '%s "zstack-ctl install_ui --host=%s"' % (ssh_cmd1, vm1_ip) process_result = test_stub.execute_shell_in_process(cmd, tmp_file) if process_result != 0: test_fail('zstack install ui failed in vm:%s' % vm1_inv.uuid) cmd = '%s "zstack-ctl start_node"' % ssh_cmd1 process_result = test_stub.execute_shell_in_process(cmd, tmp_file) if process_result != 0: if 'no management-node-ready message received within' in open( tmp_file).read(): times = 30 cmd = '%s "zstack-ctl status"' % ssh_cmd1 while (times > 0): time.sleep(10) process_result = test_stub.execute_shell_in_process( cmd, tmp_file, 10, True) times -= 1 if process_result == 0: test_util.test_logger( "management node start after extra %d seconds" % ((30 - times + 1) * 10)) break else: test_fail('start node failed in vm:%s' % vm1_inv.uuid) test_stub.check_installation(ssh_cmd1, tmp_file) os.system('rm -f %s' % tmp_file) vm1.destroy() test_obj_dict.rm_vm(vm1) vm2.destroy() test_obj_dict.rm_vm(vm2) test_util.test_pass( 'ZStack multi nodes installation Test Success on 2 CentOS7.')
def test(): global vm global mn_host for i in range(0, 10): test_util.test_logger("destroy mn vm round %s" % (i)) mn_host = test_stub.get_host_by_mn_vm(test_lib.all_scenario_config, test_lib.scenario_file) if len(mn_host) != 1: test_util.test_fail('MN VM is running on %d host(s)' % len(mn_host)) test_util.test_logger("destroy mn vm on host [%s]" % mn_host[0].ip_) test_stub.destroy_mn_vm(mn_host[0], test_lib.all_scenario_config) new_mn_host = test_stub.get_host_by_mn_vm(test_lib.all_scenario_config, test_lib.scenario_file) if len(new_mn_host) == 0: test_util.test_logger("mn vm was destroyed successfully") else: test_util.test_fail("mn vm was not destroyed successfully") test_util.test_logger( "wait for 20 seconds to see if management node VM starts on one host" ) time.sleep(20) new_mn_host_ip = test_stub.get_host_by_consul_leader( test_lib.all_scenario_config, test_lib.scenario_file) if new_mn_host_ip == "" or new_mn_host_ip != mn_host[0].ip_: test_util.test_fail( "management node VM not run correctly on [%s] after its former host [%s] down for 20s" % (new_mn_host_ip, mn_host[0].ip_)) count = 60 while count > 0: new_mn_host = test_stub.get_host_by_mn_vm( test_lib.all_scenario_config, test_lib.scenario_file) if len(new_mn_host) == 1: test_util.test_logger( "management node VM run after its former host down for 30s" ) break elif len(new_mn_host) > 1: test_util.test_fail( "management node VM runs on more than one host after its former host down" ) time.sleep(5) count -= 1 if len(new_mn_host) == 0: test_util.test_fail( "management node VM does not run after its former host down for 30s" ) elif len(new_mn_host) > 1: test_util.test_fail( "management node VM runs on more than one host after its former host down" ) test_util.test_logger( "wait for 5 minutes to see if management node starts again") try: node_ops.wait_for_management_server_start(300) except: test_util.test_fail( "management node does not recover after mn vm was destroyed") test_util.test_logger("try to create vm, timeout is 30s") time_out = 30 while time_out > 0: try: vm = test_stub.create_basic_vm() break except: time.sleep(1) time_out -= 1 if time_out == 0: test_util.test_fail('Fail to create vm after mn is ready') vm.check() vm.destroy() test_util.test_pass('Create VM Test Success')
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") host_uuid = test_lib.lib_find_host_by_vm(vm.get_vm()).uuid test_stub.ensure_all_vrs_on_host(host_uuid) #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(300, host_ip, host_username, host_password, "zsn1") time.sleep(300) vm.update() if test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp == host_ip: test_util.test_fail("VM is expected to start running on another host") vm.set_state(vm_header.RUNNING) vm.check() if test_lib.lib_get_vm_last_host(vm.get_vm()).managementIp != host_ip: test_util.test_fail( "Migrated VM's last host is expected to be the last host[ip:%s]" % (host_ip)) vm.destroy() t.join() test_util.test_pass('Test VM ha change to running within 300s Success')
def setup_fusionstor_storages(scenario_config, scenario_file, deploy_config): fusionstor_storages = dict() for host in xmlobject.safe_list(scenario_config.deployerConfig.hosts.host): for vm in xmlobject.safe_list(host.vms.vm): vm_name = vm.name_ if hasattr(vm, 'backupStorageRef'): for backupStorageRef in xmlobject.safe_list( vm.backupStorageRef): print backupStorageRef.text_ if backupStorageRef.type_ == 'fusionstor': if fusionstor_storages.has_key(backupStorageRef.text_): if vm_name in fusionstor_storages[ backupStorageRef.text_]: continue else: fusionstor_storages[ backupStorageRef.text_].append(vm_name) else: fusionstor_storages[backupStorageRef.text_] = [ vm_name ] if hasattr(vm, 'primaryStorageRef'): for primaryStorageRef in xmlobject.safe_list( vm.primaryStorageRef): print primaryStorageRef.text_ for zone in xmlobject.safe_list(deploy_config.zones.zone): if primaryStorageRef.type_ == 'fusionstor': if fusionstor_storages.has_key( backupStorageRef.text_): if vm_name in fusionstor_storages[ backupStorageRef.text_]: continue else: fusionstor_storages[ backupStorageRef.text_].append(vm_name) else: fusionstor_storages[backupStorageRef.text_] = [ vm_name ] if len(fusionstor_storages) > 0: test_util.test_logger('get fusionstor pkg') fusionstorPkg = os.environ['fusionstorPkg'] else: test_util.test_logger('no fusionstor pkg return here') return for fusionstor_storage in fusionstor_storages: test_util.test_logger('setup fusionstor [%s] service.' % (fusionstor_storage)) node1_name = fusionstor_storages[fusionstor_storage][0] node1_config = get_scenario_config_vm(node1_name, scenario_config) node1_ip = get_scenario_file_vm(node1_name, scenario_file).ip_ node_host = get_deploy_host(node1_config.hostRef.text_, deploy_config) if not hasattr(node_host, 'port_') or node_host.port_ == '22': node_host.port_ = '22' vm_ips = '' for fusionstor_node in fusionstor_storages[fusionstor_storage]: vm_nic_id = get_fusionstor_storages_nic_id(fusionstor_storage, scenario_config) vm = get_scenario_file_vm(fusionstor_node, scenario_file) if vm_nic_id == None: vm_ips += vm.ip_ + ' ' else: vm_ips += vm.ips.ip[vm_nic_id].ip_ + ' ' ssh.scp_file("%s/%s" % (os.environ.get('woodpecker_root_path'), '/tools/setup_fusionstor_nodes.sh'), '/tmp/setup_fusionstor_nodes.sh', node1_ip, node1_config.imageUsername_, node1_config.imagePassword_, port=int(node_host.port_)) ssh.scp_file(fusionstorPkg, fusionstorPkg, node1_ip, node1_config.imageUsername_, node1_config.imagePassword_, port=int(node_host.port_)) cmd = "bash -ex /tmp/setup_fusionstor_nodes.sh %s %s" % ( (fusionstorPkg), (vm_ips)) try: ssh.execute(cmd, node1_ip, node1_config.imageUsername_, node1_config.imagePassword_, True, int(node_host.port_)) except Exception as e: print str(e) ssh.execute(cmd, node1_ip, node1_config.imageUsername_, node1_config.imagePassword_, True, int(node_host.port_))
def test(): global session_to global session_mc session_to = con_ops.change_global_config('identity', 'session.timeout', '720000') session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000') test_util.test_dsc('Create test vm as utility vm') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) #use root volume to skip add_checking_point test_util.test_dsc('Use root volume for snapshot testing') root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm()) root_volume = zstack_volume_header.ZstackTestVolume() root_volume.set_volume(root_volume_inv) root_volume.set_state(volume_header.ATTACHED) root_volume.set_target_vm(vm) test_obj_dict.add_volume(root_volume) vm.check() snapshots = test_obj_dict.get_volume_snapshot( root_volume.get_volume().uuid) snapshots.set_utility_vm(vm) ori_num = 100 index = 1 while index < 101: thread = threading.Thread(target=snapshots.create_snapshot, args=('create_snapshot%s' % str(index), )) thread.start() index += 1 while threading.activeCount() > 1: time.sleep(0.1) cond = res_ops.gen_query_conditions('volumeUuid', '=', root_volume.get_volume().uuid) sps_num = res_ops.query_resource_count(res_ops.VOLUME_SNAPSHOT, cond) if sps_num != ori_num: test_util_test_fail( 'Create %d snapshots, but only %d snapshots were successfully created' % (ori_num, sps_num)) test_num = 100 snapshot_list = snapshots.get_snapshot_list() for index in range(test_num): thread_1 = threading.Thread(target=snapshots.delete_snapshot, args=(random.choice(snapshot_list), )) thread_2 = threading.Thread(target=snapshots.use_snapshot, args=(random.choice(snapshot_list), )) thread_1.start() thread_2.start() while threading.activeCount() > 1: time.sleep(0.1) #snapshot.check() doesn't work for root volume #snapshots.check() #check if snapshot exists in ps (host) install_path ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm()) if ps.type == inventory.NFS_PRIMARY_STORAGE_TYPE or ps.type == inventory.LOCAL_STORAGE_TYPE: cond = res_ops.gen_query_conditions('volumeUuid', '=', root_volume.get_volume().uuid) sps_in_database = res_ops.query_resource(res_ops.VOLUME_SNAPSHOT, cond) host = test_lib.lib_get_vm_host(vm.get_vm()) for snapshot_inv in sps_in_database: sp_ps_install_path = snapshot_inv.primaryStorageInstallPath if test_lib.lib_check_file_exist(host, sp_ps_install_path): test_util.test_logger( 'Check result: snapshot %s is found in host %s in path %s' % (snapshot_inv.name, host.managementIp, sp_ps_install_path)) else: test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_fail( 'Check result: snapshot %s is not found in host %s in path %s' % (snapshot_inv.name, host.managementIp, sp_ps_install_path)) else: test_util.test_logger( 'Skip check file install path for %s primary storage' % (ps.type)) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass( 'Test delete and revert 100 snapshots simultaneously success')
def setup_host_vm(vm_inv, vm_config, deploy_config): vm_ip = test_lib.lib_get_vm_nic_by_l3(vm_inv, vm_inv.defaultL3NetworkUuid).ip cmd = 'hostnamectl set-hostname %s' % (vm_ip.replace('.', '-')) ssh.execute(cmd, vm_ip, vm_config.imageUsername_, vm_config.imagePassword_, True, 22) udev_config = '' nic_id = 0 for l3network in xmlobject.safe_list(vm_config.l3Networks.l3Network): for vmnic in vm_inv.vmNics: if vmnic.l3NetworkUuid == l3network.uuid_: vmnic_mac = vmnic.mac break nic_name = None if hasattr(l3network, 'l2NetworkRef'): for l2networkref in xmlobject.safe_list(l3network.l2NetworkRef): nic_name = get_ref_l2_nic_name(l2networkref.text_, deploy_config) if nic_name.find('.') < 0: break if nic_name == None: nic_name = "eth%s" % (nic_id) nic_id += 1 udev_config = udev_config + '\\nACTION=="add", SUBSYSTEM=="net", DRIVERS=="?*", ATTR{type}=="1", ATTR{address}=="%s", NAME="%s"' % ( vmnic_mac, nic_name) cmd = 'echo %s > /etc/udev/rules.d/70-persistent-net.rules' % (udev_config) ssh.execute(cmd, vm_ip, vm_config.imageUsername_, vm_config.imagePassword_, True, 22) for l3network in xmlobject.safe_list(vm_config.l3Networks.l3Network): if hasattr(l3network, 'l2NetworkRef'): for l2networkref in xmlobject.safe_list(l3network.l2NetworkRef): nic_name = get_ref_l2_nic_name(l2networkref.text_, deploy_config) if nic_name.find('.') >= 0: vlan = nic_name.split('.')[1] test_util.test_logger('[vm:] %s %s is created.' % (vm_ip, nic_name)) cmd = 'vconfig add %s %s' % (nic_name.split('.')[0], vlan) ssh.execute(cmd, vm_ip, vm_config.imageUsername_, vm_config.imagePassword_, True, 22) host = get_deploy_host(vm_config.hostRef.text_, deploy_config) if hasattr(host, 'port_') and host.port_ != '22': cmd = "sed -i 's/#Port 22/Port %s/g' /etc/ssh/sshd_config && iptables -I INPUT -p tcp -m tcp --dport %s -j ACCEPT && service sshd restart" % ( host.port_, host.port_) ssh.execute(cmd, vm_ip, vm_config.imageUsername_, vm_config.imagePassword_, True, 22) else: host.port_ = '22' if host.username_ != 'root': cmd = 'adduser %s && echo -e %s\\\\n%s | passwd %s' % ( host.username_, host.password_, host.password_, host.username_) ssh.execute(cmd, vm_ip, vm_config.imageUsername_, vm_config.imagePassword_, True, int(host.port_)) cmd = "echo '%s ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers" % ( host.username_) ssh.execute(cmd, vm_ip, vm_config.imageUsername_, vm_config.imagePassword_, True, int(host.port_))
def setup_ocfs2smp_primary_storages(scenario_config, scenario_file, deploy_config, vm_inv_lst, vm_cfg_lst): ocfs2_storages = dict() smp_url = None for host in xmlobject.safe_list(scenario_config.deployerConfig.hosts.host): for vm in xmlobject.safe_list(host.vms.vm): vm_name = vm.name_ if hasattr(vm, 'primaryStorageRef'): for primaryStorageRef in xmlobject.safe_list( vm.primaryStorageRef): for zone in xmlobject.safe_list(deploy_config.zones.zone): if primaryStorageRef.type_ == 'ocfs2smp': if ocfs2_storages.has_key(primaryStorageRef.text_): if vm_name in ocfs2_storages[ primaryStorageRef.text_]: continue else: ocfs2_storages[primaryStorageRef. text_].append(vm_name) else: ocfs2_storages[primaryStorageRef.text_] = [ vm_name ] if hasattr(primaryStorageRef, 'url_'): smp_url = primaryStorageRef.url_ for ocfs2_storage in ocfs2_storages: test_util.test_logger('setup ocfs2 [%s] service.' % (ocfs2_storage)) node1_name = ocfs2_storages[ocfs2_storage][0] node1_config = get_scenario_config_vm(node1_name, scenario_config) #node1_ip = get_scenario_file_vm(node1_name, scenario_file).ip_ node_host = get_deploy_host(node1_config.hostRef.text_, deploy_config) if not hasattr(node_host, 'port_') or node_host.port_ == '22': node_host.port_ = '22' vm_ips = '' for ocfs2_node in ocfs2_storages[ocfs2_storage]: vm_nic_id = get_ceph_storages_nic_id(ocfs2_storage, scenario_config) vm = get_scenario_file_vm(ocfs2_node, scenario_file) if vm_nic_id == None: vm_ips += vm.ip_ + ' ' else: vm_ips += vm.ips.ip[vm_nic_id].ip_ + ' ' #ssh.scp_file("%s/%s" % (os.environ.get('woodpecker_root_path'), '/tools/setup_ocfs2.sh'), '/tmp/setup_ocfs2.sh', node1_ip, node1_config.imageUsername_, node1_config.imagePassword_, port=int(node_host.port_)) import commands status, woodpecker_ip = commands.getstatusoutput( "ip addr show eth0 | sed -n '3p' | awk '{print $2}' | awk -F / '{print $1}'" ) if smp_url: cmd = "SMP_URL=%s bash %s/%s %s" % ( smp_url, os.environ.get('woodpecker_root_path'), '/tools/setup_ocfs2.sh', vm_ips) else: cmd = "bash %s/%s %s" % (os.environ.get('woodpecker_root_path'), '/tools/setup_ocfs2.sh', vm_ips) ssh.execute(cmd, woodpecker_ip, node1_config.imageUsername_, node1_config.imagePassword_, True, int(node_host.port_)) if ocfs2_storages: for vm_inv, vm_config in zip(vm_inv_lst, vm_cfg_lst): recover_after_host_vm_reboot(vm_inv, vm_config, deploy_config)
def env_recover(): test_util.test_logger("recover consul on host: %s" % (mn_host[0].ip_)) test_stub.start_consul(mn_host[0], test_lib.all_scenario_config) test_stub.wait_for_mn_ha_ready(test_lib.all_scenario_config, test_lib.scenario_file)
def setup_ceph_storages(scenario_config, scenario_file, deploy_config): ceph_storages = dict() for host in xmlobject.safe_list(scenario_config.deployerConfig.hosts.host): for vm in xmlobject.safe_list(host.vms.vm): vm_name = vm.name_ if hasattr(vm, 'backupStorageRef'): for backupStorageRef in xmlobject.safe_list( vm.backupStorageRef): print backupStorageRef.text_ if backupStorageRef.type_ == 'ceph': if ceph_storages.has_key(backupStorageRef.text_): if vm_name in ceph_storages[ backupStorageRef.text_]: continue else: ceph_storages[backupStorageRef.text_].append( vm_name) else: ceph_storages[backupStorageRef.text_] = [vm_name] if hasattr(vm, 'primaryStorageRef'): for primaryStorageRef in xmlobject.safe_list( vm.primaryStorageRef): print primaryStorageRef.text_ for zone in xmlobject.safe_list(deploy_config.zones.zone): if primaryStorageRef.type_ == 'ceph': if ceph_storages.has_key(backupStorageRef.text_): if vm_name in ceph_storages[ backupStorageRef.text_]: continue else: ceph_storages[ backupStorageRef.text_].append(vm_name) else: ceph_storages[backupStorageRef.text_] = [ vm_name ] for ceph_storage in ceph_storages: test_util.test_logger('setup ceph [%s] service.' % (ceph_storage)) node1_name = ceph_storages[ceph_storage][0] node1_config = get_scenario_config_vm(node1_name, scenario_config) node1_ip = get_scenario_file_vm(node1_name, scenario_file).ip_ node_host = get_deploy_host(node1_config.hostRef.text_, deploy_config) if not hasattr(node_host, 'port_') or node_host.port_ == '22': node_host.port_ = '22' vm_ips = '' for ceph_node in ceph_storages[ceph_storage]: vm_nic_id = get_ceph_storages_nic_id(ceph_storage, scenario_config) vm = get_scenario_file_vm(ceph_node, scenario_file) if vm_nic_id == None: vm_ips += vm.ip_ + ' ' else: vm_ips += vm.ips.ip[vm_nic_id].ip_ + ' ' ssh.scp_file("%s/%s" % (os.environ.get('woodpecker_root_path'), '/tools/setup_ceph_nodes.sh'), '/tmp/setup_ceph_nodes.sh', node1_ip, node1_config.imageUsername_, node1_config.imagePassword_, port=int(node_host.port_)) cmd = "bash -ex /tmp/setup_ceph_nodes.sh %s" % (vm_ips) ssh.execute(cmd, node1_ip, node1_config.imageUsername_, node1_config.imagePassword_, True, int(node_host.port_))
def test(): global original_rate global new_offering_uuid test_util.test_dsc('Test memory allocation and reclaiming.') cond = res_ops.gen_query_conditions('state', '=', 'Enabled') cond = res_ops.gen_query_conditions('status', '=', 'Connected', cond) host = res_ops.query_resource_with_num(res_ops.HOST, cond, limit = 1) if not host: test_util.test_skip('No Enabled/Connected host was found, skip test.' ) return True host = host[0] over_provision_rate = 1 target_vm_num = 5 host_res = test_lib.lib_get_cpu_memory_capacity(host_uuids = [host.uuid]) #avail_mem = host_res.availableMemory * over_provision_rate avail_mem = host_res.availableMemory if avail_mem <= 1024*1024*1024: test_util.test_skip('Available memory is less than 1024MB, skip test.') return True original_rate = test_lib.lib_set_provision_memory_rate(over_provision_rate) host_res = test_lib.lib_get_cpu_memory_capacity(host_uuids = [host.uuid]) avail_mem = host_res.availableMemory test_mem = avail_mem / target_vm_num new_offering_mem = test_mem new_offering = test_lib.lib_create_instance_offering(memorySize = new_offering_mem) new_offering_uuid = new_offering.uuid rounds = 0 while (rounds < 3): times = 1 while (times <= (target_vm_num)): thread = threading.Thread(target = parallelly_create_vm, \ args = ('parallel_vm_creating_%d' % times, \ host.uuid, \ new_offering.uuid, )) thread.start() times += 1 times = 1 print 'Running VM: %s ' % len(test_obj_dict.get_vm_list()) while threading.active_count() > 1: check_thread_exception() time.sleep(1) if times > 5: test_util.test_fail('creating vm time exceed 5s') times += 1 check_thread_exception() for vm in test_obj_dict.get_all_vm_list(): try: vm.destroy() test_obj_dict.rm_vm(vm) except Exception as e: test_util.test_logger("VM Destroying Failure in memory reclaiming test. :%s " % e) raise e host_res2 = test_lib.lib_get_cpu_memory_capacity(host_uuids = [host.uuid]) avail_mem2 = host_res2.availableMemory if avail_mem2 != avail_mem: test_util.test_fail('Available memory reclaiming is not correct. Current available memory : %d, original available memory: %d , after creating and destroying %d vms. in round: %d' % (avail_mem2, avail_mem, target_vm_num, rounds)) rounds += 1 test_lib.lib_set_provision_memory_rate(original_rate) vm_ops.delete_instance_offering(new_offering_uuid) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Parallel vm creation Test Pass')
def test(): global vm global default_mode # default_mode = conf_ops.get_global_config_value('kvm', 'videoType') default_mode = conf_ops.change_global_config('vm', 'videoType', 'qxl') vm = test_stub.create_sg_vm() console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid) test_util.test_logger('[vm:] %s console is on %s:%s' % (vm.get_vm().uuid, console.hostIp, console.port)) display = str(int(console.port) - 5900) vm.check() vm_mode = test_lib.lib_get_vm_video_type(vm.get_vm()) if vm_mode != 'qxl': test_util.test_fail( 'VM is expected to work in qxl mode instead of %s' % (vm_mode)) client = api.connect(console.hostIp + ":" + display) client.captureScreen('tmp.png') image = Image.open('tmp.png') if image.width != 720 or image.height != 400: test_util.test_fail( "VM is expected to work in 720x400 while its %sx%s" % (image.width, image.height)) box = image.getbbox() if box != (0, 18, 403, 79) and box != (0, 18, 403, 80): test_util.test_fail( "VM is expected to display text in area (0, 18, 403, 79) while it's actually: (%s, %s, %s, %s)" % (box[0], box[1], box[2], box[3])) test_util.test_logger( '[vm:] change vga mode to vga=794 which is 1280x1024') cmd = 'sed -i "s/115200$/115200 vga=794/g" /boot/grub2/grub.cfg' test_lib.lib_execute_command_in_vm(vm.get_vm(), cmd) vm.reboot() vm.check() client = api.connect(console.hostIp + ":" + display) client.captureScreen('tmp.png') image = Image.open('tmp.png') if image.width != 1280 or image.height != 1024: test_util.test_fail( "VM is expected to work in 1280x1024 while its %sx%s" % (image.width, image.height)) box = image.getbbox() if box != (0, 18, 359, 79) and box != (0, 18, 359, 80): test_util.test_fail( "VM is expected to display text in area (0, 18, 359, 79) while it's actually: (%s, %s, %s, %s)" % (box[0], box[1], box[2], box[3])) test_util.test_logger( '[vm:] change vga mode to vga=907 which is 2560x1600') cmd = 'sed -i "s/vga=794/vga=907/g" /boot/grub2/grub.cfg' test_lib.lib_execute_command_in_vm(vm.get_vm(), cmd) vm.reboot() vm.check() client = api.connect(console.hostIp + ":" + display) client.captureScreen('tmp.png') image = Image.open('tmp.png') if image.width != 2560 or image.height != 1600: test_util.test_fail( "VM is expected to work in 2560x1600 while its %sx%s" % (image.width, image.height)) box = image.getbbox() if box != (0, 18, 359, 79) and box != (0, 18, 359, 80): test_util.test_fail( "VM is expected to display text in area (0, 18, 359, 79) while it's actually: (%s, %s, %s, %s)" % (box[0], box[1], box[2], box[3])) vm.destroy() vm.check() conf_ops.change_global_config('vm', 'videoType', default_mode) test_util.test_pass('Create VM Test Success')
def test(): global vm global mn_host_list global need_recover_mn_host_list global pub_mn_ip global mag_mn_ip test_stub.skip_if_scenario_not_multiple_networks() pub_mn_ip = os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] mag_mn_ip = res_ops.query_resource(res_ops.MANAGEMENT_NODE)[0].hostName os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mag_mn_ip mn_host_list = test_stub.get_mn_host(test_lib.all_scenario_config, test_lib.scenario_file) mn_host_num = len(mn_host_list) test_mn_host_list = random.sample(range(mn_host_num), (mn_host_num + 1) / 2) for host in mn_host_list: test_util.test_logger("shutdown host's network [%s]" % (host.ip_)) test_stub.shutdown_host_network(host, test_lib.all_scenario_config, downMagt=False) need_recover_mn_host_list = range(mn_host_num) test_util.test_logger("wait 10s for MN VM to stop") time.sleep(10) mn_host = test_stub.get_host_by_mn_vm(test_lib.all_scenario_config, test_lib.scenario_file) if len(mn_host) == 0: test_util.test_fail('MN VM has been murdered, expected result should not be impacted when the separated network is down.') for index in test_mn_host_list: test_util.test_logger("recover host [%s]" % (mn_host_list[index].ip_)) test_stub.recover_host(mn_host_list[index], test_lib.all_scenario_config, test_lib.deploy_config) need_recover_mn_host_list.remove(index) test_util.test_logger("wait for 20 seconds to see if management node VM starts on any host") time.sleep(20) new_mn_host_ip = test_stub.get_host_by_consul_leader(test_lib.all_scenario_config, test_lib.scenario_file) if new_mn_host_ip == "": test_util.test_fail("management node VM not run correctly on [%s] after its former host [%s] down for 20s" % (new_mn_host_ip, mn_host_list[0].ip_)) count = 120 while count > 0: new_mn_host = test_stub.get_host_by_mn_vm(test_lib.all_scenario_config, test_lib.scenario_file) if len(new_mn_host) == 1: test_util.test_logger("management node VM run after its former host down for 120s") break elif len(new_mn_host) > 1: test_util.test_fail("management node VM runs on more than one host after its former host down") time.sleep(5) count -= 1 if len(new_mn_host) == 0: test_util.test_fail("management node VM does not run after its former host down for 120s") elif len(new_mn_host) > 1: test_util.test_fail("management node VM runs on more than one host after its former host down") #node_ops.wait_for_management_server_start(300) test_stub.wrapper_of_wait_for_management_server_start(600) test_stub.ensure_hosts_connected() test_stub.ensure_bss_host_connected_from_sep_net_down(test_lib.scenario_file, test_lib.all_scenario_config, downMagt=False) test_stub.ensure_bss_connected() test_stub.ensure_pss_connected() test_stub.return_pass_ahead_if_3sites("TEST PASS") vm = test_stub.create_basic_vm() vm.check() vm.destroy() test_util.test_pass('Create VM Test Success')
def test(): global vm global mn_host_list global test_mn_host_list test_util.test_skip("2 hosts down at the same time is not support") test_stub.skip_if_scenario_is_multiple_networks() mn_host_list = test_stub.get_mn_host(test_lib.all_scenario_config, test_lib.scenario_file) mn_host_num = len(mn_host_list) test_mn_host_list = random.sample(range(mn_host_num), (mn_host_num + 1) / 2) for index in test_mn_host_list: test_util.test_logger("force stop host [%s]" % (mn_host_list[index].ip_)) test_stub.stop_host(mn_host_list[index], test_lib.all_scenario_config, 'cold') test_util.test_logger("wait 10s for MN VM to stop") time.sleep(10) mn_host = test_stub.get_host_by_mn_vm(test_lib.all_scenario_config, test_lib.scenario_file) if len(mn_host) != 0: test_util.test_fail('MN VM is still running on %d host(s)' % len(mn_host)) test_util.test_logger("recover host [%s]" % (mn_host_list[test_mn_host_list[-1]])) test_stub.recover_host(mn_host_list[test_mn_host_list[-1]], test_lib.all_scenario_config, test_lib.deploy_config) test_mn_host_list.pop() test_util.test_logger( "wait for 20 seconds to see if management node VM starts on any host") time.sleep(20) new_mn_host_ip = test_stub.get_host_by_consul_leader( test_lib.all_scenario_config, test_lib.scenario_file) if new_mn_host_ip == "": test_util.test_fail( "management node VM not run correctly on [%s] after its former host [%s] down for 20s" % (new_mn_host_ip, mn_host_list[0].ip_)) count = 60 while count > 0: new_mn_host = test_stub.get_host_by_mn_vm(test_lib.all_scenario_config, test_lib.scenario_file) if len(new_mn_host) == 1: test_util.test_logger( "management node VM run after its former host down for 30s") break elif len(new_mn_host) > 1: test_util.test_fail( "management node VM runs on more than one host after its former host down" ) time.sleep(5) count -= 1 if len(new_mn_host) == 0: test_util.test_fail( "management node VM does not run after its former host down for 30s" ) elif len(new_mn_host) > 1: test_util.test_fail( "management node VM runs on more than one host after its former host down" ) test_util.test_logger( "wait for 5 minutes to see if management node starts again") try: node_ops.wait_for_management_server_start(300) except: test_util.test_fail( "management node does not recover after recover one mn host") test_stub.ensure_hosts_connected() test_stub.ensure_bss_host_connected_from_stop(test_lib.scenario_file, test_lib.all_scenario_config, test_lib.deploy_config) test_stub.ensure_pss_connected() test_stub.ensure_bss_connected() vm = test_stub.create_basic_vm() vm.check() vm.destroy() test_util.test_pass('Create VM Test Success')
def test(): global test_obj_dict ova_image_name = os.environ['vcenterDefaultmplate'] network_pattern1 = os.environ['l3vCenterNoVlanNetworkName'] disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('largeDiskOfferingName')) test_util.test_dsc('Create vm and check') vm = test_stub.create_vm_in_vcenter(vm_name='test_volume_after_sync_vm', image_name=ova_image_name, l3_name=network_pattern1) test_obj_dict.add_vm(vm) vm.check() ps_uuid = vm.vm.allVolumes[0].primaryStorageUuid vc_ps = test_lib.lib_get_primary_storage_by_uuid(ps_uuid) vc_host = test_lib.lib_find_host_by_vm(vm.vm).managementIp test_util.test_dsc('Create volumes and check') volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume_creation_option.set_name('vcenter_volume') volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() volume.attach(vm) volume.check() volume.detach() volume.check() volume_creation_option.set_name('vcenter_volume1') volume_creation_option.set_primary_storage_uuid(ps_uuid) volume1 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume1) volume1.check() volume1.attach(vm) volume1.check() volume1.delete() volume1.check() test_util.test_dsc('Sync vcenter') vcenter_uuid = vct_ops.lib_get_vcenter_by_name(os.environ['vcenter']).uuid vct_ops.sync_vcenter(vcenter_uuid) time.sleep(5) test_util.test_dsc('check volumes after synchronizing vcenter') db_volume = test_lib.lib_get_volume_by_uuid(volume.get_volume().uuid) db_volume1 = test_lib.lib_get_volume_by_uuid(volume1.get_volume().uuid) if db_volume.status != 'Ready' or db_volume1.status != 'Deleted': test_util.test_fail( "check data volumes fail after synchronizing vcenter") #delete volume file volume_installPath = vc_ps.url.split( '//')[1] + db_volume.installPath.split('[' + vc_ps.name + ']')[1].lstrip() test_util.test_logger(volume_installPath) cmd = 'rm -f %s' % volume_installPath vchost_user = os.environ['vchostUser'] vchost_password = os.environ['vchostpwd'] result = test_lib.lib_execute_ssh_cmd(vc_host, vchost_user, vchost_password, cmd, 180) test_util.test_dsc('Sync vcenter') vct_ops.sync_vcenter(vcenter_uuid) time.sleep(5) db_volume = test_lib.lib_get_volume_by_uuid(volume.get_volume().uuid) if db_volume: test_util.test_fail( "check data volumes fail after synchronizing vcenter") #cleanup vm.destroy() vm.expunge() volume1.expunge() test_util.test_pass("Test sync volume in vcenter passed.")
def test(): global vm global host_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") test_lib.lib_skip_if_ps_num_is_not_eq_number(2) 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('ls_vm_ha_self_start') vm = test_vm_header.ZstackTestVm() vm.set_creation_option(vm_creation_option) vm.create() test_stub.ensure_host_has_no_vr(host_uuid) #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) vm_stop_time = None cond = res_ops.gen_query_conditions('name', '=', 'ls_vm_ha_self_start') cond = res_ops.gen_query_conditions('uuid', '=', vm.vm.uuid, cond) for i in range(0, max_time): vm_stop_time = i if res_ops.query_resource(res_ops.VM_INSTANCE, cond)[0].state == "Unknown": test_stub.up_host_network(host_ip, test_lib.all_scenario_config) break time.sleep(1) if vm_stop_time is None: vm_stop_time = max_time for i in range(vm_stop_time, max_time): if res_ops.query_resource(res_ops.VM_INSTANCE, cond)[0].state == "Running": break time.sleep(1) else: test_util.test_fail( "vm has not been changed to running as expected within %s s." % (max_time)) vm.destroy() test_util.test_pass('Test VM ha change to running within %s s Success' % (max_time))
def env_recover(): test_util.test_logger("recover host: %s" % (mn_host[0].ip_)) test_stub.recover_host(mn_host[0], test_lib.all_scenario_config, test_lib.deploy_config) test_stub.wait_for_mn_ha_ready(test_lib.all_scenario_config, test_lib.scenario_file)
def test(): # create_instanceoffering_min_cpu with tag_soft instance_offering_option = test_util.InstanceOfferingOption() instance_offering_option.set_cpuNum(1) instance_offering_option.set_memorySize(1 * 1024 * 1024 * 1024) instance_offering_option.set_allocatorStrategy( "MinimumCPUUsageHostAllocatorStrategy") instance_offering_option.set_type("UserVm") instance_offering_option.set_name('cpu') cpu_off = vm_ops.create_instance_offering(instance_offering_option) test_obj_dict.add_instance_offering(cpu_off) cpu_tag = tag_ops.create_system_tag( resourceType="InstanceOfferingVO", resourceUuid=cpu_off.uuid, tag="minimumCPUUsageHostAllocatorStrategyMode::soft") # create_instanceoffering_min_memory with tag_soft instance_offering_option.set_cpuNum(1) instance_offering_option.set_memorySize(1 * 1024 * 1024 * 1024) instance_offering_option.set_allocatorStrategy( "MinimumMemoryUsageHostAllocatorStrategy") instance_offering_option.set_type("UserVm") instance_offering_option.set_name('memory') memory_off = vm_ops.create_instance_offering(instance_offering_option) test_obj_dict.add_instance_offering(cpu_off) memory_tag = tag_ops.create_system_tag( resourceType="InstanceOfferingVO", resourceUuid=memory_off.uuid, tag="minimumMemoryUsageHostAllocatorStrategyMode::soft") # kill prometheus cmd = "kill -9 `netstat -nlp | awk -F'[ /]*' '/9090/{print $(NF-2)}'`" mn_ip = os.environ["ZSTACK_BUILT_IN_HTTP_SERVER_IP"] test_lib.lib_execute_ssh_cmd(mn_ip, "root", "password", cmd) condition = res_ops.gen_query_conditions('name', '=', 'ttylinux') img_name = res_ops.query_resource(res_ops.IMAGE, condition)[0].name l3_name = res_ops.query_resource(res_ops.L3_NETWORK)[0].name try: vm = test_stub.create_vm_with_instance_offering( "cpu_1", img_name, l3_name, cpu_off) test_obj_dict.add_vm(vm) except Exception as e: test_util.test_fail(e) try: vm = test_stub.create_vm_with_instance_offering( "memory_1", img_name, l3_name, memory_off) test_obj_dict.add_vm(vm) except Exception as e: test_util.test_fail(e) tag_ops.update_system_tag( cpu_tag.uuid, tag="minimumCPUUsageHostAllocatorStrategyMode::hard") tag_ops.update_system_tag( memory_tag.uuid, tag="minimumMemoryUsageHostAllocatorStrategyMode::hard") try: vm = test_stub.create_vm_with_instance_offering( "cpu_2", img_name, l3_name, cpu_off) test_obj_dict.add_vm(vm) test_util.test_fail("hard model can not create vm") except Exception as e: test_util.test_logger(e) try: vm = test_stub.create_vm_with_instance_offering( "memory_2", img_name, l3_name, memory_off) test_obj_dict.add_vm(vm) test_util.test_fail("hard model can not create vm") except Exception as e: test_util.test_logger(e) test_lib.lib_execute_ssh_cmd(mn_ip, "root", "password", "zstack-ctl restart_node", timeout=300) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass( "test instanceoffering soft->hard and create vm case pass")
def test(): global vm global host_uuid global host_ip global max_attempts global storagechecker_timeout allow_ps_list = [inventory.CEPH_PRIMARY_STORAGE_TYPE, inventory.NFS_PRIMARY_STORAGE_TYPE, 'SharedMountPoint'] 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('l3NoVlanNetworkName1') 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() #vrs = test_lib.lib_find_vr_by_l3_uuid(l3_net_uuid) #vr_host_ips = [] #for vr in vrs: # vr_host_ips.append(test_lib.lib_find_host_by_vr(vr).managementIp) # if test_lib.lib_is_vm_running(vr) != True: # vm_ops.start_vm(vr.uuid) #time.sleep(60) 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) #for vr_host_ip in vr_host_ips: # conditions = res_ops.gen_query_conditions('managementIp', '!=', vr_host_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_status_runnning') vm = test_vm_header.ZstackTestVm() vm.set_creation_option(vm_creation_option) vm.create() vm.check() test_stub.ensure_host_has_no_vr(host_uuid) vm_creation_option.set_name('multihost_basic_vm_status_stopped') vm2 = test_vm_header.ZstackTestVm() vm2.set_creation_option(vm_creation_option) vm2.create() vm2.stop() vm2.check() #vm.check() host_ip = test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp host_port = test_lib.lib_get_host_port(host_ip) test_util.test_logger("host %s is disconnecting" %(host_ip)) test_stub.down_host_network(host_ip, test_lib.all_scenario_config) test_util.test_logger("wait for 180 seconds") time.sleep(180) test_stub.up_host_network(host_ip, test_lib.all_scenario_config) vm.set_state(vm_header.STOPPED) vm2.set_state(vm_header.STOPPED) vm.check() vm2.check() vm.destroy() vm2.destroy() test_util.test_pass('Test vm checking status after network disconnect and connect success')
def create_checker(self, test_obj): import zstackwoodpecker.zstack_test.zstack_test_snapshot as \ zstack_sp_header if isinstance(test_obj, vm_header.TestVm): checker_chain = VmCheckerFactory().create_checker(test_obj) obj_uuid = test_obj.get_vm().uuid elif isinstance(test_obj, volume_header.TestVolume): checker_chain = VolumeCheckerFactory().create_checker(test_obj) obj_uuid = test_obj.get_volume().uuid elif isinstance(test_obj, image_header.TestImage): checker_chain = ImageCheckerFactory().create_checker(test_obj) #elif isinstance(test_obj, sg_header.TestSecurityGroup): # checker_chain = SecurityGroupCheckerFactory().create_checker(test_obj) obj_uuid = test_obj.get_image().uuid elif isinstance(test_obj, sg_header.TestSecurityGroupVm): checker_chain = SecurityGroupCheckerFactory().create_checker( test_obj) obj_uuid = 'security group vm' elif isinstance(test_obj, test_pf_header.TestPortForwarding): checker_chain = PortForwardingCheckerFactory().create_checker( test_obj) obj_uuid = test_obj.get_port_forwarding().uuid elif isinstance(test_obj, zstack_test_node.ZstackTestNode): checker_chain = NodeCheckerFactory().create_checker(test_obj) obj_uuid = test_obj.get_test_node().uuid elif isinstance(test_obj, host_header.TestHost): checker_chain = HostCheckerFactory().create_checker(test_obj) obj_uuid = test_obj.get_host().uuid elif isinstance(test_obj, eip_header.TestEIP): checker_chain = EipCheckerFactory().create_checker(test_obj) obj_uuid = test_obj.get_eip().uuid elif isinstance(test_obj, vip_header.TestVip): checker_chain = VipCheckerFactory().create_checker(test_obj) obj_uuid = test_obj.get_vip().uuid elif isinstance(test_obj, sp_header.TestSnapshot): checker_chain = SnapshotCheckerFactory().create_checker(test_obj) obj_uuid = test_obj.get_snapshot().uuid elif isinstance(test_obj, zstack_sp_header.ZstackVolumeSnapshot): checker_chain = SnapshotCheckerFactory().create_checker(test_obj) volume_obj = test_obj.get_target_volume().get_volume() if not volume_obj: #volume is deleted, but volume snapshot has been backuped. obj_uuid = None else: obj_uuid = volume_obj.uuid elif isinstance(test_obj, lb_header.TestLoadBalancer): checker_chain = LoadBalancerCheckerFactory().create_checker( test_obj) obj_uuid = test_obj.get_load_balancer().uuid test_util.test_logger('Add checker for [%s:] %s. Checkers are: %s' % \ (test_obj.__class__.__name__, obj_uuid, checker_chain)) return checker_chain
def test(): 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") image_option = test_util.ImageOption() image_option.set_name('test_image_cache_cleanup') image_option.set_format('qcow2') image_option.set_mediaType('RootVolumeTemplate') image_option.set_url(os.environ.get('imageUrl_s')) 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() 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 conditions = res_ops.gen_query_conditions('state', '=', 'Enabled') conditions = res_ops.gen_query_conditions('status', '=', 'Connected', conditions) host_uuid = res_ops.query_resource(res_ops.HOST, conditions)[0].uuid vm_creation_option = test_util.VmOption() vm_creation_option.set_host_uuid(host_uuid) vm_creation_option.set_l3_uuids([l3_net_uuid]) vm_creation_option.set_image_uuid(new_image.image.uuid) vm_creation_option.set_instance_offering_uuid(instance_offering_uuid) vm_creation_option.set_name('test_image_cache_cleanup_vm1') vm = test_vm_header.ZstackTestVm() vm.set_creation_option(vm_creation_option) vm.create() 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()) vm.destroy() vm.expunge() conditions = res_ops.gen_query_conditions('state', '=', 'Enabled') conditions = res_ops.gen_query_conditions('status', '=', 'Connected', conditions) conditions = res_ops.gen_query_conditions('uuid', '!=', host.uuid, 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_name('test_image_cache_cleanup_vm2') vm2 = test_vm_header.ZstackTestVm() vm2.set_creation_option(vm_creation_option) vm2.create() host2 = test_lib.lib_find_host_by_vm(vm2.get_vm()) test_obj_dict.add_vm(vm2) if ps.type == inventory.CEPH_PRIMARY_STORAGE_TYPE: test_util.test_skip( 'ceph is not directly using image cache, skip test.') image_cache_path = "%s/imagecache/template/%s" % (ps.mountPath, new_image.image.uuid) if not test_lib.lib_check_file_exist(host, image_cache_path): test_util.test_fail('image cache is expected to exist') if bss[0].type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: image_cache_path = "%s/zstore-cache/%s" % (ps.mountPath, new_image.image.uuid) if not test_lib.lib_check_file_exist(host, image_cache_path): test_util.test_fail('image cache is expected to exist') new_image.delete() new_image.expunge() ps_ops.cleanup_imagecache_on_primary_storage(ps.uuid) if ps.type == inventory.LOCAL_STORAGE_TYPE: count = 0 while True: image_cache_path = "%s/imagecache/template/%s/%s.qcow2" % ( ps.mountPath, new_image.image.uuid, new_image.image.uuid) if not test_lib.lib_check_file_exist(host, image_cache_path): break elif count > 5: test_util.test_fail('image cache is expected to be deleted') test_util.test_logger('check %s times: image cache still exist' % (count)) time.sleep(5) count += 1 vm2.destroy() vm2.expunge() ps_ops.cleanup_imagecache_on_primary_storage(ps.uuid) count = 0 while True: image_cache_path = "%s/imagecache/template/%s" % (ps.mountPath, new_image.image.uuid) if not test_lib.lib_check_file_exist(host, image_cache_path): break elif count > 5: test_util.test_fail('image cache is expected to be deleted') test_util.test_logger('check %s times: image cache still exist' % (count)) time.sleep(5) count += 1 count = 0 while True: image_cache_path = "%s/zstore-cache/%s" % (ps.mountPath, new_image.image.uuid) if not test_lib.lib_check_file_exist(host, image_cache_path): break elif count > 5: test_util.test_fail('image cache is expected to be deleted') test_util.test_logger('check %s times: image cache still exist' % (count)) time.sleep(5) count += 1 test_util.test_pass('imagecache cleanup Pass.')
def test(): global vm global host_uuid global host_ip global max_attempts global storagechecker_timeout allow_ps_list = [inventory.CEPH_PRIMARY_STORAGE_TYPE, inventory.NFS_PRIMARY_STORAGE_TYPE, 'SharedMountPoint'] 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('l3NoVlanNetworkName1') 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() #vrs = test_lib.lib_find_vr_by_l3_uuid(l3_net_uuid) #vr_host_ips = [] #for vr in vrs: # vr_host_ips.append(test_lib.lib_find_host_by_vr(vr).managementIp) # if test_lib.lib_is_vm_running(vr) != True: # vm_ops.start_vm(vr.uuid) #time.sleep(60) 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) #for vr_host_ip in vr_host_ips: # conditions = res_ops.gen_query_conditions('managementIp', '!=', vr_host_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() test_stub.ensure_host_has_no_vr(host_uuid) #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) #Here we wait for 300 seconds for all vms have been killed, but test result show: #no need to wait, the reaction of killing the vm is very quickly. #test_util.test_logger("wait for 300 seconds") #time.sleep(300) vm_stop_time = None cond = res_ops.gen_query_conditions('uuid', '=', vm.vm.uuid) for i in range(0, max_time): vm_stop_time = i if res_ops.query_resource(res_ops.VM_INSTANCE, cond)[0].state == "Unknown": test_stub.up_host_network(host_ip, test_lib.all_scenario_config) break time.sleep(1) if vm_stop_time is None: vm_stop_time = max_time for i in range(vm_stop_time, max_time): if res_ops.query_resource(res_ops.VM_INSTANCE, cond)[0].state == "Running": break time.sleep(1) else: test_util.test_fail("vm has not been changed to running as expected within %s s." %(max_time)) vm.destroy() test_util.test_pass('Test VM ha change to running within 120s Success')
def test(): global test_obj_dict, bs, ps #judge whether BS is imagestore bs = res_ops.query_resource(res_ops.BACKUP_STORAGE) for i in bs: if i.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break else: test_util.test_skip('Skip test on non-imagestore') #judge whether PS is SharedBlock ps = res_ops.query_resource(res_ops.PRIMARY_STORAGE) for i in ps: if i.type in ['SharedBlock', 'AliyunNAS']: test_util.test_skip('Skip test on SharedBlock and AliyunNAS PS') volume_creation_option = test_util.VolumeOption() test_util.test_dsc('Create volume and check') disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() volume_uuid = volume.volume.uuid vol_size = volume.volume.size image_name = os.environ.get('imageName_s') l3_name = os.environ.get('l3PublicNetworkName') vm = test_stub.create_vm("test_vm", image_name, l3_name) #vm.check() test_obj_dict.add_vm(vm) volume.attach(vm) new_vm = vm.clone(['test_vm_clone_with_one_data_volume'], full=True)[0] test_obj_dict.add_vm(new_vm) volumes_number = len(test_lib.lib_get_all_volumes(new_vm.vm)) if volumes_number != 2: test_util.test_fail('Did not find 2 volumes for [vm:] %s. But we assigned 2 data volume when create the vm. We only catch %s volumes' % (new_vm.vm.uuid, volumes_number)) else: test_util.test_logger('Find 2 volumes for [vm:] %s.' % new_vm.vm.uuid) #Set_size = 1024*1024*1024*5 #Vol_ops.resize_data_volume(volume_uuid, set_size) #Vm.update() #Vol_size_after = test_lib.lib_get_data_volumes(vm.get_vm())[0].size #If set_size != vol_size_after: # test_util.test_fail('Resize Data Volume failed, size = %s' % vol_size_after) #Volume.detach() #Vm.update() #Target_host = test_lib.lib_find_random_host(vm.get_vm()) #Vol_ops.migrate_volume(volume_uuid, target_host.uuid) #Cond = res_ops.gen_query_conditions('uuid', '=', volume_uuid) #Data_volume = res_ops.query_resource(res_ops.VOLUME, cond) #Vol_size_after = data_volume[0].size #If set_size != vol_size_after: # test_util.test_fail('Resize Data Volume failed, size = %s' % vol_size_after) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Test clone vm with one data volume Success')
def _delete_files(host_ip, path): cmd = host_plugin.HostShellCmd() cmd.command = "rm -rf %s*" % path test_util.test_logger("Delete files: %s in Host: %s" % (path, host_ip)) http.json_dump_post(testagent.build_http_path(host_ip, host_plugin.HOST_SHELL_CMD_PATH), cmd)