def test(): #If test execution machine is not the same one as Host machine, deploy work is needed to separated to 2 steps(deploy_test_agent, execute_plan_without_deploy_test_agent). And it can not directly call SetupAction.run() mevoco1_ip = os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] mevoco2_ip = os.environ['serverIp2'] os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip test_lib.setup_plan.deploy_test_agent() test_lib.setup_plan.execute_plan_without_deploy_test_agent() deploy_operations.deploy_initial_database(test_lib.deploy_config) if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT): os.system("bash %s" % EXTRA_SUITE_SETUP_SCRIPT) if test_lib.lib_get_ha_selffencer_maxattempts() != None: test_lib.lib_set_ha_selffencer_maxattempts('60') test_lib.lib_set_ha_selffencer_storagechecker_timeout('60') test_lib.lib_set_primary_storage_imagecache_gc_interval(1) test_lib.lib_set_provision_storage_rate(6) test_lib.lib_set_provision_memory_rate(3) os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip test_lib.setup_plan.deploy_test_agent() #test_lib.setup_plan.execute_plan_without_deploy_test_agent() #deploy_operations.deploy_initial_database(test_lib.deploy_config) if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT): os.system("bash %s" % EXTRA_SUITE_SETUP_SCRIPT) if test_lib.lib_get_ha_selffencer_maxattempts() != None: test_lib.lib_set_ha_selffencer_maxattempts('60') test_lib.lib_set_ha_selffencer_storagechecker_timeout('60') test_lib.lib_set_primary_storage_imagecache_gc_interval(1) test_lib.lib_set_provision_storage_rate(6) test_lib.lib_set_provision_memory_rate(3) test_util.test_pass('Suite Setup Success')
def test(): os.environ['ZSTACK_THREAD_THRESHOLD'] = '1000' os.environ['ZSTACK_TEST_NUM'] = '1000' test_lib.lib_set_provision_memory_rate(20) test_lib.lib_set_provision_storage_rate(20) lib_set_provision_cpu_rate(20) Create() time.sleep(180) create_vm_begin_time = get_begin_time() create_vm_end_time = get_end_time() print("begin time = %s") % create_vm_begin_time print("end time = %s") % create_vm_end_time if create_vm_end_time != 0 and create_vm_begin_time != 0: create_1000_vm_time = create_vm_end_time - create_vm_begin_time test_util.test_dsc("create_vm_time is " + str(create_1000_vm_time)) Destroy_VM() time.sleep(180) Expunge_VM() time.sleep(180) zone_name = os.environ.get('zoneName') zone = res_ops.get_resource(res_ops.ZONE, name=zone_name)[0] zone_ops.delete_zone(zone.uuid) test_util.test_pass('Create 1000 vms success,takes %s time' % create_1000_vm_time)
def test(): os.environ['ZSTACK_THREAD_THRESHOLD']='1000' os.environ['ZSTACK_TEST_NUM']='1000' test_lib.lib_set_provision_memory_rate(20) test_lib.lib_set_provision_storage_rate(20) lib_set_provision_cpu_rate(20) Create() time.sleep(180) create_vm_begin_time = get_begin_time() create_vm_end_time = get_end_time() print ("begin time = %s") % create_vm_begin_time print ("end time = %s") % create_vm_end_time if create_vm_end_time != 0 and create_vm_begin_time != 0: create_1000_vm_time = create_vm_end_time - create_vm_begin_time test_util.test_dsc("create_vm_time is "+str(create_1000_vm_time)) Destroy_VM() time.sleep(180) Expunge_VM() time.sleep(180) zone_name = os.environ.get('zoneName') zone = res_ops.get_resource(res_ops.ZONE, name = zone_name)[0] zone_ops.delete_zone(zone.uuid) test_util.test_pass('Create 1000 vms success,takes %s time' % create_1000_vm_time)
def test(): os.environ['ZSTACK_THREAD_THRESHOLD']='1000' os.environ['ZSTACK_TEST_NUM']='1000' test_lib.lib_set_provision_memory_rate(20) test_lib.lib_set_provision_storage_rate(20) lib_set_provision_cpu_rate(20) while True: Create() time.sleep(180) Stop_VM() time.sleep(180) Start_VM() time.sleep(180) Reboot_VM() time.sleep(360) Ha_NeverStop_VM() time.sleep(30) Stop_VM_Simple_Scheduler() time.sleep(180) Cancel_Ha_VM() time.sleep(30) Stop_VM_Simple_Scheduler() time.sleep(180) Start_VM_Simple_Scheduler() time.sleep(180) Reboot_VM_Simple_Scheduler() time.sleep(180) Snapshot_VM_Simple_Scheduler() time.sleep(30) Force_Stop_VM() time.sleep(180) Destroy_VM() time.sleep(180) Recover_VM() time.sleep(180) Start_VM() time.sleep(180) Destroy_VM() time.sleep(180) Expunge_VM() time.sleep(180) while True: time.sleep(3600)
def error_cleanup(): test_lib.lib_error_cleanup(test_obj_dict) if original_rate: test_lib.lib_set_provision_storage_rate(original_rate)
def test(): global original_rate global new_offering_uuid global delete_policy 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) hosts = res_ops.query_resource_with_num(res_ops.HOST, cond) if not hosts: test_util.test_skip('No Enabled/Connected host was found, skip test.' ) return True ps = res_ops.query_resource_with_num(res_ops.PRIMARY_STORAGE, cond, limit = 1) if not ps: test_util.test_skip('No Enabled/Connected primary storage was found, skip test.' ) return True host = random.choice(hosts) ps = ps[0] over_provision_rate = 1 target_vm_num = 5 host_res = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0] avail_cap = host_res.availableCapacity image_name = os.environ.get('imageName_net') image = test_lib.lib_get_image_by_name(image_name) image_size = image.size original_rate = test_lib.lib_set_provision_storage_rate(over_provision_rate) data_volume_size = int(over_provision_rate * (avail_cap - image_size * target_vm_num) / target_vm_num) if data_volume_size < 0: test_util.test_skip('Do not have enough disk space to do test') return True delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct') delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct') host_res = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0] avail_cap = host_res.availableCapacity disk_offering_option = test_util.DiskOfferingOption() disk_offering_option.set_name('vm-parallel-creation-test') disk_offering_option.set_diskSize(data_volume_size) data_volume_offering = vol_ops.create_volume_offering(disk_offering_option) test_obj_dict.add_disk_offering(data_volume_offering) rounds = 1 while (rounds <= 3): times = 1 test_util.test_logger('test round: %s' % rounds) while (times <= (target_vm_num)): thread = threading.Thread(target = parallelly_create_vm, \ args = ('parallel_vm_creating_%d' % times, \ image_name, \ host.uuid, \ data_volume_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 > 10: test_util.test_fail('creating vm time exceed 10s') times += 1 check_thread_exception() try: vm = test_stub.create_vm(vm_name = 'unexpected vm', \ image_name = image_name, \ host_uuid = host.uuid) test_obj_dict.add_vm(vm) except: test_util.test_logger('expect vm creation failure') else: test_util.test_fail('The extra vm is unexpected to be created up') for vm in test_obj_dict.get_all_vm_list(): try: test_lib.lib_destroy_vm_and_data_volumes_objs_update_test_dict(vm, test_obj_dict) except Exception as e: test_util.test_logger("VM Destroying Failure in vm parallel creation test. :%s " % e) raise e rounds += 1 test_lib.lib_set_provision_storage_rate(original_rate) test_lib.lib_robot_cleanup(test_obj_dict) test_lib.lib_set_delete_policy('vm', delete_policy) test_lib.lib_set_delete_policy('volume', delete_policy) test_util.test_pass('Parallel vm creation Test Pass')
def test(): global original_rate test_util.test_dsc('Test change storage over provision rate method') zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid 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_rate1 = 2.5 over_provision_rate2 = 1.5 target_volume_num = 12 kept_disk_size = 10 * 1024 * 1024 vm = test_stub.create_vm(vm_name = 'storage_over_prs_vm_1', \ host_uuid = host.uuid) test_obj_dict.add_vm(vm) host_res = test_lib.lib_get_cpu_memory_capacity(host_uuids = [host.uuid]) ps_res = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) avail_cap = ps_res.availableCapacity if avail_cap < kept_disk_size: test_util.test_skip('available disk capacity:%d is too small, skip test.' % avail_cap) return True original_rate = test_lib.lib_set_provision_storage_rate(over_provision_rate1) data_volume_size = int(over_provision_rate1 * (avail_cap - kept_disk_size) / target_volume_num) disk_offering_option = test_util.DiskOfferingOption() disk_offering_option.set_name('storage-over-ps-test') disk_offering_option.set_diskSize(data_volume_size) data_volume_offering = vol_ops.create_volume_offering(disk_offering_option) test_obj_dict.add_disk_offering(data_volume_offering) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(data_volume_offering.uuid) volume_creation_option.set_name('volume-1') volume1 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume1) #res = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) #test_util.test_logger('Current available storage size: %d' % res.availableCapacity) volume1.attach(vm) test_lib.lib_set_provision_storage_rate(over_provision_rate2) volume_creation_option.set_name('volume-2') volume2 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume2) #res = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) #test_util.test_logger('Current available storage size: %d' % res.availableCapacity) volume2.attach(vm) volume1.delete() test_lib.lib_set_provision_storage_rate(over_provision_rate1) volume2.delete() test_lib.lib_set_provision_storage_rate(original_rate) ps_res2 = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) avail_cap2 = ps_res2.availableCapacity if avail_cap2 != avail_cap: test_util.test_fail('Available disk size: %d is different with original size: %d, after creating volume under different over rate.' % (avail_cap2, avail_cap)) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Memory Over Provision Test Pass')
def test(): global original_rate test_util.test_dsc('Test change storage over provision rate method') zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid 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_rate1 = 2.5 over_provision_rate2 = 1.5 target_volume_num = 12 kept_disk_size = 10 * 1024 * 1024 vm = test_stub.create_vm(vm_name = 'storage_over_prs_vm_1', \ host_uuid = host.uuid) test_obj_dict.add_vm(vm) host_res = test_lib.lib_get_cpu_memory_capacity(host_uuids=[host.uuid]) ps_res = test_lib.lib_get_storage_capacity(zone_uuids=[zone_uuid]) avail_cap = ps_res.availableCapacity if avail_cap < kept_disk_size: test_util.test_skip( 'available disk capacity:%d is too small, skip test.' % avail_cap) return True original_rate = test_lib.lib_set_provision_storage_rate( over_provision_rate1) data_volume_size = int(over_provision_rate1 * (avail_cap - kept_disk_size) / target_volume_num) disk_offering_option = test_util.DiskOfferingOption() disk_offering_option.set_name('storage-over-ps-test') disk_offering_option.set_diskSize(data_volume_size) data_volume_offering = vol_ops.create_volume_offering(disk_offering_option) test_obj_dict.add_disk_offering(data_volume_offering) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(data_volume_offering.uuid) volume_creation_option.set_name('volume-1') volume1 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume1) #res = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) #test_util.test_logger('Current available storage size: %d' % res.availableCapacity) volume1.attach(vm) test_lib.lib_set_provision_storage_rate(over_provision_rate2) volume_creation_option.set_name('volume-2') volume2 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume2) #res = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) #test_util.test_logger('Current available storage size: %d' % res.availableCapacity) volume2.attach(vm) volume1.delete() test_lib.lib_set_provision_storage_rate(over_provision_rate1) volume2.delete() test_lib.lib_set_provision_storage_rate(original_rate) ps_res2 = test_lib.lib_get_storage_capacity(zone_uuids=[zone_uuid]) avail_cap2 = ps_res2.availableCapacity if avail_cap2 != avail_cap: test_util.test_fail( 'Available disk size: %d is different with original size: %d, after creating volume under different over rate.' % (avail_cap2, avail_cap)) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Memory Over Provision Test Pass')
def test(): global original_rate test_util.test_dsc('Test storage over provision method') zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid 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 ps = res_ops.query_resource_with_num(res_ops.PRIMARY_STORAGE, cond, limit = 1) if not ps: test_util.test_skip('No Enabled/Connected primary storage was found, skip test.' ) return True host = host[0] ps = ps[0] over_provision_rate = 2.5 target_volume_num = 12 kept_disk_size = 10 * 1024 * 1024 vm = test_stub.create_vm(vm_name = 'storage_over_prs_vm_1', \ host_uuid = host.uuid) test_obj_dict.add_vm(vm) host_res = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0] avail_cap = host_res.availableCapacity if avail_cap < kept_disk_size: test_util.test_skip('available disk capacity:%d is too small, skip test.' % avail_cap) return True original_rate = test_lib.lib_set_provision_storage_rate(over_provision_rate) data_volume_size = int(over_provision_rate * (avail_cap - kept_disk_size) / target_volume_num) #will change the rate back to check if available capacity is same with original one. This was a bug, that only happened when system create 1 vm. test_lib.lib_set_provision_storage_rate(original_rate) host_res_tmp = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0] avail_cap_tmp = host_res_tmp.availableCapacity if avail_cap != avail_cap_tmp: test_util.test_fail('disk size is not same, between 2 times provision. Before change over rate, 1st cap: %d; 2nd cap: %d' % (avail_cap, avail_cap_tmp)) test_lib.lib_set_provision_storage_rate(over_provision_rate) test_util.test_logger('Will create a serial of volume. Each of them will have %d size.' % data_volume_size) disk_offering_option = test_util.DiskOfferingOption() disk_offering_option.set_name('storage-over-ps-test') disk_offering_option.set_diskSize(data_volume_size) data_volume_offering = vol_ops.create_volume_offering(disk_offering_option) test_obj_dict.add_disk_offering(data_volume_offering) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(data_volume_offering.uuid) times = 1 while (times <= target_volume_num): try: volume_creation_option.set_name('volume-%d' % times) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) res = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0] test_util.test_logger('Current available storage size: %d' % res.availableCapacity) volume.attach(vm) except Exception as e: test_util.test_logger("Unexpected volume Creation Failure in storage over provision test. ") raise e times += 1 host_res2 = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0] avail_cap2 = host_res2.availableCapacity if avail_cap2 > data_volume_size: test_util.test_fail('Available disk size: %d is still bigger than offering disk size: %d , after creating %d volumes.' % (avail_cap2, data_volume_size, target_volume_num)) try: volume_creation_option.set_name('volume-%d' % (times + 1)) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.attach(vm) except: test_util.test_logger("Expected Volume Creation Failure in storage over provision test. ") else: test_util.test_fail("The %dth Volume is still attachable, which is wrong"% (target_volume_num + 1)) test_lib.lib_set_provision_storage_rate(original_rate) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Memory Over Provision Test Pass')
def test(): total_create_vms_time = 0 total_destroy_vms_time = 0 total_expunge_vms_time = 0 create_vms_time = [] destroy_vms_time = [] expunge_vms_time = [] test_lib.lib_set_provision_memory_rate(20) test_lib.lib_set_provision_storage_rate(20) lib_set_provision_cpu_rate(20) for i in range(0, perf_loop): test_util.test_dsc("start the %d interation" % i) vm_name_prefix = 'multi_vms_%s' % str(get_random_name(4)) Create(vm_name_prefix) time.sleep(time_interval) create_vm_begin_time = get_begin_time(vm_name_prefix, 'create') create_vm_end_time = get_end_time(vm_name_prefix, 'create') print ("vm creation begin time = %s") % create_vm_begin_time print ("vm creation end time = %s") % create_vm_end_time if create_vm_end_time != 0 and create_vm_begin_time != 0: create_vms_time.append(create_vm_end_time - create_vm_begin_time) test_util.test_dsc("create_vm_time is "+str(create_vms_time[i])) Destroy_VM() time.sleep(180) destroy_vm_begin_time = get_begin_time(vm_name_prefix, 'destroy') destroy_vm_end_time = get_end_time(vm_name_prefix, 'destroy') print ("vm destroy begin time = %s") % destroy_vm_begin_time print ("vm destroy end time = %s") % destroy_vm_end_time if destroy_vm_end_time != 0 and destroy_vm_begin_time != 0: destroy_vms_time.append(destroy_vm_end_time - destroy_vm_begin_time) test_util.test_dsc("destroy_vm_time is "+str(destroy_vms_time[i])) Expunge_VM() time.sleep(180) expunge_vm_begin_time = get_begin_time(vm_name_prefix, 'expunge') expunge_vm_end_time = get_end_time(vm_name_prefix, 'expunge') print ("vm expunge begin time = %s") % expunge_vm_begin_time print ("vm expunge end time = %s") % expunge_vm_end_time if expunge_vm_end_time != 0 and expunge_vm_begin_time != 0: expunge_vms_time.append(expunge_vm_end_time - expunge_vm_begin_time) test_util.test_dsc("expunge_vm_time is "+str(expunge_vms_time[i])) print ("totally %d iterations executed") % perf_loop print "\t\tCre\tDes\tExp" for i in range(0, perf_loop): print "Iteration%d\t%d\t%d\t%d" % (i, create_vms_time[i], destroy_vms_time[i], expunge_vms_time[i]) total_create_vms_time = total_create_vms_time + create_vms_time[i] total_destroy_vms_time = total_destroy_vms_time + destroy_vms_time[i] total_expunge_vms_time = total_expunge_vms_time + expunge_vms_time[i] print "Average\t\t%d\t%d\t%d" % (int(total_create_vms_time/perf_loop), int(total_destroy_vms_time/perf_loop), int(total_expunge_vms_time/perf_loop))
def test(): global original_rate must_ps_list = [inventory.LOCAL_STORAGE_TYPE, inventory.NFS_PRIMARY_STORAGE_TYPE] test_lib.skip_test_if_any_ps_not_deployed(must_ps_list) test_util.test_dsc('Test change storage over provision rate method') zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid 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_rate1 = 2.5 over_provision_rate2 = 1.5 target_volume_num = 12 kept_disk_size = 10 * 1024 * 1024 vm = test_stub.create_vm(vm_name = 'storage_over_prs_vm_1', \ host_uuid = host.uuid) vm.check() test_obj_dict.add_vm(vm) cond = res_ops.gen_query_conditions('state', '=', 'Enabled') cond = res_ops.gen_query_conditions('status', '=', 'Connected', cond) ps = res_ops.query_resource_with_num(res_ops.PRIMARY_STORAGE, cond, limit = 2) if not ps: test_util.test_skip('No Enabled/Connected primary storage was found, skip test.' ) return True ps1 = ps[0].uuid ps1_res = test_lib.lib_get_storage_capacity(ps_uuids=[ps1]) test_util.test_dsc("ps1[uuid:%s]'s available capacity is %s" % (ps1, ps1_res.availableCapacity)) avail_cap = ps1_res.availableCapacity if len(ps) > 1: ps2 = ps[1].uuid ps2_res = test_lib.lib_get_storage_capacity(ps_uuids=[ps2]) test_util.test_dsc("ps2[uuid:%s]'s available capacity is %s" % (ps2, ps2_res.availableCapacity)) avail_cap = ps1_res.availableCapacity + ps2_res.availableCapacity if avail_cap < kept_disk_size: test_util.test_skip('available disk capacity:%d is too small, skip test.' % avail_cap) return True original_rate = test_lib.lib_set_provision_storage_rate(over_provision_rate1) data_volume_size = int(over_provision_rate1 * (avail_cap - kept_disk_size) / target_volume_num) disk_offering_option = test_util.DiskOfferingOption() disk_offering_option.set_name('storage-over-ps-test') disk_offering_option.set_diskSize(data_volume_size) data_volume_offering = vol_ops.create_volume_offering(disk_offering_option) test_obj_dict.add_disk_offering(data_volume_offering) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(data_volume_offering.uuid) volume_creation_option.set_name('volume-1') volume1 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume1) #res = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) #test_util.test_logger('Current available storage size: %d' % res.availableCapacity) volume1.attach(vm) test_lib.lib_set_provision_storage_rate(over_provision_rate2) volume_creation_option.set_name('volume-2') volume2 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume2) #res = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) #test_util.test_logger('Current available storage size: %d' % res.availableCapacity) volume2.attach(vm) volume1.delete() volume1.expunge() test_lib.lib_set_provision_storage_rate(over_provision_rate1) volume2.delete() volume2.expunge() test_lib.lib_set_provision_storage_rate(original_rate) time.sleep(10) ps1_res2 = test_lib.lib_get_storage_capacity(ps_uuids=[ps1]) test_util.test_dsc("ps1[uuid:%s]'s available capacity is %s" % (ps1, ps1_res.availableCapacity)) avail_cap2 = ps1_res2.availableCapacity if len(ps) > 1: ps2_res2 = test_lib.lib_get_storage_capacity(ps_uuids=[ps2]) test_util.test_dsc("ps2[uuid:%s]'s available capacity is %s" % (ps2, ps2_res.availableCapacity)) avail_cap2 = ps1_res2.availableCapacity + ps2_res2.availableCapacity if avail_cap2 != avail_cap: test_util.test_fail('Available disk size: %d is different with original size: %d, after creating volume under different over rate.' % (avail_cap2, avail_cap)) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Memory Over Provision Test Pass')
def test(): global original_rate must_ps_list = [ inventory.LOCAL_STORAGE_TYPE, inventory.NFS_PRIMARY_STORAGE_TYPE ] test_lib.skip_test_if_any_ps_not_deployed(must_ps_list) test_util.test_dsc('Test change storage over provision rate method') zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid 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_rate1 = 2.5 over_provision_rate2 = 1.5 target_volume_num = 12 kept_disk_size = 10 * 1024 * 1024 vm = test_stub.create_vm(vm_name = 'storage_over_prs_vm_1', \ host_uuid = host.uuid) vm.check() test_obj_dict.add_vm(vm) cond = res_ops.gen_query_conditions('state', '=', 'Enabled') cond = res_ops.gen_query_conditions('status', '=', 'Connected', cond) ps = res_ops.query_resource_with_num(res_ops.PRIMARY_STORAGE, cond, limit=2) if not ps: test_util.test_skip( 'No Enabled/Connected primary storage was found, skip test.') return True ps1 = ps[0].uuid ps1_res = test_lib.lib_get_storage_capacity(ps_uuids=[ps1]) test_util.test_dsc("ps1[uuid:%s]'s available capacity is %s" % (ps1, ps1_res.availableCapacity)) avail_cap = ps1_res.availableCapacity if len(ps) > 1: ps2 = ps[1].uuid ps2_res = test_lib.lib_get_storage_capacity(ps_uuids=[ps2]) test_util.test_dsc("ps2[uuid:%s]'s available capacity is %s" % (ps2, ps2_res.availableCapacity)) avail_cap = ps1_res.availableCapacity + ps2_res.availableCapacity if avail_cap < kept_disk_size: test_util.test_skip( 'available disk capacity:%d is too small, skip test.' % avail_cap) return True original_rate = test_lib.lib_set_provision_storage_rate( over_provision_rate1) data_volume_size = int(over_provision_rate1 * (avail_cap - kept_disk_size) / target_volume_num) disk_offering_option = test_util.DiskOfferingOption() disk_offering_option.set_name('storage-over-ps-test') disk_offering_option.set_diskSize(data_volume_size) data_volume_offering = vol_ops.create_volume_offering(disk_offering_option) test_obj_dict.add_disk_offering(data_volume_offering) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(data_volume_offering.uuid) volume_creation_option.set_name('volume-1') volume1 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume1) #res = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) #test_util.test_logger('Current available storage size: %d' % res.availableCapacity) volume1.attach(vm) test_lib.lib_set_provision_storage_rate(over_provision_rate2) volume_creation_option.set_name('volume-2') volume2 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume2) #res = test_lib.lib_get_storage_capacity(zone_uuids = [zone_uuid]) #test_util.test_logger('Current available storage size: %d' % res.availableCapacity) volume2.attach(vm) volume1.delete() volume1.expunge() test_lib.lib_set_provision_storage_rate(over_provision_rate1) volume2.delete() volume2.expunge() test_lib.lib_set_provision_storage_rate(original_rate) time.sleep(10) ps1_res2 = test_lib.lib_get_storage_capacity(ps_uuids=[ps1]) test_util.test_dsc("ps1[uuid:%s]'s available capacity is %s" % (ps1, ps1_res.availableCapacity)) avail_cap2 = ps1_res2.availableCapacity if len(ps) > 1: ps2_res2 = test_lib.lib_get_storage_capacity(ps_uuids=[ps2]) test_util.test_dsc("ps2[uuid:%s]'s available capacity is %s" % (ps2, ps2_res.availableCapacity)) avail_cap2 = ps1_res2.availableCapacity + ps2_res2.availableCapacity if avail_cap2 != avail_cap: test_util.test_fail( 'Available disk size: %d is different with original size: %d, after creating volume under different over rate.' % (avail_cap2, avail_cap)) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Memory Over Provision Test Pass')
def error_cleanup(): test_lib.lib_error_cleanup(test_obj_dict) if original_rate: test_lib.lib_set_provision_storage_rate(original_rate) test_lib.lib_set_delete_policy('vm', delete_policy) test_lib.lib_set_delete_policy('volume', delete_policy)
def test(): global original_rate test_util.test_dsc('Test storage over provision method') zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid 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 ps = res_ops.query_resource_with_num(res_ops.PRIMARY_STORAGE, cond, limit=1) if not ps: test_util.test_skip( 'No Enabled/Connected primary storage was found, skip test.') return True host = host[0] ps = ps[0] ps_type = ps.type #TODO: Fix ceph testing if ps_type == 'Ceph' or ps_type == 'SharedMountPoint': test_util.test_skip('skip test for ceph and smp.') over_provision_rate = 2.5 target_volume_num = 12 kept_disk_size = 10 * 1024 * 1024 vm = test_stub.create_vm(vm_name = 'storage_over_prs_vm_1', \ host_uuid = host.uuid) test_obj_dict.add_vm(vm) vm.check() avail_cap = get_storage_capacity(ps_type, host.uuid, ps.uuid) if avail_cap < kept_disk_size: test_util.test_skip( 'available disk capacity:%d is too small, skip test.' % avail_cap) return True original_rate = test_lib.lib_set_provision_storage_rate( over_provision_rate) data_volume_size = int(over_provision_rate * (avail_cap - kept_disk_size) / target_volume_num) #will change the rate back to check if available capacity is same with original one. This was a bug, that only happened when system create 1 vm. test_lib.lib_set_provision_storage_rate(original_rate) avail_cap_tmp = get_storage_capacity(ps_type, host.uuid, ps.uuid) if avail_cap != avail_cap_tmp: test_util.test_fail( 'disk size is not same, between 2 times provision. Before change over rate, 1st cap: %d; 2nd cap: %d' % (avail_cap, avail_cap_tmp)) test_lib.lib_set_provision_storage_rate(over_provision_rate) test_util.test_logger( 'Will create a serial of volume. Each of them will have %d size.' % data_volume_size) disk_offering_option = test_util.DiskOfferingOption() disk_offering_option.set_name('storage-over-ps-test') disk_offering_option.set_diskSize(data_volume_size) data_volume_offering = vol_ops.create_volume_offering(disk_offering_option) test_obj_dict.add_disk_offering(data_volume_offering) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(data_volume_offering.uuid) times = 1 while (times <= target_volume_num): try: volume_creation_option.set_name('volume-%d' % times) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) test_util.test_logger( 'Current available storage size: %d' % get_storage_capacity(ps_type, host.uuid, ps.uuid)) volume.attach(vm) except Exception as e: test_util.test_logger( "Unexpected volume Creation Failure in storage over provision test. " ) raise e times += 1 time.sleep(2) avail_cap2 = get_storage_capacity(ps_type, host.uuid, ps.uuid) if avail_cap2 > data_volume_size: test_util.test_fail( 'Available disk size: %d is still bigger than offering disk size: %d , after creating %d volumes.' % (avail_cap2, data_volume_size, target_volume_num)) try: volume_creation_option.set_name('volume-%d' % (times + 1)) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.attach(vm) except: test_util.test_logger( "Expected Volume Creation Failure in storage over provision test. " ) else: test_util.test_fail( "The %dth Volume is still attachable, which is wrong" % (target_volume_num + 1)) test_lib.lib_set_provision_storage_rate(original_rate) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Memory Over Provision Test Pass')
def test(): global original_rate global new_offering_uuid global delete_policy 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) hosts = res_ops.query_resource_with_num(res_ops.HOST, cond) if not hosts: test_util.test_skip('No Enabled/Connected host was found, skip test.' ) return True ps = res_ops.query_resource_with_num(res_ops.PRIMARY_STORAGE, cond, limit = 1) if not ps: test_util.test_skip('No Enabled/Connected primary storage was found, skip test.' ) return True if ps[0].type == inventory.CEPH_PRIMARY_STORAGE_TYPE or ps[0].type == 'SharedMountPoint': test_util.test_skip('skip test on ceph and smp.' ) return True host = random.choice(hosts) ps = ps[0] over_provision_rate = 1 target_vm_num = 5 host_res = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0] avail_cap = host_res.availableCapacity image_name = os.environ.get('imageName_net') image = test_lib.lib_get_image_by_name(image_name) image_size = image.size original_rate = test_lib.lib_set_provision_storage_rate(over_provision_rate) data_volume_size = int(avail_cap / target_vm_num * over_provision_rate - image_size) if data_volume_size < 0: test_util.test_skip('Do not have enough disk space to do test') return True delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct') delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct') host_res = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0] avail_cap = host_res.availableCapacity disk_offering_option = test_util.DiskOfferingOption() disk_offering_option.set_name('vm-parallel-creation-test') disk_offering_option.set_diskSize(data_volume_size) data_volume_offering = vol_ops.create_volume_offering(disk_offering_option) test_obj_dict.add_disk_offering(data_volume_offering) rounds = 1 while (rounds <= 3): times = 1 test_util.test_logger('test round: %s' % rounds) while (times <= (target_vm_num)): thread = threading.Thread(target = parallelly_create_vm, \ args = ('parallel_vm_creating_%d' % times, \ image_name, \ host.uuid, \ data_volume_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 > 30: test_util.test_fail('creating vm time exceed 30s') times += 1 check_thread_exception() try: vm = test_stub.create_vm(vm_name = 'unexpected vm', \ image_name = image_name, \ host_uuid = host.uuid) test_obj_dict.add_vm(vm) except: test_util.test_logger('expect vm creation failure') else: test_util.test_fail('The extra vm is unexpected to be created up') for vm in test_obj_dict.get_all_vm_list(): try: test_lib.lib_destroy_vm_and_data_volumes_objs_update_test_dict(vm, test_obj_dict) except Exception as e: test_util.test_logger("VM Destroying Failure in vm parallel creation test. :%s " % e) raise e rounds += 1 test_lib.lib_set_provision_storage_rate(original_rate) test_lib.lib_robot_cleanup(test_obj_dict) test_lib.lib_set_delete_policy('vm', delete_policy) test_lib.lib_set_delete_policy('volume', delete_policy) test_util.test_pass('Parallel vm creation Test Pass')