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 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')