def test():
global test_obj_dict
global delete_policy
delete_policy = test_lib.lib_set_delete_policy('vm', 'Delay')
l3_name = os.environ.get('l3VlanNetworkName1')
#l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
image_name = os.environ.get('imageName_net')
vm = test_stub.create_vm(l3_name=l3_name, image_name=image_name, vm_name='basic-test-vm')
test_obj_dict.add_vm(vm)
vm.check()
vm_nic_uuid = vm.vm.vmNics[0].uuid
net_ops.detach_l3(vm_nic_uuid)
vm.destroy()
vm.set_state(vm_header.DESTROYED)
vm.check()
vm.recover()
vm.set_state(vm_header.STOPPED)
vm.check()
test_lib.lib_set_delete_policy('vm', delete_policy)
try:
vm.start()
except Exception, e:
#if "please attach a nic and try again" in str(e):
test_util.test_pass('test detach l3 check vm passed.')
def test():
if test_lib.scenario_config != None and test_lib.scenario_file != None and not os.path.exists(
test_lib.scenario_file):
scenario_operations.deploy_scenario(test_lib.all_scenario_config,
test_lib.scenario_file,
test_lib.deploy_config)
test_util.test_skip('Suite Setup Success')
if test_lib.scenario_config != None and test_lib.scenario_destroy != None:
scenario_operations.destroy_scenario(test_lib.all_scenario_config,
test_lib.scenario_destroy)
setup = setup_actions.SetupAction()
setup.plan = test_lib.all_config
setup.run()
shell.call('yum --disablerepo=epel install -y libvirt-devel')
shell.call('pip install virtualbmc')
shell.call('cp %s/integrationtest/vm/baremetal/vbmc.py \
/var/lib/zstack/virtualenv/woodpecker/lib/python2.7/site-packages/virtualbmc/vbmc.py -fr' \
% os.environ.get('woodpecker_root_path'))
test_util.test_logger('Virtualbmc has been deployed on Host')
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s" % EXTRA_SUITE_SETUP_SCRIPT)
deploy_operations.deploy_initial_database(test_lib.deploy_config,
test_lib.all_scenario_config,
test_lib.scenario_file)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
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_util.test_pass('Suite Setup Success')
def test():
#This vlan creation is not a must, if testing is under nested virt env. But it is required on physical host without enough physcial network devices and your test execution machine is not the same one as Host machine.
#linux.create_vlan_eth("eth0", 10, "10.0.0.200", "255.255.255.0")
#linux.create_vlan_eth("eth0", 11, "10.0.1.200", "255.255.255.0")
#no matter if current host is a ZStest host, we need to create 2 vlan devs for future testing connection for novlan test cases.
linux.create_vlan_eth("eth0", 10)
linux.create_vlan_eth("eth0", 11)
#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()
test_lib.setup_plan.deploy_test_agent()
cmd = host_plugin.CreateVlanDeviceCmd()
hosts = test_lib.lib_get_all_hosts_from_plan()
if type(hosts) != type([]):
hosts = [hosts]
for host in hosts:
cmd.ethname = 'eth0'
cmd.vlan = 10
http.json_dump_post(testagent.build_http_path(host.managementIp_, host_plugin.CREATE_VLAN_DEVICE_PATH), cmd)
cmd.vlan = 11
http.json_dump_post(testagent.build_http_path(host.managementIp_, host_plugin.CREATE_VLAN_DEVICE_PATH), cmd)
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)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
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_util.test_pass('Suite Setup Success')
def delete_all_volumes(thread_threshold = 1000):
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')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
expunge_time = test_lib.lib_set_expunge_time('volume', 1)
cond = res_ops.gen_query_conditions('status', '!=', 'Deleted')
num = res_ops.query_resource_count(res_ops.VOLUME, cond)
if num <= thread_threshold:
volumes = res_ops.query_resource(res_ops.VOLUME, cond)
do_delete_volumes(volumes, thread_threshold)
else:
start = 0
limit = thread_threshold - 1
curr_num = start
volumes = []
while curr_num < num:
volumes_temp = res_ops.query_resource_fields(res_ops.VOLUME, \
cond, None, ['uuid'], start, limit)
volumes.extend(volumes_temp)
curr_num += limit
start += limit
do_delete_volumes(volumes, thread_threshold)
test_lib.lib_set_delete_policy('volume', delete_policy)
test_lib.lib_set_expunge_time('volume', expunge_time)
test_util.test_logger('Volumes destroy Success. Destroy %d Volumes.' % num)
def test():
global test_obj_dict
global delete_policy
delete_policy = test_lib.lib_set_delete_policy('vm', 'Delay')
l3_name = os.environ.get('l3VlanNetworkName1')
#l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
image_name = os.environ.get('imageName_net')
vm = test_stub.create_vm(l3_name=l3_name,
image_name=image_name,
vm_name='basic-test-vm')
test_obj_dict.add_vm(vm)
vm.check()
vm_nic_uuid = vm.vm.vmNics[0].uuid
net_ops.detach_l3(vm_nic_uuid)
vm.destroy()
vm.set_state(vm_header.DESTROYED)
vm.check()
vm.recover()
vm.set_state(vm_header.STOPPED)
vm.check()
test_lib.lib_set_delete_policy('vm', delete_policy)
try:
vm.start()
except Exception, e:
if "please attach a nic and try again" in str(e):
test_util.test_pass('test detach l3 check vm passed.')
def delete_all_volumes(thread_threshold=1000):
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")
delete_policy = test_lib.lib_set_delete_policy("volume", "Direct")
expunge_time = test_lib.lib_set_expunge_time("volume", 1)
cond = res_ops.gen_query_conditions("status", "!=", "Deleted")
num = res_ops.query_resource_count(res_ops.VOLUME, cond)
if num <= thread_threshold:
volumes = res_ops.query_resource(res_ops.VOLUME, cond)
do_delete_volumes(volumes, thread_threshold)
else:
start = 0
limit = thread_threshold - 1
curr_num = start
volumes = []
while curr_num < num:
volumes_temp = res_ops.query_resource_fields(res_ops.VOLUME, cond, None, ["uuid"], start, limit)
volumes.extend(volumes_temp)
curr_num += limit
start += limit
do_delete_volumes(volumes, thread_threshold)
test_lib.lib_set_delete_policy("volume", delete_policy)
test_lib.lib_set_expunge_time("volume", expunge_time)
test_util.test_logger("Volumes destroy Success. Destroy %d Volumes." % num)
def test():
if test_lib.scenario_config != None and test_lib.scenario_file != None and not os.path.exists(
test_lib.scenario_file):
scenario_operations.deploy_scenario(test_lib.all_scenario_config,
test_lib.scenario_file,
test_lib.deploy_config)
test_util.test_skip('Suite Setup Success')
if test_lib.scenario_config != None and test_lib.scenario_destroy != None:
scenario_operations.destroy_scenario(test_lib.all_scenario_config,
test_lib.scenario_destroy)
setup = setup_actions.SetupAction()
setup.plan = test_lib.all_config
setup.run()
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s" % EXTRA_SUITE_SETUP_SCRIPT)
deploy_operations.deploy_initial_database(test_lib.deploy_config,
test_lib.all_scenario_config,
test_lib.scenario_file)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
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_util.test_pass('Suite Setup Success')
def test():
global curr_deploy_conf
global test_obj_dict
global l3_name
global l3
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Delay')
l3_name = os.environ.get('l3VlanNetworkName1')
l3 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name)[0]
vm = test_stub.create_vlan_vm(l3_name)
vm.check()
test_obj_dict.add_vm(vm)
net_ops.delete_l3(l3.uuid)
if test_lib.lib_get_l3_by_uuid(l3.uuid):
test_util.test_fail(
'l3 should not be found when associated L3 is deleted')
#vm_nic_uuid = vm.vm.vmNics[0].uuid
#net_ops.detach_l3(vm_nic_uuid)
vm.destroy()
vm.set_state(vm_header.DESTROYED)
vm.check()
vm.recover()
vm.set_state(vm_header.STOPPED)
vm.check()
test_lib.lib_set_delete_policy('vm', delete_policy)
try:
vm.start()
except Exception, e:
#if "please attach a nic and try again" in str(e):
test_util.test_pass('test detach l3 check vm passed.')
def delete_all_volumes(thread_threshold=1000):
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')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
expunge_time = test_lib.lib_set_expunge_time('volume', 1)
cond = res_ops.gen_query_conditions('status', '!=', 'Deleted')
num = res_ops.query_resource_count(res_ops.VOLUME, cond)
if num <= thread_threshold:
volumes = res_ops.query_resource(res_ops.VOLUME, cond)
do_delete_volumes(volumes, thread_threshold)
else:
start = 0
limit = thread_threshold - 1
curr_num = start
volumes = []
while curr_num < num:
volumes_temp = res_ops.query_resource_fields(res_ops.VOLUME, \
cond, None, ['uuid'], start, limit)
volumes.extend(volumes_temp)
curr_num += limit
start += limit
do_delete_volumes(volumes, thread_threshold)
test_lib.lib_set_delete_policy('volume', delete_policy)
test_lib.lib_set_expunge_time('volume', expunge_time)
test_util.test_logger('Volumes destroy Success. Destroy %d Volumes.' % num)
def test():
if test_lib.scenario_config != None and test_lib.scenario_file != None and not os.path.exists(test_lib.scenario_file):
scenario_operations.deploy_scenario(test_lib.all_scenario_config, test_lib.scenario_file, test_lib.deploy_config)
test_util.test_skip('Suite Setup Success')
if test_lib.scenario_config != None and test_lib.scenario_destroy != None:
scenario_operations.destroy_scenario(test_lib.all_scenario_config, test_lib.scenario_destroy)
setup = setup_actions.SetupAction()
setup.plan = test_lib.all_config
setup.run()
if test_lib.scenario_config != None and test_lib.scenario_file != None and os.path.exists(test_lib.scenario_file):
mn_ips = deploy_operations.get_nodes_from_scenario_file(test_lib.all_scenario_config, test_lib.scenario_file, test_lib.deploy_config)
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s '%s'" % (EXTRA_SUITE_SETUP_SCRIPT, mn_ips))
elif os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s" % (EXTRA_SUITE_SETUP_SCRIPT))
deploy_operations.deploy_initial_database(test_lib.deploy_config, test_lib.all_scenario_config, test_lib.scenario_file)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
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_util.test_pass('Suite Setup Success')
def test():
if test_lib.scenario_config != None and test_lib.scenario_file != None and not os.path.exists(test_lib.scenario_file):
scenario_operations.deploy_scenario(test_lib.all_scenario_config, test_lib.scenario_file, test_lib.deploy_config)
test_util.test_skip('Suite Setup Success')
if test_lib.scenario_config != None and test_lib.scenario_destroy != None:
scenario_operations.destroy_scenario(test_lib.all_scenario_config, test_lib.scenario_destroy)
nic_name = "eth0"
if test_lib.scenario_config != None and test_lib.scenario_file != None and os.path.exists(test_lib.scenario_file):
nic_name = "zsn0"
public_l2_vlan = int(os.getenv('l2PublicVlan'))
#This vlan creation is not a must, if testing is under nested virt env. But it is required on physical host without enough physcial network devices and your test execution machine is not the same one as Host machine.
#linux.create_vlan_eth("eth0", 10, "10.0.0.200", "255.255.255.0")
#linux.create_vlan_eth("eth0", 11, "10.0.1.200", "255.255.255.0")
#no matter if current host is a ZStest host, we need to create 2 vlan devs for future testing connection for novlan test cases.
linux.create_vlan_eth(nic_name, 10)
linux.create_vlan_eth(nic_name, 11)
linux.create_vlan_eth(nic_name, public_l2_vlan)
#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()
test_lib.setup_plan.deploy_test_agent()
cmd = host_plugin.CreateVlanDeviceCmd()
hosts = test_lib.lib_get_all_hosts_from_plan()
if type(hosts) != type([]):
hosts = [hosts]
for host in hosts:
cmd.ethname = nic_name
cmd.vlan = 10
http.json_dump_post(testagent.build_http_path(host.managementIp_, host_plugin.CREATE_VLAN_DEVICE_PATH), cmd)
cmd.vlan = 11
http.json_dump_post(testagent.build_http_path(host.managementIp_, host_plugin.CREATE_VLAN_DEVICE_PATH), cmd)
cmd.vlan = public_l2_vlan
http.json_dump_post(testagent.build_http_path(host.managementIp_, host_plugin.CREATE_VLAN_DEVICE_PATH), cmd)
test_lib.setup_plan.execute_plan_without_deploy_test_agent()
if test_lib.scenario_config != None and test_lib.scenario_file != None and os.path.exists(test_lib.scenario_file):
mn_ips = deploy_operations.get_nodes_from_scenario_file(test_lib.all_scenario_config, test_lib.scenario_file, test_lib.deploy_config)
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s '%s'" % (EXTRA_SUITE_SETUP_SCRIPT, mn_ips))
elif os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s" % (EXTRA_SUITE_SETUP_SCRIPT))
deploy_operations.deploy_initial_database(test_lib.deploy_config, test_lib.all_scenario_config, test_lib.scenario_file)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
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)
bss = res_ops.query_resource(res_ops.BACKUP_STORAGE)
bs = bss[0]
test_util.test_pass('Suite Setup Success')
def test():
global delete_policy
delete_policy = test_lib.lib_set_delete_policy('vm', 'Delay')
vm = test_stub.create_vm(vm_name = 'basic-test-vm')
test_obj_dict.add_vm(vm)
time.sleep(1)
vm.destroy()
vm.expunge()
test_lib.lib_set_delete_policy('vm', delete_policy)
test_util.test_pass('Expunge VM Test Success')
def test():
setup = setup_actions.SetupAction()
setup.plan = test_lib.all_config
setup.run()
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s" % EXTRA_SUITE_SETUP_SCRIPT)
deploy_operations.deploy_initial_database(test_lib.deploy_config)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
test_util.test_pass('Suite Setup Success')
def test():
global delete_policy
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
os.system('dd if=/dev/zero of=%s bs=1M count=300' % test_image)
time.sleep(1)
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
img_ops.reconnect_sftp_backup_storage(bs.uuid)
time.sleep(1)
image_name = 'test-image-%s' % time.time()
image_option = test_util.ImageOption()
image_option.set_name(image_name)
image_option.set_description('test image which is upload from local filesystem.')
image_option.set_url('file://%s' % test_image)
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
avail_cap = bs.availableCapacity
total_cap = bs.totalCapacity
image_option.set_backup_storage_uuid_list([bs.uuid])
image_option.set_format('raw')
image_option.set_mediaType('RootVolumeTemplate')
image_inv = img_ops.add_root_volume_template(image_option)
time.sleep(10)
image = zstack_image_header.ZstackTestImage()
image.set_creation_option(image_option)
image.set_image(image_inv)
test_obj_dict.add_image(image)
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
avail_cap1 = bs.availableCapacity
total_cap1 = bs.totalCapacity
if total_cap != total_cap1:
test_util.test_fail('Backup storage total capacity is not same, after adding new image: %s. The previous value: %s, the current value: %s' % (image_inv.uuid, total_cap, total_cap1))
if avail_cap <= avail_cap1 :
test_util.test_fail('Backup storage available capacity is not correct, after adding new image: %s. The previous value: %s, the current value: %s' % (image_inv.uuid, avail_cap, avail_cap1))
image.delete()
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
avail_cap2 = bs.availableCapacity
total_cap2 = bs.totalCapacity
if total_cap != total_cap2 :
test_util.test_fail('Backup storage total capacity is not same, after deleting new image: %s. The previous value: %s, the current value: %s' % (image_inv.uuid, total_cap, total_cap2))
if avail_cap > (avail_cap2 + 1024000) or avail_cap < avail_cap2:
test_util.test_fail('Backup storage available capacity is not correct, after adding and deleting new image: %s. The previous value: %s, the current value: %s' % (image_inv.uuid, avail_cap, avail_cap2))
os.system('rm -f %s' % test_image)
test_lib.lib_set_delete_policy('image', delete_policy)
test_util.test_pass('Test backup storage capacity for adding/deleting image pass.')
def test():
global vm
vm = test_stub.create_vm()
vm.check()
delete_policy = test_lib.lib_set_delete_policy('vm', 'Delay')
vm.destroy()
ha_ops.set_vm_instance_ha_level(vm.get_vm().uuid, "NeverStop")
vm.recover()
time.sleep(60)
vm.set_state(vm_header.RUNNING)
vm.check()
vm.destroy()
test_lib.lib_set_delete_policy('vm', delete_policy)
test_util.test_pass('VM ha never stop auto start with recover Test Success')
def error_cleanup():
global ps_uuid
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
if ps_uuid != None:
ps_ops.change_primary_storage_state(ps_uuid, 'enable')
global host_uuid
if host_uuid != None:
host_ops.reconnect_host(host_uuid)
global vr_uuid
if vr_uuid != None:
vm_ops.reconnect_vr(vr_uuid)
global test_obj_dict
test_lib.lib_error_cleanup(test_obj_dict)
def test():
global test_obj_dict
global ps_uuid
global host_uuid
global vr_uuid
allow_ps_list = [inventory.CEPH_PRIMARY_STORAGE_TYPE, "SharedBlock"]
test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list)
test_util.test_dsc('Create test vm and check')
bs_cond = res_ops.gen_query_conditions("status", '=', "Connected")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, \
None)
if not bss:
test_util.test_skip("not find available backup storage. Skip test")
test_lib.lib_set_delete_policy('vm', 'Delay')
test_lib.lib_set_delete_policy('volume', 'Delay')
l3_1_name = os.environ.get('l3VlanNetworkName1')
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
vr_uuid = vr.uuid
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
test_obj_dict.add_vm(vm)
vm.check()
disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('rootDiskOfferingName'))
volume_creation_option = test_util.VolumeOption()
volume_creation_option.set_disk_offering_uuid(disk_offering.uuid)
volume_creation_option.set_system_tags(['ephemeral::shareable', 'capability::virtio-scsi'])
volume = test_stub.create_volume(volume_creation_option)
test_obj_dict.add_volume(volume)
volume.check()
volume.attach(vm)
#ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
#ps_uuid = ps.uuid
#ps_ops.change_primary_storage_state(ps_uuid, 'disable')
test_stub.disable_all_pss()
if not test_lib.lib_wait_target_up(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to running when PS change to disable state')
vm.set_state(vm_header.RUNNING)
vm.check()
volume.delete()
volume.check()
volume.expunge()
volume.check()
#ps_ops.change_primary_storage_state(ps_uuid, 'enable')
test_stub.enable_all_pss()
host_ops.reconnect_host(host_uuid)
vm_ops.reconnect_vr(vr_uuid)
vm.destroy()
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
test_util.test_pass('Delete volume under PS disable mode Test Success')
def error_cleanup():
global ps_uuid
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
if ps_uuid != None:
ps_ops.change_primary_storage_state(ps_uuid, 'enable')
global host_uuid
if host_uuid != None:
host_ops.reconnect_host(host_uuid)
global vr_uuid
if vr_uuid != None:
vm_ops.reconnect_vr(vr_uuid)
global test_obj_dict
test_lib.lib_error_cleanup(test_obj_dict)
def test():
global test_obj_dict
global ps_uuid
global host_uuid
global vr_uuid
test_util.test_dsc('Create test vm and check')
bs_cond = res_ops.gen_query_conditions("status", '=', "Connected")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, \
None)
if not bss:
test_util.test_skip("not find available backup storage. Skip test")
if bss[0].type != inventory.CEPH_BACKUP_STORAGE_TYPE:
test_util.test_skip("not find available ceph backup storage. Skip test")
test_lib.lib_set_delete_policy('vm', 'Delay')
test_lib.lib_set_delete_policy('volume', 'Delay')
l3_1_name = os.environ.get('l3VlanNetworkName1')
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
vr_uuid = vr.uuid
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
test_obj_dict.add_vm(vm)
vm.check()
disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('rootDiskOfferingName'))
volume_creation_option = test_util.VolumeOption()
volume_creation_option.set_disk_offering_uuid(disk_offering.uuid)
volume_creation_option.set_system_tags(['ephemeral::shareable', 'capability::virtio-scsi'])
volume = test_stub.create_volume(volume_creation_option)
test_obj_dict.add_volume(volume)
volume.check()
volume.attach(vm)
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
ps_uuid = ps.uuid
ps_ops.change_primary_storage_state(ps_uuid, 'disable')
if not test_lib.lib_wait_target_up(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to running when PS change to disable state')
vm.set_state(vm_header.RUNNING)
vm.check()
volume.delete()
#volume.expunge()
volume.check()
ps_ops.change_primary_storage_state(ps_uuid, 'enable')
host_ops.reconnect_host(host_uuid)
vm_ops.reconnect_vr(vr_uuid)
vm.destroy()
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
test_util.test_pass('Delete volume under PS disable mode Test Success')
def test():
global test_obj_dict
global ps_uuid
global host_uuid
global vr_uuid
test_util.test_dsc('Create test vm and check')
test_lib.lib_set_delete_policy('vm', 'Delay')
test_lib.lib_set_delete_policy('volume', 'Delay')
l3_1_name = os.environ.get('l3VlanNetworkName1')
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
#l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
#vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
#vr_uuid = vr.uuid
#l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
test_obj_dict.add_vm(vm)
vm.check()
disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('rootDiskOfferingName'))
volume_creation_option = test_util.VolumeOption()
volume_creation_option.set_disk_offering_uuid(disk_offering.uuid)
#volume_creation_option.set_system_tags(['ephemeral::shareable', 'capability::virtio-scsi'])
volume = test_stub.create_volume(volume_creation_option)
test_obj_dict.add_volume(volume)
volume.check()
volume.delete()
volume.check()
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
ps_uuid = ps.uuid
ps_ops.change_primary_storage_state(ps_uuid, 'maintain')
if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to stop when PS change to maintain state')
vm.set_state(vm_header.STOPPED)
vm.check()
volume.recover()
volume.check()
ps_ops.change_primary_storage_state(ps_uuid, 'enable')
host_ops.reconnect_host(host_uuid)
#vm_ops.reconnect_vr(vr_uuid)
vrs = test_lib.lib_get_all_vrs()
for vr in vrs:
vm_ops.start_vm(vr.uuid)
vm.start()
vm.check()
volume.delete()
#volume.expunge()
volume.check()
vm.destroy()
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
test_util.test_pass('Delete volume under PS maintain mode Test Success')
def test():
setup = setup_actions.SetupAction()
setup.plan = test_lib.all_config
setup.run()
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s" % EXTRA_SUITE_SETUP_SCRIPT)
deploy_operations.deploy_initial_database(test_lib.deploy_config)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
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_util.test_pass('Suite Setup Success')
def test():
setup = setup_actions.SetupAction()
setup.plan = test_lib.all_config
setup.run()
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s" % EXTRA_SUITE_SETUP_SCRIPT)
deploy_operations.deploy_initial_database(test_lib.deploy_config)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
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_util.test_pass('Suite Setup Success')
def test():
global test_obj_dict
global ps_uuid
global host_uuid
global vr_uuid
test_util.test_dsc('Create test vm and check')
test_lib.lib_set_delete_policy('vm', 'Delay')
test_lib.lib_set_delete_policy('volume', 'Delay')
l3_1_name = os.environ.get('l3VlanNetworkName1')
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
#l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
#vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
#vr_uuid = vr.uuid
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
test_obj_dict.add_vm(vm)
vm.check()
disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('rootDiskOfferingName'))
volume_creation_option = test_util.VolumeOption()
volume_creation_option.set_disk_offering_uuid(disk_offering.uuid)
volume_creation_option.set_system_tags(['ephemeral::shareable', 'capability::virtio-scsi'])
volume = test_stub.create_volume(volume_creation_option)
test_obj_dict.add_volume(volume)
volume.check()
volume.delete()
volume.check()
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
ps_uuid = ps.uuid
ps_ops.change_primary_storage_state(ps_uuid, 'maintain')
if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to stop when PS change to maintain state')
vm.set_state(vm_header.STOPPED)
vm.check()
volume.recover()
volume.check()
ps_ops.change_primary_storage_state(ps_uuid, 'enable')
host_ops.reconnect_host(host_uuid)
#vm_ops.reconnect_vr(vr_uuid)
vrs = test_lib.lib_get_all_vrs()
for vr in vrs:
vm_ops.start_vm(vr.uuid)
vm.start()
vm.check()
volume.delete()
#volume.expunge()
volume.check()
vm.destroy()
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
test_util.test_pass('Delete volume under PS maintain mode Test Success')
def test():
global delete_policy
delete_policy = test_lib.lib_set_delete_policy('vm', 'Delay')
test_util.test_dsc('Test storage capacity when using expunge vm')
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
ps = ps[0]
avail_cap = ps.availableCapacity
vm = test_stub.create_vm(vm_name='basic-test-vm')
test_obj_dict.add_vm(vm)
ps = res_ops.query_resource_with_num(res_ops.PRIMARY_STORAGE,
cond,
limit=1)[0]
avail_cap1 = ps.availableCapacity
if avail_cap == avail_cap1:
test_util.test_fail(
'PS capacity is same after create vm. Capacity before create vm: %s, after create vm: %s '
% (avail_cap, avail_cap1))
time.sleep(1)
vm.destroy()
vm.expunge()
ps = res_ops.query_resource_with_num(res_ops.PRIMARY_STORAGE,
cond,
limit=1)[0]
avail_cap2 = ps.availableCapacity
if avail_cap != avail_cap2:
test_util.test_fail(
'PS capacity is not same after create/expunge vm. Capacity before create vm: %s, after expunge vm: %s '
% (avail_cap, avail_cap2))
test_lib.lib_set_delete_policy('vm', delete_policy)
test_util.test_pass('Expunge VM Test Success')
def error_cleanup():
global vcenter_uuid1
global vcenter_uuid2
global mevoco2_ip
global img_uuid
global delete_policy1
global delete_policy2
test_lib.lib_set_delete_policy('image', delete_policy1)
if img_uuid:
img_ops.delete_image(img_uuid)
img_ops.expunge_image(img_uuid)
if vcenter_uuid1:
vct_ops.delete_vcenter(vcenter_uuid1)
if vcenter_uuid2:
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
test_lib.lib_set_delete_policy('image', delete_policy2)
vct_ops.delete_vcenter(vcenter_uuid2)
def error_cleanup():
global vcenter_uuid1
global vcenter_uuid2
global mevoco2_ip
global img_uuid
global delete_policy1
global delete_policy2
test_lib.lib_set_delete_policy('image', delete_policy1)
if img_uuid:
img_ops.delete_image(img_uuid)
img_ops.expunge_image(img_uuid)
if vcenter_uuid1:
vct_ops.delete_vcenter(vcenter_uuid1)
if vcenter_uuid2:
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
test_lib.lib_set_delete_policy('image', delete_policy2)
vct_ops.delete_vcenter(vcenter_uuid2)
def test():
if test_lib.scenario_config != None and test_lib.scenario_file != None and not os.path.exists(
test_lib.scenario_file):
scenario_operations.deploy_scenario(test_lib.all_scenario_config,
test_lib.scenario_file,
test_lib.deploy_config)
test_util.test_skip('Suite Setup Success')
if test_lib.scenario_config != None and test_lib.scenario_destroy != None:
scenario_operations.destroy_scenario(test_lib.all_scenario_config,
test_lib.scenario_destroy)
test_lib.setup_plan.deploy_test_agent()
test_lib.setup_plan.execute_plan_without_deploy_test_agent()
if test_lib.scenario_config != None and test_lib.scenario_file != None and os.path.exists(
test_lib.scenario_file):
mn_ips = deploy_operations.get_nodes_from_scenario_file(
test_lib.all_scenario_config, test_lib.scenario_file,
test_lib.deploy_config)
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s '%s' %s" %
(EXTRA_SUITE_SETUP_SCRIPT, mn_ips, 'baremetal'))
deploy_vbmc(mn_ips)
elif os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s %s" % (EXTRA_SUITE_SETUP_SCRIPT, 'baremetal'))
deploy_vbmc()
deploy_operations.deploy_initial_database(test_lib.deploy_config,
test_lib.all_scenario_config,
test_lib.scenario_file)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
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_util.test_pass('Suite Setup Success')
def test():
global delete_policy
delete_policy = test_lib.lib_set_delete_policy('vm', 'Delay')
test_util.test_dsc('Test storage capacity when using expunge vm')
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]
host_res = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0]
avail_cap = host_res.availableCapacity
vm = test_stub.create_vm(vm_name = 'basic-test-vm', host_uuid = host.uuid)
test_obj_dict.add_vm(vm)
host_res1 = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0]
avail_cap1 = host_res1.availableCapacity
if avail_cap == avail_cap1:
test_util.test_fail('PS capacity is same after create vm on host: %s. Capacity before create vm: %s, after create vm: %s ' % (host.uuid, avail_cap, avail_cap1))
time.sleep(1)
vm.destroy()
vm.expunge()
host_res2 = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0]
avail_cap2 = host_res2.availableCapacity
if avail_cap != avail_cap2:
test_util.test_fail('PS capacity is not same after create/expunge vm on host: %s. Capacity before create vm: %s, after expunge vm: %s ' % (host.uuid, avail_cap, avail_cap2))
test_lib.lib_set_delete_policy('vm', delete_policy)
test_util.test_pass('Expunge VM Test Success')
def test():
global delete_policy1
global delete_policy2
delete_policy1 = test_lib.lib_set_delete_policy('vm', 'Delay')
delete_policy2 = test_lib.lib_set_delete_policy('volume', 'Delay')
test_util.test_dsc('Test storage capacity when using expunge vm')
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]
host_res = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0]
avail_cap = host_res.availableCapacity
vm = test_stub.create_vm(vm_name = 'basic-test-vm', host_uuid = host.uuid)
test_obj_dict.add_vm(vm)
data_volume_size = 1024 * 1024 * 10
disk_offering_option = test_util.DiskOfferingOption()
disk_offering_option.set_name('test-expunge-data-volume')
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')
volume = test_stub.create_volume(volume_creation_option)
test_obj_dict.add_volume(volume)
volume.attach(vm)
time.sleep(1)
vm.destroy()
vm.expunge()
test_obj_dict.rm_vm(vm)
volume.delete()
volume.expunge()
test_obj_dict.rm_volume(volume)
host_res2 = vol_ops.get_local_storage_capacity(host.uuid, ps.uuid)[0]
avail_cap2 = host_res.availableCapacity
if avail_cap != avail_cap2:
test_util.test_fail('PS capacity is not same after create/expunge vm/volume on host: %s. Capacity before create vm: %s, after expunge vm: %s ' % (host.uuid, avail_cap, avail_cap2))
test_lib.lib_set_delete_policy('vm', delete_policy1)
test_lib.lib_set_delete_policy('volume', delete_policy2)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Expunge VM Test Success')
def test():
global test_obj_dict
global ps_uuid
global host_uuid
global vr_uuid
test_util.test_dsc('Create test vm and check')
test_lib.lib_set_delete_policy('vm', 'Delay')
test_lib.lib_set_delete_policy('volume', 'Delay')
l3_1_name = os.environ.get('l3VlanNetworkName1')
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
#l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
#vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
#vr_uuid = vr.uuid
l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
test_obj_dict.add_vm(vm)
vm.check()
#ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
#ps_uuid = ps.uuid
#ps_ops.change_primary_storage_state(ps_uuid, 'maintain')
test_stub.maintain_all_pss()
if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail(
'VM is expected to stop when PS change to maintain state')
vm.set_state(vm_header.STOPPED)
vm.check()
vm.destroy()
#vm.expunge() maintain mode is not support expunge ops.
vm.check()
#ps_ops.change_primary_storage_state(ps_uuid, 'enable')
test_stub.enable_all_pss()
host_ops.reconnect_host(host_uuid)
#vm_ops.reconnect_vr(vr_uuid)
vrs = test_lib.lib_get_all_vrs()
for vr in vrs:
vm_ops.start_vm(vr.uuid)
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
test_util.test_pass('PS maintain mode Test Success')
def test():
global test_obj_dict
global ps_uuid
global host_uuid
global vr_uuid
test_util.test_dsc('Create test vm and check')
test_lib.lib_set_delete_policy('vm', 'Delay')
test_lib.lib_set_delete_policy('volume', 'Delay')
l3_1_name = os.environ.get('l3VlanNetworkName1')
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
vr_uuid = vr.uuid
l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
test_obj_dict.add_vm(vm)
vm.check()
#ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
#ps_uuid = ps.uuid
#ps_ops.change_primary_storage_state(ps_uuid, 'disable')
test_stub.disable_all_pss()
if not test_lib.lib_wait_target_up(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail(
'VM is expected to running when PS change to disable state')
vm.set_state(vm_header.RUNNING)
vm.check()
vm.destroy()
vm.check()
vm.expunge()
vm.check()
#ps_ops.change_primary_storage_state(ps_uuid, 'enable')
test_stub.enable_all_pss()
host_ops.reconnect_host(host_uuid)
vm_ops.reconnect_vr(vr_uuid)
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
test_util.test_pass('PS disable mode Test Success')
def test():
global test_obj_dict
global ps_uuid
global host_uuid
global vr_uuid
test_util.test_dsc('Create test vm and check')
test_lib.lib_set_delete_policy('vm', 'Delay')
test_lib.lib_set_delete_policy('volume', 'Delay')
l3_1_name = os.environ.get('l3VlanNetworkName1')
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
vr_uuid = vr.uuid
l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
test_obj_dict.add_vm(vm)
vm.check()
#ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
#ps_uuid = ps.uuid
#ps_ops.change_primary_storage_state(ps_uuid, 'disable')
test_stub.disable_all_pss()
if not test_lib.lib_wait_target_up(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to running when PS change to disable state')
vm.set_state(vm_header.RUNNING)
vm.check()
vm.destroy()
vm.check()
vm.expunge()
vm.check()
#ps_ops.change_primary_storage_state(ps_uuid, 'enable')
test_stub.enable_all_pss()
host_ops.reconnect_host(host_uuid)
vm_ops.reconnect_vr(vr_uuid)
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
test_util.test_pass('PS disable mode Test Success')
def test():
global test_obj_dict
global ps_uuid
global host_uuid
global vr_uuid
allow_ps_list = [inventory.CEPH_PRIMARY_STORAGE_TYPE, "SharedBlock"]
test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list)
test_util.test_dsc('Create test vm and check')
bs_cond = res_ops.gen_query_conditions("status", '=', "Connected")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, \
None)
if not bss:
test_util.test_skip("not find available backup storage. Skip test")
test_lib.lib_set_delete_policy('vm', 'Delay')
test_lib.lib_set_delete_policy('volume', 'Delay')
l3_1_name = os.environ.get('l3VlanNetworkName1')
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
#l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
#vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
#vr_uuid = vr.uuid
#l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
test_obj_dict.add_vm(vm)
vm.check()
disk_offering = test_lib.lib_get_disk_offering_by_name(
os.environ.get('rootDiskOfferingName'))
volume_creation_option = test_util.VolumeOption()
volume_creation_option.set_disk_offering_uuid(disk_offering.uuid)
volume_creation_option.set_system_tags(
['ephemeral::shareable', 'capability::virtio-scsi'])
volume = test_stub.create_volume(volume_creation_option)
test_obj_dict.add_volume(volume)
volume.check()
volume.attach(vm)
#ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
#ps_uuid = ps.uuid
#ps_ops.change_primary_storage_state(ps_uuid, 'maintain')
test_stub.maintain_all_pss()
if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail(
'VM is expected to stop when PS change to maintain state')
vm.set_state(vm_header.STOPPED)
vm.check()
volume.delete()
#volume.expunge() maintain mode is not support volume expunge
volume.check()
#ps_ops.change_primary_storage_state(ps_uuid, 'enable')
test_stub.enable_all_pss()
host_ops.reconnect_host(host_uuid)
#vm_ops.reconnect_vr(vr_uuid)
vrs = test_lib.lib_get_all_vrs()
for vr in vrs:
vm_ops.start_vm(vr.uuid)
vm.start()
vm.check()
vm.destroy()
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
test_util.test_pass('Delete volume under PS maintain mode Test Success')
def test():
global vms, exec_info, delete_policy1
ps = res_ops.query_resource(res_ops.PRIMARY_STORAGE)[0]
if ps.type != inventory.CEPH_PRIMARY_STORAGE_TYPE:
test_util.test_skip(
'this test is for moniter expunge vm on ceph, not found ceph, skip test.'
)
delete_policy1 = test_lib.lib_set_delete_policy('vm', 'Delay')
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3NoVlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
cpuNum = 1
memorySize = 268435456
name = 'vm-offering-allocator-strategy'
new_offering_option = test_util.InstanceOfferingOption()
new_offering_option.set_cpuNum(cpuNum)
new_offering_option.set_memorySize(memorySize)
new_offering_option.set_name(name)
new_offering = vm_ops.create_instance_offering(new_offering_option)
test_obj_dict.add_instance_offering(new_offering)
instance_offering_uuid = new_offering.uuid
each_vm_cpu_consume = cpuNum
vm_creation_option = test_util.VmOption()
vm_creation_option.set_l3_uuids([l3_net_uuid])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
#trigger vm create
exec_info = []
ts = []
for i in range(vm_num):
t = threading.Thread(target=create_vm_wrapper,
args=(i, vm_creation_option))
ts.append(t)
t.start()
for t in ts:
t.join()
check_exception("created")
#trigger vm destroy
exec_info = []
ts = []
for i, vm in zip(range(vm_num), vms):
t = threading.Thread(target=destroy_vm_wrapper, args=(i, vm.vm.uuid))
ts.append(t)
t.start()
for t in ts:
t.join()
check_exception("destroyed")
#trigger vm expunge
exec_info = []
ts = []
for i, vm in zip(range(vm_num), vms):
t = threading.Thread(target=expunge_vm_wrapper, args=(i, vm.vm.uuid))
ts.append(t)
t.start()
for t in ts:
t.join()
check_exception("expunged")
test_lib.lib_set_delete_policy('vm', delete_policy1)
test_util.test_pass('Create VM Test Success')
def error_cleanup():
test_lib.lib_error_cleanup(test_obj_dict)
os.system('rm -f %s' % test_image)
test_lib.lib_set_delete_policy('image', delete_policy)
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 test_obj_dict
global ps_uuid
global host_uuid
global vr_uuid
test_util.test_dsc('Create test vm and check')
test_lib.lib_set_delete_policy('vm', 'Delay')
test_lib.lib_set_delete_policy('volume', 'Delay')
l3_1_name = os.environ.get('l3VlanNetworkName1')
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
#l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
#vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
#vr_uuid = vr.uuid
#l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
test_obj_dict.add_vm(vm)
vm.check()
disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('rootDiskOfferingName'))
volume_creation_option = test_util.VolumeOption()
volume_creation_option.set_disk_offering_uuid(disk_offering.uuid)
#volume_creation_option.set_system_tags(['ephemeral::shareable', 'capability::virtio-scsi'])
volume = test_stub.create_volume(volume_creation_option)
test_obj_dict.add_volume(volume)
volume.check()
volume.delete()
volume.check()
#ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
#ps_uuid = ps.uuid
#ps_ops.change_primary_storage_state(ps_uuid, 'maintain')
test_stub.maintain_all_pss()
if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to stop when PS change to maintain state')
vm.set_state(vm_header.STOPPED)
vm.check()
volume.recover()
volume.check()
#ps_ops.change_primary_storage_state(ps_uuid, 'enable')
test_stub.enable_all_pss()
host_ops.reconnect_host(host_uuid)
#vm_ops.reconnect_vr(vr_uuid)
test_stub.ensure_pss_connected()
vrs = test_lib.lib_get_all_vrs()
time.sleep(5)
for vr in vrs:
vr_cond = res_ops.gen_query_conditions('uuid', '=', vr.uuid)
vr_inv = res_ops.query_resource(res_ops.VM_INSTANCE, vr_cond)[0]
if vr_inv.state == 'Stopped':
vm_ops.start_vm(vr.uuid)
else:
test_lib.lib_wait_target_up(vr_inv.vmNics[0].ip, '22', 360)
for _ in xrange(100):
if res_ops.query_resource(res_ops.VM_INSTANCE, vr_cond)[0].state != 'Running':
time.sleep(3)
else:
break
vm.start()
vm.check()
volume.delete()
#volume.expunge()
volume.check()
vm.destroy()
test_lib.lib_set_delete_policy('vm', 'Direct')
test_lib.lib_set_delete_policy('volume', 'Direct')
test_util.test_pass('Delete volume under PS maintain mode Test Success')
def error_cleanup():
test_lib.lib_error_cleanup(test_obj_dict)
test_lib.lib_set_delete_policy('vm', delete_policy)
def test():
global delete_policy
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
os.system('dd if=/dev/zero of=%s bs=1M count=300' % test_image)
time.sleep(1)
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
img_ops.reconnect_sftp_backup_storage(bs.uuid)
time.sleep(1)
image_name = 'test-image-%s' % time.time()
image_option = test_util.ImageOption()
image_option.set_name(image_name)
image_option.set_description(
'test image which is upload from local filesystem.')
image_option.set_url('file://%s' % test_image)
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
avail_cap = bs.availableCapacity
total_cap = bs.totalCapacity
image_option.set_backup_storage_uuid_list([bs.uuid])
image_option.set_format('raw')
image_option.set_mediaType('RootVolumeTemplate')
image_inv = img_ops.add_root_volume_template(image_option)
time.sleep(10)
image = zstack_image_header.ZstackTestImage()
image.set_creation_option(image_option)
image.set_image(image_inv)
test_obj_dict.add_image(image)
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
avail_cap1 = bs.availableCapacity
total_cap1 = bs.totalCapacity
if total_cap != total_cap1:
test_util.test_fail(
'Backup storage total capacity is not same, after adding new image: %s. The previous value: %s, the current value: %s'
% (image_inv.uuid, total_cap, total_cap1))
if avail_cap <= avail_cap1:
test_util.test_fail(
'Backup storage available capacity is not correct, after adding new image: %s. The previous value: %s, the current value: %s'
% (image_inv.uuid, avail_cap, avail_cap1))
image.delete()
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
avail_cap2 = bs.availableCapacity
total_cap2 = bs.totalCapacity
if total_cap != total_cap2:
test_util.test_fail(
'Backup storage total capacity is not same, after deleting new image: %s. The previous value: %s, the current value: %s'
% (image_inv.uuid, total_cap, total_cap2))
if avail_cap > (avail_cap2 + 1024000) or avail_cap < avail_cap2:
test_util.test_fail(
'Backup storage available capacity is not correct, after adding and deleting new image: %s. The previous value: %s, the current value: %s'
% (image_inv.uuid, avail_cap, avail_cap2))
os.system('rm -f %s' % test_image)
test_lib.lib_set_delete_policy('image', delete_policy)
test_util.test_pass(
'Test backup storage capacity for adding/deleting image 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')
def error_cleanup():
test_lib.lib_error_cleanup(test_obj_dict)
test_lib.lib_set_delete_policy('vm', delete_policy)
def test():
if test_lib.scenario_config != None and test_lib.scenario_file != None and not os.path.exists(
test_lib.scenario_file):
scenario_operations.deploy_scenario(test_lib.all_scenario_config,
test_lib.scenario_file,
test_lib.deploy_config)
test_util.test_skip('Suite Setup Success')
if test_lib.scenario_config != None and test_lib.scenario_destroy != None:
scenario_operations.destroy_scenario(test_lib.all_scenario_config,
test_lib.scenario_destroy)
nic_name = "eth0"
if test_lib.scenario_config != None and test_lib.scenario_file != None and os.path.exists(
test_lib.scenario_file):
nic_name = "zsn0"
public_l2_vlan = int(os.getenv('l2PublicVlan'))
#This vlan creation is not a must, if testing is under nested virt env. But it is required on physical host without enough physcial network devices and your test execution machine is not the same one as Host machine.
#linux.create_vlan_eth("eth0", 10, "10.0.0.200", "255.255.255.0")
#linux.create_vlan_eth("eth0", 11, "10.0.1.200", "255.255.255.0")
#no matter if current host is a ZStest host, we need to create 2 vlan devs for future testing connection for novlan test cases.
linux.create_vlan_eth(nic_name, 10)
linux.create_vlan_eth(nic_name, 11)
linux.create_vlan_eth(nic_name, public_l2_vlan)
#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()
test_lib.setup_plan.deploy_test_agent()
cmd = host_plugin.CreateVlanDeviceCmd()
hosts = test_lib.lib_get_all_hosts_from_plan()
if type(hosts) != type([]):
hosts = [hosts]
for host in hosts:
cmd.ethname = nic_name
cmd.vlan = 10
http.json_dump_post(
testagent.build_http_path(host.managementIp_,
host_plugin.CREATE_VLAN_DEVICE_PATH),
cmd)
cmd.vlan = 11
http.json_dump_post(
testagent.build_http_path(host.managementIp_,
host_plugin.CREATE_VLAN_DEVICE_PATH),
cmd)
cmd.vlan = public_l2_vlan
http.json_dump_post(
testagent.build_http_path(host.managementIp_,
host_plugin.CREATE_VLAN_DEVICE_PATH),
cmd)
test_lib.setup_plan.execute_plan_without_deploy_test_agent()
if test_lib.scenario_config != None and test_lib.scenario_file != None and os.path.exists(
test_lib.scenario_file):
mn_ips = deploy_operations.get_nodes_from_scenario_file(
test_lib.all_scenario_config, test_lib.scenario_file,
test_lib.deploy_config)
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s '%s'" % (EXTRA_SUITE_SETUP_SCRIPT, mn_ips))
elif os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s" % (EXTRA_SUITE_SETUP_SCRIPT))
deploy_operations.deploy_initial_database(test_lib.deploy_config,
test_lib.all_scenario_config,
test_lib.scenario_file)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
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)
bss = res_ops.query_resource(res_ops.BACKUP_STORAGE)
bs = bss[0]
test_util.test_pass('Suite Setup Success')
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
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 error_cleanup():
global delete_policy
test_lib.lib_set_delete_policy('vm', delete_policy)
global vm
if vm:
vm.destroy()
def error_cleanup():
test_lib.lib_error_cleanup(test_obj_dict)
os.system('rm -f %s' % test_image)
test_lib.lib_set_delete_policy('image', delete_policy)
def env_recover():
global delete_policy1
test_lib.lib_set_delete_policy('vm', delete_policy1)
def test():
if test_lib.scenario_config != None and test_lib.scenario_file != None and not os.path.exists(test_lib.scenario_file):
scenario_operations.deploy_scenario(test_lib.all_scenario_config, test_lib.scenario_file, test_lib.deploy_config)
test_util.test_skip('Suite Setup Success')
if test_lib.scenario_config != None and test_lib.scenario_destroy != None:
scenario_operations.destroy_scenario(test_lib.all_scenario_config, test_lib.scenario_destroy)
nic_name = "eth0"
if test_lib.scenario_config != None and test_lib.scenario_file != None and os.path.exists(test_lib.scenario_file):
nic_name = "zsn0"
linux.create_vlan_eth(nic_name, 1010)
linux.create_vlan_eth(nic_name, 1011)
#This vlan creation is not a must, if testing is under nested virt env. But it is required on physical host without enough physcial network devices and your test execution machine is not the same one as Host machine.
#linux.create_vlan_eth("eth0", 10, "10.0.0.200", "255.255.255.0")
#linux.create_vlan_eth("eth0", 11, "10.0.1.200", "255.255.255.0")
#no matter if current host is a ZStest host, we need to create 2 vlan devs for future testing connection for novlan test cases.
linux.create_vlan_eth(nic_name, 10)
linux.create_vlan_eth(nic_name, 11)
#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()
test_lib.setup_plan.deploy_test_agent()
cmd = host_plugin.CreateVlanDeviceCmd()
hosts = test_lib.lib_get_all_hosts_from_plan()
if type(hosts) != type([]):
hosts = [hosts]
for host in hosts:
cmd.ethname = nic_name
cmd.vlan = 10
http.json_dump_post(testagent.build_http_path(host.managementIp_, host_plugin.CREATE_VLAN_DEVICE_PATH), cmd)
cmd.vlan = 11
http.json_dump_post(testagent.build_http_path(host.managementIp_, host_plugin.CREATE_VLAN_DEVICE_PATH), cmd)
test_lib.setup_plan.execute_plan_without_deploy_test_agent()
conf_ops.change_global_config("applianceVm", "agent.deployOnStart", 'true')
if os.path.exists(EXTRA_SUITE_SETUP_SCRIPT):
os.system("bash %s" % EXTRA_SUITE_SETUP_SCRIPT)
deploy_operations.deploy_initial_database(test_lib.deploy_config, test_lib.all_scenario_config, test_lib.scenario_file)
for host in hosts:
os.system("bash %s %s" % (EXTRA_HOST_SETUP_SCRIPT, host.managementIp_))
test_util.test_dsc("create vpc vrouter")
vr = test_stub.create_vpc_vrouter()
test_util.test_dsc("Try to create one vm in random L3 not attached")
with test_lib.expected_failure("create one vm in random L3 not attached", Exception):
test_stub.create_vm_with_random_offering(vm_name='vpc_vm1', l3_name=random.choice(test_stub.L3_SYSTEM_NAME_LIST))
test_util.test_dsc("attach vpc l3 to vpc vrouter")
test_stub.attach_l3_to_vpc_vr(vr, test_stub.L3_SYSTEM_NAME_LIST)
test_util.test_dsc("create cloud router")
vm1 = test_stub.create_vlan_vm(os.environ.get('l3NoVlanNetworkName2'))
test_obj_dict.add_vm(vm1)
vm1.clean()
test_util.test_dsc("create load balance")
l3_public_name = os.environ.get('l3PublicNetworkName')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_public_name).uuid
vip = test_stub.create_vip('vip_for_lb_test', l3_net_uuid)
test_obj_dict.add_vip(vip)
lb = zstack_lb_header.ZstackTestLoadBalancer()
lb.create('autoscaling lb test', vip.get_vip().uuid)
test_obj_dict.add_load_balancer(lb)
lb_creation_option = test_lib.lib_create_lb_listener_option('check vm http healthy','tcp',22,80)
lbl = lb.create_listener(lb_creation_option)
delete_policy = test_lib.lib_set_delete_policy('vm', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('volume', 'Direct')
delete_policy = test_lib.lib_set_delete_policy('image', 'Direct')
# 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_util.test_pass('Suite Setup Success')
def test():
global vcenter_uuid1
global vcenter_uuid2
global mevoco1_ip
global mevoco2_ip
global img_uuid
global delete_policy1
global delete_policy2
print os.environ
vcenter1_name = os.environ['vcenter2_name']
vcenter1_domain_name = os.environ['vcenter2_ip']
vcenter1_username = os.environ['vcenter2_domain_name']
vcenter1_password = os.environ['vcenter2_password']
sync_image_url = os.environ['vcenter2_sync_image_url']
image_name = os.environ['vcenter2_sync_image_name']
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
delete_policy1 = test_lib.lib_set_delete_policy('image', 'Delay')
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name,
vcenter1_username, vcenter1_password, True,
zone_uuid)
vcenter_uuid1 = inv.uuid
if vcenter_uuid1 == None:
test_util.test_fail("vcenter_uuid is None")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
delete_policy2 = test_lib.lib_set_delete_policy('image', 'Delay')
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name,
vcenter1_username, vcenter1_password, True,
zone_uuid)
vcenter_uuid2 = inv.uuid
if vcenter_uuid2 == None:
test_util.test_fail("vcenter_uuid is None")
#bs_cond = res_ops.gen_query_conditions("name", '=', "vCenter[vm-center]")
bs_cond = res_ops.gen_query_conditions("type", '=', "VCenter")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, \
None, fields=['uuid'])
if not bss:
test_util.test_skip("not find available backup storage. Skip test")
#add sync image in mevoco2
image_option = test_util.ImageOption()
image_option.set_name(image_name)
#image_option.set_mediaType('RootVolumeTemplate')
image_option.set_format('vmtx')
image_option.set_system_tags('vcenter::datacenter::datacenter1')
#image_option.set_url(os.environ.get(sync_image_url))
image_option.set_url(sync_image_url)
image_option.set_backup_storage_uuid_list([bss[0].uuid])
new_image = zstack_image_header.ZstackTestImage()
new_image.set_creation_option(image_option)
#if a error happens here, check whether the image with the same name is already
#exist in vcenter, which is also raise exception about can't download on all backup storage
test_util.test_logger("add image from url:%s" % (sync_image_url))
new_image.add_root_volume_template()
#reconnect vcenter and check newly add image in mevoco1
test_util.test_logger("check image sync from mevoco1")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
bs_cond = res_ops.gen_query_conditions("type", '=', "VCenter")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE,
bs_cond,
None,
fields=['uuid'])
bs_ops.reconnect_backup_storage(bss[0].uuid)
image_cond = res_ops.gen_query_conditions("name", '=', image_name)
img_inv = res_ops.query_resource_fields(res_ops.IMAGE,
image_cond,
None,
fields=['uuid'])[0]
img_uuid = img_inv.uuid
if not img_uuid:
test_util.test_fail("local woodpecker image uuid is null")
#delete image in mevoco2
test_util.test_logger("delete image from mevoco2")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
image_cond = res_ops.gen_query_conditions("name", '=', image_name)
img_inv = res_ops.query_resource_fields(res_ops.IMAGE,
image_cond,
None,
fields=['uuid'])[0]
img_uuid = img_inv.uuid
img_ops.delete_image(img_uuid)
img_ops.expunge_image(img_uuid)
#check image in mevoco1
test_util.test_logger("check image delete sync from mevoco1")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
bs_cond = res_ops.gen_query_conditions("type", '=', "VCenter")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE,
bs_cond,
None,
fields=['uuid'])
bs_ops.reconnect_backup_storage(bss[0].uuid)
image_cond = res_ops.gen_query_conditions("name", '=', image_name)
#img_inv = res_ops.query_resource_fields(res_ops.IMAGE, image_cond, None, fields=['uuid'])[0]
#img_uuid = img_inv.uuid
img_inv = res_ops.query_resource_fields(res_ops.IMAGE,
image_cond,
None,
fields=['uuid'])
if img_inv:
test_util.test_fail(
"local woodpecker image is not deleted as expected")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
test_lib.lib_set_delete_policy('image', delete_policy2)
if vcenter_uuid2:
vct_ops.delete_vcenter(vcenter_uuid2)
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
test_lib.lib_set_delete_policy('image', delete_policy1)
if vcenter_uuid1:
vct_ops.delete_vcenter(vcenter_uuid1)
test_util.test_pass("vcenter sync image test passed.")
def set_delete_policy(self, policy):
test_lib.lib_set_delete_policy(category = 'vm', value = policy)
super(ZstackTestVm, self).set_delete_policy(policy)
def test():
global vcenter_uuid1
global vcenter_uuid2
global mevoco1_ip
global mevoco2_ip
global img_uuid
global delete_policy1
global delete_policy2
print os.environ
vcenter1_name = os.environ['vcenter2_name']
vcenter1_domain_name = os.environ['vcenter2_ip']
vcenter1_username = os.environ['vcenter2_domain_name']
vcenter1_password = os.environ['vcenter2_password']
sync_image_url = os.environ['vcenter2_sync_image_url']
image_name = os.environ['vcenter2_sync_image_name']
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
delete_policy1 = test_lib.lib_set_delete_policy('image', 'Delay')
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name, vcenter1_username, vcenter1_password, True, zone_uuid)
vcenter_uuid1 = inv.uuid
if vcenter_uuid1 == None:
test_util.test_fail("vcenter_uuid is None")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
delete_policy2 = test_lib.lib_set_delete_policy('image', 'Delay')
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name, vcenter1_username, vcenter1_password, True, zone_uuid)
vcenter_uuid2 = inv.uuid
if vcenter_uuid2 == None:
test_util.test_fail("vcenter_uuid is None")
#bs_cond = res_ops.gen_query_conditions("name", '=', "vCenter[vm-center]")
bs_cond = res_ops.gen_query_conditions("type", '=', "VCenter")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, \
None, fields=['uuid'])
if not bss:
test_util.test_skip("not find available backup storage. Skip test")
#add sync image in mevoco2
image_option = test_util.ImageOption()
image_option.set_name(image_name)
#image_option.set_mediaType('RootVolumeTemplate')
image_option.set_format('vmtx')
image_option.set_system_tags('vcenter::datacenter::datacenter1')
#image_option.set_url(os.environ.get(sync_image_url))
image_option.set_url(sync_image_url)
image_option.set_backup_storage_uuid_list([bss[0].uuid])
new_image = zstack_image_header.ZstackTestImage()
new_image.set_creation_option(image_option)
#if a error happens here, check whether the image with the same name is already
#exist in vcenter, which is also raise exception about can't download on all backup storage
test_util.test_logger("add image from url:%s" %(sync_image_url))
new_image.add_root_volume_template()
#reconnect vcenter and check newly add image in mevoco1
test_util.test_logger("check image sync from mevoco1")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
bs_cond = res_ops.gen_query_conditions("type", '=', "VCenter")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, None, fields=['uuid'])
bs_ops.reconnect_backup_storage(bss[0].uuid)
image_cond = res_ops.gen_query_conditions("name", '=', image_name)
img_inv = res_ops.query_resource_fields(res_ops.IMAGE, image_cond, None, fields=['uuid'])[0]
img_uuid = img_inv.uuid
if not img_uuid:
test_util.test_fail("local woodpecker image uuid is null")
#delete image in mevoco2
test_util.test_logger("delete image from mevoco2")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
image_cond = res_ops.gen_query_conditions("name", '=', image_name)
img_inv = res_ops.query_resource_fields(res_ops.IMAGE, image_cond, None, fields=['uuid'])[0]
img_uuid = img_inv.uuid
img_ops.delete_image(img_uuid)
img_ops.expunge_image(img_uuid)
#check image in mevoco1
test_util.test_logger("check image delete sync from mevoco1")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
bs_cond = res_ops.gen_query_conditions("type", '=', "VCenter")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, None, fields=['uuid'])
bs_ops.reconnect_backup_storage(bss[0].uuid)
image_cond = res_ops.gen_query_conditions("name", '=', image_name)
#img_inv = res_ops.query_resource_fields(res_ops.IMAGE, image_cond, None, fields=['uuid'])[0]
#img_uuid = img_inv.uuid
img_inv = res_ops.query_resource_fields(res_ops.IMAGE, image_cond, None, fields=['uuid'])
if img_inv:
test_util.test_fail("local woodpecker image is not deleted as expected")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
test_lib.lib_set_delete_policy('image', delete_policy2)
if vcenter_uuid2:
vct_ops.delete_vcenter(vcenter_uuid2)
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
test_lib.lib_set_delete_policy('image', delete_policy1)
if vcenter_uuid1:
vct_ops.delete_vcenter(vcenter_uuid1)
test_util.test_pass("vcenter sync image test passed.")
