def test(): global vms for i in range(12): vms.append(test_stub.create_vm()) session_uuid = acc_ops.login_as_admin() for vm in vms: if vm: vm.check() console = test_lib.lib_get_vm_console_address( vm.get_vm().uuid, session_uuid) if test_lib.lib_network_check(console.hostIp, console.port): test_util.test_logger( '[vm:] %s console on %s:%s is connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) else: test_util.test_fail( '[vm:] %s console on %s:%s is not connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) acc_ops.logout(session_uuid) for vm in vms: if vm: vm.destroy() vm.check() test_util.test_pass('Request Access Multiple VM Console Test Success')
def add_l3_resource(deploy_config, l3_name, l2_name = None, zone_name = None, \ session_uuid = None): session_uuid_flag = True if not session_uuid: session_uuid = acc_ops.login_as_admin() session_uuid_flag = False try: dep_ops.add_l3_network(None, None, deploy_config, session_uuid, l3_name = l3_name, \ l2_name = l2_name, zone_name = zone_name) dep_ops.add_virtual_router(None, None, deploy_config, session_uuid, \ l3_name = l3_name, zone_name = zone_name) l3_uuid = res_ops.get_resource(res_ops.L3_NETWORK, session_uuid, \ name = l3_name)[0].uuid except Exception as e: test_util.test_logger( '[Error] zstack deployment meets exception when adding l3 resource .' ) traceback.print_exc(file=sys.stdout) raise e finally: if not session_uuid_flag: acc_ops.logout(session_uuid) test_util.action_logger('Complete add l3 resources for [uuid:] %s' \ % l3_uuid)
def test(): global session_to global session_mc global session_uuid session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) session_uuid = acc_ops.login_as_admin() cond = res_ops.gen_query_conditions('type', '=', 'Data') num = res_ops.query_resource_count(res_ops.VOLUME, cond, session_uuid) if num <= thread_threshold: volumes = res_ops.query_resource(res_ops.VOLUME, cond, session_uuid) delete_volumes(volumes) else: start = 0 limit = thread_threshold - 1 curr_num = start volumes = [] while curr_num < num: volumes_temp = res_ops.query_resource_with_num(res_ops.VOLUME, cond, session_uuid, start, limit) volumes.extend(volumes_temp) start += limit curr_num += limit delete_volumes(volumes) #con_ops.change_global_config('identity', 'session.timeout', session_to) #con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) left_num = res_ops.query_resource_count(res_ops.VOLUME, cond, session_uuid) acc_ops.logout(session_uuid) if left_num == 0: test_util.test_pass('Delete Data Volume Success. Delete %d Volumes.' % num) else: test_util.test_fail('Delete Data Volume Fail. %d Volumes are not deleted.' % left_num)
def test(): global vm vm = test_stub.create_vr_vm('migrate_vm', 'imageName_s', 'l3VlanNetwork2') vm.check() session_uuid = acc_ops.login_as_admin() console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid, session_uuid) if test_lib.lib_network_check(console.hostIp, console.port): test_util.test_logger('[vm:] %s console on %s:%s is connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) else: test_util.test_fail('[vm:] %s console on %s:%s is not connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) acc_ops.logout(session_uuid) test_stub.migrate_vm_to_random_host(vm) vm.check() session_uuid = acc_ops.login_as_admin() console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid, session_uuid) if test_lib.lib_network_check(console.hostIp, console.port): test_util.test_logger('[vm:] %s console on %s:%s is connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) else: test_util.test_fail('[vm:] %s console on %s:%s is not connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) acc_ops.logout(session_uuid) vm.destroy() test_util.test_pass('Migrate VM Console Access Test Success')
def error_cleanup(): if session_to: con_ops.change_global_config("identity", "session.timeout", session_to) if session_mc: con_ops.change_global_config("identity", "session.maxConcurrent", session_mc) if session_uuid: acc_ops.logout(session_uuid)
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 error_cleanup(): if session_to: con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) if session_mc: con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) if session_uuid: acc_ops.logout(session_uuid)
def test(): global ldap_server_uuid global new_account_uuid system_tag = ["ldapUseAsLoginName::uid"] ldap_server = ldp_ops.add_ldap_server('ldap1', 'ldap for test', os.environ.get('ldapServerUrl'), os.environ.get('ldapServerBase'), os.environ.get('ldapServerUsername'), os.environ.get('ldapServerPassword'), 'TLS', systemtags=system_tag) ldap_server_uuid = ldap_server.inventory.uuid conditions = res_ops.gen_query_conditions('type', '=', 'SystemAdmin') account = res_ops.query_resource(res_ops.ACCOUNT, conditions)[0] new_account = acc_ops.create_account('new_account', 'password', 'Normal') new_account_uuid = new_account.uuid ldap_account = ldp_ops.bind_ldap_account(os.environ.get('ldapDn'), new_account.uuid) ldap_account_uuid = ldap_account.inventory.uuid session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), os.environ.get('ldapPassword')) acc_ops.logout(session_uuid) get_expected_exception = False try: session_uuid = acc_ops.login_by_ldap( os.environ.get('ldapUid'), os.environ.get('ldapPassword') + '1') acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login with wrong password') get_expected_exception = False try: session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), '') acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login with blank password') get_expected_exception = False try: session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), None) acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login without password') ldp_ops.unbind_ldap_account(ldap_account_uuid) acc_ops.delete_account(new_account.uuid) ldp_ops.delete_ldap_server(ldap_server_uuid) test_util.test_pass('Create VM by normal user account Success') acc_ops.logout(session_uuid)
def test(): global session_to global session_mc global session_uuid session_to = con_ops.change_global_config("identity", "session.timeout", "720000", session_uuid) session_mc = con_ops.change_global_config("identity", "session.maxConcurrent", "10000", session_uuid) session_uuid = acc_ops.login_as_admin() num = res_ops.query_resource_count(res_ops.SECURITY_GROUP, [], session_uuid) if num <= thread_threshold: sgs = res_ops.query_resource(res_ops.SECURITY_GROUP, [], session_uuid) delete_sgs(sgs) else: start = 0 limit = thread_threshold - 1 curr_num = start sgs = [] while curr_num < num: sgs_tmp = res_ops.query_resource_fields(res_ops.SECURITY_GROUP, [], session_uuid, ["uuid"], start, limit) sgs.extend(sgs_tmp) curr_num += limit start += limit delete_sgs(sgs) # con_ops.change_global_config('identity', 'session.timeout', session_to) # con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) con_ops.change_global_config("identity", "session.timeout", session_to, session_uuid) con_ops.change_global_config("identity", "session.maxConcurrent", session_mc, session_uuid) left_num = res_ops.query_resource_count(res_ops.SECURITY_GROUP, [], session_uuid) acc_ops.logout(session_uuid) if left_num == 0: test_util.test_pass("Delete SG Success. Delete %d SGs." % num) else: test_util.test_fail("Delete SG Fail. %d SGs are not deleted." % left_num)
def test(): global session_to global session_mc global session_uuid session_uuid = acc_ops.login_as_admin() session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) cond = res_ops.gen_query_conditions('type', '=', inventory.USER_VM_TYPE) num = res_ops.query_resource_count(res_ops.VM_INSTANCE, cond, session_uuid) if num <= thread_threshold: vms = res_ops.query_resource(res_ops.VM_INSTANCE, cond, session_uuid) destroy_vms(vms) else: start = 0 limit = thread_threshold - 1 curr_num = start vms = [] while curr_num < num: vms_temp = res_ops.query_resource_fields(res_ops.VM_INSTANCE, \ cond, session_uuid, ['uuid'], start, limit) vms.extend(vms_temp) curr_num += limit start += limit destroy_vms(vms) vip_num = res_ops.query_resource_count(res_ops.VIP, [], session_uuid) if vip_num <= thread_threshold: vips = res_ops.query_resource(res_ops.VIP, [], session_uuid) destroy_vips(vips) else: start = 0 limit = thread_threshold - 1 curr_num = start vms = [] while curr_num < vip_num: vips_temp = res_ops.query_resource_fields(res_ops.VIP, \ [], session_uuid, ['uuid'], start, limit) vips.extend(vips_temp) curr_num += limit start += limit destroy_vips(vips) #con_ops.change_global_config('identity', 'session.timeout', session_to) #con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) left_num = res_ops.query_resource_count(res_ops.VM_INSTANCE, cond, session_uuid) if left_num == 0: test_util.test_pass('None VR VMs destroy Success. Destroy %d VMs.' % num) else: test_util.test_fail('None VR VMs destroy Fail. %d VMs are not Destroied.' % left_num) left_num = res_ops.query_resource_count(res_ops.VIP, [], session_uuid) if left_num == 0: test_util.test_pass('VIP destroy Success. Destroy %d VIP.' % num) else: test_util.test_fail('VIP destroy Fail. %d VIP are not Destroied.' % left_num) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) acc_ops.logout(session_uuid)
def test(): global session_to global session_mc global session_uuid session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) session_uuid = acc_ops.login_as_admin() num = res_ops.query_resource_count(res_ops.SECURITY_GROUP, [], session_uuid) if num <= thread_threshold: sgs = res_ops.query_resource(res_ops.SECURITY_GROUP, [], session_uuid) delete_sgs(sgs) else: start = 0 limit = thread_threshold - 1 curr_num = start sgs = [] while curr_num < num: sgs_tmp = res_ops.query_resource_fields(res_ops.SECURITY_GROUP, \ [], session_uuid, ['uuid'], start, limit) sgs.extend(sgs_tmp) curr_num += limit start += limit delete_sgs(sgs) #con_ops.change_global_config('identity', 'session.timeout', session_to) #con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) left_num = res_ops.query_resource_count(res_ops.SECURITY_GROUP, [], session_uuid) acc_ops.logout(session_uuid) if left_num == 0: test_util.test_pass('Delete SG Success. Delete %d SGs.' % num) else: test_util.test_fail('Delete SG Fail. %d SGs are not deleted.' % left_num)
def test(): global session_uuid global session_to global session_mc vm_num = os.environ.get('ZSTACK_TEST_NUM') if not vm_num: vm_num = 0 else: vm_num = int(vm_num) test_util.test_logger('ZSTACK_THREAD_THRESHOLD is %d' % thread_threshold) test_util.test_logger('ZSTACK_TEST_NUM is %d' % vm_num) org_num = vm_num vm_creation_option = test_util.VmOption() image_name = os.environ.get('imageName_sim') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid l3_name = os.environ.get('l3VlanNetworkName1') conditions = res_ops.gen_query_conditions('name', '=', l3_name) l3_uuid = res_ops.query_resource_with_num(res_ops.L3_NETWORK, conditions, \ session_uuid, start = 0, limit = 1)[0].uuid vm_creation_option.set_l3_uuids([l3_uuid]) conditions = res_ops.gen_query_conditions('type', '=', 'UserVm') instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid vm_creation_option.set_image_uuid(image_uuid) vm_creation_option.set_instance_offering_uuid(instance_offering_uuid) session_uuid = acc_ops.login_as_admin() #change account session timeout. session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) vm_creation_option.set_session_uuid(session_uuid) vm = test_vm_header.ZstackTestVm() random_name = random.random() vm_name = 'multihost_sim_vm_%s' % str(random_name) vm_creation_option.set_name(vm_name) while vm_num > 0: check_thread_exception() vm.set_creation_option(vm_creation_option) vm_num -= 1 thread = threading.Thread(target=create_vm, args=(vm,)) while threading.active_count() > thread_threshold: time.sleep(1) thread.start() while threading.active_count() > 1: time.sleep(0.01) cond = res_ops.gen_query_conditions('name', '=', vm_name) vms = res_ops.query_resource_count(res_ops.VM_INSTANCE, cond, session_uuid) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) acc_ops.logout(session_uuid) if vms == org_num: test_util.test_pass('Create %d VMs Test Success' % org_num) else: test_util.test_fail('Create %d VMs Test Failed. Only find %d VMs.' % (org_num, vms))
def umount_all_primary_storages_violently(): session_uuid = acc_ops.login_as_admin() zones = res_ops.query_resource(res_ops.ZONE) for zone in zones: conditions = res_ops.gen_query_conditions('zoneUuid', '=', zone.uuid) conditions = res_ops.gen_query_conditions('state', '=', 'Enabled', conditions) pss = res_ops.query_resource(res_ops.PRIMARY_STORAGE, conditions, session_uuid) conditions = res_ops.gen_query_conditions('zoneUuid', '=', zone.uuid) conditions = res_ops.gen_query_conditions('state', '=', host_header.ENABLED, conditions) conditions = res_ops.gen_query_conditions('status', '=', host_header.CONNECTED, conditions) conditions = res_ops.gen_query_conditions( 'hypervisorType', '=', inventory.KVM_HYPERVISOR_TYPE, conditions) all_hosts = res_ops.query_resource(res_ops.HOST, conditions, session_uuid) for host in all_hosts: for ps in pss: ps_url = ps.mountPath thread = threading.Thread(\ target = umount_primary_storage_violently, \ args = (host.managementIp, ps_url)) thread.start() while threading.active_count() > 1: time.sleep(0.1) acc_ops.logout(session_uuid) delete_ps_ceph_pools()
def test(): global vm vm = test_stub.create_vm() vm.check() session_uuid = acc_ops.login_as_admin() console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid, session_uuid) if test_lib.lib_network_check(console.hostIp, console.port): test_util.test_logger('[vm:] %s console on %s:%s is connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) else: test_util.test_fail('[vm:] %s console on %s:%s is not connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) vm.destroy() vm.check() if test_lib.lib_network_check(console.hostIp, console.port): test_util.test_fail( '[vm:] %s console on %s:%s is connectable, while VM is already destroyed' % (vm.get_vm().uuid, console.hostIp, console.port)) else: test_util.test_logger('[vm:] %s console on %s:%s is not connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) acc_ops.logout(session_uuid) test_util.test_pass('Request Access VM Console Test Success')
def umount_all_primary_storages_violently(): session_uuid = acc_ops.login_as_admin() zones = res_ops.query_resource(res_ops.ZONE) for zone in zones: conditions = res_ops.gen_query_conditions('zoneUuid', '=', zone.uuid) conditions = res_ops.gen_query_conditions('state', '=', 'Enabled', conditions) pss = res_ops.query_resource(res_ops.PRIMARY_STORAGE, conditions, session_uuid) conditions = res_ops.gen_query_conditions('zoneUuid', '=', zone.uuid) conditions = res_ops.gen_query_conditions('state', '=', host_header.ENABLED, conditions) conditions = res_ops.gen_query_conditions('status', '=', host_header.CONNECTED, conditions) conditions = res_ops.gen_query_conditions('hypervisorType', '=', inventory.KVM_HYPERVISOR_TYPE, conditions) all_hosts = res_ops.query_resource(res_ops.HOST, conditions, session_uuid) for host in all_hosts: for ps in pss: ps_url = ps.mountPath thread = threading.Thread(\ target = umount_primary_storage_violently, \ args = (host.managementIp, ps_url)) thread.start() while threading.active_count() > 1: time.sleep(0.1) acc_ops.logout(session_uuid) delete_ps_ceph_pools()
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_storage_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 test(): session_uuid = acc_ops.login_as_admin() acc_ops.logout(session_uuid) image_name = os.environ.get('imageName3') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid try: vm = test_stub.create_vm(image_uuid=image_uuid, session_uuid=session_uuid) test_util.test_fail( 'Expect exception after logout while there is none') except: pass vm = test_stub.create_vm(image_uuid=image_uuid) vm_ops.stop_vm(vm.get_vm().uuid) vm_ops.start_vm(vm.get_vm().uuid) try: vm_ops.stop_vm(vm.get_vm().uuid, session_uuid=session_uuid) test_util.test_fail( 'Expect exception after logout while there is none') except: pass vm.destroy() vm.expunge() test_util.test_pass('Test operations after session logout passed')
def add_zone_resource(deploy_config, zone_name): session_uuid = acc_ops.login_as_admin() try: dep_ops.add_zone(deploy_config, session_uuid, zone_name=zone_name) dep_ops.add_l2_network(deploy_config, session_uuid, \ zone_name = zone_name) dep_ops.add_primary_storage(deploy_config, session_uuid, \ zone_name = zone_name) dep_ops.add_cluster(deploy_config, session_uuid, \ zone_name = zone_name) dep_ops.add_host(deploy_config, session_uuid, \ zone_name = zone_name) dep_ops.add_l3_network(deploy_config, session_uuid, \ zone_name = zone_name) 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 test(): global session_to global session_mc global session_uuid session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) session_uuid = acc_ops.login_as_admin() num = res_ops.query_resource_count(res_ops.VIP, [], session_uuid) if num <= thread_threshold: vips = res_ops.query_resource(res_ops.VIP, [], session_uuid) delete_vips(vips) else: start = 0 limit = thread_threshold - 1 curr_num = start vips = [] while curr_num < num: vips_temp = res_ops.query_resource_fields(res_ops.VIP, [], \ session_uuid, ['uuid'], start, limit) vips.extend(vips_temp) curr_num += limit start += limit delete_vips(vips) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) left_num = res_ops.query_resource_count(res_ops.VIP, [], session_uuid) acc_ops.logout(session_uuid) if left_num == 0: test_util.test_pass('Delete VIP Success. Delete %d VIPs.' % num) else: test_util.test_fail('Delete VIP Fail. %d VIPs are not deleted.' % left_num)
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 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 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 test(): global session_uuid global session_to global session_mc vm_num = os.environ.get('ZSTACK_TEST_NUM') if not vm_num: vm_num = 0 else: vm_num = int(vm_num) test_util.test_logger('ZSTACK_THREAD_THRESHOLD is %d' % thread_threshold) test_util.test_logger('ZSTACK_TEST_NUM is %d' % vm_num) org_num = vm_num vm_creation_option = test_util.VmOption() image_name = os.environ.get('imageName_s') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid l3_name = os.environ.get('l3VlanNetworkName1') conditions = res_ops.gen_query_conditions('name', '=', l3_name) l3_uuid = res_ops.query_resource_with_num(res_ops.L3_NETWORK, conditions, \ session_uuid, start = 0, limit = 1)[0].uuid vm_creation_option.set_l3_uuids([l3_uuid]) conditions = res_ops.gen_query_conditions('type', '=', 'UserVm') instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid vm_creation_option.set_image_uuid(image_uuid) vm_creation_option.set_instance_offering_uuid(instance_offering_uuid) session_uuid = acc_ops.login_as_admin() #change account session timeout. session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) vm_creation_option.set_session_uuid(session_uuid) vm = test_vm_header.ZstackTestVm() random_name = random.random() vm_name = 'multihost_basic_vm_%s' % str(random_name) vm_creation_option.set_name(vm_name) while vm_num > 0: check_thread_exception() vm.set_creation_option(vm_creation_option) vm_num -= 1 thread = threading.Thread(target=create_vm, args=(vm,)) while threading.active_count() > thread_threshold: time.sleep(1) thread.start() while threading.active_count() > 1: time.sleep(0.01) cond = res_ops.gen_query_conditions('name', '=', vm_name) vms = res_ops.query_resource_count(res_ops.VM_INSTANCE, cond, session_uuid) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) acc_ops.logout(session_uuid) if vms == org_num: test_util.test_pass('Create %d VMs Test Success' % org_num) else: test_util.test_fail('Create %d VMs Test Failed. Only find %d VMs.' % (org_num, vms))
def test(): iam2_ops.clean_iam2_enviroment() # 1 create project project_name = 'test_project' project = iam2_ops.create_iam2_project(project_name) project_name = project.name project_uuid = project.uuid # 2 create plain user plain_user_name = 'username' plain_user_password = \ 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86' plain_user_uuid = iam2_ops.create_iam2_virtual_id( plain_user_name, plain_user_password, project_uuid=project_uuid).uuid # 3 add virtual id to project iam2_ops.add_iam2_virtual_ids_to_project([plain_user_uuid], project_uuid) # 4 login in project by plain user plain_user_session_uuid = iam2_ops.login_iam2_virtual_id( plain_user_name, plain_user_password) # 4 login in project # project_inv=iam2_ops.get_iam2_projects_of_virtual_id(plain_user_session_uuid) project_session_uuid = iam2_ops.login_iam2_project( project_name, plain_user_session_uuid).uuid # 5 get iam2 virtual id api permission and project iam2_ops.get_iam2_virtual_id_permission(session_uuid=project_session_uuid) # time.sleep(20) # 6 logout acc_ops.logout(project_session_uuid) try: iam2_ops.login_iam2_virtual_id(plain_user_name, plain_user_password) except: test_util.test_dsc("the user [%s] is deleted,can't login" % plain_user_name) username = '******' * 85 password = \ 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86' iam2_ops.create_iam2_virtual_id(username, password) test_util.test_dsc("success test 255 varchar long username") username = '******' * 256 try: iam2_ops.create_iam2_virtual_id(username, password) test_util.test_fail( "256 varchar long name is bigger than number in database") except: test_util.test_dsc( "can't create username more than 255 varchar ,success!") iam2_ops.clean_iam2_enviroment() test_util.test_pass('success test iam2 login in by plain user')
def Create(vm_name_prefix): global session_uuid global session_to global session_mc session_uuid = None session_to = None session_mc = None vm_num = os.environ.get('ZSTACK_TEST_NUM') if not vm_num: vm_num = 1000 else: vm_num = int(vm_num) test_util.test_logger('ZSTACK_THREAD_THRESHOLD is %d' % thread_threshold) test_util.test_logger('ZSTACK_TEST_NUM is %d' % vm_num) vm_creation_option = test_util.VmOption() image_name = os.environ.get('imageName_s') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid cond = res_ops.gen_query_conditions('category', '=', 'Private') l3net_uuid = res_ops.query_resource(res_ops.L3_NETWORK, cond, session_uuid)[0].uuid l3s = test_lib.lib_get_l3s() conditions = res_ops.gen_query_conditions('type', '=', 'UserVm') instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid vm_creation_option.set_image_uuid(image_uuid) vm_creation_option.set_instance_offering_uuid(instance_offering_uuid) #change account session timeout. session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) session_uuid = acc_ops.login_as_admin() vm_creation_option.set_session_uuid(session_uuid) vm = test_vm_header.ZstackTestVm() vm_creation_option.set_l3_uuids([l3net_uuid]) while vm_num > 0: check_thread_exception() vm_name = '%s_%s' % (vm_name_prefix, str(vm_num)) vm_creation_option.set_name(vm_name) vm.set_creation_option(vm_creation_option) vm_num -= 1 thread = threading.Thread(target=create_vm, args=(vm,)) while threading.active_count() > thread_threshold: time.sleep(1) thread.start() while threading.active_count() > 1: time.sleep(0.05) cond = res_ops.gen_query_conditions('name', '=', vm_name) vms = res_ops.query_resource_count(res_ops.VM_INSTANCE, cond, session_uuid) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) acc_ops.logout(session_uuid)
def test(): global ldap_server_uuid global new_account_uuid ldap_server = ldp_ops.add_ldap_server('ldap1', 'ldap for test', os.environ.get('ldapServerUrl'), os.environ.get('ldapServerBase'), os.environ.get('ldapServerUsername'), os.environ.get('ldapServerPassword'), 'TLS') ldap_server_uuid = ldap_server.inventory.uuid conditions = res_ops.gen_query_conditions('type', '=', 'SystemAdmin') account = res_ops.query_resource(res_ops.ACCOUNT, conditions)[0] get_expected_exception = False try: ldap_account = ldp_ops.bind_ldap_account(os.environ.get('ldapUid'), account.uuid) except: get_expected_exception = True if not get_expected_exception: test_util.test_fail('should not be able to bind ldapuid to admin account') new_account = acc_ops.create_account('new_account', 'password', 'Normal') new_account_uuid = new_account.uuid ldap_account = ldp_ops.bind_ldap_account(os.environ.get('ldapUid'), new_account.uuid) ldap_account_uuid = ldap_account.inventory.uuid session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), os.environ.get('ldapPassword')) acc_ops.logout(session_uuid) get_expected_exception = False try: session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), os.environ.get('ldapPassword')+'1') acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login with wrong password') get_expected_exception = False try: session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), '') acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login with blank password') get_expected_exception = False try: session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), None) acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login without password') ldp_ops.unbind_ldap_account(ldap_account_uuid) acc_ops.delete_account(new_account.uuid) ldp_ops.delete_ldap_server(ldap_server_uuid) test_util.test_pass('Create VM by normal user account Success') acc_ops.logout(session_uuid)
def Create(): global session_uuid global session_to global session_mc vm_num = os.environ.get('ZSTACK_TEST_NUM') if not vm_num: vm_num = 1000 else: vm_num = int(vm_num) test_util.test_logger('ZSTACK_THREAD_THRESHOLD is %d' % thread_threshold) test_util.test_logger('ZSTACK_TEST_NUM is %d' % vm_num) org_num = vm_num vm_creation_option = test_util.VmOption() image_name = os.environ.get('imageName_s') image_uuid = test_lib.lib_get_image_by_name(image_name).uuid l3_name = os.environ.get('l3PublicNetworkName') l3 = test_lib.lib_get_l3_by_name(l3_name) l3s = test_lib.lib_get_l3s() conditions = res_ops.gen_query_conditions('type', '=', 'UserVm') instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid vm_creation_option.set_image_uuid(image_uuid) vm_creation_option.set_instance_offering_uuid(instance_offering_uuid) #change account session timeout. session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) session_uuid = acc_ops.login_as_admin() vm_creation_option.set_session_uuid(session_uuid) vm = test_vm_header.ZstackTestVm() vm_creation_option.set_l3_uuids([l3.uuid]) while vm_num > 0: check_thread_exception() vm_name = 'multihost_basic_vm_%s' % str(vm_num) vm_creation_option.set_name(vm_name) vm.set_creation_option(vm_creation_option) vm_num -= 1 thread = threading.Thread(target=create_vm, args=(vm,)) while threading.active_count() > thread_threshold: time.sleep(1) thread.start() while threading.active_count() > 1: time.sleep(0.05) cond = res_ops.gen_query_conditions('name', '=', vm_name) vms = res_ops.query_resource_count(res_ops.VM_INSTANCE, cond, session_uuid) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) acc_ops.logout(session_uuid)
def test(): iam2_ops.clean_iam2_enviroment() # 1 create project project_name = 'test_project' project = iam2_ops.create_iam2_project(project_name) project_name = project.name project_uuid = project.uuid # 2 create plain user plain_user_name = 'username' plain_user_password = \ 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86' plain_user_uuid = iam2_ops.create_iam2_virtual_id(plain_user_name, plain_user_password, project_uuid=project_uuid).uuid # 3 add virtual id to project iam2_ops.add_iam2_virtual_ids_to_project([plain_user_uuid], project_uuid) # 4 login in project by plain user plain_user_session_uuid = iam2_ops.login_iam2_virtual_id(plain_user_name, plain_user_password) # 4 login in project # project_inv=iam2_ops.get_iam2_projects_of_virtual_id(plain_user_session_uuid) project_session_uuid = iam2_ops.login_iam2_project(project_name, plain_user_session_uuid).uuid # 5 get iam2 virtual id api permission and project iam2_ops.get_iam2_virtual_id_permission(session_uuid=project_session_uuid) # time.sleep(20) # 6 logout acc_ops.logout(project_session_uuid) try: iam2_ops.login_iam2_virtual_id(plain_user_name, plain_user_password) except: test_util.test_dsc("the user [%s] is deleted,can't login" % plain_user_name) username = '******' * 85 password = \ 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86' iam2_ops.create_iam2_virtual_id(username, password) test_util.test_dsc("success test 255 varchar long username") username = '******' * 256 try: iam2_ops.create_iam2_virtual_id(username, password) test_util.test_fail("256 varchar long name is bigger than number in database") except: test_util.test_dsc("can't create username more than 255 varchar ,success!") iam2_ops.clean_iam2_enviroment() test_util.test_pass('success test iam2 login in by plain user')
def cleanup_all_vms_violently(): session_uuid = account_operations.login_as_admin() result = res_ops.get_resource(res_ops.VM_INSTANCE, session_uuid) for vm in result: thread = threading.Thread(target = destroy_vm_and_storage_violently\ , args = (vm, session_uuid, )) thread.start() while threading.active_count() > 1: time.sleep(0.1) account_operations.logout(session_uuid)
def error_cleanup(): global ldap_server_uuid global new_account_uuid if ldap_server_uuid: ldp_ops.delete_ldap_server(ldap_server_uuid) if new_account_uuid: acc_ops.delete_account(new_account_uuid) ldp_ops.unbind_ldap_account(ldap_account_uuid) acc_ops.delete_account(new_account.uuid) ldp_ops.delete_ldap_server(ldap_server_uuid) test_util.test_pass('Create VM by normal user account Success') acc_ops.logout(session_uuid)
def cleanup_all_vms_violently(): destroy_all_vm_and_vips() session_uuid = acc_ops.login_as_admin() result = res_ops.get_resource(res_ops.VM_INSTANCE, session_uuid) for vm in result: thread = threading.Thread(target=destroy_vm_and_storage_violently, args=(vm, session_uuid)) thread.start() while threading.active_count() > 1: time.sleep(0.1) acc_ops.logout(session_uuid)
def test(): global session_to global session_mc global session_uuid session_uuid = acc_ops.login_as_admin() session_to = con_ops.change_global_config('identity', 'session.timeout', '720000') session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000') clean_util.delete_accounts() test_util.test_pass('Accounts Delete Success.') con_ops.change_global_config('identity', 'session.timeout', session_to) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) acc_ops.logout(session_uuid)
def test(): global session_to global session_mc global session_uuid session_uuid = acc_ops.login_as_admin() session_to = con_ops.change_global_config('identity', 'session.timeout', '720000') session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000') clean_util.destroy_all_vm_and_vips() test_util.test_pass('vms destroy Success.') con_ops.change_global_config('identity', 'session.timeout', session_to) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) acc_ops.logout(session_uuid)
def exercise_connection(ops_num=120, thread_threshold=10): session_uuid = acc_ops.login_as_admin() for ops_id in range(ops_num): thread = threading.Thread(target=create_delete_account, args=(ops_id, session_uuid, )) while threading.active_count() > thread_threshold: time.sleep(0.5) exc = sys.exc_info() thread.start() while threading.activeCount() > 1: exc = sys.exc_info() time.sleep(0.1) acc_ops.logout(session_uuid)
def test(): global ad_server_uuid global new_account_uuid system_tag = ["ldapUseAsLoginName::cn"] ad_server = ldp_ops.add_ldap_server('ad1', 'ad for test', os.environ.get('adServerUrl'), os.environ.get('adServerBase'), os.environ.get('adServerUsername'), os.environ.get('adServerPassword'), systemtags=system_tag) ad_server_uuid = ad_server.inventory.uuid conditions = res_ops.gen_query_conditions('type', '=', 'SystemAdmin') account = res_ops.query_resource(res_ops.ACCOUNT, conditions)[0] account_uuid = account.uuid new_account = acc_ops.create_account('new_account', 'password', 'Normal') new_account_uuid = new_account.uuid ad_account = ldp_ops.bind_ldap_account(os.environ.get('adUserDn'), account.uuid) ad_account_uuid = ad_account.inventory.uuid session_uuid = acc_ops.login_by_ldap(os.environ.get('adUserCn'), os.environ.get('adPassword')) new_account2 = acc_ops.create_account('new_account2', 'password', 'Normal', session_uuid) acc_ops.delete_account(new_account2.uuid) acc_ops.logout(session_uuid) get_expected_exception = False try: session_uuid = acc_ops.login_by_ldap(os.environ.get('adUserCn'), os.environ.get('adPassword')+'1') acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login with wrong password') get_expected_exception = False try: session_uuid = acc_ops.login_by_ldap(os.environ.get('adUserCn'), '') acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login with blank password') get_expected_exception = False try: session_uuid = acc_ops.login_by_ldap(os.environ.get('adUserCn'), None) acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login without password') ldp_ops.unbind_ldap_account(ad_account_uuid) acc_ops.delete_account(new_account.uuid) ldp_ops.delete_ldap_server(ad_server_uuid) test_util.test_pass('Login zstack admin by AD Success') acc_ops.logout(session_uuid)
def test(): global session_to global session_mc global session_uuid session_uuid = acc_ops.login_as_admin() session_to = con_ops.change_global_config('identity', 'session.timeout', '720000') session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000') cond = [] num = res_ops.query_resource_count(res_ops.VM_INSTANCE, cond) if num <= thread_threshold: vms = res_ops.query_resource(res_ops.VM_INSTANCE, cond) destroy_vms(vms) else: start = 0 limit = thread_threshold - 1 curr_num = start vms = [] while curr_num < num: vms_temp = res_ops.query_resource_fields(res_ops.VM_INSTANCE, \ cond, None, ['uuid'], start, limit) vms.extend(vms_temp) curr_num += limit start += limit destroy_vms(vms) vip_num = res_ops.query_resource_count(res_ops.VIP, [], session_uuid) if vip_num <= thread_threshold: vips = res_ops.query_resource(res_ops.VIP, [], session_uuid) destroy_vips(vips) else: start = 0 limit = thread_threshold - 1 curr_num = start vms = [] while curr_num < vip_num: vips_temp = res_ops.query_resource_fields(res_ops.VIP, \ [], session_uuid, ['uuid'], start, limit) vips.extend(vips_temp) curr_num += limit start += limit destroy_vips(vips) test_util.test_pass('vms destroy Success. Destroy %d VMs.' % num) con_ops.change_global_config('identity', 'session.timeout', session_to) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) acc_ops.logout(session_uuid)
def test(): iam2_ops.clean_iam2_enviroment() # 1 create project project_name = 'test_project' project_uuid = iam2_ops.create_iam2_project(project_name).uuid # 2 create project operator and virtual id project_operator_name = 'username' project_operator_password = '******' password='******' attributes = [{"name": "__ProjectOperator__", "value": project_uuid}] project_operator_uuid = iam2_ops.create_iam2_virtual_id(project_operator_name,project_operator_password,attributes=attributes).uuid virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo',password).uuid # 3 login in project by project operator iam2_ops.add_iam2_virtual_ids_to_project([project_operator_uuid],project_uuid) project_operator_session_uuid = iam2_ops.login_iam2_virtual_id(project_operator_name,project_operator_password) project_login_uuid = iam2_ops.login_iam2_project(project_name,session_uuid=project_operator_session_uuid).uuid # 4 create virtual id group virtual_id_group_uuid = iam2_ops.create_iam2_virtual_id_group(project_uuid,'test_virtual_id_group',session_uuid=project_login_uuid).uuid # 5 add virtual id into project and group iam2_ops.add_iam2_virtual_ids_to_project([virtual_id_uuid], project_uuid, session_uuid=project_login_uuid) iam2_ops.add_iam2_virtual_ids_to_group([virtual_id_uuid],virtual_id_group_uuid,session_uuid=project_login_uuid) # 6 remove virtual id from project and group iam2_ops.remove_iam2_virtual_ids_from_group([virtual_id_uuid],virtual_id_group_uuid,session_uuid=project_login_uuid) iam2_ops.remove_iam2_virtual_ids_from_project([virtual_id_uuid], project_uuid, session_uuid=project_login_uuid) # 7 create role statements = [{"effect": "Allow", "actions": ["org.zstack.header.vm.**"]}] role_uuid = iam2_ops.create_role('role1', statements,session_uuid=project_login_uuid).uuid # 8 add/remove roles to/from virtual id(group) iam2_ops.add_roles_to_iam2_virtual_id_group([role_uuid],virtual_id_group_uuid,session_uuid=project_login_uuid) iam2_ops.remove_roles_from_iam2_virtual_idgroup([role_uuid],virtual_id_group_uuid,session_uuid=project_login_uuid) iam2_ops.add_roles_to_iam2_virtual_id([role_uuid],virtual_id_uuid,session_uuid=project_login_uuid) iam2_ops.remove_roles_from_iam2_virtual_id([role_uuid],virtual_id_uuid,session_uuid=project_login_uuid) # 9 delete iam2_ops.delete_role(role_uuid,session_uuid=project_login_uuid) iam2_ops.delete_iam2_virtual_id_group(virtual_id_group_uuid,session_uuid=project_login_uuid) acc_ops.logout(project_login_uuid) iam2_ops.clean_iam2_enviroment() test_util.test_pass('success test iam2 login by project operator')
def test(): iam2_ops.clean_iam2_enviroment() # 1 create platformAdmin username = '******' password = '******' platform_admin_uuid = iam2_ops.create_iam2_virtual_id(username, password).uuid attributes = [{"name": "__PlatformAdmin__"}] iam2_ops.add_attributes_to_iam2_virtual_id(platform_admin_uuid, attributes) platform_admin_session_uuid = iam2_ops.login_iam2_virtual_id( username, password) # 2 create platformAdmin by platformAdmin username_02 = 'username_02' password_02 = 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86' virtual_id_uuid = iam2_ops.create_iam2_virtual_id( username_02, password_02, session_uuid=platform_admin_session_uuid).uuid try: iam2_ops.add_attributes_to_iam2_virtual_id( virtual_id_uuid, attributes, session_uuid=platform_admin_session_uuid) test_util.test_fail("platformAdmin can't create platformAdmin") except: pass # 3 delete platformAdmin by platformAdmin iam2_ops.add_attributes_to_iam2_virtual_id(virtual_id_uuid, attributes) try: iam2_ops.remove_attributes_from_iam2_virtual_id( virtual_id_uuid, attributes, session_uuid=platform_admin_session_uuid) test_util.test_fail("platformAdmin can't cancel platformAdmin") except: pass acc_ops.logout(platform_admin_session_uuid) iam2_ops.delete_iam2_virtual_id(platform_admin_uuid) try: iam2_ops.login_iam2_virtual_id(username, password) test_util.test_fail( "the platform admin is Deleted,can't login,but now login success,test fail" ) except: pass iam2_ops.clean_iam2_enviroment() test_util.test_pass("success test platform admin negtive operations")
def test(): global session_to global session_mc global session_uuid session_to = con_ops.change_global_config('identity', \ 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', \ 'session.maxConcurrent', '10000', session_uuid) session_uuid = acc_ops.login_as_admin() num = res_ops.query_resource_count(res_ops.VOLUME_SNAPSHOT_TREE, [], \ session_uuid) sps_del = [] if num <= thread_threshold: sps = res_ops.query_resource_with_num(res_ops.VOLUME_SNAPSHOT_TREE,\ [], session_uuid, start = 0, limit = num) for sp in sps: sps_del.append(sp.tree.inventory.uuid) else: start = 0 limit = thread_threshold - 1 curr_num = start while curr_num < num: sps_temp = res_ops.query_resource_with_num(\ res_ops.VOLUME_SNAPSHOT_TREE, \ [], session_uuid, start, limit) for sp in sps_temp: sps_del.append(sp.tree.inventory.uuid) start += limit curr_num += limit delete_sps(sps_del) #con_ops.change_global_config('identity', 'session.timeout', session_to) #con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) left_num = res_ops.query_resource_count(res_ops.VOLUME_SNAPSHOT, [], \ session_uuid) acc_ops.logout(session_uuid) if left_num == 0: test_util.test_pass( 'Delete Volume Snapshot Success. Delete %d Volume Snapshots.' % num) else: test_util.test_fail( 'Delete Data Volume Snapshot Fail. %d Volume Snapshots are not deleted.' % left_num)
def test(): global vm vm = test_stub.create_vm() vm.check() session_uuid = acc_ops.login_as_admin() console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid, session_uuid) acc_ops.logout(session_uuid) time.sleep(5) if test_lib.lib_network_check(console.hostIp, console.port): test_util.test_fail('[vm:] %s console on %s:%s is connectable, while already logout' % (vm.get_vm().uuid, console.hostIp, console.port)) else: test_util.test_logger('[vm:] %s console on %s:%s is not connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) vm.destroy() vm.check() test_util.test_pass('Request Access VM Console after logout Test Success')
def test(): global session_uuid session_uuid = acc_ops.login_as_admin() l3_name = os.environ.get('l3VlanDNATNetworkName') vm1 = test_stub.create_vlan_vm(l3_name=l3_name) test_obj_dict.add_vm(vm1) vm2 = test_stub.create_vlan_vm(l3_name=l3_name) test_obj_dict.add_vm(vm2) vm3 = test_stub.create_vlan_vm(l3_name=l3_name) test_obj_dict.add_vm(vm3) vm4 = test_stub.create_vlan_vm(l3_name=l3_name) test_obj_dict.add_vm(vm4) vms = [vm1, vm2, vm3, vm4] for vm in vms: thread = threading.Thread(target=vm_ops.stop_vm, args=( vm.get_vm().uuid, None, session_uuid, )) thread.start() while threading.activeCount() > 1: time.sleep(0.1) for vm in vms: thread = threading.Thread(target=vm_ops.start_vm, args=( vm.get_vm().uuid, session_uuid, )) thread.start() vm1.check() vm2.check() vm3.check() vm4.check() time.sleep(1) acc_ops.logout(session_uuid) while threading.activeCount() > 1: time.sleep(0.1) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Test start VRs simultaneously success')
def add_cluster_resource(deploy_config, cluster_name, zone_name = None): session_uuid = acc_ops.login_as_admin() try: dep_ops.add_cluster(deploy_config, session_uuid, \ zone_name = zone_name, cluster_name = cluster_name) dep_ops.add_host(deploy_config, session_uuid, \ zone_name = zone_name, cluster_name = cluster_name) cluster = res_ops.get_resource(res_ops.CLUSTER, session_uuid, \ name = cluster_name)[0] except Exception as e: test_util.test_logger('[Error] zstack deployment meets exception when adding cluster resource .') traceback.print_exc(file=sys.stdout) raise e finally: acc_ops.logout(session_uuid) test_util.action_logger('Complete add cluster resources for [uuid:] %s' \ % cluster.uuid)
def add_l2_resource(deploy_config, l2_name, zone_name = None, \ session_uuid = None): session_uuid_flag = True if not session_uuid: session_uuid = acc_ops.login_as_admin() session_uuid_flag = False try: dep_ops.add_l2_network(deploy_config, session_uuid, l2_name, \ zone_name = zone_name) l2_uuid = res_ops.get_resource(res_ops.L2_NETWORK, session_uuid, \ name = l2_name)[0].uuid for zone in xmlobject.safe_list(deploy_config.zones.zone): if zone_name and zone_name != zone.name_: continue for cluster in xmlobject.safe_list(zone.clusters.cluster): if xmlobject.has_element(cluster, 'l2NetworkRef'): for l2ref in xmlobject.safe_list(cluster.l2NetworkRef): if l2_name != l2ref.text_: continue cluster_uuid = res_ops.get_resource(res_ops.CLUSTER, \ session_uuid, name=cluster.name_)[0].uuid attach_l2(l2_uuid, cluster_uuid, session_uuid) dep_ops.add_l3_network(None, None, deploy_config, session_uuid, l2_name = l2_name, \ zone_name = zone_name) cond = res_ops.gen_query_conditions('l2NetworkUuid', '=', l2_uuid) l3_name = res_ops.query_resource(res_ops.L3_NETWORK, cond, \ session_uuid)[0].name dep_ops.add_virtual_router(None, None, deploy_config, session_uuid, \ l3_name = l3_name, zone_name = zone_name) except Exception as e: test_util.test_logger( '[Error] zstack deployment meets exception when adding l2 resource .' ) traceback.print_exc(file=sys.stdout) raise e finally: if not session_uuid_flag: acc_ops.logout(session_uuid) test_util.action_logger('Complete add l2 resources for [uuid:] %s' \ % l2_uuid)
def test(): global cert iam2_ops.clean_iam2_enviroment() zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid # 1 create project project_name = 'test_project' password = \ 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86' project = iam2_ops.create_iam2_project(project_name) project_uuid = project.uuid linked_account_uuid = project.linkedAccountUuid attributes = [{"name": "__ProjectRelatedZone__", "value": zone_uuid}] iam2_ops.add_attributes_to_iam2_project(project_uuid, attributes) test_stub.share_admin_resource_include_vxlan_pool([linked_account_uuid]) # 2 create projectAdmin into project project_admin_name = 'projectadmin' project_admin_uuid = iam2_ops.create_iam2_virtual_id( project_admin_name, password).uuid iam2_ops.add_iam2_virtual_ids_to_project([project_admin_uuid], project_uuid) attributes = [{"name": "__ProjectAdmin__", "value": project_uuid}] iam2_ops.add_attributes_to_iam2_virtual_id(project_admin_uuid, attributes) project_admin_session_uuid = iam2_ops.login_iam2_virtual_id( project_admin_name, password) project_admin_session_uuid = iam2_ops.login_iam2_project( project_name, project_admin_session_uuid).uuid cert = net_ops.create_certificate('certificate_for_pm', 'fake certificate', session_uuid=project_admin_session_uuid) acc_ops.logout(project_admin_session_uuid) # 4 delete project iam2_ops.delete_iam2_project(project_uuid) iam2_ops.expunge_iam2_project(project_uuid) # 5 check for cascade delete test_stub.check_resource_not_exist(cert.uuid, res_ops.CERTIFICATE) iam2_ops.clean_iam2_enviroment() test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
def test(): global session_to global session_mc global session_uuid session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) session_uuid = acc_ops.login_as_admin() cond = res_ops.gen_query_conditions('type', '=', 'Data') num = res_ops.query_resource_count(res_ops.VOLUME, cond, session_uuid) if num <= thread_threshold: volumes = res_ops.query_resource(res_ops.VOLUME, cond, session_uuid) delete_volumes(volumes) else: start = 0 limit = thread_threshold - 1 curr_num = start volumes = [] while curr_num < num: volumes_temp = res_ops.query_resource_with_num( res_ops.VOLUME, cond, session_uuid, start, limit) volumes.extend(volumes_temp) start += limit curr_num += limit delete_volumes(volumes) #con_ops.change_global_config('identity', 'session.timeout', session_to) #con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) left_num = res_ops.query_resource_count(res_ops.VOLUME, cond, session_uuid) acc_ops.logout(session_uuid) if left_num == 0: test_util.test_pass('Delete Data Volume Success. Delete %d Volumes.' % num) else: test_util.test_fail( 'Delete Data Volume Fail. %d Volumes are not deleted.' % left_num)
def add_l2_resource(deploy_config, l2_name, zone_name = None, \ session_uuid = None): session_uuid_flag = True if not session_uuid: session_uuid = acc_ops.login_as_admin() session_uuid_flag = False try: dep_ops.add_l2_network(deploy_config, session_uuid, l2_name, \ zone_name = zone_name) l2_uuid = res_ops.get_resource(res_ops.L2_NETWORK, session_uuid, \ name = l2_name)[0].uuid for zone in xmlobject.safe_list(deploy_config.zones.zone): if zone_name and zone_name != zone.name_: continue for cluster in xmlobject.safe_list(zone.clusters.cluster): if xmlobject.has_element(cluster, 'l2NetworkRef'): for l2ref in xmlobject.safe_list(cluster.l2NetworkRef): if l2_name != l2ref.text_: continue cluster_uuid = res_ops.get_resource(res_ops.CLUSTER, \ session_uuid, name=cluster.name_)[0].uuid attach_l2(l2_uuid, cluster_uuid, session_uuid) dep_ops.add_l3_network(None, None, deploy_config, session_uuid, l2_name = l2_name, \ zone_name = zone_name) cond = res_ops.gen_query_conditions('l2NetworkUuid', '=', l2_uuid) l3_name = res_ops.query_resource(res_ops.L3_NETWORK, cond, \ session_uuid)[0].name dep_ops.add_virtual_router(None, None, deploy_config, session_uuid, \ l3_name = l3_name, zone_name = zone_name) except Exception as e: test_util.test_logger('[Error] zstack deployment meets exception when adding l2 resource .') traceback.print_exc(file=sys.stdout) raise e finally: if not session_uuid_flag: acc_ops.logout(session_uuid) test_util.action_logger('Complete add l2 resources for [uuid:] %s' \ % l2_uuid)
def parall_test_run(self): test_util.test_logger('ZSTACK_THREAD_THRESHOLD is %d' % self.thread_threshold) test_util.test_logger('ZSTACK_TEST_NUM is %d' % self.host_num) tmp_host_num = self.host_num while tmp_host_num > 0: self.check_thread_exception() tmp_host_num -= 1 thread = threading.Thread(target=self.operate_host_parall, args=(self.hosts[self.i].uuid,)) self.i += 1 while threading.active_count() > self.thread_threshold: time.sleep(1) thread.start() while threading.active_count() > 1: time.sleep(0.01) con_ops.change_global_config('identity', 'session.timeout', self.session_to, self.session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', self.session_mc, self.session_uuid) acc_ops.logout(self.session_uuid)
def add_cluster_resource(deploy_config, cluster_name, zone_name=None): session_uuid = acc_ops.login_as_admin() try: dep_ops.add_cluster(deploy_config, session_uuid, \ zone_name = zone_name, cluster_name = cluster_name) dep_ops.add_host(deploy_config, session_uuid, \ zone_name = zone_name, cluster_name = cluster_name) cluster = res_ops.get_resource(res_ops.CLUSTER, session_uuid, \ name = cluster_name)[0] except Exception as e: test_util.test_logger( '[Error] zstack deployment meets exception when adding cluster resource .' ) traceback.print_exc(file=sys.stdout) raise e finally: acc_ops.logout(session_uuid) test_util.action_logger('Complete add cluster resources for [uuid:] %s' \ % cluster.uuid)
def test(): iam2_ops.clean_iam2_enviroment() # 1 create platformAdmin username = '******' password = '******' platform_admin_uuid = iam2_ops.create_iam2_virtual_id(username, password).uuid attributes = [{"name": "__PlatformAdmin__"}] iam2_ops.add_attributes_to_iam2_virtual_id(platform_admin_uuid, attributes) platform_admin_session_uuid = iam2_ops.login_iam2_virtual_id(username, password) # 2 create platformAdmin by platformAdmin username_02 = 'username_02' password_02 = 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86' virtual_id_uuid = iam2_ops.create_iam2_virtual_id(username_02, password_02, session_uuid=platform_admin_session_uuid).uuid try: iam2_ops.add_attributes_to_iam2_virtual_id(virtual_id_uuid, attributes, session_uuid=platform_admin_session_uuid) test_util.test_fail("platformAdmin can't create platformAdmin") except: pass # 3 delete platformAdmin by platformAdmin iam2_ops.add_attributes_to_iam2_virtual_id(virtual_id_uuid, attributes) try: iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes, session_uuid=platform_admin_session_uuid) test_util.test_fail("platformAdmin can't cancel platformAdmin") except: pass acc_ops.logout(platform_admin_session_uuid) iam2_ops.delete_iam2_virtual_id(platform_admin_uuid) try: iam2_ops.login_iam2_virtual_id(username,password) test_util.test_fail("the platform admin is Deleted,can't login,but now login success,test fail") except: pass iam2_ops.clean_iam2_enviroment() test_util.test_pass("success test platform admin negtive operations")
def test(): global session_to global session_mc global session_uuid session_uuid = acc_ops.login_as_admin() session_to = con_ops.change_global_config('identity', 'session.timeout', '720000', session_uuid) session_mc = con_ops.change_global_config('identity', 'session.maxConcurrent', '10000', session_uuid) num = res_ops.query_resource_count(res_ops.VIP, [], session_uuid) if num <= thread_threshold: vips = res_ops.query_resource(res_ops.VIP, [], session_uuid) destroy_vips(vips) else: start = 0 limit = thread_threshold - 1 curr_num = start vms = [] while curr_num < num: vips_temp = res_ops.query_resource_fields(res_ops.VIP, \ [], session_uuid, ['uuid'], start, limit) vips.extend(vips_temp) curr_num += limit start += limit destroy_vips(vips) #con_ops.change_global_config('identity', 'session.timeout', session_to) #con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc) con_ops.change_global_config('identity', 'session.timeout', session_to, session_uuid) con_ops.change_global_config('identity', 'session.maxConcurrent', session_mc, session_uuid) left_num = res_ops.query_resource_count(res_ops.VIP, [], session_uuid) acc_ops.logout(session_uuid) if left_num == 0: test_util.test_pass('VIP destroy Success. Destroy %d VIP.' % num) else: test_util.test_fail('VIP destroy Fail. %d VIP are not Destroied.' % left_num)
def test(): global vms for i in range(12): vms.append(test_stub.create_vm()) session_uuid = acc_ops.login_as_admin() for vm in vms: if vm: vm.check() console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid, session_uuid) if test_lib.lib_network_check(console.hostIp, console.port): test_util.test_logger('[vm:] %s console on %s:%s is connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) else: test_util.test_fail('[vm:] %s console on %s:%s is not connectable' % (vm.get_vm().uuid, console.hostIp, console.port)) acc_ops.logout(session_uuid) for vm in vms: if vm: vm.destroy() vm.check() test_util.test_pass('Request Access Multiple VM Console Test Success')
def test(): global ldap_server_uuid global new_account_uuid global new_account_uuid2 system_tags = ["ldapCleanBindingFilter::(uidNumber=1002)", "ldapUseAsLoginName::uid"] ldap_server = ldp_ops.add_ldap_server('ldap1', 'ldap for test', os.environ.get('ldapServerUrl'), os.environ.get('ldapServerBase'), os.environ.get('ldapServerUsername'), os.environ.get('ldapServerPassword'), 'None', system_tags) ldap_server_uuid = ldap_server.inventory.uuid conditions = res_ops.gen_query_conditions('type', '=', 'SystemAdmin') account = res_ops.query_resource(res_ops.ACCOUNT, conditions)[0] new_account = acc_ops.create_account('new_account', 'password', 'Normal') new_account_uuid = new_account.uuid ldap_account = ldp_ops.bind_ldap_account(os.environ.get('ldapDn'), new_account.uuid) ldap_account_uuid = ldap_account.inventory.uuid session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), os.environ.get('ldapPassword')) acc_ops.logout(session_uuid) ldp_ops.clean_invalid_ldap_binding() get_excepted_exception = False try: session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), os.environ.get('ldapPassword')) acc_ops.logout(session_uuid) except: get_excepted_exception = True if not get_excepted_exception: test_util.test_fail('should not be able to login with filter account') new_account2 = acc_ops.create_account('new_account2', 'password', 'Normal') new_account_uuid2 = new_account2.uuid ldap_account2 = ldp_ops.bind_ldap_account('uid=ldapuser3,ou=People,dc=mevoco,dc=com', new_account2.uuid) ldap_account_uuid2 = ldap_account2.inventory.uuid session_uuid2 = acc_ops.login_by_ldap('ldapuser3', 'password') acc_ops.logout(session_uuid) '''