def error_cleanup():
global disaster_bs_uuid
global image_uuid
global vm
vm_ops.destroy_vm(vm.uuid)
img_ops.delete_image(image_uuid)
if disaster_bs_uuid != None:
bs_ops.delete_backup_storage(disaster_bs_uuid)
def query_autoscaling_vm_instance_and_destroy_vmm(imageUuid):
Result = autoscaling.query_vm_install([{'name': 'uuid', 'op': '!=', 'value': 'NULL'}])
for evt in Result:
if evt.imageUuid == imageUuid:
test_util.test_logger("%s" %(evt.imageUuid))
vm_ops.destroy_vm(evt.uuid, None, None)
vm_ops.expunge_vm(evt.uuid, None, None)
test_util.test_logger("stop autoscaling vmm instance")
def error_cleanup():
global disaster_bs_uuid
global image_uuid
global vm
vm_ops.destroy_vm(vm.uuid)
img_ops.delete_image(image_uuid)
if disaster_bs_uuid != None:
bs_ops.delete_backup_storage(disaster_bs_uuid)
def error_cleanup():
global vcenter_uuid, vm_uuid
if vm_uuid:
vm_ops.destroy_vm(vm_uuid)
vm_ops.expunge_vm(vm_uuid)
if vcenter_uuid:
vct_ops.delete_vcenter(vcenter_uuid)
def error_cleanup():
global vcenter_uuid, vm_uuid
if vm_uuid:
vm_ops.destroy_vm(vm_uuid)
vm_ops.expunge_vm(vm_uuid)
if vcenter_uuid:
vct_ops.delete_vcenter(vcenter_uuid)
def remove_all_vpc_vrouter():
cond = res_ops.gen_query_conditions('applianceVmType', '=', 'vpcvrouter')
vr_vm_list = res_ops.query_resource(res_ops.APPLIANCE_VM, cond)
if vr_vm_list:
for vr_vm in vr_vm_list:
nic_uuid_list = [nic.uuid for nic in vr_vm.vmNics if nic.metaData == '4']
for nic_uuid in nic_uuid_list:
net_ops.detach_l3(nic_uuid)
vm_ops.destroy_vm(vr_vm.uuid)
def remove_all_vpc_vrouter():
cond = res_ops.gen_query_conditions('applianceVmType', '=', 'vpcvrouter')
vr_vm_list = res_ops.query_resource(res_ops.APPLIANCE_VM, cond)
if vr_vm_list:
for vr_vm in vr_vm_list:
nic_uuid_list = [nic.uuid for nic in vr_vm.vmNics if nic.metaData == '4']
for nic_uuid in nic_uuid_list:
net_ops.detach_l3(nic_uuid)
vm_ops.destroy_vm(vr_vm.uuid)
def test():
global vcenter_uuid, vm_uuid
vcenter1_name = os.environ['vcenter2_name']
vcenter1_domain_name = os.environ['vcenter2_ip']
vcenter1_username = os.environ['vcenter2_domain_name']
vcenter1_password = os.environ['vcenter2_password']
#ova_image_name = os.environ['vcenter2_template_exist']
vm_name = os.environ['vcenter2_no_nic_vm']
network_pattern1 = os.environ['vcenter2_network_pattern1']
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name,
vcenter1_username, vcenter1_password, True,
zone_uuid)
vcenter_uuid = inv.uuid
if vcenter_uuid == None:
test_util.test_fail("vcenter_uuid is None")
#vm = test_stub.create_vm_in_vcenter(vm_name = 'vm-start-stop-test', image_name = ova_image_name, l3_name = network_pattern1)
vm_cond = res_ops.gen_query_conditions("name", '=', vm_name)
vm_inv = res_ops.query_resource_fields(res_ops.VM_INSTANCE,
vm_cond,
None,
fields=['uuid', 'state'])[0]
vm_uuid = vm_inv.uuid
vm_state = vm_inv.state.strip().lower()
if not vm_uuid:
test_util.test_fail("remote woodpecker vm uuid is null")
elif vm_uuid and vm_state != "running":
print "#%s#" % vm_state
vm_ops.start_vm(vm_uuid)
if not test_lib.lib_wait_target_up(vm_inv.vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to running')
vm.stop()
if not test_lib.lib_wait_target_down(vm_inv.vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to stopped')
elif vm_uuid and vm_state == "running":
print "#%s#" % vm_state
vm.stop()
if not test_lib.lib_wait_target_down(vm_inv.vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to stopped')
vm_ops.start_vm(vm_uuid)
if not test_lib.lib_wait_target_up(vm_inv.vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to running')
vm_ops.destroy_vm(vm_uuid)
vm_ops.expunge_vm(vm_uuid)
vct_ops.delete_vcenter(vcenter_uuid)
test_util.test_pass("vm start and stop of vcenter test passed.")
def check_resource():
hosts = res_ops.query_resource(res_ops.HOST, [], None)
for host in hosts:
if host.status != "Connected":
host_ops.reconnect_host(host.uuid)
return False
pss = res_ops.query_resource(res_ops.PRIMARY_STORAGE, [], None)
for ps in pss:
if ps.status != "Connected":
ps_ops.reconnect_primary_storage(ps.uuid)
return False
bss = res_ops.query_resource(res_ops.BACKUP_STORAGE, [], None)
for bs in bss:
if bs.status != "Connected":
bs_ops.reconnect_backup_storage(bs.uuid)
return False
if os.environ.get('WOODPECKER_PARALLEL') != None and os.environ.get(
'WOODPECKER_PARALLEL') == '0':
vms = res_ops.query_resource(res_ops.VM_INSTANCE, [], None)
for vm in vms:
if vm.type == 'UserVm':
try:
vm_ops.destroy_vm(vm.uuid)
except:
test_util.test_logger('ignore exception try to destroy vm')
try:
vm_ops.expunge_vm(vm.uuid)
except:
test_util.test_logger('ignore exception try to expunge vm')
vrs = res_ops.query_resource(res_ops.APPLIANCE_VM, [], None)
for vr in vrs:
if vr.status != "Connected" or vr.state != "Running":
if vr.applianceVmType != "vrouter":
try:
vm_ops.stop_vm(vr.uuid, force='cold')
vm_ops.start_vm(vr.uuid)
except:
test_util.test_logger('Exception when reboot vr vm')
else:
try:
vm_ops.stop_vm(vr.uuid, force='cold')
except:
test_util.test_logger('Exception when reboot vr vm')
return False
return True
def check_resource():
hosts = res_ops.query_resource(res_ops.HOST, [], None)
for host in hosts:
if host.status != "Connected":
host_ops.reconnect_host(host.uuid)
return False
pss = res_ops.query_resource(res_ops.PRIMARY_STORAGE, [], None)
for ps in pss:
if ps.status != "Connected":
ps_ops.reconnect_primary_storage(ps.uuid)
return False
bss = res_ops.query_resource(res_ops.BACKUP_STORAGE, [], None)
for bs in bss:
if bs.status != "Connected":
bs_ops.reconnect_backup_storage(bs.uuid)
return False
if os.environ.get('WOODPECKER_PARALLEL') != None and os.environ.get('WOODPECKER_PARALLEL') == '0':
vms = res_ops.query_resource(res_ops.VM_INSTANCE, [], None)
for vm in vms:
if vm.type == 'UserVm':
try:
vm_ops.destroy_vm(vm.uuid)
except:
test_util.test_logger('ignore exception try to destroy vm')
try:
vm_ops.expunge_vm(vm.uuid)
except:
test_util.test_logger('ignore exception try to expunge vm')
vrs = res_ops.query_resource(res_ops.APPLIANCE_VM, [], None)
for vr in vrs:
if vr.status != "Connected" or vr.state != "Running":
if vr.applianceVmType != "vrouter":
try:
vm_ops.stop_vm(vr.uuid, force='cold')
vm_ops.start_vm(vr.uuid)
except:
test_util.test_logger('Exception when reboot vr vm')
else:
try:
vm_ops.stop_vm(vr.uuid, force='cold')
except:
test_util.test_logger('Exception when reboot vr vm')
return False
return True
def test():
vms = res_ops.query_resource(res_ops.VM_INSTANCE)
for vm in vms:
try:
vm_ops.destroy_vm(vm.uuid)
except:
pass
time.sleep(1)
volumes = res_ops.query_resource(res_ops.VOLUME)
for volume in volumes:
try:
vol_ops.delete_volume(volume.uuid)
except:
pass
def error_cleanup():
global vcenter_uuid1
global vcenter_uuid2
global mevoco2_ip
global vm_uuid
if vm_uuid:
vm_ops.destroy_vm(vm_uuid)
vm_ops.expunge_vm(vm_uuid)
if vcenter_uuid1:
vct_ops.delete_vcenter(vcenter_uuid1)
if vcenter_uuid2:
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
vct_ops.delete_vcenter(vcenter_uuid2)
def error_cleanup():
global vcenter_uuid1
global vcenter_uuid2
global mevoco2_ip
global vm_uuid
if vm_uuid:
vm_ops.destroy_vm(vm_uuid)
vm_ops.expunge_vm(vm_uuid)
if vcenter_uuid1:
vct_ops.delete_vcenter(vcenter_uuid1)
if vcenter_uuid2:
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
vct_ops.delete_vcenter(vcenter_uuid2)
def test():
global vcenter_uuid, vm_uuid
vcenter1_name = os.environ['vcenter2_name']
vcenter1_domain_name = os.environ['vcenter2_ip']
vcenter1_username = os.environ['vcenter2_domain_name']
vcenter1_password = os.environ['vcenter2_password']
#ova_image_name = os.environ['vcenter2_template_exist']
vm_name = os.environ['vcenter2_no_nic_vm']
network_pattern1 = os.environ['vcenter2_network_pattern1']
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name, vcenter1_username, vcenter1_password, True, zone_uuid)
vcenter_uuid = inv.uuid
if vcenter_uuid == None:
test_util.test_fail("vcenter_uuid is None")
#vm = test_stub.create_vm_in_vcenter(vm_name = 'vm-start-stop-test', image_name = ova_image_name, l3_name = network_pattern1)
vm_cond = res_ops.gen_query_conditions("name", '=', vm_name)
vm_inv = res_ops.query_resource_fields(res_ops.VM_INSTANCE, vm_cond, None, fields=['uuid', 'state'])[0]
vm_uuid = vm_inv.uuid
vm_state = vm_inv.state.strip().lower()
if not vm_uuid:
test_util.test_fail("remote woodpecker vm uuid is null")
elif vm_uuid and vm_state != "running":
print "#%s#" % vm_state
vm_ops.start_vm(vm_uuid)
if not test_lib.lib_wait_target_up(vm_inv.vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to running')
vm.stop()
if not test_lib.lib_wait_target_down(vm_inv.vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to stopped')
elif vm_uuid and vm_state == "running":
print "#%s#" % vm_state
vm.stop()
if not test_lib.lib_wait_target_down(vm_inv.vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to stopped')
vm_ops.start_vm(vm_uuid)
if not test_lib.lib_wait_target_up(vm_inv.vmNics[0].ip, '22', 90):
test_util.test_fail('VM is expected to running')
vm_ops.destroy_vm(vm_uuid)
vm_ops.expunge_vm(vm_uuid)
vct_ops.delete_vcenter(vcenter_uuid)
test_util.test_pass("vm start and stop of vcenter test passed.")
def test():
global session_uuid
session_uuid = acc_ops.login_as_admin()
l3_1_name = os.environ.get('l3VlanNetworkName1')
l3_1 = test_lib.lib_get_l3_by_name(l3_1_name)
#create VRs.
vrs = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)
if not vrs:
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
vm.destroy()
vr1 = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0]
else:
vr1 = vrs[0]
vm_ops.destroy_vm(vr1.uuid)
vm = test_stub.create_vlan_vm(l3_name=l3_1_name)
vm.destroy()
test_util.test_pass('destroy VR VM success')
def test():
global deploy_conf
global vm_inv
global vm
test_util.test_dsc('Test Delete VR Offering and Teboot Normal VM')
vm = test_stub.create_basic_vm()
test_obj_dict.add_vm(vm)
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
vm.check()
test_util.test_dsc('Record current virtual router offering information')
deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
cond = res_ops.gen_query_conditions('zone.vmInstance.uuid', '=',
vm_inv.uuid)
vr_offering_uuid = res_ops.query_resource(res_ops.VR_OFFERING,
cond)[0].uuid
test_util.test_dsc('Delete VR-RM and VR-Offering')
cond = res_ops.gen_query_conditions('zone.vmInstance.uuid', '=',
vm_inv.uuid)
vr_vm_uuid = res_ops.query_resource(res_ops.VIRTUALROUTER_VM, cond)[0].uuid
vm_ops.destroy_vm(vr_vm_uuid)
vm_ops.delete_instance_offering(vr_offering_uuid)
test_util.test_dsc(
'Create new VR-Offering, same as the former one, stop and start VM')
session_uuid = acc_ops.login_as_admin()
dep_ops.add_virtual_router(None, None, deploy_conf, session_uuid)
vm.reboot()
vm.destroy()
test_obj_dict.rm_vm(vm)
test_util.test_pass('Delete VR Offering and reboot normal VM: SUCCESS')
def test():
global deploy_conf
global vm_inv
global vm
test_util.test_dsc('Test Delete VR Offering and Teboot Normal VM')
vm = test_stub.create_basic_vm()
test_obj_dict.add_vm(vm)
vm_inv = vm.get_vm()
vm_ip = vm_inv.vmNics[0].ip
vm.check()
test_util.test_dsc('Record current virtual router offering information')
deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
cond = res_ops.gen_query_conditions('zone.vmInstance.uuid', '=', vm_inv.uuid)
vr_offering_uuid = res_ops.query_resource(res_ops.VR_OFFERING, cond)[0].uuid
test_util.test_dsc('Delete VR-RM and VR-Offering')
cond = res_ops.gen_query_conditions('zone.vmInstance.uuid', '=', vm_inv.uuid)
vr_vm_uuid = res_ops.query_resource(res_ops.VIRTUALROUTER_VM, cond)[0].uuid
vm_ops.destroy_vm(vr_vm_uuid)
vm_ops.delete_instance_offering(vr_offering_uuid)
test_util.test_dsc('Create new VR-Offering, same as the former one, stop and start VM')
session_uuid = acc_ops.login_as_admin()
dep_ops.add_virtual_router(None, None, deploy_conf, session_uuid)
vm.reboot()
vm.destroy()
test_obj_dict.rm_vm(vm)
test_util.test_pass('Delete VR Offering and reboot normal VM: SUCCESS')
def stopped_vm_operations(vm,bss):
vm_uuid = vm.get_vm().uuid
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
vm_ops.stop_vm(vm_uuid)
#Change vm's instanceoffering
vm_ops.update_vm(vm_uuid,2,2048*1024*1024)
#Change vm's status
ha_ops.set_vm_instance_ha_level(vm_uuid,'neverstop')
vm_ops.stop_vm(vm_uuid)
ha_ops.del_vm_instance_ha_level(vm_uuid)
vm_ops.stop_vm(vm_uuid)
if ps.type != 'LocalStorage':
target_host_uuid = test_lib.lib_find_random_host(vm.get_vm()).uuid
if target_host_uuid != None:
vm_ops.start_vm_with_target_host(vm_uuid,target_host_uuid)
#vm_ops.stop_vm(vm_uuid)
vm_ops.destroy_vm(vm_uuid)
vm_ops.recover_vm(vm_uuid)
vm_ops.reinit_vm(vm_uuid)
#clone
vm_ops.clone_vm(vm_uuid,['vm-1','vm-2','vm-3'],'InstantStart')
#migrate
vm_ops.start_vm(vm_uuid)
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
vm_ops.stop_vm(vm_uuid)
migrate_host_uuids = []
if candidate_hosts != None:
for host in candidate_hosts.inventories:
migrate_host_uuids.append(host.uuid)
if ps.type == 'LocalStorage':
vol_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid
#vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
vol_ops.migrate_volume(vol_uuid, migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
#resize root volume
vol_size = test_lib.lib_get_root_volume(vm.get_vm()).size
vol_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid
set_size = 1024*1024*1024*5
vol_ops.resize_volume(vol_uuid, set_size)
vm.update()
vol_size_after = test_lib.lib_get_root_volume(vm.get_vm()).size
if set_size != vol_size_after:
test_util.test_fail('Resize Root Volume failed, size = %s' % vol_size_after)
test_util.test_logger('resize vm success')
#storage migrate
#change vm image
image_list = vm_ops.get_image_candidates_for_vm_to_change(vm_uuid)
image_uuids = []
for image in image_list.inventories:
image_uuids.append(image.uuid)
vm_ops.change_vm_image(vm_uuid,image_uuids[0])
vm.update()
#update vm nic mac
nic_uuid = vm.get_vm().vmNics[0].uuid
mac = 'fa:4c:ee:9a:76:00'
vm_ops.update_vm_nic_mac(nic_uuid,mac)
#set/del static ip
l3network_uuid = test_lib.lib_get_l3_uuid_by_nic(nic_uuid)
vm_ops.change_vm_static_ip(vm_uuid, l3network_uuid, vm.get_vm().vmNics[0].ip)
vm_ops.delete_vm_static_ip(vm_uuid, l3network_uuid)
#snapshot operations
sp_option = test_util.SnapshotOption()
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
sp_option.set_volume_uuid(root_volume_uuid)
sp = vol_ops.create_snapshot(sp_option)
vol_ops.use_snapshot(sp.uuid)
vol_ops.delete_snapshot(sp.uuid)
common_operations(vm,bss,'stopped')
vm.destroy()
vm.expunge()
def running_vm_operations(vm, bss):
numa = config_ops.get_global_config_value('vm', 'numa')
live_migration = config_ops.get_global_config_value(
'localStoragePrimaryStorage', 'liveMigrationWithStorage.allow')
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
vm_uuid = vm.get_vm().uuid
#change vm's instanceoffering
if numa == 'false':
try:
vm_ops.update_vm(vm_uuic, 2, 2048 * 1024 * 1024)
test_util.test_fail(
'Test Fail.Cannot change instanceoffering of running vm when NUMA is false'
)
except:
config_ops.change_global_config('vm', 'numa', 'true')
vm_ops.reboot_vm(vm_uuid)
vm_ops.update_vm(vm_uuid, 2, 2048 * 1024 * 1024)
#Change vm's status;set ha level/stop/del ha level/reboot/pause/resume/force stop
ha_ops.set_vm_instance_ha_level(vm_uuid, 'neverstop')
vm_ops.stop_vm(vm_uuid)
ha_ops.del_vm_instance_ha_level(vm_uuid)
vm_ops.stop_vm(vm_uuid)
vm_ops.start_vm(vm_uuid)
vm_ops.reboot_vm(vm_uuid)
vm_ops.suspend_vm(vm_uuid)
vm_ops.resume_vm(vm_uuid)
vm_ops.stop_vm(vm_uuid, 'cold')
vm_ops.start_vm(vm_uuid)
#clone vms
vm_ops.clone_vm(vm_uuid, ['vm-1', 'vm-2', 'vm-3'], 'InstantStart')
#migrate
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
migrate_host_uuids = []
if candidate_hosts == None:
pass
else:
for host in candidate_hosts.inventories:
migrate_host_uuids.append(host.uuid)
if ps.type == 'LocalStorage':
if live_migration == 'false':
try:
vm_ops.migrate_vm(vm_uuid, migrate_host_uuids[0])
test_util.test_fail(
'Test Fail.Cannot migrate localstorage vm when liveMigrationWithStorage is false.'
)
except:
config_ops.change_global_config(
'localStoragePrimaryStorage',
'liveMigrationWithStorage.allow', 'true')
else:
vm_ops.migrate_vm(vm_uuid, migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
else:
vm_ops.migrate_vm(vm_uuid, migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
#change vm's password(qga)
try:
vm_ops.change_vm_password(vm_uuid, 'root', 'testpassword')
test_util.test_fail(
'Test Fail.Cannot change vm password when qga is disabled.')
except:
vm_ops.set_vm_qga_enable(vm_uuid)
vm_ops.change_vm_password(vm_uuid, 'root', 'testpassword')
vm_ops.set_vm_qga_disable(vm_uuid)
#snapshot operations
sp_option = test_util.SnapshotOption()
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
test_util.test_logger('rootvolumerunning:%s' % root_volume_uuid)
sp_option.set_volume_uuid(root_volume_uuid)
sp = vol_ops.create_snapshot(sp_option)
vm_ops.stop_vm(vm_uuid)
vol_ops.use_snapshot(sp.uuid)
vm_ops.start_vm(vm_uuid)
vol_ops.delete_snapshot(sp.uuid)
common_operations(vm, bss, 'running')
vm_ops.destroy_vm(vm_uuid)
vm_ops.recover_vm(vm_uuid)
vm_ops.start_vm(vm_uuid)
vm.destroy()
vm.expunge()
def common_operations(vm, bss, status):
vm_uuid = vm.get_vm().uuid
#image operations
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
image_option = test_util.ImageOption()
image_option.set_root_volume_uuid(root_volume_uuid)
image_option.set_name('image_base_on_%s_vm' % status)
image_option.set_backup_storage_uuid_list([bss[0].uuid])
image = img_ops.create_root_volume_template(image_option)
test_util.test_logger('create image success')
image_base_on_stopped_vm_uuid = test_lib.lib_get_image_by_name(
"image_base_on_%s_vm" % status).uuid
base_on_image_vm = test_stub.create_vm(
image_uuid=image_base_on_stopped_vm_uuid)
vm_ops.destroy_vm(base_on_image_vm.get_vm().uuid)
vm_ops.expunge_vm(base_on_image_vm.get_vm().uuid)
#volume operations
volume = test_stub.create_volume()
vol_uuid = volume.get_volume().uuid
test_lib.lib_attach_volume(vol_uuid, vm_uuid)
test_util.test_logger('attach volume success')
vm_ops.set_vm_disk_qos(vol_uuid, '20480')
test_util.test_logger('set volume qos success')
vm_ops.del_vm_disk_qos(vol_uuid)
test_util.test_logger('delete volume qos success')
test_lib.lib_detach_volume(vol_uuid)
test_util.test_logger('detach volume success')
test_lib.lib_delete_volume(vol_uuid)
test_util.test_logger('delete volume success')
#network operations
nic_uuid = vm.get_vm().vmNics[0].uuid
l3_uuid = test_lib.lib_get_random_l3(zone_uuid=vm.get_vm().zoneUuid).uuid
test_util.test_logger("l3_uuid:%s" % l3_uuid)
net_ops.detach_l3(nic_uuid)
test_util.test_logger("l3_uuid:%s" % l3_uuid)
net_ops.attach_l3(l3_uuid, vm_uuid)
vm_uuid = vm.get_vm().uuid
#set/del console password
console_ops.set_vm_console_password(vm_uuid, 'testpassword')
console_ops.delete_vm_console_password(vm_uuid)
#add/del sshkey
sshkeyimage_uuid = test_lib.lib_get_image_by_name('sshkeyimage').uuid
sshkey_vm = test_stub.create_vm(image_uuid=sshkeyimage_uuid)
sshkey_vm_uuid = sshkey_vm.get_vm().uuid
test_lib.lib_add_vm_sshkey(sshkey_vm_uuid, 'testsshkey')
vm_ops.delete_vm_ssh_key(sshkey_vm_uuid)
vm_ops.destroy_vm(sshkey_vm_uuid)
vm_ops.expunge_vm(sshkey_vm_uuid)
#change owner
account_name = uuid.uuid1().get_hex()
account_pass = uuid.uuid1().get_hex()
#account_pass = hashlib.sha512(account_name).hexdigest()
test_account = account_operations.create_normal_account(
account_name, account_pass)
test_account_uuid = test_account.uuid
admin_uuid = res_ops.get_resource_owner([vm_uuid])
res_ops.change_recource_owner(test_account_uuid, vm_uuid)
res_ops.change_recource_owner(admin_uuid, vm_uuid)
account_operations.delete_account(test_account_uuid)
#create/delete user tag
tag = tag_ops.create_user_tag('VmInstanceVO', vm_uuid, 'a simulator vm')
tag_ops.delete_tag(tag.uuid)
#set vm monitor number
vm_ops.set_vm_monitor_number(vm_uuid, '2')
#set vm usb redirect
vm_ops.set_vm_usb_redirect(vm_uuid, 'true')
vm_ops.set_vm_usb_redirect(vm_uuid, 'false')
#set vm rdp
vm_ops.set_vm_rdp(vm_uuid, 'true')
vm_ops.set_vm_rdp(vm_uuid, 'false')
def stopped_vm_operations(vm, bss):
vm_uuid = vm.get_vm().uuid
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
vm_ops.stop_vm(vm_uuid)
#Change vm's instanceoffering
vm_ops.update_vm(vm_uuid, 2, 2048 * 1024 * 1024)
#Change vm's status
ha_ops.set_vm_instance_ha_level(vm_uuid, 'neverstop')
vm_ops.stop_vm(vm_uuid)
ha_ops.del_vm_instance_ha_level(vm_uuid)
vm_ops.stop_vm(vm_uuid)
if ps.type != 'LocalStorage':
target_host_uuid = test_lib.lib_find_random_host(vm.get_vm()).uuid
if target_host_uuid != None:
vm_ops.start_vm_with_target_host(vm_uuid, target_host_uuid)
#vm_ops.stop_vm(vm_uuid)
vm_ops.destroy_vm(vm_uuid)
vm_ops.recover_vm(vm_uuid)
vm_ops.reinit_vm(vm_uuid)
#clone
vm_ops.clone_vm(vm_uuid, ['vm-1', 'vm-2', 'vm-3'], 'InstantStart')
#migrate
vm_ops.start_vm(vm_uuid)
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
vm_ops.stop_vm(vm_uuid)
migrate_host_uuids = []
if candidate_hosts != None:
for host in candidate_hosts.inventories:
migrate_host_uuids.append(host.uuid)
if ps.type == 'LocalStorage':
vol_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid
#vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
vol_ops.migrate_volume(vol_uuid, migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
#resize root volume
vol_size = test_lib.lib_get_root_volume(vm.get_vm()).size
vol_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid
set_size = 1024 * 1024 * 1024 * 5
vol_ops.resize_volume(vol_uuid, set_size)
vm.update()
vol_size_after = test_lib.lib_get_root_volume(vm.get_vm()).size
if set_size != vol_size_after:
test_util.test_fail('Resize Root Volume failed, size = %s' %
vol_size_after)
test_util.test_logger('resize vm success')
#storage migrate
#change vm image
image_list = vm_ops.get_image_candidates_for_vm_to_change(vm_uuid)
image_uuids = []
for image in image_list.inventories:
image_uuids.append(image.uuid)
vm_ops.change_vm_image(vm_uuid, image_uuids[0])
vm.update()
#update vm nic mac
nic_uuid = vm.get_vm().vmNics[0].uuid
mac = 'fa:4c:ee:9a:76:00'
vm_ops.update_vm_nic_mac(nic_uuid, mac)
#set/del static ip
l3network_uuid = test_lib.lib_get_l3_uuid_by_nic(nic_uuid)
vm_ops.change_vm_static_ip(vm_uuid, l3network_uuid,
vm.get_vm().vmNics[0].ip)
vm_ops.delete_vm_static_ip(vm_uuid, l3network_uuid)
#snapshot operations
sp_option = test_util.SnapshotOption()
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
sp_option.set_volume_uuid(root_volume_uuid)
sp = vol_ops.create_snapshot(sp_option)
vol_ops.use_snapshot(sp.uuid)
vol_ops.delete_snapshot(sp.uuid)
common_operations(vm, bss, 'stopped')
vm.destroy()
vm.expunge()
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 vcenter_uuid1
global vcenter_uuid2
global mevoco1_ip
global mevoco2_ip
global vm_uuid
vcenter1_name = os.environ['vcenter2_name']
vcenter1_domain_name = os.environ['vcenter2_ip']
vcenter1_username = os.environ['vcenter2_domain_name']
vcenter1_password = os.environ['vcenter2_password']
sync_vm = os.environ['vcenter2_sync_vm_create_delete']
sync_image_name = os.environ['vcenter2_template_exist']
network_pattern1 = os.environ['vcenter2_network_pattern1']
mevoco1_ip = os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP']
mevoco2_ip = os.environ['serverIp2']
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name, vcenter1_username, vcenter1_password, True, zone_uuid)
vcenter_uuid1 = inv.uuid
if vcenter_uuid1 == None:
test_util.test_fail("vcenter_uuid is None")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name, vcenter1_username, vcenter1_password, True, zone_uuid)
vcenter_uuid2 = inv.uuid
if vcenter_uuid2 == None:
test_util.test_fail("vcenter_uuid is None")
#create vm in remote and check
test_util.test_logger("create vm for sync test")
vm = test_stub.create_vm_in_vcenter(vm_name = sync_vm, image_name = sync_image_name, l3_name = network_pattern1)
vm.check()
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
vm_cond = res_ops.gen_query_conditions("name", '=', sync_vm)
vm_inv = res_ops.query_resource_fields(res_ops.VM_INSTANCE, vm_cond, None, fields=['uuid', 'state'])
if not vm_inv:
test_util.test_fail("not found target vm being sync")
vm_uuid = vm_inv[0].uuid
if not vm_uuid:
test_util.test_fail("remote woodpecker vm uuid is null")
vm_state = vm_inv[0].state.strip().lower()
if vm_state != "running":
test_util.test_fail("vcenter sync vm start failed.")
#delete vm in remote and check
test_util.test_logger("delete vm for sync test")
if vm_uuid:
vm_ops.destroy_vm(vm_uuid)
vm_ops.expunge_vm(vm_uuid)
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
vm_inv = res_ops.query_resource_fields(res_ops.VM_INSTANCE, vm_cond, None, fields=['uuid', 'state'])
if vm_inv:
test_util.test_fail("found the expected deleted vm")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
if vcenter_uuid2:
vct_ops.delete_vcenter(vcenter_uuid2)
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
if vcenter_uuid1:
vct_ops.delete_vcenter(vcenter_uuid1)
test_util.test_pass("vcenter sync start and stop vm test passed.")
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():
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 destroy(self):
vm_ops.destroy_vm(self.vm.uuid)
super(ZstackTestVm, self).destroy()
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 destroy_vm_wrapper(i, vm_uuid):
global exec_info
try:
vm_ops.destroy_vm(vm_uuid)
except:
exec_info.append("vm-%s" % (i))
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 vcenter_uuid1
global vcenter_uuid2
global mevoco1_ip
global mevoco2_ip
global vm_uuid
vcenter1_name = os.environ['vcenter2_name']
vcenter1_domain_name = os.environ['vcenter2_ip']
vcenter1_username = os.environ['vcenter2_domain_name']
vcenter1_password = os.environ['vcenter2_password']
sync_vm = os.environ['vcenter2_sync_vm_create_delete']
sync_image_name = os.environ['vcenter2_template_exist']
network_pattern1 = os.environ['vcenter2_network_pattern1']
mevoco1_ip = os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP']
mevoco2_ip = os.environ['serverIp2']
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name,
vcenter1_username, vcenter1_password, True,
zone_uuid)
vcenter_uuid1 = inv.uuid
if vcenter_uuid1 == None:
test_util.test_fail("vcenter_uuid is None")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid
inv = vct_ops.add_vcenter(vcenter1_name, vcenter1_domain_name,
vcenter1_username, vcenter1_password, True,
zone_uuid)
vcenter_uuid2 = inv.uuid
if vcenter_uuid2 == None:
test_util.test_fail("vcenter_uuid is None")
#create vm in remote and check
test_util.test_logger("create vm for sync test")
vm = test_stub.create_vm_in_vcenter(vm_name=sync_vm,
image_name=sync_image_name,
l3_name=network_pattern1)
vm.check()
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
vm_cond = res_ops.gen_query_conditions("name", '=', sync_vm)
vm_inv = res_ops.query_resource_fields(res_ops.VM_INSTANCE,
vm_cond,
None,
fields=['uuid', 'state'])
if not vm_inv:
test_util.test_fail("not found target vm being sync")
vm_uuid = vm_inv[0].uuid
if not vm_uuid:
test_util.test_fail("remote woodpecker vm uuid is null")
vm_state = vm_inv[0].state.strip().lower()
if vm_state != "running":
test_util.test_fail("vcenter sync vm start failed.")
#delete vm in remote and check
test_util.test_logger("delete vm for sync test")
if vm_uuid:
vm_ops.destroy_vm(vm_uuid)
vm_ops.expunge_vm(vm_uuid)
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
vm_inv = res_ops.query_resource_fields(res_ops.VM_INSTANCE,
vm_cond,
None,
fields=['uuid', 'state'])
if vm_inv:
test_util.test_fail("found the expected deleted vm")
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco2_ip
if vcenter_uuid2:
vct_ops.delete_vcenter(vcenter_uuid2)
os.environ['ZSTACK_BUILT_IN_HTTP_SERVER_IP'] = mevoco1_ip
if vcenter_uuid1:
vct_ops.delete_vcenter(vcenter_uuid1)
test_util.test_pass("vcenter sync start and stop vm test passed.")
def common_operations(vm,bss,status):
vm_uuid = vm.get_vm().uuid
#image operations
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
image_option = test_util.ImageOption()
image_option.set_root_volume_uuid(root_volume_uuid)
image_option.set_name('image_base_on_%s_vm' % status)
image_option.set_backup_storage_uuid_list([bss[0].uuid])
image = img_ops.create_root_volume_template(image_option)
test_util.test_logger('create image success')
image_base_on_stopped_vm_uuid = test_lib.lib_get_image_by_name("image_base_on_%s_vm" % status).uuid
base_on_image_vm = test_stub.create_vm(image_uuid=image_base_on_stopped_vm_uuid)
vm_ops.destroy_vm(base_on_image_vm.get_vm().uuid)
vm_ops.expunge_vm(base_on_image_vm.get_vm().uuid)
#volume operations
volume = test_stub.create_volume()
vol_uuid = volume.get_volume().uuid
test_lib.lib_attach_volume(vol_uuid, vm_uuid)
test_util.test_logger('attach volume success')
vm_ops.set_vm_disk_qos(vol_uuid,'20480')
test_util.test_logger('set volume qos success')
vm_ops.del_vm_disk_qos(vol_uuid)
test_util.test_logger('delete volume qos success')
test_lib.lib_detach_volume(vol_uuid)
test_util.test_logger('detach volume success')
test_lib.lib_delete_volume(vol_uuid)
test_util.test_logger('delete volume success')
#network operations
nic_uuid = vm.get_vm().vmNics[0].uuid
l3_uuid = test_lib.lib_get_random_l3(zone_uuid = vm.get_vm().zoneUuid).uuid
test_util.test_logger("l3_uuid:%s"% l3_uuid)
net_ops.detach_l3(nic_uuid)
test_util.test_logger("l3_uuid:%s"% l3_uuid)
net_ops.attach_l3(l3_uuid,vm_uuid)
vm_uuid = vm.get_vm().uuid
#set/del console password
console_ops.set_vm_console_password(vm_uuid,'testpassword')
console_ops.delete_vm_console_password(vm_uuid)
#add/del sshkey
sshkeyimage_uuid = test_lib.lib_get_image_by_name('sshkeyimage').uuid
sshkey_vm = test_stub.create_vm(image_uuid = sshkeyimage_uuid)
sshkey_vm_uuid = sshkey_vm.get_vm().uuid
test_lib.lib_add_vm_sshkey(sshkey_vm_uuid,'testsshkey')
vm_ops.delete_vm_ssh_key(sshkey_vm_uuid)
vm_ops.destroy_vm(sshkey_vm_uuid)
vm_ops.expunge_vm(sshkey_vm_uuid)
#change owner
account_name = uuid.uuid1().get_hex()
account_pass = uuid.uuid1().get_hex()
#account_pass = hashlib.sha512(account_name).hexdigest()
test_account = account_operations.create_normal_account(account_name,account_pass)
test_account_uuid = test_account.uuid
admin_uuid = res_ops.get_resource_owner([vm_uuid])
res_ops.change_recource_owner(test_account_uuid,vm_uuid)
res_ops.change_recource_owner(admin_uuid,vm_uuid)
account_operations.delete_account(test_account_uuid)
#create/delete user tag
tag = tag_ops.create_user_tag('VmInstanceVO',vm_uuid,'a simulator vm')
tag_ops.delete_tag(tag.uuid)
#set vm monitor number
vm_ops.set_vm_monitor_number(vm_uuid,'2')
#set vm usb redirect
vm_ops.set_vm_usb_redirect(vm_uuid,'true')
vm_ops.set_vm_usb_redirect(vm_uuid,'false')
#set vm rdp
vm_ops.set_vm_rdp(vm_uuid,'true')
vm_ops.set_vm_rdp(vm_uuid,'false')
def running_vm_operations(vm,bss):
numa = config_ops.get_global_config_value('vm', 'numa')
live_migration = config_ops.get_global_config_value('localStoragePrimaryStorage','liveMigrationWithStorage.allow')
ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm())
vm_uuid = vm.get_vm().uuid
#change vm's instanceoffering
if numa == 'false':
try:
vm_ops.update_vm(vm_uuic,2,2048*1024*1024)
test_util.test_fail('Test Fail.Cannot change instanceoffering of running vm when NUMA is false')
except:
config_ops.change_global_config('vm','numa','true')
vm_ops.reboot_vm(vm_uuid)
vm_ops.update_vm(vm_uuid,2,2048*1024*1024)
#Change vm's status;set ha level/stop/del ha level/reboot/pause/resume/force stop
ha_ops.set_vm_instance_ha_level(vm_uuid,'NeverStop')
vm_ops.stop_vm(vm_uuid)
ha_ops.del_vm_instance_ha_level(vm_uuid)
vm_ops.stop_vm(vm_uuid)
vm_ops.start_vm(vm_uuid)
vm_ops.reboot_vm(vm_uuid)
vm_ops.suspend_vm(vm_uuid)
vm_ops.resume_vm(vm_uuid)
vm_ops.stop_vm(vm_uuid,'cold')
vm_ops.start_vm(vm_uuid)
#clone vms
vm_ops.clone_vm(vm_uuid,['vm-1','vm-2','vm-3'],'InstantStart')
#migrate
candidate_hosts = vm_ops.get_vm_migration_candidate_hosts(vm_uuid)
migrate_host_uuids = []
if candidate_hosts == None:
pass
else:
for host in candidate_hosts.inventories:
migrate_host_uuids.append(host.uuid)
if ps.type == 'LocalStorage':
if live_migration == 'false':
try:
vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
test_util.test_fail('Test Fail.Cannot migrate localstorage vm when liveMigrationWithStorage is false.' )
except:
config_ops.change_global_config('localStoragePrimaryStorage','liveMigrationWithStorage.allow','true')
else:
vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
else:
vm_ops.migrate_vm(vm_uuid,migrate_host_uuids[0])
test_util.test_logger('migrate vm success')
#change vm's password(qga)
try:
vm_ops.change_vm_password(vm_uuid,'root','testpassword')
test_util.test_fail('Test Fail.Cannot change vm password when qga is disabled.')
except:
vm_ops.set_vm_qga_enable(vm_uuid)
vm_ops.change_vm_password(vm_uuid,'root','testpassword')
vm_ops.set_vm_qga_disable(vm_uuid)
#snapshot operations
sp_option = test_util.SnapshotOption()
vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm())
root_volume_uuid = vm_root_volume_inv.uuid
test_util.test_logger('rootvolumerunning:%s' % root_volume_uuid)
sp_option.set_volume_uuid(root_volume_uuid)
sp = vol_ops.create_snapshot(sp_option)
vm_ops.stop_vm(vm_uuid)
vol_ops.use_snapshot(sp.uuid)
vm_ops.start_vm(vm_uuid)
vol_ops.delete_snapshot(sp.uuid)
common_operations(vm,bss,'running')
vm_ops.destroy_vm(vm_uuid)
vm_ops.recover_vm(vm_uuid)
vm_ops.start_vm(vm_uuid)
vm.destroy()
vm.expunge()
#Check if recovery root volume success
if recovery_image.backupStorageRefs[0].backupStorageUuid != local_bs_uuid:
test_util.test_fail('Recovery image failed, image uuid is %s' %recovery_image.uuid)
if recovery_image.mediaType != 'RootVolumeTemplate':
test_util.test_fail('Wrong image type after recovery, the expect is "RootVolumeTemplate", the real is "%s"' %recovery_image.mediaType)
image_uuid = recovery_image.uuid
try:
#Try to recovery the same image again, it's negative test
recovery_image = img_ops.recovery_image_from_image_store_backup_storage(local_bs_uuid, disaster_bs_uuid, disaster_bs_image_uuid)
img_ops.delete_image(recovery_image.uuid)
except Exception,e:
if unicode(e).encode("utf-8").find('包含') != -1:
test_util.test_pass('Try to recovery the same image again and get the error info expectly: %s' %unicode(e).encode("utf-8"))
finally:
vm_ops.destroy_vm(vm.uuid)
img_ops.delete_image(image_uuid)
test_util.test_fail('Try to recovery the same image second time success unexpectly')
#Will be called only if exception happens in test().
def error_cleanup():
global disaster_bs_uuid
global image_uuid
global vm
vm_ops.destroy_vm(vm.uuid)
img_ops.delete_image(image_uuid)
if disaster_bs_uuid != None:
bs_ops.delete_backup_storage(disaster_bs_uuid)
#recover envrionment wehether the test pass or not
def env_recover():
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!')
'Wrong image type after recovery, the expect is "RootVolumeTemplate", the real is "%s"'
% recovery_image.mediaType)
image_uuid = recovery_image.uuid
try:
#Try to recovery the same image again, it's negative test
recovery_image = img_ops.recovery_image_from_image_store_backup_storage(
local_bs_uuid, disaster_bs_uuid, disaster_bs_image_uuid)
img_ops.delete_image(recovery_image.uuid)
except Exception, e:
if unicode(e).encode("utf-8").find('包含') != -1:
test_util.test_pass(
'Try to recovery the same image again and get the error info expectly: %s'
% unicode(e).encode("utf-8"))
finally:
vm_ops.destroy_vm(vm.uuid)
img_ops.delete_image(image_uuid)
test_util.test_fail(
'Try to recovery the same image second time success unexpectly')
#Will be called only if exception happens in test().
def error_cleanup():
global disaster_bs_uuid
global image_uuid
global vm
vm_ops.destroy_vm(vm.uuid)
img_ops.delete_image(image_uuid)
if disaster_bs_uuid != None:
bs_ops.delete_backup_storage(disaster_bs_uuid)
def destroy(self, session_uuid = None):
vm_ops.destroy_vm(self.vm.uuid, session_uuid)
super(ZstackTestVm, self).destroy()
def destroy(self):
vm_ops.destroy_vm(self.vm.uuid)
super(ZstackTestVm, self).destroy()
