コード例 #1
0
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')
コード例 #2
0
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')
コード例 #3
0
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)
コード例 #4
0
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)
コード例 #5
0
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)
コード例 #6
0
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')
コード例 #8
0
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')
コード例 #9
0
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')
コード例 #11
0
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))
コード例 #12
0
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)
コード例 #14
0
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)
コード例 #16
0
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 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
    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')