def test():
global volume_offering_uuid
test_util.test_dsc('Test VM data volume bandwidth QoS by 20MB')
#unit is KB
write_bandwidth = 5*1024*1024
new_volume_offering = test_lib.lib_create_disk_offering(write_bandwidth = write_bandwidth)
volume_offering_uuid = new_volume_offering.uuid
vm = test_stub.create_vm(vm_name='vm_volume_qos', disk_offering_uuids = [volume_offering_uuid])
vm.check()
test_obj_dict.add_vm(vm)
vm_inv = vm.get_vm()
cond = res_ops.gen_query_conditions("vmInstanceUuid", '=', vm_inv.uuid)
cond = res_ops.gen_query_conditions("type", '=', 'Data', cond)
volume_uuid = res_ops.query_resource(res_ops.VOLUME, cond)[0].uuid
test_lib.lib_mkfs_for_volume(volume_uuid, vm_inv)
path = '/mnt'
user_name = 'root'
user_password = '******'
os.system("sshpass -p '%s' ssh %s@%s 'mount /dev/vdb1 %s'"%(user_password, user_name, vm_inv.vmNics[0].ip, path))
vm.check()
test_stub.make_ssh_no_password(vm_inv)
test_stub.install_fio(vm_inv)
if vm_ops.get_vm_disk_qos(test_lib.lib_get_data_volumes(vm_inv)[0].uuid).volumeBandwidthRead != -1 and \
vm_ops.get_vm_disk_qos(test_lib.lib_get_data_volumes(vm_inv)[0].uuid).volumeBandwidthWrite != write_bandwidth:
test_util.test_fail('Retrieved disk qos not match')
test_stub.test_fio_bandwidth(vm_inv, write_bandwidth, path)
if test_stub.test_fio_bandwidth(vm_inv, write_bandwidth/2, '/dev/vdb', raise_exception=False):
test_util.test_fail('disk read qos is not expected to have limit as only write qos was set')
vol_ops.delete_disk_offering(volume_offering_uuid)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('VM data volume write QoS Test Pass')
def test():
global volume_offering_uuid
test_util.test_dsc('Test VM data volume bandwidth QoS by 20MB')
#unit is KB
volume_bandwidth = 5*1024*1024
new_volume_offering = test_lib.lib_create_disk_offering(volume_bandwidth = volume_bandwidth)
volume_offering_uuid = new_volume_offering.uuid
vm = test_stub.create_vm(vm_name = 'vm_volume_qos', disk_offering_uuids = [volume_offering_uuid])
vm.check()
test_obj_dict.add_vm(vm)
vm_inv = vm.get_vm()
cond = res_ops.gen_query_conditions("vmInstanceUuid", '=', vm_inv.uuid)
cond = res_ops.gen_query_conditions("type", '=', 'Data', cond)
volume_uuid = res_ops.query_resource(res_ops.VOLUME, cond)[0].uuid
test_lib.lib_mkfs_for_volume(volume_uuid, vm_inv)
path = '/mnt'
user_name = 'root'
user_password = '******'
os.system("sshpass -p '%s' ssh %s@%s 'mount /dev/vdb1 %s'"%(user_password, user_name, vm_inv.vmNics[0].ip, path))
vm.check()
test_stub.make_ssh_no_password(vm_inv)
test_stub.install_fio(vm_inv)
test_stub.test_fio_bandwidth(vm_inv, volume_bandwidth, path)
vol_ops.delete_disk_offering(volume_offering_uuid)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('VM data volume QoS Test Pass')
def error_cleanup():
global volume_offering_uuid
test_lib.lib_error_cleanup(test_obj_dict)
try:
vol_ops.delete_disk_offering(volume_offering_uuid)
except:
pass
def test():
global volume_offering_uuid
test_util.test_dsc('Test VM data volume bandwidth QoS by 20MB')
#unit is KB
volume_bandwidth = 5 * 1024 * 1024
new_volume_offering = test_lib.lib_create_disk_offering(
volume_bandwidth=volume_bandwidth)
volume_offering_uuid = new_volume_offering.uuid
vm = test_stub.create_vm(vm_name='vm_volume_qos',
disk_offering_uuids=[volume_offering_uuid])
test_obj_dict.add_vm(vm)
vm_inv = vm.get_vm()
cond = res_ops.gen_query_conditions("vmInstanceUuid", '=', vm_inv.uuid)
cond = res_ops.gen_query_conditions("type", '=', 'Data', cond)
volume_uuid = res_ops.query_resource(res_ops.VOLUME, cond)[0].uuid
test_lib.lib_mkfs_for_volume(volume_uuid, vm_inv)
path = '/mnt'
user_name = 'root'
user_password = '******'
os.system("sshpass -p '%s' ssh %s@%s 'mount /dev/vdb1 %s'" %
(user_password, user_name, vm_inv.vmNics[0].ip, path))
vm.check()
test_stub.make_ssh_no_password(vm_inv)
test_stub.install_fio(vm_inv)
test_stub.test_fio_bandwidth(vm_inv, volume_bandwidth, path)
vol_ops.delete_disk_offering(volume_offering_uuid)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('VM data volume QoS Test Pass')
def error_cleanup():
global vm, all_volume_offering_uuid, rw_volume_offering_uuid, all_volume_uuid, rw_volume_uuid, test_account_session, instance_offering_uuid
if vm:
vm.destroy(test_account_session)
vol_ops.delete_disk_offering(all_volume_offering_uuid)
vol_ops.delete_disk_offering(rw_volume_offering_uuid)
vol_ops.delete_volume(all_volume_uuid, test_account_session)
vol_ops.delete_volume(rw_volume_uuid, test_account_session)
acc_ops.delete_account(test_account_uuid)
vm_ops.delete_instance_offering(instance_offering_uuid)
def test():
global volume_offering_uuid
test_util.test_dsc('Test VM disk bandwidth QoS by 20MB')
#unit is KB
volume_bandwidth = 5 * 1024 * 1024
new_volume_offering = test_lib.lib_create_disk_offering(
volume_bandwidth=volume_bandwidth)
volume_offering_uuid = new_volume_offering.uuid
vm = test_stub.create_vm(vm_name='vm_volume_qos',
disk_offering_uuids=[volume_offering_uuid])
test_obj_dict.add_vm(vm)
vm_inv = vm.get_vm()
cond = res_ops.gen_query_conditions("vmInstanceUuid", '=', vm_inv.uuid)
cond = res_ops.gen_query_conditions("type", '=', 'Data', cond)
volume_uuid = res_ops.query_resource(res_ops.VOLUME, cond)[0].uuid
test_lib.lib_mkfs_for_volume(volume_uuid, vm_inv)
path = '/mnt'
user_name = 'root'
user_password = '******'
os.system("sshpass -p '%s' ssh %s@%s 'mount /dev/vdb1 %s'" %
(user_password, user_name, vm_inv.vmNics[0].ip, path))
test_stub.make_ssh_no_password(vm_inv)
test_stub.install_fio(vm_inv)
test_stub.test_fio_bandwidth(vm_inv, volume_bandwidth, path)
if vm_ops.get_vm_disk_qos(test_lib.lib_get_data_volumes(vm_inv)
[0].uuid).volumeBandwidth != volume_bandwidth:
test_util.test_fail('Retrieved disk qos not match')
vm_ops.set_vm_disk_qos(
test_lib.lib_get_data_volumes(vm_inv)[0].uuid, volume_bandwidth / 2)
test_stub.test_fio_bandwidth(vm_inv, volume_bandwidth / 2, path)
vm_ops.del_vm_disk_qos(test_lib.lib_get_data_volumes(vm_inv)[0].uuid)
if test_stub.test_fio_bandwidth(vm_inv,
volume_bandwidth / 2,
path,
raise_exception=False):
test_util.test_fail(
'disk qos is not expected to have limit after qos setting is deleted'
)
vol_ops.delete_disk_offering(volume_offering_uuid)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('VM data volume QoS Test Pass')
def test():
test_util.test_logger("start data volume billing")
test_util.test_logger("create many data volume billing instantiation")
bill_datavolume = test_stub.DataVolumeBilling()
test_util.test_logger("loop 400 to create data volume billing")
test_stub.create_option_billing(bill_datavolume, count)
test_util.test_logger("verify data volume billing instantiation if is right,and then delete all")
test_stub.verify_option_billing(count)
test_util.test_logger("create data volume billing instantiation")
bill_datavolume.set_timeUnit("s")
bill_datavolume.set_price("1")
bill_datavolume.set_resourceUnit("M")
bill_datavolume.create_resource_type()
test_util.test_logger("create vm instance")
global vm
vm = test_stub.create_vm_billing("test_vmm", test_stub.set_vm_resource()[0], None,\
test_stub.set_vm_resource()[1], test_stub.set_vm_resource()[2])
disk_offering_uuid = bill_datavolume.create_disk_offer(1048576,"test_disk").uuid
bill_datavolume.create_volume_and_attach_vmm(disk_offering_uuid,"test_volume",vm)
test_util.test_logger("antony @@@@debug %s" %(bill_datavolume.disk.get_name()))
dataVolumeSize = res_ops.query_resource(res_ops.DISK_OFFERING, \
res_ops.gen_query_conditions('name', '=',\
bill_datavolume.disk.get_name()))[0].diskSize / 1024 / float(1024)
test_util.test_logger("antony @@@@debug %s" %(dataVolumeSize))
time.sleep(1)
if bill_datavolume.get_price_total().total < dataVolumeSize * int(bill_datavolume.get_price()):
test_util.test_fail("calculate data volume cost fail,actual result is %s" %(bill_datavolume.get_price_total().total))
vm.clean()
time.sleep(1)
test_util.test_logger("delete data volume")
bill_datavolume.volume.clean()
test_util.test_logger("delete disk offering")
vol_ops.delete_disk_offering(disk_offering_uuid)
test_util.test_logger("delete bill resource")
bill_datavolume.delete_resource()
test_util.test_pass("check data volume billing pass")
def error_cleanup():
global vm, all_volume_offering_uuid, rw_volume_offering_uuid, all_volume_uuid, rw_volume_uuid, volume_offering_3, volume_offering_4, volume_offering_5, volume_offering_6
global instance_offering_uuid, volume_uuid_3, volume_uuid_4, volume_uuid_5, volume_uuid_6
if vm:
vm.destroy()
vol_ops.delete_disk_offering(all_volume_offering_uuid)
vol_ops.delete_disk_offering(rw_volume_offering_uuid)
vol_ops.delete_disk_offering(volume_offering_3.uuid)
vol_ops.delete_disk_offering(volume_offering_4.uuid)
vol_ops.delete_disk_offering(volume_offering_5.uuid)
vol_ops.delete_disk_offering(volume_offering_6.uuid)
vol_ops.delete_volume(all_volume_uuid)
vol_ops.delete_volume(rw_volume_uuid)
vol_ops.delete_volume(volume_uuid_3)
vol_ops.delete_volume(volume_uuid_4)
vol_ops.delete_volume(volume_uuid_5)
vol_ops.delete_volume(volume_uuid_6)
vm_ops.delete_instance_offering(instance_offering_uuid)
def test():
data_volume_size = 10737418240
disk_offering_option = test_util.DiskOfferingOption()
disk_offering_option.set_name('root-disk-iso')
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)
cpuNum = 1
cpuSpeed = 16
memorySize = 536870912
name = 'vm-offering-iso'
new_offering_option = test_util.InstanceOfferingOption()
new_offering_option.set_cpuNum(cpuNum)
new_offering_option.set_cpuSpeed(cpuSpeed)
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)
img_option = test_util.ImageOption()
img_option.set_name('image-iso')
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [],
None)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
img_option.set_url(
'http://172.20.1.15:7480/iso/iso_for_install_vm_test.iso')
image_inv = img_ops.add_iso_template(img_option)
image_uuid = image_inv.uuid
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
test_obj_dict.add_image(image)
l3_name = os.environ.get('l3PublicNetworkName')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
root_disk_uuid = data_volume_offering.uuid
vm = test_stub.create_vm_with_iso([l3_net_uuid], image_uuid, 'vm-iso',
root_disk_uuid, new_offering.uuid)
test_obj_dict.add_vm(vm)
test_util.test_dsc('wait for iso installation')
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
test_lib.lib_wait_target_up(vm_ip, '22', 2400)
cmd = '[ -e /root ] && echo yes || echo no'
ssh_num = 0
ssh_ok = 0
while ssh_num <= 5 and ssh_ok == 0:
rsp = test_lib.lib_execute_ssh_cmd(vm_ip, 'root', 'password', cmd, 180)
if rsp == False:
time.sleep(30)
else:
ssh_ok = 1
break
ssh_num = ssh_num + 1
if ssh_ok == 0:
test_util.test_fail('fail to ssh to VM')
vm.check()
vm.destroy()
test_obj_dict.rm_vm(vm)
image.delete()
test_obj_dict.rm_image(image)
vol_ops.delete_disk_offering(root_disk_uuid)
test_obj_dict.rm_disk_offering(data_volume_offering)
vm_ops.delete_instance_offering(new_offering.uuid)
test_obj_dict.rm_instance_offering(new_offering)
test_util.test_pass('Create VM with ISO Installation Test Success')
def test():
test_util.test_logger("start check vm lifecycle")
test_util.test_logger("create data volume billing")
bill_datavolume = test_stub.DataVolumeBilling()
bill_datavolume.set_timeUnit("s")
bill_datavolume.set_price("1")
bill_datavolume.set_resourceUnit("M")
bill_datavolume.create_resource_type()
test_util.test_logger("create vm instance")
global vm
vm = test_stub.create_vm_billing("test_vmm", test_stub.set_vm_resource()[0], None,\
test_stub.set_vm_resource()[1], test_stub.set_vm_resource()[2])
disk_offering_uuid = bill_datavolume.create_disk_offer(1048576,"test_disk").uuid
bill_datavolume.create_volume_and_attach_vmm(disk_offering_uuid,"test_volume",vm)
test_util.test_logger("antony @@@@debug %s" %(bill_datavolume.disk.get_name()))
dataVolumeSize = res_ops.query_resource(res_ops.DISK_OFFERING, \
res_ops.gen_query_conditions('name', '=',\
bill_datavolume.disk.get_name()))[0].diskSize / 1024 / float(1024)
time.sleep(1)
test_util.test_logger("verify calculate if right is")
if bill_datavolume.get_price_total().total < dataVolumeSize * int(bill_datavolume.get_price()):
test_util.test_fail("calculate data volume cost fail,actual result is %s" \
%(bill_datavolume.get_price_total().total))
test_util.test_logger("stop vm instance")
vm.stop()
bill_datavolume.compare("stop")
test_util.test_logger("destory vm instance")
vm.destroy()
bill_datavolume.compare("destory")
test_util.test_logger("recover vm instance")
vm.recover()
vm.start()
bill_datavolume.compare("recover")
test_util.test_logger("clean vm instance")
vm.clean()
bill_datavolume.compare("clean")
test_util.test_logger("destory volume")
bill_datavolume.volume.delete()
bill_datavolume.compare("delete_volume")
test_util.test_logger("expunge volume")
bill_datavolume.volume.expunge()
bill_datavolume.compare("volume_clean")
test_util.test_logger("delete disk offering")
vol_ops.delete_disk_offering(disk_offering_uuid)
test_util.test_logger("delete public ip resource")
resourcePrices = test_stub.query_resource_price()
for resource_price in resourcePrices:
test_stub.delete_price(resource_price.uuid)
test_util.test_pass("check vm lifecycle with public ip billing pass")
def error_cleanup():
test_lib.lib_error_cleanup(test_obj_dict)
if volume_offering_uuid:
vol_ops.delete_disk_offering(volume_offering_uuid)
def test():
global image
global test_obj_dict
#run condition
hosts = res_ops.query_resource(res_ops.HOST)
if len(hosts) <= 1:
test_util.test_skip(
"skip for host_num is not satisfy condition host_num>1")
bs_cond = res_ops.gen_query_conditions("status", '=', "Connected")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE,
bs_cond,
None,
fields=['uuid'])
#create disk offering
data_volume_size = 10737418240
disk_offering_option = test_util.DiskOfferingOption()
disk_offering_option.set_name('root-disk-iso')
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)
#create instance offering
cpuNum = 2
memorySize = 1024 * 1024 * 1024
name = 'iso-vm-offering'
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)
#add iso
img_option = test_util.ImageOption()
img_option.set_name('iso1')
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [],
None)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
img_option.set_url(os.environ.get('isoForVmUrl'))
image_inv = img_ops.add_iso_template(img_option)
image_uuid = image_inv.uuid
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
test_obj_dict.add_image(image)
#create vm by iso
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
root_disk_uuid = data_volume_offering.uuid
vm = test_stub.create_vm_with_iso([l3_net_uuid], image_uuid, 'iso-vm',
root_disk_uuid, new_offering.uuid)
host_ip = test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp
test_obj_dict.add_vm(vm)
#check vm
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
#cmd ='[ -e /root ]'
#ssh_timeout = test_lib.SSH_TIMEOUT
#test_lib.SSH_TIMEOUT = 3600
test_lib.lib_set_vm_host_l2_ip(vm_inv)
test_lib.lib_wait_target_up(vm.get_vm().vmNics[0].ip, 22, 1800)
#if not test_lib.lib_ssh_vm_cmd_by_agent_with_retry(host_ip, vm_ip, 'root', 'password', cmd):
# test_lib.SSH_TIMEOUT = ssh_timeout
# test_util.test_fail("iso has been failed to installed.")
#test_lib.SSH_TIMEOUT = ssh_timeout
#delete iso
image.delete()
test_obj_dict.rm_image(image)
#expunge iso
image.expunge()
#detach iso
img_ops.detach_iso(vm.vm.uuid)
#vm ops test
test_stub.vm_ops_test(vm, "VM_TEST_REIMAGE")
vm.destroy()
vol_ops.delete_disk_offering(root_disk_uuid)
vm_ops.delete_instance_offering(new_offering.uuid)
test_obj_dict.rm_vm(vm)
test_obj_dict.rm_disk_offering(data_volume_offering)
test_obj_dict.rm_instance_offering(new_offering)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Create VM Image in Image Store Success')
def test():
global ssh_timeout
data_volume_size = 10737418240
disk_offering_option = test_util.DiskOfferingOption()
disk_offering_option.set_name('root-disk-iso')
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)
cpuNum = 1
memorySize = 536870912
name = 'vm-offering-iso'
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)
cond = res_ops.gen_query_conditions('name', '=', 'image-iso')
iso_image = res_ops.query_resource(res_ops.IMAGE, cond)
if not iso_image:
img_option = test_util.ImageOption()
img_option.set_name('image-iso')
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [], None)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
img_option.set_url(os.environ.get('imageServer')+'/iso/iso_for_install_vm_test.iso')
image_inv = img_ops.add_iso_template(img_option)
image_uuid = image_inv.uuid
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
test_obj_dict.add_image(image)
else:
image_uuid = iso_image[0].uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
root_disk_uuid = data_volume_offering.uuid
vm = test_stub.create_vm_with_iso([l3_net_uuid], image_uuid, 'vm-iso', root_disk_uuid, new_offering.uuid, system_tags=["cdroms::%s::Empty::Empty" % (image_uuid)])
host_ip = test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp
test_obj_dict.add_vm(vm)
test_util.test_dsc('wait for iso installation')
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
#test_lib.lib_wait_target_up(vm_ip, '22', 2400)
#vm.check()
#cmd ='[ -e /root ] && echo yes || echo no'
cmd ='[ -e /root ]'
#ssh_num = 0
#ssh_ok = 0
#while ssh_num <= 5 and ssh_ok == 0 :
# rsp = test_lib.lib_execute_ssh_cmd(vm_ip, 'root', 'password', cmd, 180)
# if rsp == False:
# time.sleep(30)
# else:
# ssh_ok = 1
# break
# ssh_num = ssh_num + 1
#if ssh_ok == 0:
# test_util.test_fail('fail to ssh to VM')
ssh_timeout = test_lib.SSH_TIMEOUT
test_lib.SSH_TIMEOUT = 3600
test_lib.lib_set_vm_host_l2_ip(vm_inv)
if not test_lib.lib_ssh_vm_cmd_by_agent_with_retry(host_ip, vm_ip, 'root', 'password', cmd):
test_lib.SSH_TIMEOUT = ssh_timeout
test_util.test_fail("iso has not been failed to installed.")
cmd_cdrom = 'ls /dev/ | grep sr | wc -l'
cdroms = test_lib.lib_ssh_vm_cmd_by_agent_with_retry(host_ip, vm_ip, 'root', 'password', cmd_cdrom)
assert str(cdroms).strip() == '3'
test_lib.SSH_TIMEOUT = ssh_timeout
vm.destroy()
test_obj_dict.rm_vm(vm)
# image.delete()
# test_obj_dict.rm_image(image)
vol_ops.delete_disk_offering(root_disk_uuid)
test_obj_dict.rm_disk_offering(data_volume_offering)
vm_ops.delete_instance_offering(new_offering.uuid)
test_obj_dict.rm_instance_offering(new_offering)
test_util.test_pass('Create VM with ISO Installation Test Success')
def test():
global vm, session_uuid
global all_volume_offering_uuid, rw_volume_offering_uuid, instance_offering_uuid
global test_account_uuid
test_util.test_dsc('Test normal account change the qos network and volume ')
#create normal account
test_util.test_dsc('create normal account')
account_name = 'a'
account_pass = hashlib.sha512(account_name).hexdigest()
test_account = acc_ops.create_normal_account(account_name, account_pass)
test_account_uuid = test_account.uuid
test_account_session = acc_ops.login_by_account(account_name, account_pass)
#create disk offering
test_util.test_dsc('create disk offering')
name_all = 'all_disk_offering'
volume_bandwidth = 30*1024*1024
all_volume_offering = test_lib.lib_create_disk_offering(name = name_all, volume_bandwidth = volume_bandwidth)
all_volume_offering_uuid = all_volume_offering.uuid
name_rw = 'rw_disk_offering'
volume_read_bandwidth = 90*1024*1024
volume_write_bandwidth = 100*1024*1024
rw_volume_offering = test_lib.lib_create_disk_offering(name = name_rw, read_bandwidth = volume_read_bandwidth, write_bandwidth = volume_write_bandwidth)
rw_volume_offering_uuid = rw_volume_offering.uuid
#create instance offering
test_util.test_dsc('create instance offering')
read_bandwidth = 50*1024*1024
write_bandwidth = 60*1024*1024
net_outbound_bandwidth = 70*1024*1024
net_inbound_bandwidth = 80*1024*1024
new_instance_offering = test_lib.lib_create_instance_offering(read_bandwidth = read_bandwidth, write_bandwidth=write_bandwidth, net_outbound_bandwidth = net_outbound_bandwidth, net_inbound_bandwidth = net_inbound_bandwidth)
instance_offering_uuid = new_instance_offering.uuid
#share admin resoure to normal account
test_util.test_dsc('share admin resoure to normal account')
test_stub.share_admin_resource([test_account_uuid])
acc_ops.share_resources([test_account_uuid], [all_volume_offering_uuid, rw_volume_offering_uuid])
#create vm with 2 data volumes
test_util.test_dsc('create vm with volumes qos by normal account a')
l3net_uuid = res_ops.get_resource(res_ops.L3_NETWORK, session_uuid = test_account_session)[0].uuid
cond = res_ops.gen_query_conditions('platform', '=', 'Linux')
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond, session_uuid = test_account_session)[0].uuid
vm_creation_option = test_util.VmOption()
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_l3_uuids([l3net_uuid])
vm = test_stub.create_vm_with_volume(vm_creation_option = vm_creation_option, data_volume_uuids = [all_volume_offering_uuid, rw_volume_offering_uuid], session_uuid = test_account_session)
vm_inv = vm.get_vm()
# get the nic uuid
test_util.test_dsc('get the vm_nic')
l3_uuid = vm_inv.vmNics[0].l3NetworkUuid
vm_nic = test_lib.lib_get_vm_nic_by_l3(vm_inv, l3_uuid)
# get the volume uuid
test_util.test_dsc('get the vm data volumes')
cond1 = res_ops.gen_query_conditions("diskOfferingUuid", '=', all_volume_offering_uuid)
cond2 = res_ops.gen_query_conditions("diskOfferingUuid", '=', rw_volume_offering_uuid)
all_volume_uuid = res_ops.query_resource(res_ops.VOLUME, cond1)[0].uuid
rw_volume_uuid = res_ops.query_resource(res_ops.VOLUME, cond2)[0].uuid
#set root disk qos
test_util.test_dsc('set read*2, read/2, write*2, write/2 and del the root disk read and write qos')
try:
vm_ops.set_vm_disk_qos(test_lib.lib_get_root_volume(vm_inv).uuid, volumeBandwidth = read_bandwidth*2, mode = 'read', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('del the root disk read qos')
try:
vm_ops.del_vm_disk_qos(test_lib.lib_get_root_volume(vm_inv).uuid, mode = 'read', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
vm_ops.set_vm_disk_qos(test_lib.lib_get_root_volume(vm_inv).uuid, volumeBandwidth = read_bandwidth/2, mode = 'read', session_uuid = test_account_session)
test_util.test_dsc('set 2 times the root disk write qos')
try:
vm_ops.set_vm_disk_qos(test_lib.lib_get_root_volume(vm_inv).uuid, volumeBandwidth = write_bandwidth*2, mode = 'write', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('del the root disk write qos')
try:
vm_ops.del_vm_disk_qos(test_lib.lib_get_root_volume(vm_inv).uuid, mode = 'write', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('set below the root disk write qos')
vm_ops.set_vm_disk_qos(test_lib.lib_get_root_volume(vm_inv).uuid, volumeBandwidth = write_bandwidth/2, mode = 'write', session_uuid = test_account_session)
#set data disk all_volume_uuid qos
test_util.test_dsc('set read*2, read/2, write*2, write/2 and del the volume1 disk read and write qos')
try:
vm_ops.set_vm_disk_qos(all_volume_uuid, volumeBandwidth = volume_bandwidth*2, session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('del the data volume qos')
try:
vm_ops.del_vm_disk_qos(all_volume_uuid, session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
vm_ops.set_vm_disk_qos(all_volume_uuid, volumeBandwidth = volume_bandwidth/2, session_uuid = test_account_session)
#set data disk rw_volume_uuid write qos
test_util.test_dsc('set 2 times the data rw_volume_uuid write qos')
try:
vm_ops.set_vm_disk_qos(rw_volume_uuid, volumeBandwidth = volume_write_bandwidth*2, mode = 'write', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('del the data rw_volume_uuid write qos')
try:
vm_ops.del_vm_disk_qos(rw_volume_uuid, mode = 'write', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
vm_ops.set_vm_disk_qos(rw_volume_uuid, volumeBandwidth = volume_write_bandwidth/2, mode = 'write', session_uuid = test_account_session)
#set data disk rw_volume_uuid read qos
test_util.test_dsc('set 2 times the data rw_volume_uuid read qos')
try:
vm_ops.set_vm_disk_qos(rw_volume_uuid, volumeBandwidth = volume_read_bandwidth*2, mode = 'read', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('del the data rw_volume_uuid read qos')
try:
vm_ops.del_vm_disk_qos(rw_volume_uuid, mode = 'read', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
vm_ops.set_vm_disk_qos(rw_volume_uuid, volumeBandwidth = volume_read_bandwidth/2, mode = 'read', session_uuid = test_account_session)
# set the vm nic qos
test_util.test_dsc('set higher than net out and in ')
try:
vm_ops.set_vm_nic_qos(vm_nic.uuid, outboundBandwidth = net_outbound_bandwidth*2, inboundBandwidth = net_inbound_bandwidth*2, session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('set higher than net out and equal in ')
try:
vm_ops.set_vm_nic_qos(vm_nic.uuid, outboundBandwidth = net_outbound_bandwidth*2, inboundBandwidth = net_inbound_bandwidth, session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('del net in ')
try:
vm_ops.del_vm_nic_qos(vm_nic.uuid, direction = 'in', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('del net out ')
try:
vm_ops.del_vm_nic_qos(vm_nic.uuid, direction = 'out', session_uuid = test_account_session)
except:
print "Test results were in line with expectations"
pass
test_util.test_dsc('set equal net out and in ')
try:
vm_ops.set_vm_nic_qos(vm_nic.uuid, outboundBandwidth = net_outbound_bandwidth, inboundBandwidth = net_inbound_bandwidth, session_uuid = test_account_session)
#except:
except Exception as e:
test_util.test_logger(e)
test_util.test_dsc('set below net out and in ')
vm_ops.set_vm_nic_qos(vm_nic.uuid, outboundBandwidth = net_outbound_bandwidth/2, inboundBandwidth = net_inbound_bandwidth/2, session_uuid = test_account_session)
vm.check()
vm.destroy(test_account_session)
vm.check()
vol_ops.delete_disk_offering(all_volume_offering_uuid)
vol_ops.delete_disk_offering(rw_volume_offering_uuid)
vol_ops.delete_volume(all_volume_uuid, test_account_session)
vol_ops.delete_volume(rw_volume_uuid, test_account_session)
acc_ops.delete_account(test_account_uuid)
vm_ops.delete_instance_offering(instance_offering_uuid)
test_util.test_pass('Create VM Test Success')
def test():
#skip ceph in c74
cmd = "cat /etc/redhat-release | grep '7.4'"
mn_ip = res_ops.query_resource(res_ops.MANAGEMENT_NODE)[0].hostName
rsp = test_lib.lib_execute_ssh_cmd(mn_ip, 'root', 'password', cmd, 180)
if rsp != False:
ps = res_ops.query_resource(res_ops.PRIMARY_STORAGE)
for i in ps:
if i.type == 'Ceph':
test_util.test_skip('cannot hotplug iso to the vm in ceph,it is a libvirt bug:https://bugzilla.redhat.com/show_bug.cgi?id=1541702.')
global image
global test_obj_dict
allow_bs_list = [inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE, inventory.CEPH_BACKUP_STORAGE_TYPE]
test_lib.skip_test_when_bs_type_not_in_list(allow_bs_list)
allow_ps_list = [inventory.CEPH_PRIMARY_STORAGE_TYPE, inventory.NFS_PRIMARY_STORAGE_TYPE, 'SharedMountPoint']
test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list)
#run condition
hosts = res_ops.query_resource(res_ops.HOST)
if len(hosts) <= 1:
test_util.test_skip("skip for host_num is not satisfy condition host_num>1")
bs_cond = res_ops.gen_query_conditions("status", '=', "Connected")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, None, fields=['uuid'])
#create disk offering
data_volume_size = 10737418240
disk_offering_option = test_util.DiskOfferingOption()
disk_offering_option.set_name('root-disk-iso')
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)
#create instance offering
cpuNum = 2
memorySize = 1024*1024*1024
name = 'iso-vm-offering'
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)
#add iso
img_option = test_util.ImageOption()
img_option.set_name('iso1')
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [], None)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
img_option.set_url(os.environ.get('isoForVmUrl'))
image_inv = img_ops.add_iso_template(img_option)
image_uuid = image_inv.uuid
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
test_obj_dict.add_image(image)
#create vm by iso
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
root_disk_uuid = data_volume_offering.uuid
vm = test_stub.create_vm_with_iso([l3_net_uuid], image_uuid, 'iso-vm', root_disk_uuid, new_offering.uuid)
host_ip = test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp
test_obj_dict.add_vm(vm)
#check vm
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
#cmd ='[ -e /root ]'
#ssh_timeout = test_lib.SSH_TIMEOUT
#test_lib.SSH_TIMEOUT = 3600
test_lib.lib_set_vm_host_l2_ip(vm_inv)
test_lib.lib_wait_target_up(vm.get_vm().vmNics[0].ip, 22, 1800)
#if not test_lib.lib_ssh_vm_cmd_by_agent_with_retry(host_ip, vm_ip, 'root', 'password', cmd):
# test_lib.SSH_TIMEOUT = ssh_timeout
# test_util.test_fail("iso has been failed to installed.")
#test_lib.SSH_TIMEOUT = ssh_timeout
#clone vm
cloned_vm_name = ['cloned_vm_name']
cloned_vm_obj = vm.clone(cloned_vm_name)[0]
test_obj_dict.add_vm(cloned_vm_obj)
#delete iso
image.delete()
test_obj_dict.rm_image(image)
#vm ops test
test_stub.vm_ops_test(cloned_vm_obj, "VM_TEST_ALL")
#expunge iso
image.expunge()
#detach iso
img_ops.detach_iso(vm.vm.uuid)
#vm ops test
test_stub.vm_ops_test(cloned_vm_obj, "VM_TEST_ALL")
#create image by vm root volume
cloned_vm_img_name = "cloned_vm_image1"
img_option2 = test_util.ImageOption()
img_option2.set_backup_storage_uuid_list([bs_uuid])
img_option2.set_root_volume_uuid(cloned_vm_obj.vm.rootVolumeUuid)
img_option2.set_name(cloned_vm_img_name)
image1 = test_image.ZstackTestImage()
image1.set_creation_option(img_option2)
image1.create()
image1.check()
test_obj_dict.add_image(image1)
bs_list = res_ops.query_resource(res_ops.BACKUP_STORAGE)
if inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE == bs_list[0] and len(bs_list) == 1 :
#export image
image1.export()
#create vm
vm2 = test_stub.create_vm('image-vm', cloned_vm_img_name, l3_name)
#delete image
image1.delete()
test_obj_dict.rm_image(image1)
#vm ops test
test_stub.vm_ops_test(vm2, "VM_TEST_ALL")
#expunge image
image1.expunge()
#vm ops test
test_stub.vm_ops_test(vm2, "VM_TEST_ALL")
vm.destroy()
vm2.destroy()
cloned_vm_obj.destroy()
vol_ops.delete_disk_offering(root_disk_uuid)
vm_ops.delete_instance_offering(new_offering.uuid)
test_obj_dict.rm_vm(vm)
test_obj_dict.rm_disk_offering(data_volume_offering)
test_obj_dict.rm_instance_offering(new_offering)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Create VM Image in Image Store Success')
def test():
global ssh_timeout
data_volume_size = 10737418240
disk_offering_option = test_util.DiskOfferingOption()
disk_offering_option.set_name('root-disk-iso')
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)
cpuNum = 1
memorySize = 536870912
name = 'vm-offering-iso'
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)
img_option = test_util.ImageOption()
img_option.set_name('image-iso')
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [], None)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
img_option.set_url('http://172.20.1.15:7480/iso/iso_for_install_vm_test.iso')
image_inv = img_ops.add_iso_template(img_option)
image_uuid = image_inv.uuid
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
test_obj_dict.add_image(image)
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
root_disk_uuid = data_volume_offering.uuid
vm = test_stub.create_vm_with_iso([l3_net_uuid], image_uuid, 'vm-iso', root_disk_uuid, new_offering.uuid)
host_ip = test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp
test_obj_dict.add_vm(vm)
test_util.test_dsc('wait for iso installation')
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
#test_lib.lib_wait_target_up(vm_ip, '22', 2400)
#vm.check()
#cmd ='[ -e /root ] && echo yes || echo no'
cmd ='[ -e /root ]'
#ssh_num = 0
#ssh_ok = 0
#while ssh_num <= 5 and ssh_ok == 0 :
# rsp = test_lib.lib_execute_ssh_cmd(vm_ip, 'root', 'password', cmd, 180)
# if rsp == False:
# time.sleep(30)
# else:
# ssh_ok = 1
# break
# ssh_num = ssh_num + 1
#if ssh_ok == 0:
# test_util.test_fail('fail to ssh to VM')
ssh_timeout = test_lib.SSH_TIMEOUT
test_lib.SSH_TIMEOUT = 3600
test_lib.lib_set_vm_host_l2_ip(vm_inv)
if not test_lib.lib_ssh_vm_cmd_by_agent_with_retry(host_ip, vm_ip, 'root', 'password', cmd):
test_lib.SSH_TIMEOUT = ssh_timeout
test_util.test_fail("iso has not been failed to installed.")
test_lib.SSH_TIMEOUT = ssh_timeout
vm.destroy()
test_obj_dict.rm_vm(vm)
image.delete()
test_obj_dict.rm_image(image)
vol_ops.delete_disk_offering(root_disk_uuid)
test_obj_dict.rm_disk_offering(data_volume_offering)
vm_ops.delete_instance_offering(new_offering.uuid)
test_obj_dict.rm_instance_offering(new_offering)
test_util.test_pass('Create VM with ISO Installation Test Success')
def test():
data_volume_size = 10737418240
disk_offering_option = test_util.DiskOfferingOption()
disk_offering_option.set_name('root-disk-iso')
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)
cpuNum = 1
cpuSpeed = 16
memorySize = 536870912
name = 'vm-offering-iso'
new_offering_option = test_util.InstanceOfferingOption()
new_offering_option.set_cpuNum(cpuNum)
new_offering_option.set_cpuSpeed(cpuSpeed)
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)
img_option = test_util.ImageOption()
img_option.set_name('image-iso')
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [], None)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
img_option.set_url('http://172.20.1.15:7480/iso/iso_for_install_vm_test.iso')
image_inv = img_ops.add_iso_template(img_option)
image_uuid = image_inv.uuid
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
test_obj_dict.add_image(image)
l3_name = os.environ.get('l3PublicNetworkName')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
root_disk_uuid = data_volume_offering.uuid
vm = test_stub.create_vm_with_iso([l3_net_uuid], image_uuid, 'vm-iso', root_disk_uuid, new_offering.uuid)
test_obj_dict.add_vm(vm)
test_util.test_dsc('wait for iso installation')
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
test_lib.lib_wait_target_up(vm_ip, '22', 2400)
cmd ='[ -e /root ] && echo yes || echo no'
ssh_num = 0
ssh_ok = 0
while ssh_num <= 5 and ssh_ok == 0 :
rsp = test_lib.lib_execute_ssh_cmd(vm_ip, 'root', 'password', cmd, 180)
if rsp == False:
time.sleep(30)
else:
ssh_ok = 1
break
ssh_num = ssh_num + 1
if ssh_ok == 0:
test_util.test_fail('fail to ssh to VM')
vm.check()
vm.destroy()
test_obj_dict.rm_vm(vm)
image.delete()
test_obj_dict.rm_image(image)
vol_ops.delete_disk_offering(root_disk_uuid)
test_obj_dict.rm_disk_offering(data_volume_offering)
vm_ops.delete_instance_offering(new_offering.uuid)
test_obj_dict.rm_instance_offering(new_offering)
test_util.test_pass('Create VM with ISO Installation Test Success')
def test():
global volume_offering_uuid,new_offering_uuid
test_util.test_dsc('Test VM data volume bandwidth QoS by 20MB')
# Only imagestore supports full clone
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)
for i in bs:
if i.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE:
break
else:
test_util.test_skip('Skip test on non-imagestore')
# SharedBlock and AliyunNAS not support full clone
ps = res_ops.query_resource(res_ops.PRIMARY_STORAGE)
for i in ps:
if i.type in ['SharedBlock', 'AliyunNAS']:
test_util.test_skip('Skip test on SharedBlock and AliyunNAS PS')
#unit is KB
write_bandwidth = 10*1024*1024
new_offering = test_lib.lib_create_instance_offering(write_bandwidth = write_bandwidth)
new_offering_uuid = new_offering.uuid
new_volume_offering = test_lib.lib_create_disk_offering(write_bandwidth = write_bandwidth)
volume_offering_uuid = new_volume_offering.uuid
vm = test_stub.create_vm(vm_name='vm_volume_qos', instance_offering_uuid = new_offering_uuid,
disk_offering_uuids = [volume_offering_uuid])
test_obj_dict.add_vm(vm)
vm.check()
vm_inv = vm.get_vm()
cond = res_ops.gen_query_conditions("vmInstanceUuid", '=', vm_inv.uuid)
cond = res_ops.gen_query_conditions("type", '=', 'Data', cond)
volume_uuid = res_ops.query_resource(res_ops.VOLUME, cond)[0].uuid
test_lib.lib_mkfs_for_volume(volume_uuid, vm_inv)
path = '/mnt'
user_name = 'root'
user_password = '******'
os.system("sshpass -p '%s' ssh %s@%s 'mount /dev/vdb1 %s'"%(user_password, user_name, vm_inv.vmNics[0].ip, path))
vm.check()
test_stub.make_ssh_no_password(vm_inv)
# test_stub.install_fio(vm_inv)
vm_ops.set_vm_disk_qos(test_lib.lib_get_data_volumes(vm_inv)[0].uuid, write_bandwidth*2, 'write')
vm_ops.set_vm_disk_qos(test_lib.lib_get_root_volume(vm_inv).uuid, write_bandwidth*2, 'write')
new_vm = vm.clone(['full_cloned_vm'], full=True)[0]
new_vm.check()
test_obj_dict.add_vm(new_vm)
volumes_number = len(test_lib.lib_get_all_volumes(new_vm.vm))
if volumes_number != 2:
test_util.test_fail('Did not find 2 volumes for [vm:] %s. But we assigned 2 data volume when create the vm. We only catch %s volumes' % (new_vm.vm.uuid, volumes_number))
else:
test_util.test_logger('Find 2 volumes for [vm:] %s.' % new_vm.vm.uuid)
new_vm_inv = new_vm.get_vm()
test_stub.install_fio(new_vm_inv)
if vm_ops.get_vm_disk_qos(test_lib.lib_get_data_volumes(new_vm_inv)[0].uuid).volumeBandwidthWrite != write_bandwidth*2:
test_util.test_fail('Retrieved disk qos not match')
test_stub.test_fio_bandwidth(new_vm_inv, write_bandwidth*2)
test_stub.test_fio_bandwidth(new_vm_inv, write_bandwidth*2, path)
if test_stub.test_fio_bandwidth(vm_inv, write_bandwidth, '/dev/vda', raise_exception=False):
test_util.test_fail('disk read qos is not expected to have limit as only read qos was set')
if test_stub.test_fio_bandwidth(vm_inv, write_bandwidth, '/dev/vdb', raise_exception=False):
test_util.test_fail('disk read qos is not expected to have limit as only read qos was set')
vm_ops.delete_instance_offering(new_offering_uuid)
vol_ops.delete_disk_offering(volume_offering_uuid)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('VM data volume read QoS Test Pass')
def test():
global vm, all_volume_offering_uuid, rw_volume_offering_uuid, all_volume_uuid, rw_volume_uuid, volume_offering_3, volume_offering_4, volume_offering_5, volume_offering_6
global instance_offering_uuid, volume_uuid_3, volume_uuid_4, volume_uuid_5, volume_uuid_6
#create disk offering
test_util.test_dsc('create disk offering')
name_all = 'all_disk_offering'
volume_bandwidth = 30*1024*1024
all_volume_offering = test_lib.lib_create_disk_offering(name = name_all, volume_bandwidth = volume_bandwidth)
all_volume_offering_uuid = all_volume_offering.uuid
name_rw = 'rw_disk_offering'
volume_read_bandwidth = 90*1024*1024
volume_write_bandwidth = 100*1024*1024
rw_volume_offering = test_lib.lib_create_disk_offering(name = name_rw, read_bandwidth = volume_read_bandwidth, write_bandwidth = volume_write_bandwidth)
rw_volume_offering_uuid = rw_volume_offering.uuid
volume_offering_3 = test_lib.lib_create_disk_offering(name = "volume_offering_3")
volume_offering_4 = test_lib.lib_create_disk_offering(name = "volume_offering_4")
volume_offering_5 = test_lib.lib_create_disk_offering(name = "volume_offering_5")
volume_offering_6 = test_lib.lib_create_disk_offering(name = "volume_offering_6")
#create instance offering
test_util.test_dsc('create instance offering')
read_bandwidth = 50*1024*1024
write_bandwidth = 60*1024*1024
net_outbound_bandwidth = 70*1024*1024
net_inbound_bandwidth = 80*1024*1024
new_instance_offering = test_lib.lib_create_instance_offering(read_bandwidth = read_bandwidth, write_bandwidth=write_bandwidth, net_outbound_bandwidth = net_outbound_bandwidth, net_inbound_bandwidth = net_inbound_bandwidth)
instance_offering_uuid = new_instance_offering.uuid
#create vm with 2 data volumes
test_util.test_dsc('create vm with volumes qos by normal account a')
l3net_uuid = res_ops.get_resource(res_ops.L3_NETWORK)[0].uuid
cond = res_ops.gen_query_conditions('name', '=', 'ttylinux')
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond)[0].uuid
vm_creation_option = test_util.VmOption()
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_l3_uuids([l3net_uuid])
vm = test_stub.create_vm_with_volume(vm_creation_option = vm_creation_option, data_volume_uuids = [all_volume_offering_uuid, rw_volume_offering_uuid, volume_offering_3.uuid, volume_offering_4.uuid, volume_offering_5.uuid, volume_offering_6.uuid])
vm_inv = vm.get_vm()
# get the volume uuid
test_util.test_dsc('get the vm data volumes')
cond1 = res_ops.gen_query_conditions("diskOfferingUuid", '=', all_volume_offering_uuid)
cond2 = res_ops.gen_query_conditions("diskOfferingUuid", '=', rw_volume_offering_uuid)
cond3 = res_ops.gen_query_conditions("diskOfferingUuid", '=', volume_offering_3.uuid)
cond4 = res_ops.gen_query_conditions("diskOfferingUuid", '=', volume_offering_4.uuid)
cond5 = res_ops.gen_query_conditions("diskOfferingUuid", '=', volume_offering_5.uuid)
cond6 = res_ops.gen_query_conditions("diskOfferingUuid", '=', volume_offering_6.uuid)
all_volume_uuid = res_ops.query_resource(res_ops.VOLUME, cond1)[0].uuid
rw_volume_uuid = res_ops.query_resource(res_ops.VOLUME, cond2)[0].uuid
volume_uuid_3 = res_ops.query_resource(res_ops.VOLUME, cond3)[0].uuid
volume_uuid_4 = res_ops.query_resource(res_ops.VOLUME, cond4)[0].uuid
volume_uuid_5 = res_ops.query_resource(res_ops.VOLUME, cond5)[0].uuid
volume_uuid_6 = res_ops.query_resource(res_ops.VOLUME, cond6)[0].uuid
tag_ops.create_system_tag('VolumeVO', all_volume_uuid, "capability::virtio-scsi")
tag_ops.create_system_tag('VolumeVO', rw_volume_uuid, "capability::virtio-scsi")
tag_ops.create_system_tag('VolumeVO', volume_uuid_3, "capability::virtio-scsi")
tag_ops.create_system_tag('VolumeVO', volume_uuid_4, "capability::virtio-scsi")
tag_ops.create_system_tag('VolumeVO', volume_uuid_5, "capability::virtio-scsi")
tag_ops.create_system_tag('VolumeVO', volume_uuid_6, "capability::virtio-scsi")
vm.check()
vm.reboot()
vol_ops.detach_volume(all_volume_uuid, vm_inv.uuid)
vol_ops.detach_volume(rw_volume_uuid, vm_inv.uuid)
vol_ops.detach_volume(volume_uuid_3, vm_inv.uuid)
vol_ops.detach_volume(volume_uuid_4, vm_inv.uuid)
vol_ops.detach_volume(volume_uuid_5, vm_inv.uuid)
vol_ops.detach_volume(volume_uuid_6, vm_inv.uuid)
vm.check()
vol_ops.attach_volume(all_volume_uuid, vm_inv.uuid)
vol_ops.attach_volume(rw_volume_uuid, vm_inv.uuid)
vol_ops.attach_volume(volume_uuid_3, vm_inv.uuid)
vol_ops.attach_volume(volume_uuid_4, vm_inv.uuid)
vol_ops.attach_volume(volume_uuid_5, vm_inv.uuid)
vol_ops.attach_volume(volume_uuid_6, vm_inv.uuid)
vm.reboot()
vm.check()
vol_ops.detach_volume(all_volume_uuid, vm_inv.uuid)
vm.check()
vol_ops.attach_volume(all_volume_uuid, vm_inv.uuid)
vm.destroy()
vm.check()
vol_ops.delete_disk_offering(all_volume_offering_uuid)
vol_ops.delete_disk_offering(rw_volume_offering_uuid)
vol_ops.delete_disk_offering(volume_offering_3.uuid)
vol_ops.delete_disk_offering(volume_offering_4.uuid)
vol_ops.delete_disk_offering(volume_offering_5.uuid)
vol_ops.delete_disk_offering(volume_offering_6.uuid)
vol_ops.delete_volume(all_volume_uuid)
vol_ops.delete_volume(rw_volume_uuid)
vol_ops.delete_volume(volume_uuid_3)
vol_ops.delete_volume(volume_uuid_4)
vol_ops.delete_volume(volume_uuid_5)
vol_ops.delete_volume(volume_uuid_6)
vm_ops.delete_instance_offering(instance_offering_uuid)
test_util.test_pass('Create VM with volumes and detach/attach and after reboot and detach/attach Test Success')
def test():
global image
global test_obj_dict
allow_bs_list = [
inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE,
inventory.CEPH_BACKUP_STORAGE_TYPE, inventory.SFTP_BACKUP_STORAGE_TYPE
]
test_lib.skip_test_when_bs_type_not_in_list(allow_bs_list)
allow_ps_list = [
inventory.CEPH_PRIMARY_STORAGE_TYPE,
inventory.NFS_PRIMARY_STORAGE_TYPE, 'SharedMountPoint'
]
test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list)
#run condition
hosts = res_ops.query_resource(res_ops.HOST)
if len(hosts) <= 1:
test_util.test_skip(
"skip for host_num is not satisfy condition host_num>1")
bs_cond = res_ops.gen_query_conditions("status", '=', "Connected")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE,
bs_cond,
None,
fields=['uuid'])
#create disk offering
data_volume_size = 10737418240
disk_offering_option = test_util.DiskOfferingOption()
disk_offering_option.set_name('root-disk-iso')
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)
#create instance offering
cpuNum = 2
memorySize = 2147483648
name = 'iso-vm-offering'
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)
#add iso
img_option = test_util.ImageOption()
img_option.set_name('iso1')
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [],
None)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
img_option.set_url(
'http://172.20.1.15:7480/iso/CentOS-x86_64-7.2-Minimal.iso')
image_inv = img_ops.add_iso_template(img_option)
image_uuid = image_inv.uuid
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
test_obj_dict.add_image(image)
#create vm by iso
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
root_disk_uuid = data_volume_offering.uuid
vm = test_stub.create_vm_with_iso([l3_net_uuid], image_uuid, 'iso-vm',
root_disk_uuid, new_offering.uuid)
host_ip = test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp
test_obj_dict.add_vm(vm)
#check vm
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
#cmd ='[ -e /root ]'
#ssh_timeout = test_lib.SSH_TIMEOUT
#test_lib.SSH_TIMEOUT = 3600
test_lib.lib_set_vm_host_l2_ip(vm_inv)
test_lib.lib_wait_target_up(vm.get_vm().vmNics[0].ip, 22, 1800)
#if not test_lib.lib_ssh_vm_cmd_by_agent_with_retry(host_ip, vm_ip, 'root', 'password', cmd):
# test_lib.SSH_TIMEOUT = ssh_timeout
# test_util.test_fail("iso has been failed to installed.")
#test_lib.SSH_TIMEOUT = ssh_timeout
#clone vm
cloned_vm_name = ['cloned_vm_name']
cloned_vm_obj = vm.clone(cloned_vm_name)[0]
test_obj_dict.add_vm(cloned_vm_obj)
#delete iso
image.delete()
test_obj_dict.rm_image(image)
#vm ops test
test_stub.vm_ops_test(cloned_vm_obj, "VM_TEST_ALL")
#expunge iso
image.expunge()
#detach iso
img_ops.detach_iso(vm.vm.uuid)
#vm ops test
test_stub.vm_ops_test(cloned_vm_obj, "VM_TEST_ALL")
#create image by vm root volume
cloned_vm_img_name = "cloned_vm_image1"
img_option2 = test_util.ImageOption()
img_option2.set_backup_storage_uuid_list([bs_uuid])
img_option2.set_root_volume_uuid(cloned_vm_obj.vm.rootVolumeUuid)
img_option2.set_name(cloned_vm_img_name)
image1 = test_image.ZstackTestImage()
image1.set_creation_option(img_option2)
image1.create()
image1.check()
test_obj_dict.add_image(image1)
#export image
image1.export()
#create vm
vm2 = test_stub.create_vm('image-vm', cloned_vm_img_name, l3_name)
#delete image
image1.delete()
test_obj_dict.rm_image(image1)
#vm ops test
test_stub.vm_ops_test(vm2, "VM_TEST_ALL")
#expunge image
image1.expunge()
#vm ops test
test_stub.vm_ops_test(vm2, "VM_TEST_ALL")
vm.destroy()
vm2.destroy()
cloned_vm_obj.destroy()
vol_ops.delete_disk_offering(root_disk_uuid)
vm_ops.delete_instance_offering(new_offering.uuid)
test_obj_dict.rm_vm(vm)
test_obj_dict.rm_disk_offering(data_volume_offering)
test_obj_dict.rm_instance_offering(new_offering)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Create VM Image in Image Store Success')
def test():
global image
global test_obj_dict
#run condition
hosts = res_ops.query_resource(res_ops.HOST)
if len(hosts) <= 1:
test_util.test_skip("skip for host_num is not satisfy condition host_num>1")
bs_cond = res_ops.gen_query_conditions("status", '=', "Connected")
bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, None, fields=['uuid'])
#create disk offering
data_volume_size = 10737418240
disk_offering_option = test_util.DiskOfferingOption()
disk_offering_option.set_name('root-disk-iso')
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)
#create instance offering
cpuNum = 2
memorySize = 1024*1024*1024
name = 'iso-vm-offering'
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)
#add iso
img_option = test_util.ImageOption()
img_option.set_name('iso1')
bs_uuid = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [], None)[0].uuid
img_option.set_backup_storage_uuid_list([bs_uuid])
img_option.set_url(os.environ.get('isoForVmUrl'))
image_inv = img_ops.add_iso_template(img_option)
image_uuid = image_inv.uuid
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
test_obj_dict.add_image(image)
#create vm by iso
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
root_disk_uuid = data_volume_offering.uuid
vm = test_stub.create_vm_with_iso([l3_net_uuid], image_uuid, 'iso-vm', root_disk_uuid, new_offering.uuid)
host_ip = test_lib.lib_find_host_by_vm(vm.get_vm()).managementIp
test_obj_dict.add_vm(vm)
#check vm
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
#cmd ='[ -e /root ]'
#ssh_timeout = test_lib.SSH_TIMEOUT
#test_lib.SSH_TIMEOUT = 3600
test_lib.lib_set_vm_host_l2_ip(vm_inv)
test_lib.lib_wait_target_up(vm.get_vm().vmNics[0].ip, 22, 1800)
#if not test_lib.lib_ssh_vm_cmd_by_agent_with_retry(host_ip, vm_ip, 'root', 'password', cmd):
# test_lib.SSH_TIMEOUT = ssh_timeout
# test_util.test_fail("iso has been failed to installed.")
#test_lib.SSH_TIMEOUT = ssh_timeout
#delete iso
image.delete()
test_obj_dict.rm_image(image)
#expunge iso
image.expunge()
#detach iso
img_ops.detach_iso(vm.vm.uuid)
#vm ops test
test_stub.vm_ops_test(vm, "VM_TEST_STATE")
vm.destroy()
vol_ops.delete_disk_offering(root_disk_uuid)
vm_ops.delete_instance_offering(new_offering.uuid)
test_obj_dict.rm_vm(vm)
test_obj_dict.rm_disk_offering(data_volume_offering)
test_obj_dict.rm_instance_offering(new_offering)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Create VM Image in Image Store Success')
