def env_recover():
global tag_uuid
try:
if tag_uuid:
tag_ops.delete_tag(tag_uuid)
except:
pass
def error_cleanup():
global tag
test_lib.lib_error_cleanup(test_obj_dict)
try:
tag_ops.delete_tag(tag.uuid)
except:
pass
test_stub.recover_ps(ps_inv)
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)
vm = test_stub.create_vm(
vm_name='userdata-vm',
image_name=image_name,
system_tags=["userdata::%s" % os.environ.get('userdata_systemTags')])
test_obj_dict.add_vm(vm)
time.sleep(60)
cond = res_ops.gen_query_conditions('resourceUuid', '=', vm.vm.uuid)
system_tag = res_ops.query_resource(res_ops.SYSTEM_TAG, cond)
if system_tag != []:
test_util.test_logger('Success get system tags.')
else:
test_util.test_fail('Failed to get system tags.')
sys_tags = res_ops.query_resource(res_ops.SYSTEM_TAG, cond)
system_tag_uuid = [tag.uuid for tag in sys_tags
if 'userdata' in tag.tag][0]
# system_tag_uuid = res_ops.query_resource(res_ops.SYSTEM_TAG, cond)[0].uuid
tag_ops.delete_tag(system_tag_uuid)
# system_tag = res_ops.query_resource(res_ops.SYSTEM_TAG, cond)
system_tag_after = res_ops.query_resource(res_ops.SYSTEM_TAG, cond)
system_tag = [tag for tag in system_tag_after if 'userdata' in tag.tag]
if system_tag == []:
test_util.test_logger('Success delete system tags.')
else:
test_util.test_fail('Failed to delete system tags.')
vm.destroy()
test_obj_dict.rm_vm(vm)
image.delete()
image.expunge()
test_obj_dict.rm_image(image)
test_util.test_pass('Delete userdata Success')
def error_cleanup():
global tag
global ps_uuid
global cluster_uuid
try:
ps_ops.attach_primary_storage(ps_uuid, cluster_uuid)
except:
pass
test_lib.lib_error_cleanup(test_obj_dict)
try:
tag_ops.delete_tag(tag.uuid)
except:
pass
def error_cleanup():
global tag
global ps_uuid
global cluster_uuid
try:
ps_ops.attach_primary_storage(ps_uuid, cluster_uuid)
except:
pass
test_lib.lib_error_cleanup(test_obj_dict)
try:
tag_ops.delete_tag(tag.uuid)
except:
pass
def test():
host = res_ops.query_resource(res_ops.HOST)[0]
host_uuid = host.uuid
host_state = host.state
ept_status = host_ops.get_ept_status(host.managementIp, host.username, "password", host.sshPort)
#Test ept changes under maintenance state
if host_state != "Maintenance":
host_ops.change_host_state(host_uuid, "maintain")
time.sleep(10)
if ept_status == "enable":
try:
tag_ops.create_system_tag("HostVO", host_uuid, "pageTableExtensionDisabled")
host_ops.change_host_state(host_uuid, "enable")
time.sleep(60)
status = host_ops.get_ept_status(host.managementIp, host.username, "password", host.sshPort)
if status != "disable":
test_util.test_fail('Fail to disable ept')
except:
test_util.test_fail('Exception catched when disabling ept')
else:
try:
cond = res_ops.gen_query_conditions('tag', '=', 'pageTableExtensionDisabled')
cond = res_ops.gen_query_conditions('resourceUuid', '=', host_uuid, cond)
tag = res_ops.query_resource(res_ops.SYSTEM_TAG, cond)[0]
if tag != None:
tag_ops.delete_tag(tag.uuid)
host_ops.change_host_state(host_uuid, "enable")
time.sleep(60)
status = host_ops.get_ept_status(host.managementIp, host.username, "password", host.sshPort)
if status != "enable":
test_util.test_fail('Fail to enable ept')
except:
test_util.test_fail('Exception catched when enabling ept')
#Enable ept
cond = res_ops.gen_query_conditions('tag', '=', 'pageTableExtensionDisabled')
cond = res_ops.gen_query_conditions('resourceUuid', '=', host_uuid, cond)
tag = res_ops.query_resource(res_ops.SYSTEM_TAG, cond)
if tag != []:
if host_state != "Maintenance":
host_ops.change_host_state(host_uuid, "maintain")
time.sleep(10)
tag_ops.delete_tag(tag[0].uuid)
host_ops.change_host_state(host_uuid, "enable")
time.sleep(60)
test_util.test_pass('EPT disable/enable Test Success')
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 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 test():
global ps_inv
global ps_uuid
global cluster_uuid
global tag
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up primary storage 1 and set system tag for instance offering.
zone_name = os.environ.get('zoneName1')
zone_uuid = res_ops.get_resource(res_ops.ZONE, name=zone_name)[0].uuid
cond = res_ops.gen_query_conditions('zoneUuid', '=', zone_uuid)
ps_inv = res_ops.query_resource(res_ops.PRIMARY_STORAGE, cond)[0]
if ps_inv.type == inventory.NFS_PRIMARY_STORAGE_TYPE:
ps_name1 = os.environ.get('nfsPrimaryStorageName1')
elif ps_inv.type == inventory.CEPH_PRIMARY_STORAGE_TYPE:
ps_name1 = os.environ.get('cephPrimaryStorageName1')
ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name=ps_name1)[0]
ps_uuid = ps_inv.uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, \
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_vm_ps_ops')
tag = tag_ops.create_system_tag('InstanceOfferingVO', \
instance_offering_uuid, \
'primaryStorage::allocator::uuid::%s' % ps_uuid)
l3_name = os.environ.get('l3VlanNetworkName1')
l3 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name)[0]
vm_creation_option.set_l3_uuids([l3.uuid])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
cluster_uuid = vm1.get_vm().clusterUuid
test_util.test_dsc("Detach Primary Storage")
ps_ops.detach_primary_storage(ps_uuid, cluster_uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm1.set_state(vm_header.STOPPED)
vm1.check()
vm1.start()
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
test_util.test_dsc("Delete Primary Storage")
tag_ops.delete_tag(tag.uuid)
ps_ops.delete_primary_storage(ps_inv.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED)
vm1.set_state(vm_header.DESTROYED)
vm1.check()
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED)
vm2.set_state(vm_header.DESTROYED)
vm2.check()
try:
vm3 = test_lib.lib_create_vm(vm_creation_option)
except:
test_util.test_logger(
'Catch expected vm creation exception, since primary storage has been deleted. '
)
else:
test_util.test_fail(
'Fail: Primary Storage has been deleted. But vm is still created with it.'
)
test_stub.recover_ps(ps_inv)
test_util.test_dsc("Attach Primary Storage")
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Test primary storage operations Success')
def test():
global ps_inv
global tag
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
zone1_name = os.environ.get('zoneName1')
zone1 = res_ops.get_resource(res_ops.ZONE, name = zone1_name)[0]
#pick up primary storage 1 and set system tag for instance offering.
zone_name = os.environ.get('zoneName1')
zone_uuid = res_ops.get_resource(res_ops.ZONE, name = zone_name)[0].uuid
cond = res_ops.gen_query_conditions('zoneUuid', '=', zone_uuid)
ps_inv = res_ops.query_resource(res_ops.PRIMARY_STORAGE, cond)[0]
if ps_inv.type == inventory.NFS_PRIMARY_STORAGE_TYPE:
ps_name1 = os.environ.get('nfsPrimaryStorageName1')
elif ps_inv.type == inventory.CEPH_PRIMARY_STORAGE_TYPE:
ps_name1 = os.environ.get('cephPrimaryStorageName1')
ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name = ps_name1)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_vm_detach_ps')
vm_creation_option.set_zone_uuid(zone1.uuid)
tag = tag_ops.create_system_tag('InstanceOfferingVO', \
instance_offering_uuid, \
'primaryStorage::allocator::uuid::%s' % ps_inv.uuid)
l3_name = os.environ.get('l3VlanNetworkName1')
l3 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name)[0]
vm_creation_option.set_l3_uuids([l3.uuid])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
volume1 = test_stub.create_volume()
test_obj_dict.add_volume(volume1)
volume1.attach(vm1)
test_util.test_dsc("Delete Primary Storage")
#need to delete tag as well
tag_ops.delete_tag(tag.uuid)
ps_ops.delete_primary_storage(ps_inv.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED)
vm1.update()
test_obj_dict.rm_volume(volume1)
volume1.update()
test_lib.lib_robot_status_check(test_obj_dict)
test_util.test_dsc("Recover Primary Storage")
test_stub.recover_ps(ps_inv)
test_lib.lib_robot_status_check(test_obj_dict)
#update tag
ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name = ps_name1)[0]
tag = tag_ops.create_system_tag('InstanceOfferingVO', \
instance_offering_uuid, \
'primaryStorage::allocator::uuid::%s' % ps_inv.uuid)
test_util.test_dsc("Create new VM and Volume")
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
volume2 = test_stub.create_volume()
test_obj_dict.add_volume(volume2)
volume2.attach(vm2)
vm2.check()
volume2.check()
tag_ops.delete_tag(tag.uuid)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Test deleting primary storage Success')
def test():
test_util.test_dsc('Create Scheduler Trigger and Scheduler Job')
cond = res_ops.gen_query_conditions('type', '=', 'ImageStoreBackupStorage')
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE, cond)
if not bs :
test_util.test_skip('Not find image store type backup storage.')
image_name = os.environ.get('imageName_net')
l3_name = os.environ.get('l3PublicNetworkName')
remote_bs_vm = test_stub.create_vm('remote_bs_vm', image_name, l3_name)
test_obj_dict.add_vm(remote_bs_vm)
image_name = os.environ.get('imageName_s')
l3_name = os.environ.get('l3VlanNetworkName1')
test_vm = test_stub.create_vm('test-vm', image_name, l3_name)
test_obj_dict.add_vm(test_vm)
add_local_bs_tag = tag_ops.create_system_tag('ImageStoreBackupStorageVO', bs[0].uuid,'allowbackup')
#wait for vm start up
test_lib.lib_wait_target_up(remote_bs_vm.vm.vmNics[0].ip, '22', 90)
remote_bs = test_stub.create_image_store_backup_storage('remote_bs', remote_bs_vm.vm.vmNics[0].ip, 'root', 'password', '/zstack_bs', '22')
add_remote_bs = tag_ops.create_system_tag('ImageStoreBackupStorageVO', remote_bs.uuid,'remotebackup')
zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid
bs_ops.attach_backup_storage(remote_bs.uuid, zone_uuid)
parameters= {"retentionType":"Count","retentionValue":"1","backupStorageUuids":bs[0].uuid,"remoteBackupStorageUuid":""}
schd_job = schd_ops.create_scheduler_job('backup_database_scheduler', 'backup_database_scheduler', '7ae6456c0b01324dae6d4bef358a5772', 'databaseBackup',parameters=parameters)
schd_trigger = schd_ops.create_scheduler_trigger('backup_database_schedule',type='cron', cron='0 * * ? * *')
schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid)
#wait for 60s *2
time.sleep(120)
db_backup1 = schd_ops.query_db_backup()
if len(db_backup1) != 1:
test_util.test_fail('there sholuld be 1 db backup,but now there are %s' % len(db_backup1))
db_backup2 = schd_ops.get_db_backup_from_imagestore(url = 'ssh://*****:*****@%s:22/zstack_bs' % bs[0].hostname)
if len(db_backup2.backups) != 1:
test_util.test_fail('there sholuld be 1 db backup,but now there are %s' % len(db_backup2.backups))
db_url = schd_ops.export_db_backup_from_bs(bs[0].uuid, db_backup1[0].uuid)
test_util.test_dsc('export database backup successfully,url is %s' % db_url.databaseBackupUrl)
schd_ops.sync_db_from_imagestore_bs(remote_bs.uuid, bs[0].uuid, db_backup1[0].uuid)
test_vm.destroy()
test_util.test_dsc('Recover db From BackupStorage')
backupStorageUrl = 'ssh://*****:*****@%s:22/zstack_bs' % remote_bs_vm.vm.vmNics[0].ip
recover_db = schd_ops.recover_db_from_backup(backupStorageUrl = backupStorageUrl, backupInstallPath = db_backup2.backups[0].installPath, mysqlRootPassword='******')
#wait for db recover
time.sleep(60)
cond = res_ops.gen_query_conditions('name', '=', 'test-vm')
vm = res_ops.query_resource(res_ops.VM_INSTANCE, cond)
if not vm:
test_util.test_fail('there sholuld be a vm after recovering db from remote backup bs')
schd_ops.change_scheduler_state(schd_job.uuid, 'disable')
db_backup3 = schd_ops.query_db_backup()
zone = res_ops.query_resource(res_ops.ZONE)[0]
zone_ops.delete_zone(zone.uuid)
recover_db = schd_ops.recover_db_from_backup(uuid=db_backup3[0].uuid, mysqlRootPassword='******')
#wait for db recover
time.sleep(60)
vm = res_ops.query_resource(res_ops.VM_INSTANCE, cond)
if not vm:
test_util.test_fail('there sholuld be a vm after recovering db from local backup bs')
test_util.test_dsc('Clear env')
schd_ops.del_scheduler_job(schd_job.uuid)
schd_ops.del_scheduler_trigger(schd_trigger.uuid)
tag_ops.delete_tag(add_local_bs_tag.uuid)
bs_ops.delete_backup_storage(remote_bs.uuid)
bs_ops.reclaim_space_from_bs(bs[0].uuid)
remote_bs_vm.destroy()
test_vm.destroy()
def test():
global ldap_server_uuid
global new_account_uuid
global new_account_uuid2
system_tag = "ldapUseAsLoginName::uid"
ldap_server = ldp_ops.add_ldap_server('ldap1', 'ldap for test', os.environ.get('ldapServerUrl'), os.environ.get('ldapServerBase'), os.environ.get('ldapServerUsername'), os.environ.get('ldapServerPassword'), systemtags=[system_tag])
ldap_server_uuid = ldap_server.inventory.uuid
conditions = res_ops.gen_query_conditions('type', '=', 'SystemAdmin')
account = res_ops.query_resource(res_ops.ACCOUNT, conditions)[0]
new_account = acc_ops.create_account('new_account', 'password', 'Normal')
new_account_uuid = new_account.uuid
new_account2 = acc_ops.create_account('new_account2', 'password', 'Normal')
new_account_uuid2 = new_account2.uuid
ldap_account = ldp_ops.bind_ldap_account(os.environ.get('ldapDn'), new_account.uuid)
ldap_account_uuid = ldap_account.inventory.uuid
session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), os.environ.get('ldapPassword'))
acc_ops.logout(session_uuid)
ldap_account2 = ldp_ops.bind_ldap_account('uid=ldapuser3,ou=People,dc=mevoco,dc=com', new_account2.uuid)
ldap_account_uuid2 = ldap_account2.inventory.uuid
session_uuid2 = acc_ops.login_by_ldap('ldapuser3', 'password')
acc_ops.logout(session_uuid)
#Update multi ldap filters
system_tags = ["ldapCleanBindingFilter::(&(loginShell=/bin/bash)(|(homeDirectory=/home/mldapuser)(homeDirectory=/home/ldapuser3)))", "ldapUseAsLoginName::uid"]
ldap_filter = ldp_ops.update_ldap_server(ldap_server_uuid, system_tags)
ldp_ops.clean_invalid_ldap_binding()
get_excepted_exception = False
try:
session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), os.environ.get('ldapPassword'))
acc_ops.logout(session_uuid)
except:
get_excepted_exception = True
if not get_excepted_exception:
test_util.test_fail('should not be able to login with filter account')
get_excepted_exception = False
try:
session_uuid = acc_ops.login_by_ldap('ldapuser3','password')
acc_ops.logout(session_uuid)
except:
get_excepted_exception = True
if not get_excepted_exception:
test_util.test_fail('should not be able to login with filter account')
cond = res_ops.gen_query_conditions('resourceUuid', '=', ldap_server_uuid)
ldap_clean_binding_filter_tag_uuid = res_ops.query_resource(res_ops.SYSTEM_TAG, cond)[0].uuid
#Clear filter
tag_ops.delete_tag(ldap_clean_binding_filter_tag_uuid)
ldap_filter = ldp_ops.update_ldap_server(ldap_server_uuid, [system_tag])
ldap_account = ldp_ops.bind_ldap_account(os.environ.get('ldapDn'), new_account.uuid)
ldap_account_uuid = ldap_account.inventory.uuid
session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), os.environ.get('ldapPassword'))
acc_ops.logout(session_uuid)
ldap_account2 = ldp_ops.bind_ldap_account('uid=ldapuser3,ou=People,dc=mevoco,dc=com', new_account2.uuid)
ldap_account_uuid2 = ldap_account2.inventory.uuid
session_uuid2 = acc_ops.login_by_ldap('ldapuser3', 'password')
acc_ops.logout(session_uuid)
ldp_ops.clean_invalid_ldap_binding()
get_excepted_exception = False
try:
session_uuid = acc_ops.login_by_ldap(os.environ.get('ldapUid'), os.environ.get('ldapPassword'))
acc_ops.logout(session_uuid)
except:
get_excepted_exception = True
if get_excepted_exception:
test_util.test_fail('should be able to login after removed filter but login failed')
get_excepted_exception = False
try:
session_uuid = acc_ops.login_by_ldap('ldapuser3','password')
acc_ops.logout(session_uuid)
except:
get_excepted_exception = True
if get_excepted_exception:
test_util.test_fail('should be able to login after removed filter but login failed')
ldp_ops.unbind_ldap_account(ldap_account_uuid)
ldp_ops.unbind_ldap_account(ldap_account_uuid2)
acc_ops.delete_account(new_account_uuid)
acc_ops.delete_account(new_account_uuid2)
ldp_ops.delete_ldap_server(ldap_server_uuid)
test_util.test_pass('Create VM by normal user account Success')
acc_ops.logout(session_uuid)
def test():
global ps_inv
global ps_uuid
global cluster_uuid
global tag
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up primary storage 1 and set system tag for instance offering.
zone_name = os.environ.get('zoneName1')
zone_uuid = res_ops.get_resource(res_ops.ZONE, name = zone_name)[0].uuid
cond = res_ops.gen_query_conditions('zoneUuid', '=', zone_uuid)
ps_inv = res_ops.query_resource(res_ops.PRIMARY_STORAGE, cond)[0]
if ps_inv.type == inventory.NFS_PRIMARY_STORAGE_TYPE:
ps_name1 = os.environ.get('nfsPrimaryStorageName1')
elif ps_inv.type == inventory.CEPH_PRIMARY_STORAGE_TYPE:
ps_name1 = os.environ.get('cephPrimaryStorageName1')
ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name = ps_name1)[0]
ps_uuid = ps_inv.uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, \
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_vm_ps_ops')
tag = tag_ops.create_system_tag('InstanceOfferingVO', \
instance_offering_uuid, \
'primaryStorage::allocator::uuid::%s' % ps_uuid)
l3_name = os.environ.get('l3VlanNetworkName1')
l3 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name)[0]
vm_creation_option.set_l3_uuids([l3.uuid])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
cluster_uuid = vm1.get_vm().clusterUuid
test_util.test_dsc("Detach Primary Storage")
ps_ops.detach_primary_storage(ps_uuid, cluster_uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm1.set_state(vm_header.STOPPED)
vm1.check()
vm1.start()
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
test_util.test_dsc("Delete Primary Storage")
tag_ops.delete_tag(tag.uuid)
ps_ops.delete_primary_storage(ps_inv.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED)
vm1.set_state(vm_header.DESTROYED)
vm1.check()
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED)
vm2.set_state(vm_header.DESTROYED)
vm2.check()
try:
vm3 = test_lib.lib_create_vm(vm_creation_option)
except:
test_util.test_logger('Catch expected vm creation exception, since primary storage has been deleted. ')
else:
test_util.test_fail('Fail: Primary Storage has been deleted. But vm is still created with it.')
test_stub.recover_ps(ps_inv)
test_util.test_dsc("Attach Primary Storage")
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Test primary storage operations Success')
def test():
global ps_uuid
global cluster_uuid
global tag
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
cluster1_name = os.environ.get('clusterName1')
cluster1 = res_ops.get_resource(res_ops.CLUSTER, name = cluster1_name)[0]
#pick up primary storage 1 and set system tag for instance offering.
ps_name1 = os.environ.get('nfsPrimaryStorageName1')
ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name = ps_name1)[0]
ps_uuid = ps_inv.uuid
cluster_uuid = cluster1.uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, \
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_vm_detach_ps')
vm_creation_option.set_cluster_uuid(cluster_uuid)
tag = tag_ops.create_system_tag('InstanceOfferingVO', \
instance_offering_uuid, \
'primaryStorage::allocator::uuid::%s' % ps_uuid)
l3_name = os.environ.get('l3VlanNetworkName1')
l3 = res_ops.get_resource(res_ops.L3_NETWORK, name = l3_name)[0]
vm_creation_option.set_l3_uuids([l3.uuid])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
volume1 = test_stub.create_volume()
test_obj_dict.add_volume(volume1)
volume1.attach(vm1)
test_util.test_dsc("Detach Primary Storage")
ps_ops.detach_primary_storage(ps_uuid, cluster_uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm1.set_state(vm_header.STOPPED)
vm2.update()
vm2.set_state(vm_header.STOPPED)
vm1.check()
vm2.check()
test_util.test_dsc("Attach Primary Storage")
ps_ops.attach_primary_storage(ps_uuid, cluster_uuid)
vm1.start()
vm2.start()
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm1.check()
volume1.check()
vm2.check()
vm3.check()
test_util.test_dsc("Delete new added tag")
tag_ops.delete_tag(tag.uuid)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Test detaching primary storage Success')
def test():
global ps_uuid
global cluster_uuid
global tag
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
cluster1_name = os.environ.get('clusterName1')
cluster1 = res_ops.get_resource(res_ops.CLUSTER, name=cluster1_name)[0]
#pick up primary storage 1 and set system tag for instance offering.
ps_name1 = os.environ.get('nfsPrimaryStorageName1')
ps_inv = res_ops.get_resource(res_ops.PRIMARY_STORAGE, name=ps_name1)[0]
ps_uuid = ps_inv.uuid
cluster_uuid = cluster1.uuid
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, \
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_vm_detach_ps')
vm_creation_option.set_cluster_uuid(cluster_uuid)
tag = tag_ops.create_system_tag('InstanceOfferingVO', \
instance_offering_uuid, \
'primaryStorage::allocator::uuid::%s' % ps_uuid)
l3_name = os.environ.get('l3VlanNetworkName1')
l3 = res_ops.get_resource(res_ops.L3_NETWORK, name=l3_name)[0]
vm_creation_option.set_l3_uuids([l3.uuid])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
volume1 = test_stub.create_volume()
test_obj_dict.add_volume(volume1)
volume1.attach(vm1)
test_util.test_dsc("Detach Primary Storage")
ps_ops.detach_primary_storage(ps_uuid, cluster_uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.STOPPED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.STOPPED)
vm1.update()
vm1.set_state(vm_header.STOPPED)
vm2.update()
vm2.set_state(vm_header.STOPPED)
vm1.check()
vm2.check()
test_util.test_dsc("Attach Primary Storage")
ps_ops.attach_primary_storage(ps_uuid, cluster_uuid)
vm1.start()
vm2.start()
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm1.check()
volume1.check()
vm2.check()
vm3.check()
test_util.test_dsc("Delete new added tag")
tag_ops.delete_tag(tag.uuid)
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Test detaching primary storage Success')
