def test():
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
instance_offering_name).uuid
vm = test_stub.create_vm(image_name=os.environ.get('sshkeyImageName'),
instance_offering_uuid=instance_offering_uuid)
test_obj_dict.add_vm(vm)
vm_ip = vm.get_vm().vmNics[0].ip
time.sleep(10)
test_lib.lib_add_vm_sshkey(vm.get_vm().uuid,
os.environ.get('sshkeyPubKey'))
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
host_ops.reconnect_host(host_uuid)
vm.reboot()
test_lib.lib_wait_target_up(vm_ip, '22', 240)
time.sleep(10)
for i in range(5):
ssh_cmd = 'timeout 5 ssh -i %s -oPasswordAuthentication=no -oStrictHostKeyChecking=no -oCheckHostIP=no -oUserKnownHostsFile=/dev/null %s echo pass' % (
os.environ.get('sshkeyPriKey_file'), vm_ip)
process_result = test_stub.execute_shell_in_process(ssh_cmd, tmp_file)
if process_result == 0:
break
else:
time.sleep(10)
else:
test_util.test_fail("fail to use ssh key connect to VM")
vm.destroy()
test_util.test_pass('Create VM Test Success')
def create_vr_vm(test_obj_dict, l3_uuid, session_uuid=None):
'''
'''
vrs = test_lib.lib_find_vr_by_l3_uuid(l3_uuid)
if not vrs:
#create temp_vm1 for getting vlan1's vr for test pf_vm portforwarding
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
cond = res_ops.gen_query_conditions('system', '=', 'false', cond)
image_uuid = res_ops.query_resource(res_ops.IMAGE,
cond,
session_uuid=session_uuid)[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([l3_uuid])
temp_vm = create_vm(vm_creation_option, session_uuid=session_uuid)
test_obj_dict.add_vm(temp_vm)
vr = test_lib.lib_find_vr_by_vm(temp_vm.vm)[0]
temp_vm.destroy(session_uuid)
test_obj_dict.rm_vm(temp_vm)
else:
vr = vrs[0]
if not test_lib.lib_is_vm_running(vr):
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_skip('vr: %s is not running. Will skip test.' %
vr.uuid)
return vr
def test():
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
vm = test_stub.create_vm(image_name = os.environ.get('sshkeyImageName'), instance_offering_uuid = instance_offering_uuid)
test_obj_dict.add_vm(vm)
vm_ip = vm.get_vm().vmNics[0].ip
time.sleep(10)
test_lib.lib_add_vm_sshkey(vm.get_vm().uuid, os.environ.get('sshkeyPubKey'))
host = test_lib.lib_get_vm_host(vm.get_vm())
host_uuid = host.uuid
host_ops.reconnect_host(host_uuid)
vm.reboot()
test_lib.lib_wait_target_up(vm_ip, '22', 240)
time.sleep(10)
for i in range(5):
ssh_cmd = 'timeout 5 ssh -i %s -oPasswordAuthentication=no -oStrictHostKeyChecking=no -oCheckHostIP=no -oUserKnownHostsFile=/dev/null %s echo pass' % (os.environ.get('sshkeyPriKey_file'), vm_ip)
process_result = test_stub.execute_shell_in_process(ssh_cmd, tmp_file)
if process_result == 0:
break
else:
time.sleep(10)
else:
test_util.test_fail("fail to use ssh key connect to VM")
vm.destroy()
test_util.test_pass('Create VM Test Success')
def create_vm(vm_name = 'vm_for_baremetal', image_name = None, \
l3_name = None, instance_offering_uuid = None, \
host_uuid = None, disk_offering_uuid = None, cluster_uuid = None, \
system_tags = None, password = None, session_uuid = None):
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
if not image_name:
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
if not l3_name:
l3_name = os.environ.get('scenl3VPCNetworkName1')
l3_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
vm_creation_option = test_util.VmOption()
vm_creation_option.set_name(vm_name)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_l3_uuids([l3_uuid])
if cluster_uuid:
vm_creation_option.set_cluster_uuid(cluster_uuid)
if system_tags:
vm_creation_option.set_system_tags(system_tags)
if disk_offering_uuid:
vm_creation_option.set_data_disk_uuids(disk_offering_uuid)
if password:
vm_creation_option.set_root_password(password)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
os.system('swapon -a')
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
img_option = test_util.ImageOption()
UEFI_image_url = os.environ.get('imageUrl_win2016_UEFI')
image_name = os.environ.get('imageName_win2016_UEFI')
img_option.set_name(image_name)
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_format('qcow2')
img_option.set_url(UEFI_image_url)
img_option.set_timeout(6000000)
img_option.set_system_tags("bootMode::UEFI")
image_inv = img_ops.add_root_volume_template(img_option)
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
test_obj_dict.add_image(image)
vm = test_stub.create_vm(image_name = os.environ.get('imageName_win2016_UEFI'), instance_offering_uuid = instance_offering_uuid)
test_obj_dict.add_vm(vm)
time.sleep(120)
vm.check()
vm_ip = vm.get_vm().vmNics[0].ip
retcode = subprocess.call(["ping", "-c","4",vm_ip])
if retcode != 0:
test_util.test_fail('Create VM Test win2016 UEFI failed.')
else:
test_util.test_pass('Create VM Test win2016 UEFI Success.')
vm.destroy()
test_util.test_pass('Create VM Test win2016 UEFI Success')
def create_vm(vm_name='img-stor-vm', \
image_name = None, \
l3_name = None, \
instance_offering_uuid = None, \
host_uuid = None, \
disk_offering_uuids=None, system_tags=None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_s')
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
vm_creation_option = test_util.VmOption()
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_s')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
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)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_vm(vm_creation_option=None, volume_uuids=None, root_disk_uuid=None, \
image_uuid=None, session_uuid=None):
if not vm_creation_option:
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond, session_uuid)[0].uuid
l3net_uuid = res_ops.get_resource(res_ops.L3_NETWORK, session_uuid)[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])
if volume_uuids:
if isinstance(volume_uuids, list):
vm_creation_option.set_data_disk_uuids(volume_uuids)
else:
test_util.test_fail('volume_uuids type: %s is not "list".' % type(volume_uuids))
if root_disk_uuid:
vm_creation_option.set_root_disk_uuid(root_disk_uuid)
if image_uuid:
vm_creation_option.set_image_uuid(image_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_vm(vm_name='virt-vm', \
image_name = None, \
l3_name = None, \
instance_offering_uuid = None, \
host_uuid = None, \
disk_offering_uuids=None, system_tags=None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_net')
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
vm_creation_option = test_util.VmOption()
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_s')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
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)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_vm_in_vcenter(vm_name='vcenter-vm', \
image_name = None, \
l3_name = None, \
instance_offering_uuid = None, \
host_uuid = None, \
disk_offering_uuids=None, system_tags=None, \
timeout = 1200000, \
root_password=None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_net')
elif os.environ.get(image_name):
image_name = os.environ.get(image_name)
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
image = test_lib.lib_get_image_by_name(image_name)
image_uuid = image.uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
datastore_type = vc_ops.get_datastore_type(os.environ['vcenter'])
if datastore_type == 'local':
cond = res_ops.gen_query_conditions('image.uuid', '=', image_uuid)
vcbs = res_ops.query_resource(res_ops.VCENTER_BACKUP_STORAGE, cond)[0]
vcps = vc_ops.lib_get_vcenter_primary_storage_by_name(vcbs.name)
cond = res_ops.gen_query_conditions("name", '=', l3_name)
l3_inv = res_ops.query_resource(res_ops.L3_NETWORK, cond)
for l3_net in l3_inv:
cond = res_ops.gen_query_conditions("uuid", '=',
l3_net.l2NetworkUuid)
l2 = res_ops.query_resource(res_ops.L2_NETWORK, cond)[0]
if l2.attachedClusterUuids == vcps.attachedClusterUuids:
l3_net_uuid = l3_net.uuid
break
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_s')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
instance_offering_name).uuid
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)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
vm_creation_option.set_timeout(timeout)
if root_password:
vm_creation_option.set_root_password(root_password)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_vm_in_vcenter(vm_name='vcenter-vm', \
image_name = None, \
l3_name = None, \
instance_offering_uuid = None, \
host_uuid = None, \
disk_offering_uuids=None, system_tags=None, \
timeout = 1200000, \
root_password=None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_net')
elif os.environ.get(image_name):
image_name = os.environ.get(image_name)
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
image = test_lib.lib_get_image_by_name(image_name)
image_uuid = image.uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
datastore_type = vc_ops.get_datastore_type(os.environ['vcenter'])
if datastore_type == 'local':
cond = res_ops.gen_query_conditions('image.uuid', '=', image_uuid)
vcbs = res_ops.query_resource(res_ops.VCENTER_BACKUP_STORAGE, cond)[0]
vcps = vc_ops.lib_get_vcenter_primary_storage_by_name(vcbs.name)
cond = res_ops.gen_query_conditions("name", '=', l3_name)
l3_inv = res_ops.query_resource(res_ops.L3_NETWORK, cond)
for l3_net in l3_inv:
cond = res_ops.gen_query_conditions("uuid", '=', l3_net.l2NetworkUuid)
l2 = res_ops.query_resource(res_ops.L2_NETWORK, cond)[0]
if l2.attachedClusterUuids == vcps.attachedClusterUuids:
l3_net_uuid = l3_net.uuid
break
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_s')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
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)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
vm_creation_option.set_timeout(timeout)
if root_password:
vm_creation_option.set_root_password(root_password)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_windows_vm(vm_creation_option = None, volume_uuids = None, root_disk_uuid = None, image_uuid = None, session_uuid = None):
if not vm_creation_option:
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_win')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Windows', cond)
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond, session_uuid)[0].uuid
l3net_uuid = res_ops.get_resource(res_ops.L3_NETWORK, session_uuid)[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])
return create_vm(vm_creation_option, volume_uuids, root_disk_uuid, image_uuid, session_uuid)
def create_windows_vm(vm_creation_option=None, volume_uuids=None, root_disk_uuid=None, image_uuid=None, session_uuid=None):
if not vm_creation_option:
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_win')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Windows', cond)
image_uuid = res_ops.query_resource(
res_ops.IMAGE, cond, session_uuid)[0].uuid
l3net_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3VlanNetwork3')).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])
return create_vm(vm_creation_option, volume_uuids, root_disk_uuid, image_uuid, session_uuid)
def create_vm(vm_creation_option=None,
volume_uuids=None,
root_disk_uuid=None,
image_uuid=None,
ps_uuid=None,
session_uuid=None):
if not vm_creation_option:
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
cond = res_ops.gen_query_conditions('system', '=', 'false', cond)
l3net_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3VlanNetworkName3')).uuid
if image_uuid:
image_uuid = image_uuid
else:
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond,
session_uuid)[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_creation_option.set_timeout(864000000)
if volume_uuids:
if isinstance(volume_uuids, list):
vm_creation_option.set_data_disk_uuids(volume_uuids)
else:
test_util.test_fail('volume_uuids type: %s is not "list".' %
type(volume_uuids))
if root_disk_uuid:
vm_creation_option.set_root_disk_uuid(root_disk_uuid)
if image_uuid:
vm_creation_option.set_image_uuid(image_uuid)
if ps_uuid:
vm_creation_option.set_ps_uuid(ps_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_ag_vm(vm_creation_option=None,
volume_uuids=None,
root_disk_uuid=None,
image_uuid=None,
affinitygroup_uuid=None,
host_uuid=None,
session_uuid=None):
if not vm_creation_option:
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
cond = res_ops.gen_query_conditions('system', '=', 'false', cond)
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond,
session_uuid)[0].uuid
cond = res_ops.gen_query_conditions('category', '!=', 'System')
l3net_uuid = res_ops.query_resource(res_ops.L3_NETWORK, cond,
session_uuid)[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_creation_option.set_host_uuid(host_uuid)
if affinitygroup_uuid:
vm_creation_option.set_system_tags(
["affinityGroupUuid::%s" % affinitygroup_uuid])
if volume_uuids:
if isinstance(volume_uuids, list):
vm_creation_option.set_data_disk_uuids(volume_uuids)
else:
test_util.test_fail('volume_uuids type: %s is not "list".' %
type(volume_uuids))
if root_disk_uuid:
vm_creation_option.set_root_disk_uuid(root_disk_uuid)
if image_uuid:
vm_creation_option.set_image_uuid(image_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
vm = test_stub.create_vm(image_name = os.environ.get('sshkeyImageName'), instance_offering_uuid = instance_offering_uuid)
test_obj_dict.add_vm(vm)
vm_ip = vm.get_vm().vmNics[0].ip
time.sleep(10)
test_lib.lib_add_vm_sshkey(vm.get_vm().uuid, os.environ.get('sshkeyPubKey'))
vm.reboot()
time.sleep(60)
ssh_cmd = 'ssh -i %s -oStrictHostKeyChecking=no -oCheckHostIP=no -oUserKnownHostsFile=/dev/null %s echo pass' % (os.environ.get('sshkeyPriKey_file'), vm_ip)
process_result = test_stub.execute_shell_in_process(ssh_cmd, tmp_file)
if process_result != 0:
test_util.test_fail("fail to use ssh key connect to VM")
vm.destroy()
test_util.test_pass('Create VM Test Success')
def create_vm_in_vcenter(vm_name='vcenter-vm', \
image_name = None, \
l3_name = None, \
instance_offering_uuid = None, \
host_uuid = None, \
disk_offering_uuids=None, system_tags=None, \
timeout = 1200000, \
root_password=None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_net')
elif os.environ.get(image_name):
image_name = os.environ.get(image_name)
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
instance_offering_name).uuid
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)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
vm_creation_option.set_timeout(timeout)
if root_password:
vm_creation_option.set_root_password(root_password)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_vm(vm_creation_option=None,
volume_uuids=None,
root_disk_uuid=None,
image_uuid=None,
strategy_type='InstantStart',
session_uuid=None):
if not vm_creation_option:
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond,
session_uuid)[0].uuid
l3net_uuid = res_ops.get_resource(res_ops.L3_NETWORK,
session_uuid)[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])
if volume_uuids:
if isinstance(volume_uuids, list):
vm_creation_option.set_data_disk_uuids(volume_uuids)
else:
test_util.test_fail('volume_uuids type: %s is not "list".' %
type(volume_uuids))
if root_disk_uuid:
vm_creation_option.set_root_disk_uuid(root_disk_uuid)
if image_uuid:
vm_creation_option.set_image_uuid(image_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm_creation_option.set_strategy_type(strategy_type)
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_vm(vm_name = 'vm1', image_name = None, \
l3_name = None, instance_offering_uuid = None, \
host_uuid = None, disk_offering_uuid = None, \
system_tags = None, password = None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_s')
if not l3_name:
l3_name1 = os.environ.get('l3PublicNetworkName')
l3_name2 = os.environ.get('l3VlanNetworkName1')
l3_name3 = os.environ.get('l3VlanNetworkName3')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_uuid1 = test_lib.lib_get_l3_by_name(l3_name1).uuid
l3_uuid2 = test_lib.lib_get_l3_by_name(l3_name2).uuid
l3_uuid3 = test_lib.lib_get_l3_by_name(l3_name3).uuid
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
vm_creation_option = test_util.VmOption()
vm_creation_option.set_l3_uuids([l3_uuid1, l3_uuid2, l3_uuid3])
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuid)
if password:
vm_creation_option.set_root_password(password)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def create_arm_vm(vm_creation_option=None,
volume_uuids=None,
root_disk_uuid=None,
image_uuid=None,
session_uuid=None):
if not vm_creation_option:
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
image_name = os.environ.get('imageName_arm')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_name = os.environ.get('l3VlanNetworkName1')
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_name).uuid
conditions = res_ops.gen_query_conditions('name', '=', 'arm_cluster')
cluster_uuid = res_ops.query_resource(res_ops.CLUSTER,
conditions)[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([l3_net_uuid])
vm_creation_option.set_cluster_uuid(cluster_uuid)
vm_creation_option.set_name("arm_test_vm")
if volume_uuids:
if isinstance(volume_uuids, list):
vm_creation_option.set_data_disk_uuids(volume_uuids)
else:
test_util.test_fail('volume_uuids type: %s is not "list".' %
type(volume_uuids))
if root_disk_uuid:
vm_creation_option.set_root_disk_uuid(root_disk_uuid)
if image_uuid:
vm_creation_option.set_image_uuid(image_uuid)
if session_uuid:
vm_creation_option.set_session_uuid(session_uuid)
vm = test_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
instance_offering_name).uuid
vm = test_stub.create_vm(
image_name=os.environ.get('sshkeyImageName'),
system_tags=[
"%s::%s" % (vm_header.SSHKEY, os.environ.get('sshkeyPubKey'))
],
instance_offering_uuid=instance_offering_uuid)
test_obj_dict.add_vm(vm)
vm_ip = vm.get_vm().vmNics[0].ip
time.sleep(60)
ssh_cmd = 'ssh -i %s -oStrictHostKeyChecking=no -oCheckHostIP=no -oUserKnownHostsFile=/dev/null %s echo pass' % (
os.environ.get('sshkeyPriKey_file'), vm_ip)
process_result = test_stub.execute_shell_in_process(ssh_cmd, tmp_file)
if process_result != 0:
test_util.test_fail("fail to use ssh key connect to VM")
vm.destroy()
test_util.test_pass('Create VM Test Success')
def create_vm(vm_name='virt-vm', \
image_name = None, \
l3_name = None, \
instance_offering_uuid = None, \
host_uuid = None, \
disk_offering_uuids=None, system_tags=None, session_uuid = None):
if not image_name:
image_name = os.environ.get('imageName_net')
if not l3_name:
l3_name = os.environ.get('l3PublicNetworkName')
vm_creation_option = test_util.VmOption()
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
l3_names = l3_name.split(',')
print 'shuang: %s' % (l3_names)
l3_net_uuids = []
for l3_n in l3_names:
l3_net_uuid = test_lib.lib_get_l3_by_name(l3_n).uuid
l3_net_uuids.append(l3_net_uuid)
if not instance_offering_uuid:
instance_offering_name = os.environ.get('instanceOfferingName_s')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
instance_offering_name).uuid
vm_creation_option.set_l3_uuids(l3_net_uuids)
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name(vm_name)
vm_creation_option.set_system_tags(system_tags)
vm_creation_option.set_data_disk_uuids(disk_offering_uuids)
if host_uuid:
vm_creation_option.set_host_uuid(host_uuid)
vm = zstack_vm_header.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
return vm
def test():
img_option = test_util.ImageOption()
image_name = 'userdata-image'
image_url = os.environ.get('userdataImageUrl')
img_option.set_name(image_name)
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_format('raw')
img_option.set_url(image_url)
image_inv = img_ops.add_root_volume_template(img_option)
image = test_image.ZstackTestImage()
image.set_image(image_inv)
image.set_creation_option(img_option)
test_obj_dict.add_image(image)
instance_offering_name = os.environ.get('instanceOfferingName_m')
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(instance_offering_name).uuid
vm_1 = test_stub.create_vm(image_name = os.environ.get('sshkeyImageName'),instance_offering_uuid = instance_offering_uuid)
test_obj_dict.add_vm(vm_1)
time.sleep(90)
vm_1_ip = vm_1.get_vm().vmNics[0].ip
vm_2 = test_stub.create_vm(vm_name = 'userdata-and-sshkey-vm',image_name = image_name,system_tags = ["userdata::%s" % os.environ.get('userdata_systemTags'),"%s::%s" % (vm_header.SSHKEY, os.environ.get('sshkeyPubKey'))], instance_offering_uuid = instance_offering_uuid)
test_obj_dict.add_vm(vm_2)
time.sleep(90)
vm_2_ip = vm_2.get_vm().vmNics[0].ip
for i in range(5):
ssh_cmd = 'timeout 5 ssh -i %s -oPasswordAuthentication=no -oStrictHostKeyChecking=no -oCheckHostIP=no -oUserKnownHostsFile=/dev/null %s echo pass' % (os.environ.get('sshkeyPriKey_file'), vm_2_ip)
process_result = test_stub.execute_shell_in_process(ssh_cmd, tmp_file)
if process_result == 0:
break
else:
time.sleep(10)
else:
test_util.test_fail("fail to use ssh key connect to VM")
ssh_cmd = 'ssh -i %s -oStrictHostKeyChecking=no -oCheckHostIP=no -oUserKnownHostsFile=/dev/null test@%s' % (os.environ.get('sshkeyPriKey_file'), vm_2_ip)
for i in range(5):
cmd = '%s cat /tmp/helloworld_config' % ssh_cmd
process_result = test_stub.execute_shell_in_process(cmd, tmp_file)
if process_result == 0:
break
else:
time.sleep(10)
else:
test_util.test_fail("fail to cat /tmp/helloworld_config")
for i in range(5):
cmd = '%s find /tmp/temp' % ssh_cmd
process_result = test_stub.execute_shell_in_process(cmd, tmp_file)
if process_result == 0:
break
else:
time.sleep(10)
else:
test_util.test_fail("fail to find /tmp/temp")
vm_1.destroy()
test_obj_dict.rm_vm(vm_1)
vm_2.destroy()
test_obj_dict.rm_vm(vm_2)
image.delete()
image.expunge()
test_obj_dict.rm_image(image)
test_util.test_pass('Create VM with userdata Success')
def test():
from vncdotool import api
global vm
session_uuid = None
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond,
session_uuid)[0].uuid
l3net_uuid = res_ops.get_resource(res_ops.L3_NETWORK, session_uuid)[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_creation_option.set_console_password(password1)
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
vm.check()
console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid)
test_util.test_logger('[vm:] %s console is on %s:%s' %
(vm.get_vm().uuid, console.hostIp, console.port))
display = str(int(console.port) - 5900)
try:
client = api.connect(console.hostIp + ":" + display)
client.keyPress('k')
test_util.test_fail(
'[vm:] %s console on %s:%s is connectable without password' %
(vm.get_vm().uuid, console.hostIp, console.port))
except:
test_util.test_logger(
'[vm:] %s console on %s:%s is not connectable without password' %
(vm.get_vm().uuid, console.hostIp, console.port))
try:
client = api.connect(console.hostIp + ":" + display, password1)
client.keyPress('k')
test_util.test_logger(
'[vm:] %s console on %s:%s is connectable with password %s' %
(vm.get_vm().uuid, console.hostIp, console.port, password1))
except:
test_util.test_fail(
'[vm:] %s console on %s:%s is not connectable with password %s' %
(vm.get_vm().uuid, console.hostIp, console.port, password1))
test_lib.lib_set_vm_console_password(vm.get_vm().uuid, password2)
test_util.test_logger('set [vm:] %s console with password %s' %
(vm.get_vm().uuid, password2))
vm.reboot()
try:
client = api.connect(console.hostIp + ":" + display, password2)
client.keyPress('k')
test_util.test_logger(
'[vm:] %s console on %s:%s is connectable with password %s' %
(vm.get_vm().uuid, console.hostIp, console.port, password2))
except:
test_util.test_fail(
'[vm:] %s console on %s:%s is not connectable with password %s' %
(vm.get_vm().uuid, console.hostIp, console.port, password2))
import signal
def handler(signum, frame):
raise Exception()
signal.signal(signal.SIGALRM, handler)
signal.alarm(30)
try:
client = api.connect(console.hostIp + ":" + display, password1)
client.keyPress('k')
test_util.test_fail(
'[vm:] %s console on %s:%s is connectable with password %s' %
(vm.get_vm().uuid, console.hostIp, console.port, password1))
except:
test_util.test_logger(
'[vm:] %s console on %s:%s is not connectable with password %s' %
(vm.get_vm().uuid, console.hostIp, console.port, password1))
vm.destroy()
test_util.test_pass('Set VM Console Password Test Success')
def test():
global project_uuid, project_admin_uuid, virtual_id_uuid
# 1 create project
project_name = 'test_project'
project = iam2_ops.create_iam2_project(project_name)
project_uuid = project.uuid
project_linked_account_uuid = project.linkedAccountUuid
# 2 create virtual id
project_admin_name = 'username'
project_admin_password = '******'
project_admin_uuid = iam2_ops.create_iam2_virtual_id(project_admin_name, project_admin_password).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo', 'password').uuid
# 3 create project admin
iam2_ops.add_iam2_virtual_ids_to_project([project_admin_uuid],project_uuid)
attributes = [{"name": "__ProjectAdmin__", "value": project_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(project_admin_uuid, attributes)
# 4 login in project by project admin
project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(project_admin_name, project_admin_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name, session_uuid=project_admin_session_uuid).uuid
# iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes)
# Image related ops: Add, Delete, Expunge, sync image size, Update QGA, delete, expunge
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
image_option = test_util.ImageOption()
image_option.set_name('fake_image')
image_option.set_description('fake image')
image_option.set_format('raw')
image_option.set_mediaType('RootVolumeTemplate')
image_option.set_backup_storage_uuid_list([bs.uuid])
image_option.url = "http://fake/fake.raw"
image_option.set_session_uuid(project_login_uuid)
image_uuid = img_ops.add_image(image_option).uuid
img_ops.sync_image_size(image_uuid, session_uuid=project_login_uuid)
img_ops.change_image_state(image_uuid, 'disable', session_uuid=project_login_uuid)
img_ops.change_image_state(image_uuid, 'enable', session_uuid=project_login_uuid)
if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE:
img_ops.export_image_from_backup_storage(image_uuid, bs.uuid, session_uuid=project_login_uuid)
img_ops.delete_exported_image_from_backup_storage(image_uuid, bs.uuid, session_uuid=project_login_uuid)
img_ops.set_image_qga_enable(image_uuid, session_uuid=project_login_uuid)
img_ops.set_image_qga_disable(image_uuid, session_uuid=project_login_uuid)
img_ops.delete_image(image_uuid, session_uuid=project_login_uuid)
img_ops.expunge_image(image_uuid, session_uuid=project_login_uuid)
# Volume related ops: Create, Delete, Expunge, Attach, Dettach, Enable, Disable
disk_offering_uuid = res_ops.query_resource(res_ops.DISK_OFFERING)[0].uuid
acc_ops.share_resources([project_linked_account_uuid], [disk_offering_uuid])
volume_option = test_util.VolumeOption()
volume_option.set_disk_offering_uuid(disk_offering_uuid)
volume_option.set_name('data_volume_project_management')
volume_option.set_session_uuid(project_login_uuid)
data_volume = vol_ops.create_volume_from_offering(volume_option)
vol_ops.stop_volume(data_volume.uuid, session_uuid=project_login_uuid)
vol_ops.start_volume(data_volume.uuid, session_uuid=project_login_uuid)
vm_creation_option = test_util.VmOption()
l3_net_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetwork3')).uuid
acc_ops.share_resources([project_linked_account_uuid], [l3_net_uuid])
vm_creation_option.set_l3_uuids([l3_net_uuid])
image_uuid = test_lib.lib_get_image_by_name("centos").uuid
vm_creation_option.set_image_uuid(image_uuid)
acc_ops.share_resources([project_linked_account_uuid], [image_uuid])
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
acc_ops.share_resources([project_linked_account_uuid], [instance_offering_uuid])
vm_creation_option.set_name('vm_for_project_management')
vm_creation_option.set_session_uuid(project_login_uuid)
vm = test_stub.create_vm(image_uuid = image_uuid, session_uuid=project_login_uuid)
vm_uuid = vm.get_vm().uuid
vol_ops.attach_volume(data_volume.uuid, vm_uuid, session_uuid=project_login_uuid)
vol_ops.detach_volume(data_volume.uuid, vm_uuid, session_uuid=project_login_uuid)
vol_ops.delete_volume(data_volume.uuid, session_uuid=project_login_uuid)
vol_ops.expunge_volume(data_volume.uuid, session_uuid=project_login_uuid)
# VM related ops: Create, Delete, Expunge, Start, Stop, Suspend, Resume, Migrate
vm_ops.stop_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.start_vm(vm_uuid, session_uuid=project_login_uuid)
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
if candidate_hosts != None and test_lib.lib_check_vm_live_migration_cap(vm.get_vm()):
vm_ops.migrate_vm(vm_uuid, candidate_hosts.inventories[0].uuid, session_uuid=project_login_uuid)
vm_ops.stop_vm(vm_uuid, force='cold', session_uuid=project_login_uuid)
vm_ops.start_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.suspend_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.resume_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.destroy_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.expunge_vm(vm_uuid, session_uuid=project_login_uuid)
# L2 related ops: create, delete
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
try:
l2 = net_ops.create_l2_novlan('l2_for_pm', 'eth0', zone_uuid, session_uuid=project_login_uuid)
test_util.test_fail("Expect exception: project admin not allowed to create Novlan L2 except vxlan")
except:
pass
try:
l2 = net_ops.create_l2_vlan('l2_for_pm', 'eth0', zone_uuid, 1234, session_uuid=project_login_uuid)
test_util.test_fail("Expect exception: project admin not allowed to create vlan L2 except vxlan")
except:
pass
#net_ops.delete_l2(l2.uuid, session_uuid=project_login_uuid)
# L3 related ops:
# network service ops:
# zwatch ops:
# scheduler ops:
# certificate
# 11 delete
acc_ops.logout(project_login_uuid)
iam2_ops.delete_iam2_virtual_id(virtual_id_uuid)
iam2_ops.delete_iam2_virtual_id(project_admin_uuid)
iam2_ops.delete_iam2_project(project_uuid)
iam2_ops.expunge_iam2_project(project_uuid)
test_util.test_pass('success test iam2 login in by project admin!')
def test():
test_util.test_dsc('test vm life cycle on specified ceph pool')
try:
ps = res_ops.query_resource(res_ops.CEPH_PRIMARY_STORAGE)[0]
except Exception as e:
test_util.test_dsc(str(e))
test_util.test_skip('Skip for not finding ceph ps')
ps_uuid = ps.uuid
aliasName = 'test_aliasName_new_vm_life'
poolName = 'for_test_vm_life_cycle_sas_pool'
description = 'test_description'
isCreate = 'true'
test_util.test_dsc('add new pool by zstack')
ps_ops.add_ceph_primary_storage_pool(ps_uuid, poolName, aliasName, isCreate, poolType="Root")
cond = res_ops.gen_query_conditions('aliasName', '=', aliasName)
pool = res_ops.query_resource(res_ops.CEPH_PRIMARY_STORAGE_POOL, cond)[0]
print pool
test_util.test_dsc("poolName: " + str(pool.poolName))
if pool.poolName != poolName:
test_util.test_fail('Find wrong pool should find: ' + str(poolName) + 'But find: ' + str(pool.poolName))
#create vm on sas pool
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
image_uuid = test_lib.lib_get_image_by_name(
os.environ.get('imageName_s')).uuid
l3net_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3PublicNetworkName')).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_creation_option.set_rootVolume_systemTags(["ceph::rootPoolName::for_test_vm_life_cycle_sas_pool"])
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
test_util.test_dsc('Create sas VM Test Success')
#stop vm
vm.stop()
#vm.check()
#start vm
vm.start()
vm.clone(["clone_vm"])
target_host = test_lib.lib_find_random_host(vm.vm)
vm.migrate(target_host.uuid)
current_host = test_lib.lib_find_host_by_vm(vm.vm)
new_host = test_lib.lib_get_vm_host(vm.vm)
if not new_host:
test_util.test_fail('Not find available Hosts to do migration')
if new_host.uuid != target_host.uuid:
test_util.test_fail('[vm:] did not migrate from [host:] %s to target [host:] %s, but to [host:] %s' % (vm.vm.uuid, current_host.uuid, target_host.uuid, new_host.uuid))
else:
test_util.test_logger('[vm:] %s has been migrated from [host:] %s to [host:] %s' % (vm.vm.uuid, current_host.uuid, target_host.uuid))
test_util.test_pass('Test vm life cycle Success')
def test():
global project_uuid, project_admin_uuid, virtual_id_uuid
# 1 create project
project_name = 'test_project'
project = iam2_ops.create_iam2_project(project_name)
project_uuid = project.uuid
project_linked_account_uuid = project.linkedAccountUuid
# 2 create virtual id
project_admin_name = 'username'
project_admin_password = '******'
project_admin_uuid = iam2_ops.create_iam2_virtual_id(
project_admin_name, project_admin_password).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo',
'password').uuid
# 3 create project admin
iam2_ops.add_iam2_virtual_ids_to_project([project_admin_uuid],
project_uuid)
attributes = [{"name": "__ProjectAdmin__", "value": project_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(project_admin_uuid, attributes)
# 4 login in project by project admin
project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(
project_admin_name, project_admin_password)
project_login_uuid = iam2_ops.login_iam2_project(
project_name, session_uuid=project_admin_session_uuid).uuid
# iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes)
# Image related ops: Add, Delete, Expunge, sync image size, Update QGA, delete, expunge
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE)[0]
image_option = test_util.ImageOption()
image_option.set_name('fake_image')
image_option.set_description('fake image')
image_option.set_format('raw')
image_option.set_mediaType('RootVolumeTemplate')
image_option.set_backup_storage_uuid_list([bs.uuid])
image_option.url = "http://fake/fake.raw"
image_option.set_session_uuid(project_login_uuid)
image_uuid = img_ops.add_image(image_option).uuid
img_ops.sync_image_size(image_uuid, session_uuid=project_login_uuid)
img_ops.change_image_state(image_uuid,
'disable',
session_uuid=project_login_uuid)
img_ops.change_image_state(image_uuid,
'enable',
session_uuid=project_login_uuid)
if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE:
img_ops.export_image_from_backup_storage(
image_uuid, bs.uuid, session_uuid=project_login_uuid)
img_ops.delete_exported_image_from_backup_storage(
image_uuid, bs.uuid, session_uuid=project_login_uuid)
img_ops.set_image_qga_enable(image_uuid, session_uuid=project_login_uuid)
img_ops.set_image_qga_disable(image_uuid, session_uuid=project_login_uuid)
img_ops.delete_image(image_uuid, session_uuid=project_login_uuid)
img_ops.expunge_image(image_uuid, session_uuid=project_login_uuid)
# Volume related ops: Create, Delete, Expunge, Attach, Dettach, Enable, Disable
disk_offering_uuid = res_ops.query_resource(res_ops.DISK_OFFERING)[0].uuid
acc_ops.share_resources([project_linked_account_uuid],
[disk_offering_uuid])
volume_option = test_util.VolumeOption()
volume_option.set_disk_offering_uuid(disk_offering_uuid)
volume_option.set_name('data_volume_project_management')
volume_option.set_session_uuid(project_login_uuid)
data_volume = vol_ops.create_volume_from_offering(volume_option)
vol_ops.stop_volume(data_volume.uuid, session_uuid=project_login_uuid)
vol_ops.start_volume(data_volume.uuid, session_uuid=project_login_uuid)
vm_creation_option = test_util.VmOption()
l3_net_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3VlanNetwork3')).uuid
acc_ops.share_resources([project_linked_account_uuid], [l3_net_uuid])
vm_creation_option.set_l3_uuids([l3_net_uuid])
image_uuid = test_lib.lib_get_image_by_name("centos").uuid
vm_creation_option.set_image_uuid(image_uuid)
acc_ops.share_resources([project_linked_account_uuid], [image_uuid])
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
acc_ops.share_resources([project_linked_account_uuid],
[instance_offering_uuid])
vm_creation_option.set_name('vm_for_project_management')
vm_creation_option.set_session_uuid(project_login_uuid)
vm = test_stub.create_vm(image_uuid=image_uuid,
session_uuid=project_login_uuid)
vm_uuid = vm.get_vm().uuid
vol_ops.attach_volume(data_volume.uuid,
vm_uuid,
session_uuid=project_login_uuid)
vol_ops.detach_volume(data_volume.uuid,
vm_uuid,
session_uuid=project_login_uuid)
vol_ops.delete_volume(data_volume.uuid, session_uuid=project_login_uuid)
vol_ops.expunge_volume(data_volume.uuid, session_uuid=project_login_uuid)
# VM related ops: Create, Delete, Expunge, Start, Stop, Suspend, Resume, Migrate
vm_ops.stop_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.start_vm(vm_uuid, session_uuid=project_login_uuid)
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
if candidate_hosts != None and test_lib.lib_check_vm_live_migration_cap(
vm.get_vm()):
vm_ops.migrate_vm(vm_uuid,
candidate_hosts.inventories[0].uuid,
session_uuid=project_login_uuid)
vm_ops.stop_vm(vm_uuid, force='cold', session_uuid=project_login_uuid)
vm_ops.start_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.suspend_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.resume_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.destroy_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.expunge_vm(vm_uuid, session_uuid=project_login_uuid)
# L2 related ops: create, delete
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
try:
l2 = net_ops.create_l2_novlan('l2_for_pm',
'eth0',
zone_uuid,
session_uuid=project_login_uuid)
test_util.test_fail(
"Expect exception: project admin not allowed to create Novlan L2 except vxlan"
)
except:
pass
try:
l2 = net_ops.create_l2_vlan('l2_for_pm',
'eth0',
zone_uuid,
1234,
session_uuid=project_login_uuid)
test_util.test_fail(
"Expect exception: project admin not allowed to create vlan L2 except vxlan"
)
except:
pass
#net_ops.delete_l2(l2.uuid, session_uuid=project_login_uuid)
# L3 related ops:
# network service ops:
# zwatch ops:
# scheduler ops:
# certificate
# 11 delete
acc_ops.logout(project_login_uuid)
iam2_ops.delete_iam2_virtual_id(virtual_id_uuid)
iam2_ops.delete_iam2_virtual_id(project_admin_uuid)
iam2_ops.delete_iam2_project(project_uuid)
iam2_ops.expunge_iam2_project(project_uuid)
test_util.test_pass('success test iam2 login in by project admin!')
def test():
global project_uuid, project_admin_uuid, virtual_id_uuid, project_operator_uuid, plain_user_uuid
flavor = case_flavor[os.environ.get('CASE_FLAVOR')]
# 1 create project
project_name = 'test_project'
project = iam2_ops.create_iam2_project(project_name)
project_uuid = project.uuid
project_linked_account_uuid = project.linkedAccountUuid
if flavor['target_role'] == 'project_admin':
# 2 create virtual id
project_admin_name = 'username'
project_admin_password = '******'
project_admin_uuid = iam2_ops.create_iam2_virtual_id(project_admin_name, project_admin_password).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo', 'password').uuid
# 3 create project admin
iam2_ops.add_iam2_virtual_ids_to_project([project_admin_uuid],project_uuid)
attributes = [{"name": "__ProjectAdmin__", "value": project_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(project_admin_uuid, attributes)
# login in project by project admin
project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(project_admin_name, project_admin_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name, session_uuid=project_admin_session_uuid).uuid
# iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes)
elif flavor['target_role'] == 'project_operator':
project_operator_name = 'username2'
project_operator_password = '******'
attributes = [{"name": "__ProjectOperator__", "value": project_uuid}]
project_operator_uuid = iam2_ops.create_iam2_virtual_id(project_operator_name,project_operator_password,attributes=attributes).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernamethree','password').uuid
# login in project by project operator
iam2_ops.add_iam2_virtual_ids_to_project([project_operator_uuid],project_uuid)
project_operator_session_uuid = iam2_ops.login_iam2_virtual_id(project_operator_name,project_operator_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name,session_uuid=project_operator_session_uuid).uuid
elif flavor['target_role'] == 'project_member':
plain_user_name = 'username'
plain_user_password = '******'
plain_user_uuid = iam2_ops.create_iam2_virtual_id(plain_user_name, plain_user_password,
project_uuid=project_uuid).uuid
# 3 add virtual id to project
iam2_ops.add_iam2_virtual_ids_to_project([plain_user_uuid],project_uuid)
# 4 login in project by plain user
plain_user_session_uuid = iam2_ops.login_iam2_virtual_id(plain_user_name, plain_user_password)
# 4 login in project
#project_inv=iam2_ops.get_iam2_projects_of_virtual_id(plain_user_session_uuid)
project_login_uuid = iam2_ops.login_iam2_project(project_name, plain_user_session_uuid).uuid
# Image related ops: Add, Delete, Expunge, sync image size, Update QGA, delete, expunge
if flavor['target_role'] == 'project_member':
statements = [{"effect": "Allow", "actions": ["org.zstack.header.vm.**"]}]
role_uuid = iam2_ops.create_role('test_role', statements).uuid
iam2_ops.add_roles_to_iam2_virtual_id([role_uuid], plain_user_uuid)
vm_creation_option = test_util.VmOption()
l3_net_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetwork3')).uuid
acc_ops.share_resources([project_linked_account_uuid], [l3_net_uuid])
vm_creation_option.set_l3_uuids([l3_net_uuid])
image_uuid = test_lib.lib_get_image_by_name("centos").uuid
vm_creation_option.set_image_uuid(image_uuid)
acc_ops.share_resources([project_linked_account_uuid], [image_uuid])
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
acc_ops.share_resources([project_linked_account_uuid], [instance_offering_uuid])
vm_creation_option.set_name('vm_for_project_management')
vm_creation_option.set_session_uuid(project_login_uuid)
vm = test_stub.create_vm(image_uuid = image_uuid, session_uuid=project_login_uuid)
vm_uuid = vm.get_vm().uuid
# VM related ops: Create, Delete, Expunge, Start, Stop, Suspend, Resume, Migrate
vm_ops.stop_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.start_vm(vm_uuid, session_uuid=project_login_uuid)
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
if candidate_hosts != None and test_lib.lib_check_vm_live_migration_cap(vm.get_vm()):
vm_ops.migrate_vm(vm_uuid, candidate_hosts.inventories[0].uuid, session_uuid=project_login_uuid)
vm_ops.stop_vm(vm_uuid, force='cold', session_uuid=project_login_uuid)
vm_ops.start_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.suspend_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.resume_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.destroy_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.expunge_vm(vm_uuid, session_uuid=project_login_uuid)
# 11 delete
acc_ops.logout(project_login_uuid)
if virtual_id_uuid != None:
iam2_ops.delete_iam2_virtual_id(virtual_id_uuid)
if project_admin_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_admin_uuid)
if project_operator_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_operator_uuid)
if plain_user_uuid != None:
iam2_ops.delete_iam2_virtual_id(plain_user_uuid)
iam2_ops.delete_iam2_project(project_uuid)
iam2_ops.expunge_iam2_project(project_uuid)
test_util.test_pass('success test iam2 login in by project admin!')
def test():
test_util.test_dsc('create ceph pool')
try:
ps = res_ops.query_resource(res_ops.CEPH_PRIMARY_STORAGE)[0]
except Exception as e:
test_util.test_dsc(str(e))
test_util.test_skip('Skip for not finding ceph ps')
ps_uuid = ps.uuid
try:
ceph_node_ip = ps.mons[0].monAddr
except Exception as e:
test_util.test_dsc(str(e))
test_util.test_fail('Fail to get mon ip')
create_pool_cmd = 'ceph osd pool create test_create_root_ssd_pool 4'
try:
(ret, out, eout) = ssh.execute(create_pool_cmd, ceph_node_ip, 'root', 'password')
except Exception as e:
test_util.test_dsc(str(e))
test_util.test_fail('Fail to create pool by using ceph command')
aliasName = 'test_aliasName_new'
poolName = 'test_create_root_sas_pool'
description = 'test_description'
isCreate = 'true'
test_util.test_dsc('add new pool by zstack')
ps_ops.add_ceph_primary_storage_pool(ps_uuid, poolName, aliasName, isCreate, poolType="Root")
cond = res_ops.gen_query_conditions('aliasName', '=', aliasName)
pool = res_ops.query_resource(res_ops.CEPH_PRIMARY_STORAGE_POOL, cond)[0]
print pool
test_util.test_dsc("poolName: " + str(pool.poolName))
if pool.poolName != poolName:
test_util.test_fail('Find wrong pool should find: ' + str(poolName) + 'But find: ' + str(pool.poolName))
test_util.test_dsc('add exist pool by zstack')
aliasName = 'test_aliasName_exist'
ps_ops.add_ceph_primary_storage_pool(ps_uuid, 'test_create_root_ssd_pool', aliasName, poolType="Root")
cond = res_ops.gen_query_conditions('aliasName', '=', aliasName)
pool = res_ops.query_resource(res_ops.CEPH_PRIMARY_STORAGE_POOL, cond)[0]
test_util.test_dsc("poolName: " + str(pool.poolName))
if pool.poolName != 'test_create_root_ssd_pool':
test_util.test_fail('Find wrong pool should find: test_create_root_ssd_pool But find: ' + str(pool.poolName))
#create vm on sas pool
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
image_uuid = test_lib.lib_get_image_by_name(
os.environ.get('imageName_s')).uuid
l3net_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3PublicNetworkName')).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_creation_option.set_rootVolume_systemTags(["ceph::rootPoolName::test_create_root_sas_pool"])
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
test_util.test_dsc('Create sas VM Test Success')
vm_creation_option.set_rootVolume_systemTags(["ceph::rootPoolName::test_create_root_ssd_pool"])
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
test_util.test_dsc('Create ssd VM Test Success')
vm_creation_option.set_rootVolume_systemTags([])
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
test_util.test_pass('Create ssd VM Test Success')
def test():
global project_uuid, project_admin_uuid, virtual_id_uuid, project_operator_uuid, plain_user_uuid
flavor = case_flavor[os.environ.get('CASE_FLAVOR')]
# 1 create project
project_name = 'test_project'
project = iam2_ops.create_iam2_project(project_name)
project_uuid = project.uuid
project_linked_account_uuid = project.linkedAccountUuid
if flavor['target_role'] == 'project_admin':
# 2 create virtual id
project_admin_name = 'username'
project_admin_password = '******'
project_admin_uuid = iam2_ops.create_iam2_virtual_id(project_admin_name, project_admin_password).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo', 'password').uuid
# 3 create project admin
iam2_ops.add_iam2_virtual_ids_to_project([project_admin_uuid],project_uuid)
attributes = [{"name": "__ProjectAdmin__", "value": project_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(project_admin_uuid, attributes)
# login in project by project admin
project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(project_admin_name, project_admin_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name, session_uuid=project_admin_session_uuid).uuid
# iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes)
elif flavor['target_role'] == 'project_operator':
project_operator_name = 'username2'
project_operator_password = '******'
attributes = [{"name": "__ProjectOperator__", "value": project_uuid}]
project_operator_uuid = iam2_ops.create_iam2_virtual_id(project_operator_name,project_operator_password,attributes=attributes).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernamethree','password').uuid
# login in project by project operator
iam2_ops.add_iam2_virtual_ids_to_project([project_operator_uuid],project_uuid)
project_operator_session_uuid = iam2_ops.login_iam2_virtual_id(project_operator_name,project_operator_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name,session_uuid=project_operator_session_uuid).uuid
elif flavor['target_role'] == 'project_member':
plain_user_name = 'username'
plain_user_password = '******'
plain_user_uuid = iam2_ops.create_iam2_virtual_id(plain_user_name, plain_user_password,
project_uuid=project_uuid).uuid
# 3 add virtual id to project
iam2_ops.add_iam2_virtual_ids_to_project([plain_user_uuid],project_uuid)
# 4 login in project by plain user
plain_user_session_uuid = iam2_ops.login_iam2_virtual_id(plain_user_name, plain_user_password)
# 4 login in project
#project_inv=iam2_ops.get_iam2_projects_of_virtual_id(plain_user_session_uuid)
project_login_uuid = iam2_ops.login_iam2_project(project_name, plain_user_session_uuid).uuid
# Image related ops: Add, Delete, Expunge, sync image size, Update QGA, delete, expunge
if flavor['target_role'] == 'project_member':
statements = [{"effect": "Allow", "actions": ["org.zstack.header.vm.**"]}, {"effect": "Allow", "actions": ["org.zstack.scheduler.**"]}]
role_uuid = iam2_ops.create_role('test_role', statements).uuid
iam2_ops.add_roles_to_iam2_virtual_id([role_uuid], plain_user_uuid)
vm_creation_option = test_util.VmOption()
l3_net_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetwork3')).uuid
acc_ops.share_resources([project_linked_account_uuid], [l3_net_uuid])
vm_creation_option.set_l3_uuids([l3_net_uuid])
image_uuid = test_lib.lib_get_image_by_name("centos").uuid
vm_creation_option.set_image_uuid(image_uuid)
acc_ops.share_resources([project_linked_account_uuid], [image_uuid])
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
acc_ops.share_resources([project_linked_account_uuid], [instance_offering_uuid])
vm_creation_option.set_name('vm_for_project_management')
vm_creation_option.set_session_uuid(project_login_uuid)
vm = test_stub.create_vm(image_uuid = image_uuid, session_uuid=project_login_uuid)
# scheduler ops:
start_date = int(time.time())
schd_job1 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None, session_uuid=project_login_uuid)
schd_trigger1 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+5, None, 15, 'simple', session_uuid=project_login_uuid)
schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid, session_uuid=project_login_uuid)
schd_ops.change_scheduler_state(schd_job1.uuid, 'disable', session_uuid=project_login_uuid)
schd_ops.change_scheduler_state(schd_job1.uuid, 'enable', session_uuid=project_login_uuid)
schd_ops.remove_scheduler_job_from_trigger(schd_trigger1.uuid, schd_job1.uuid, session_uuid=project_login_uuid)
schd_ops.del_scheduler_job(schd_job1.uuid, session_uuid=project_login_uuid)
schd_ops.del_scheduler_trigger(schd_trigger1.uuid, session_uuid=project_login_uuid)
schd_ops.get_current_time()
vm_ops.destroy_vm(vm.get_vm().uuid, session_uuid=project_login_uuid)
vm_ops.expunge_vm(vm.get_vm().uuid, session_uuid=project_login_uuid)
# 11 delete
acc_ops.logout(project_login_uuid)
if virtual_id_uuid != None:
iam2_ops.delete_iam2_virtual_id(virtual_id_uuid)
if project_admin_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_admin_uuid)
if project_operator_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_operator_uuid)
if plain_user_uuid != None:
iam2_ops.delete_iam2_virtual_id(plain_user_uuid)
iam2_ops.delete_iam2_project(project_uuid)
iam2_ops.expunge_iam2_project(project_uuid)
test_util.test_pass('success test iam2 login in by project admin!')
def test():
from vncdotool import api
global vm
session_uuid = None
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid
cond = res_ops.gen_query_conditions('mediaType', '!=', 'ISO')
cond = res_ops.gen_query_conditions('platform', '=', 'Linux', cond)
image_uuid = res_ops.query_resource(res_ops.IMAGE, cond, session_uuid)[0].uuid
l3net_uuid = res_ops.get_resource(res_ops.L3_NETWORK, session_uuid)[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_creation_option.set_console_password(password1)
vm = test_vm.ZstackTestVm()
vm.set_creation_option(vm_creation_option)
vm.create()
vm.check()
console = test_lib.lib_get_vm_console_address(vm.get_vm().uuid)
test_util.test_logger('[vm:] %s console is on %s:%s' % (vm.get_vm().uuid, console.hostIp, console.port))
display = str(int(console.port)-5900)
try:
client = api.connect(console.hostIp+":"+display)
client.keyPress('k')
test_util.test_fail('[vm:] %s console on %s:%s is connectable without password' % (vm.get_vm().uuid, console.hostIp, console.port))
except:
test_util.test_logger('[vm:] %s console on %s:%s is not connectable without password' % (vm.get_vm().uuid, console.hostIp, console.port))
try:
client = api.connect(console.hostIp+":"+display, password1)
client.keyPress('k')
test_util.test_logger('[vm:] %s console on %s:%s is connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))
except:
test_util.test_fail('[vm:] %s console on %s:%s is not connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))
test_lib.lib_set_vm_console_password(vm.get_vm().uuid, password2)
test_util.test_logger('set [vm:] %s console with password %s' % (vm.get_vm().uuid, password2))
vm.reboot()
try:
client = api.connect(console.hostIp+":"+display, password2)
client.keyPress('k')
test_util.test_logger('[vm:] %s console on %s:%s is connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password2))
except:
test_util.test_fail('[vm:] %s console on %s:%s is not connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password2))
import signal
def handler(signum, frame):
raise Exception()
signal.signal(signal.SIGALRM, handler)
signal.alarm(30)
try:
client = api.connect(console.hostIp+":"+display, password1)
client.keyPress('k')
test_util.test_fail('[vm:] %s console on %s:%s is connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))
except:
test_util.test_logger('[vm:] %s console on %s:%s is not connectable with password %s' % (vm.get_vm().uuid, console.hostIp, console.port, password1))
vm.destroy()
test_util.test_pass('Set VM Console Password Test Success')
def test():
global project_uuid, project_admin_uuid, virtual_id_uuid, project_operator_uuid, plain_user_uuid
flavor = case_flavor[os.environ.get('CASE_FLAVOR')]
# 1 create project
project_name = 'test_project'
project = iam2_ops.create_iam2_project(project_name)
project_uuid = project.uuid
project_linked_account_uuid = project.linkedAccountUuid
if flavor['target_role'] == 'project_admin':
# 2 create virtual id
project_admin_name = 'username'
project_admin_password = '******'
project_admin_uuid = iam2_ops.create_iam2_virtual_id(
project_admin_name, project_admin_password).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id(
'usernametwo', 'password').uuid
# 3 create project admin
iam2_ops.add_iam2_virtual_ids_to_project([project_admin_uuid],
project_uuid)
attributes = [{"name": "__ProjectAdmin__", "value": project_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(project_admin_uuid,
attributes)
# login in project by project admin
project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(
project_admin_name, project_admin_password)
project_login_uuid = iam2_ops.login_iam2_project(
project_name, session_uuid=project_admin_session_uuid).uuid
# iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes)
elif flavor['target_role'] == 'project_operator':
project_operator_name = 'username2'
project_operator_password = '******'
attributes = [{"name": "__ProjectOperator__", "value": project_uuid}]
project_operator_uuid = iam2_ops.create_iam2_virtual_id(
project_operator_name,
project_operator_password,
attributes=attributes).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id(
'usernamethree', 'password').uuid
# login in project by project operator
iam2_ops.add_iam2_virtual_ids_to_project([project_operator_uuid],
project_uuid)
project_operator_session_uuid = iam2_ops.login_iam2_virtual_id(
project_operator_name, project_operator_password)
project_login_uuid = iam2_ops.login_iam2_project(
project_name, session_uuid=project_operator_session_uuid).uuid
elif flavor['target_role'] == 'project_member':
plain_user_name = 'username'
plain_user_password = '******'
plain_user_uuid = iam2_ops.create_iam2_virtual_id(
plain_user_name, plain_user_password,
project_uuid=project_uuid).uuid
# 3 add virtual id to project
iam2_ops.add_iam2_virtual_ids_to_project([plain_user_uuid],
project_uuid)
# 4 login in project by plain user
plain_user_session_uuid = iam2_ops.login_iam2_virtual_id(
plain_user_name, plain_user_password)
# 4 login in project
#project_inv=iam2_ops.get_iam2_projects_of_virtual_id(plain_user_session_uuid)
project_login_uuid = iam2_ops.login_iam2_project(
project_name, plain_user_session_uuid).uuid
# Image related ops: Add, Delete, Expunge, sync image size, Update QGA, delete, expunge
if flavor['target_role'] == 'project_member':
statements = [{
"effect": "Allow",
"actions": ["org.zstack.header.vm.**"]
}]
role_uuid = iam2_ops.create_role('test_role', statements).uuid
iam2_ops.add_roles_to_iam2_virtual_id([role_uuid], plain_user_uuid)
vm_creation_option = test_util.VmOption()
pub_l3_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3PublicNetworkName')).uuid
l3_net_uuid = test_lib.lib_get_l3_by_name(
os.environ.get('l3VlanNetworkName3')).uuid
acc_ops.share_resources([project_linked_account_uuid], [l3_net_uuid])
vm_creation_option.set_l3_uuids([l3_net_uuid])
image_uuid = test_lib.lib_get_image_by_name(
os.environ.get('imageName_net')).uuid
vm_creation_option.set_image_uuid(image_uuid)
acc_ops.share_resources([project_linked_account_uuid], [image_uuid])
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(
os.environ.get('instanceOfferingName_s')).uuid
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
acc_ops.share_resources([project_linked_account_uuid],
[instance_offering_uuid])
vm_creation_option.set_name('vm_for_project_management')
vm_creation_option.set_session_uuid(project_login_uuid)
vm = test_stub.create_vm(image_uuid=image_uuid,
session_uuid=project_login_uuid)
vm_uuid = vm.get_vm().uuid
vip_option = test_util.VipOption()
vip_option.set_name("vip for pm")
vip_option.set_session_uuid(project_login_uuid)
vip_option.set_l3_uuid(pub_l3_uuid)
vm_nic = vm.vm.vmNics[0]
vm_nic_uuid = vm_nic.uuid
vip = net_ops.create_vip(vip_option)
eip_option = test_util.EipOption()
eip_option.set_name('eip for pm')
eip_option.set_session_uuid(project_login_uuid)
eip_option.set_vip_uuid(vip.uuid)
eip_option.set_vm_nic_uuid(vm_nic_uuid)
eip = net_ops.create_eip(eip_option)
net_ops.detach_eip(eip.uuid, session_uuid=project_login_uuid)
net_ops.attach_eip(eip.uuid, vm_nic_uuid, session_uuid=project_login_uuid)
net_ops.detach_eip(eip.uuid, session_uuid=project_login_uuid)
net_ops.delete_eip(eip.uuid)
net_ops.delete_vip(vip.uuid)
vm_ops.destroy_vm(vm_uuid, session_uuid=project_login_uuid)
vm_ops.expunge_vm(vm_uuid, session_uuid=project_login_uuid)
# 11 delete
acc_ops.logout(project_login_uuid)
if virtual_id_uuid != None:
iam2_ops.delete_iam2_virtual_id(virtual_id_uuid)
if project_admin_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_admin_uuid)
if project_operator_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_operator_uuid)
if plain_user_uuid != None:
iam2_ops.delete_iam2_virtual_id(plain_user_uuid)
iam2_ops.delete_iam2_project(project_uuid)
iam2_ops.expunge_iam2_project(project_uuid)
test_util.test_pass('success test iam2 login in by project admin!')
def test():
global project_uuid, project_admin_uuid, virtual_id_uuid, project_operator_uuid, plain_user_uuid
flavor = case_flavor[os.environ.get('CASE_FLAVOR')]
# 1 create project
if flavor['target_role'] != 'system_admin':
project_name = 'test_project'
project = iam2_ops.create_iam2_project(project_name)
project_uuid = project.uuid
project_linked_account_uuid = project.linkedAccountUuid
if flavor['target_role'] == 'project_admin':
# 2 create virtual id
project_admin_name = 'username'
project_admin_password = '******'
project_admin_uuid = iam2_ops.create_iam2_virtual_id(project_admin_name, project_admin_password).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo', 'password').uuid
# 3 create project admin
iam2_ops.add_iam2_virtual_ids_to_project([project_admin_uuid],project_uuid)
attributes = [{"name": "__ProjectAdmin__", "value": project_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(project_admin_uuid, attributes)
# login in project by project admin
project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(project_admin_name, project_admin_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name, session_uuid=project_admin_session_uuid).uuid
# iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes)
elif flavor['target_role'] == 'project_operator':
project_operator_name = 'username2'
project_operator_password = '******'
attributes = [{"name": "__ProjectOperator__", "value": project_uuid}]
project_operator_uuid = iam2_ops.create_iam2_virtual_id(project_operator_name,project_operator_password,attributes=attributes).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernamethree','password').uuid
# login in project by project operator
iam2_ops.add_iam2_virtual_ids_to_project([project_operator_uuid],project_uuid)
project_operator_session_uuid = iam2_ops.login_iam2_virtual_id(project_operator_name,project_operator_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name,session_uuid=project_operator_session_uuid).uuid
elif flavor['target_role'] == 'project_member':
plain_user_name = 'username'
plain_user_password = '******'
plain_user_uuid = iam2_ops.create_iam2_virtual_id(plain_user_name, plain_user_password,
project_uuid=project_uuid).uuid
# 3 add virtual id to project
iam2_ops.add_iam2_virtual_ids_to_project([plain_user_uuid],project_uuid)
# 4 login in project by plain user
plain_user_session_uuid = iam2_ops.login_iam2_virtual_id(plain_user_name, plain_user_password)
# 4 login in project
#project_inv=iam2_ops.get_iam2_projects_of_virtual_id(plain_user_session_uuid)
project_login_uuid = iam2_ops.login_iam2_project(project_name, plain_user_session_uuid).uuid
elif flavor['target_role'] == 'system_admin':
username = "******"
password = '******'
vid_tst_obj = test_vid.ZstackTestVid()
test_stub.create_system_admin(username, password, vid_tst_obj)
virtual_id_uuid = vid_tst_obj.get_vid().uuid
project_login_uuid = acc_ops.login_by_account(username, password)
# Image related ops: Add, Delete, Expunge, sync image size, Update QGA, delete, expunge
if flavor['target_role'] == 'project_member':
statements = [{"effect": "Allow", "actions": ["org.zstack.header.vm.**"]}, {"effect": "Allow", "actions": ["org.zstack.scheduler.**"]}]
role_uuid = iam2_ops.create_role('test_role', statements).uuid
iam2_ops.add_roles_to_iam2_virtual_id([role_uuid], plain_user_uuid)
vm_creation_option = test_util.VmOption()
l3_net_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetwork3')).uuid
if flavor['target_role'] != 'system_admin':
acc_ops.share_resources([project_linked_account_uuid], [l3_net_uuid])
vm_creation_option.set_l3_uuids([l3_net_uuid])
image_uuid = test_lib.lib_get_image_by_name("centos").uuid
vm_creation_option.set_image_uuid(image_uuid)
if flavor['target_role'] != 'system_admin':
acc_ops.share_resources([project_linked_account_uuid], [image_uuid])
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
if flavor['target_role'] != 'system_admin':
acc_ops.share_resources([project_linked_account_uuid], [instance_offering_uuid])
vm_creation_option.set_name('vm_for_project_management')
vm_creation_option.set_session_uuid(project_login_uuid)
vm = test_stub.create_vm(image_uuid = image_uuid, session_uuid=project_login_uuid)
# scheduler ops:
start_date = int(time.time())
schd_job1 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None, session_uuid=project_login_uuid)
schd_trigger1 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+5, None, 15, 'simple', session_uuid=project_login_uuid)
schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid, session_uuid=project_login_uuid)
schd_ops.change_scheduler_state(schd_job1.uuid, 'disable', session_uuid=project_login_uuid)
schd_ops.change_scheduler_state(schd_job1.uuid, 'enable', session_uuid=project_login_uuid)
schd_ops.remove_scheduler_job_from_trigger(schd_trigger1.uuid, schd_job1.uuid, session_uuid=project_login_uuid)
schd_ops.del_scheduler_job(schd_job1.uuid, session_uuid=project_login_uuid)
schd_ops.del_scheduler_trigger(schd_trigger1.uuid, session_uuid=project_login_uuid)
schd_ops.get_current_time()
vm_ops.destroy_vm(vm.get_vm().uuid, session_uuid=project_login_uuid)
vm_ops.expunge_vm(vm.get_vm().uuid, session_uuid=project_login_uuid)
# 11 delete
acc_ops.logout(project_login_uuid)
if virtual_id_uuid != None:
iam2_ops.delete_iam2_virtual_id(virtual_id_uuid)
if project_admin_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_admin_uuid)
if project_operator_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_operator_uuid)
if plain_user_uuid != None:
iam2_ops.delete_iam2_virtual_id(plain_user_uuid)
if flavor['target_role'] != 'system_admin':
iam2_ops.delete_iam2_project(project_uuid)
iam2_ops.expunge_iam2_project(project_uuid)
test_util.test_pass('success test iam2 login in by project admin!')
def test():
global project_uuid, project_admin_uuid, virtual_id_uuid, project_operator_uuid, plain_user_uuid
flavor = case_flavor[os.environ.get('CASE_FLAVOR')]
# 1 create project
project_name = 'test_project'
project = iam2_ops.create_iam2_project(project_name)
project_uuid = project.uuid
project_linked_account_uuid = project.linkedAccountUuid
if flavor['target_role'] == 'project_admin':
# 2 create virtual id
project_admin_name = 'username'
project_admin_password = '******'
project_admin_uuid = iam2_ops.create_iam2_virtual_id(project_admin_name, project_admin_password).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo', 'password').uuid
# 3 create project admin
iam2_ops.add_iam2_virtual_ids_to_project([project_admin_uuid],project_uuid)
attributes = [{"name": "__ProjectAdmin__", "value": project_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(project_admin_uuid, attributes)
# login in project by project admin
project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(project_admin_name, project_admin_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name, session_uuid=project_admin_session_uuid).uuid
# iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes)
elif flavor['target_role'] == 'project_operator':
project_operator_name = 'username2'
project_operator_password = '******'
attributes = [{"name": "__ProjectOperator__", "value": project_uuid}]
project_operator_uuid = iam2_ops.create_iam2_virtual_id(project_operator_name,project_operator_password,attributes=attributes).uuid
virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernamethree','password').uuid
# login in project by project operator
iam2_ops.add_iam2_virtual_ids_to_project([project_operator_uuid],project_uuid)
project_operator_session_uuid = iam2_ops.login_iam2_virtual_id(project_operator_name,project_operator_password)
project_login_uuid = iam2_ops.login_iam2_project(project_name,session_uuid=project_operator_session_uuid).uuid
elif flavor['target_role'] == 'project_member':
plain_user_name = 'username'
plain_user_password = '******'
plain_user_uuid = iam2_ops.create_iam2_virtual_id(plain_user_name, plain_user_password,
project_uuid=project_uuid).uuid
# 3 add virtual id to project
iam2_ops.add_iam2_virtual_ids_to_project([plain_user_uuid],project_uuid)
# 4 login in project by plain user
plain_user_session_uuid = iam2_ops.login_iam2_virtual_id(plain_user_name, plain_user_password)
# 4 login in project
#project_inv=iam2_ops.get_iam2_projects_of_virtual_id(plain_user_session_uuid)
project_login_uuid = iam2_ops.login_iam2_project(project_name, plain_user_session_uuid).uuid
# Image related ops: Add, Delete, Expunge, sync image size, Update QGA, delete, expunge
if flavor['target_role'] == 'project_member':
statements = [{"effect": "Allow", "actions": ["org.zstack.header.volume.**"]}, {"effect": "Allow", "actions": ["org.zstack.header.vm.**"]}]
role_uuid = iam2_ops.create_role('test_role', statements).uuid
iam2_ops.add_roles_to_iam2_virtual_id([role_uuid], plain_user_uuid)
# Volume related ops: Create, Delete, Expunge, Attach, Dettach, Enable, Disable
disk_offering_uuid = res_ops.query_resource(res_ops.DISK_OFFERING)[0].uuid
acc_ops.share_resources([project_linked_account_uuid], [disk_offering_uuid])
volume_option = test_util.VolumeOption()
volume_option.set_disk_offering_uuid(disk_offering_uuid)
volume_option.set_name('data_volume_project_management')
volume_option.set_session_uuid(project_login_uuid)
data_volume = vol_ops.create_volume_from_offering(volume_option)
vol_ops.stop_volume(data_volume.uuid, session_uuid=project_login_uuid)
vol_ops.start_volume(data_volume.uuid, session_uuid=project_login_uuid)
vm_creation_option = test_util.VmOption()
l3_net_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetwork3')).uuid
acc_ops.share_resources([project_linked_account_uuid], [l3_net_uuid])
vm_creation_option.set_l3_uuids([l3_net_uuid])
image_uuid = test_lib.lib_get_image_by_name("centos").uuid
vm_creation_option.set_image_uuid(image_uuid)
acc_ops.share_resources([project_linked_account_uuid], [image_uuid])
instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
acc_ops.share_resources([project_linked_account_uuid], [instance_offering_uuid])
vm_creation_option.set_name('vm_for_project_management')
vm_creation_option.set_session_uuid(project_login_uuid)
vm = test_stub.create_vm(image_uuid = image_uuid, session_uuid=project_login_uuid)
vm_uuid = vm.get_vm().uuid
vol_ops.attach_volume(data_volume.uuid, vm_uuid, session_uuid=project_login_uuid)
vol_ops.detach_volume(data_volume.uuid, vm_uuid, session_uuid=project_login_uuid)
vol_ops.delete_volume(data_volume.uuid, session_uuid=project_login_uuid)
vol_ops.expunge_volume(data_volume.uuid, session_uuid=project_login_uuid)
# 11 delete
acc_ops.logout(project_login_uuid)
if virtual_id_uuid != None:
iam2_ops.delete_iam2_virtual_id(virtual_id_uuid)
if project_admin_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_admin_uuid)
if project_operator_uuid != None:
iam2_ops.delete_iam2_virtual_id(project_operator_uuid)
if plain_user_uuid != None:
iam2_ops.delete_iam2_virtual_id(plain_user_uuid)
iam2_ops.delete_iam2_project(project_uuid)
iam2_ops.expunge_iam2_project(project_uuid)
test_util.test_pass('success test iam2 login in by project admin!')
