def test(): global vm test_util.test_dsc('create VM with setting password') for root_password in root_password_list: test_util.test_dsc("root_password: \"%s\"" % (root_password)) vm = test_stub.create_vm(vm_name='c7-vm-32', image_name="imageName_i_c7_32", root_password=root_password) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') if not test_lib.lib_check_login_in_vm(vm.get_vm(), "root", root_password): test_util.test_fail("create vm with root password: %s failed", root_password) vm.destroy() vm.check() vm.expunge() vm.check() test_util.test_pass('Set password when VM is creating is successful.')
def test(): global vm, test_account_uuid, test_account_session import uuid account_name = uuid.uuid1().get_hex() account_pass = uuid.uuid1().get_hex() account_pass = hashlib.sha512(account_name).hexdigest() test_account = acc_ops.create_normal_account(account_name, account_pass) test_account_uuid = test_account.uuid test_account_session = acc_ops.login_by_account(account_name, account_pass) test_stub.share_admin_resource([test_account_uuid]) vm = test_stub.create_vm(vm_name='c7-vm-no-sys-tag', image_name="imageName_i_c7_no_tag", session_uuid=test_account_session) vm.check() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') for (usr, passwd) in zip(users, passwds): if usr not in exist_users: test_stub.create_user_in_vm(vm.get_vm(), usr, passwd) exist_users.append(usr) #When vm is running: #res_ops.enable_change_vm_password("true", vm.get_vm().uuid, 'VmInstanceVO', session_uuid = test_account_session) vm_ops.set_vm_qga_enable(vm.get_vm().uuid, session_uuid=test_account_session) vm_ops.change_vm_password(vm.get_vm().uuid, usr, passwd, skip_stopped_vm=None, session_uuid=test_account_session) if not test_lib.lib_check_login_in_vm(vm.get_vm(), usr, passwd): test_util.test_fail("create vm with user:%s password: %s failed", usr, passwd) vm_ops.change_vm_password(vm.get_vm().uuid, "root", test_stub.original_root_password, session_uuid=test_account_session) vm.check() vm.destroy(test_account_session) vm.check() vm.expunge(test_account_session) vm.check() acc_ops.delete_account(test_account_uuid) test_util.test_pass( 'enable and change vm password by normal user account Success')
def test(): global vm test_util.test_dsc('create VM with setting password') for root_password in root_password_list: test_util.test_dsc("root_password: \"%s\"" % (root_password)) #vm = test_stub.create_vm(vm_name = 'c7-vm-no-sys-tag', image_name = "imageName_i_c7_no_tag", root_password=root_password) vm = test_stub.create_vm(vm_name='c7-vm-no-sys-tag', image_name="imageName_i_c7_no_tag") backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') #if not test_lib.lib_check_login_in_vm(vm.get_vm(), "root", root_password): # test_util.test_fail("create vm with root password: %s failed", root_password) # stop vm && change vm password #vm.stop() vm.check() try: vm_ops.change_vm_password(vm.get_vm().uuid, "root", root_password) except Exception, e: test_util.test_pass( "negative test of change a no system tag image passed.")
def test(): global test_obj_dict test_util.test_dsc('Create test vm and check') bs = res_ops.query_resource(res_ops.BACKUP_STORAGE) for i in bs: if i.type == 'AliyunEBS': test_util.test_skip('Skip test on AliyunEBS') vm1 = test_stub.create_vlan_vm() #Without this checking, the image (created later) might be not able to get a DHCP IP, when using to create a new vm. vm1.check() test_obj_dict.add_vm(vm1) vm1.stop() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name('test_create_image_template') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image) image.delete() image.check() test_util.test_pass('Delete Image Template Test Success')
def test(): vm1 = test_stub.create_vm(vm_name='basic-test-vm') test_obj_dict.add_vm(vm1) vm1.check() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: image_creation_option.set_backup_storage_uuid_list( [backup_storage_list[0].uuid]) break else: test_util.test_skip('Not find image store type backup storage.') global default_snapshot_depth default_snapshot_depth = conf_ops.change_global_config('volumeSnapshot', \ 'incrementalSnapshot.maxNum', test_depth) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) test_img_num = 1 while (test_img_num < 101): image_creation_option.set_name('test_create_img_store_img_vm%d' % test_img_num) #image_creation_option.set_platform('Linux') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() image.check() test_obj_dict.add_image(image) test_img_num += 1 vm2 = test_stub.create_vm(image_name='test_create_img_store_img_vm100') test_obj_dict.add_vm(vm2) vm2.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create 100 images Success')
def test(): global vm test_util.test_dsc('create VM with setting password') for root_password in root_password_list: test_util.test_dsc("root_password: \"%s\"" %(root_password)) vm = test_stub.create_vm(vm_name = 'u13-vm', image_name = "imageName_i_u13", root_password=root_password) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') if not test_lib.lib_check_login_in_vm(vm.get_vm(), "root", root_password): test_util.test_fail("create vm with root password: %s failed", root_password) vm.destroy() vm.check() vm.expunge() vm.check() test_util.test_pass('Set password when VM is creating is successful.')
def test(): vm1 = test_stub.create_vm(vm_name = 'basic-test-vm') test_obj_dict.add_vm(vm1) vm1.check() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) break else: test_util.test_skip('Not find image store type backup storage.') global default_snapshot_depth default_snapshot_depth = conf_ops.change_global_config('volumeSnapshot', \ 'incrementalSnapshot.maxNum', test_depth) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) test_img_num = 1 while (test_img_num < 101): image_creation_option.set_name('test_create_img_store_img_vm%d' % test_img_num) #image_creation_option.set_platform('Linux') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() image.check() test_obj_dict.add_image(image) test_img_num += 1 vm2 = test_stub.create_vm(image_name = 'test_create_img_store_img_vm100') test_obj_dict.add_vm(vm2) vm2.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create 100 images Success')
def test(): global vm vm_creation_option = test_util.VmOption() image_name = os.environ.get('imageName_net') l3_name = os.environ.get('l3VlanNetworkName1') vm = test_stub.create_vm("test_resize_vm", image_name, l3_name) test_obj_dict.add_vm(vm) vm.check() vol_size = test_lib.lib_get_root_volume(vm.get_vm()).size volume_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid set_size = 1024*1024*1024*5 vol_ops.resize_volume(volume_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) bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) image_option = test_util.ImageOption() image_option.set_root_volume_uuid(volume_uuid) image_option.set_name('image_resize_template') image_option.set_backup_storage_uuid_list([bs_list[0].uuid]) image = img_ops.create_root_volume_template(image_option) new_vm = test_stub.create_vm("test_vm_after_resize", 'image_resize_template', l3_name) test_obj_dict.add_vm(new_vm) new_vm.check() new_volume_uuid = test_lib.lib_get_root_volume_uuid(new_vm.get_vm()) vol_size_after = test_lib.lib_get_root_volume(new_vm.get_vm()).size if set_size != vol_size_after: test_util.test_fail('Resize Root Volume failed, size = %s' % vol_size_after) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Create Template for Resize VM Test Success')
def test(): global test_obj_dict test_util.test_dsc('Create test vm and check') vm1 = test_stub.create_vlan_vm() #Without this checking, the image (created later) might be not able to get a DHCP IP, when using to create a new vm. vm1.check() test_obj_dict.add_vm(vm1) vm1.stop() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) image_creation_option.set_backup_storage_uuid_list( [backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name('test_create_image_template') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image) image.delete() image.check() test_util.test_pass('Delete Image Template Test Success')
def test(): global vm test_util.test_dsc('create VM with setting password') for root_password in root_password_list: test_util.test_dsc("root_password: \"%s\"" %(root_password)) #vm = test_stub.create_vm(vm_name = 'c7-vm-no-sys-tag', image_name = "imageName_i_c7_no_tag", root_password=root_password) vm = test_stub.create_vm(vm_name = 'c7-vm-no-sys-tag', image_name = "imageName_i_c7_no_tag") backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') #if not test_lib.lib_check_login_in_vm(vm.get_vm(), "root", root_password): # test_util.test_fail("create vm with root password: %s failed", root_password) # stop vm && change vm password #vm.stop() vm.check() try: vm_ops.change_vm_password(vm.get_vm().uuid, "root", root_password) except Exception, e: if "CreateSystemTag" in str(e): test_util.test_pass("negative test of change a no system tag image passed.") else: test_util.test_fail("negative test failed with not expected log: %s", str(e))
def test(): test_util.test_dsc('Create test vm and check') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) vm.stop() r_volume = zstack_volume_header.ZstackTestVolume() r_volume.set_volume(test_lib.lib_get_root_volume(vm.get_vm())) r_volume.set_state(volume_header.ATTACHED) test_util.test_dsc('Create volume template and check') bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.get_vm()) vol_tmpt = r_volume.create_template([bs_list[0].uuid], 'new_data_template') test_obj_dict.add_image(vol_tmpt) test_util.test_dsc('Try to use data vol_tempt to Create VM. ') vm_option = vm.get_creation_option() vm_option.set_image_uuid(vol_tmpt.get_image().uuid) vm2 = zstack_vm_header.ZstackTestVm() vm2.set_creation_option(vm_option) try: vm2.create() except: test_util.test_logger('Expected exception, when creating VM by using Data Volume Template as root image') else: test_util.test_fail('VM can use data volume template to create VM') vol_tmpt.delete() test_obj_dict.rm_image(vol_tmpt) vm.destroy() test_util.test_pass('Create VM from Data Volume Template Test Success')
def test(): vm = test_stub.create_vm(vm_name = vn_prefix) test_obj_dict.add_vm(vm) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') vm1 = test_stub.create_vm(vm_name = vn_prefix) test_obj_dict.add_vm(vm1) vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm()) test_util.test_dsc('create snapshot and check') snapshots = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid) snapshots.set_utility_vm(vm1) snapshots.create_snapshot('create_root_snapshot1') snapshot1 = snapshots.get_current_snapshot() snapshots.create_snapshot('create_root_snapshot2') snapshots.delete_snapshot(snapshot1) vm.reboot() new_vm1 = vm.clone(vm_name1)[0] test_obj_dict.add_vm(new_vm1) vm.destroy() new_vm1.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Clone VM Test with snapshot operations Success')
def test(): vm = test_stub.create_vm(vm_name = vn_prefix) test_obj_dict.add_vm(vm) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type in [inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE, inventory.CEPH_BACKUP_STORAGE_TYPE]: break else: vm.destroy() test_util.test_skip('Not find image store or ceph type backup storage.') vm1 = test_stub.create_vm(vm_name = vn_prefix) test_obj_dict.add_vm(vm1) vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm()) test_util.test_dsc('create snapshot and check') snapshots = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid) snapshots.set_utility_vm(vm1) snapshots.create_snapshot('create_root_snapshot1') snapshot1 = snapshots.get_current_snapshot() snapshots.create_snapshot('create_root_snapshot2') snapshots.delete_snapshot(snapshot1) vm.reboot() new_vm1 = vm.clone(vm_name1)[0] test_obj_dict.add_vm(new_vm1) vm.destroy() new_vm1.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Clone VM Test with snapshot operations Success')
def test(): allow_ps_list = [inventory.CEPH_PRIMARY_STORAGE_TYPE, "SharedBlock"] test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list) flavor = case_flavor[os.environ.get('CASE_FLAVOR')] test_util.test_dsc('Create test vm and check') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) test_util.test_dsc('Create volume and check') disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume_creation_option.set_system_tags( ['ephemeral::shareable', 'capability::virtio-scsi']) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) test_util.test_dsc('Attach volume and check') #vm.check() volume.attach(vm) if flavor['vm_running'] == False: vm.stop() if flavor['vm_running'] == True: allow_ps_list = [inventory.CEPH_PRIMARY_STORAGE_TYPE] test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list) ps_uuid = volume.get_volume().primaryStorageUuid ps = test_lib.lib_get_primary_storage_by_uuid(ps_uuid) test_util.test_dsc('Create volume template and check') bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.get_vm()) bs_uuid_list = [] for bs in bs_list: bs_uuid_list.append(bs.uuid) vol_tmpt = volume.create_template(bs_uuid_list, 'new_data_template') test_obj_dict.add_image(vol_tmpt) vol_tmpt.check() volume.check() volume.delete() test_obj_dict.rm_volume(volume) test_util.test_dsc('Create volume from template and check') volume2 = vol_tmpt.create_data_volume(ps_uuid, 'new_volume_from_template') test_obj_dict.add_volume(volume2) vol_tmpt.delete() test_obj_dict.rm_image(vol_tmpt) volume2.check() volume2.attach(vm) vm.check() volume2.check() volume2.detach() volume2.delete() test_obj_dict.rm_volume(volume2) vm.destroy() test_util.test_pass( 'Create Sharable Data Volume Template from Data Volume Success.')
def test(): global vm, exist_users test_util.test_dsc('Change unexisted user password test') vm = test_stub.create_vm(vm_name = 'cknewusrvmpswd-u13-64', image_name = "imageName_i_u13") vm.check() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') for (usr,passwd) in zip(users, passwds): if usr not in exist_users: test_util.test_logger("un-existed user:%s change vm password" %(usr)) #if the user is not existed, it should report #try: # vm_ops.change_vm_password(vm.get_vm().uuid, usr, passwd, skip_stopped_vm = None, session_uuid = None) #except Exception,e: # test_util.test_logger("unexisted user change vm password exception is %s" %(str(e))) # normal_failed_string = "not exist" # if normal_failed_string in str(e): # test_util.test_logger("unexisted user return correct, create a the user for it.") #else: # test_util.test_fail("user not exist in this OS, it should not raise exception, but return a failure.") test_stub.create_user_in_vm(vm.get_vm(), usr, passwd) exist_users.append(usr) #When vm is running: vm_ops.change_vm_password(vm.get_vm().uuid, usr, passwd, skip_stopped_vm = None, session_uuid = None) if not test_lib.lib_check_login_in_vm(vm.get_vm(), usr, passwd): test_util.test_fail("create vm with user:%s password: %s failed", usr, passwd) #When vm is stopped: #vm.stop() vm_ops.change_vm_password(vm.get_vm().uuid, "root", test_stub.original_root_password) #vm.start() vm.check() vm.destroy() vm.check() vm.expunge() vm.check() test_util.test_pass('Set password when VM is creating is successful.')
def test(): global origin_interval global bs_type test_util.test_dsc('Create test vm and check') bs = res_ops.query_resource(res_ops.BACKUP_STORAGE) for i in bs: if i.type == 'AliyunEBS': test_util.test_skip('Skip test on AliyunEBS') vm1 = test_stub.create_vlan_vm() #Without this checking, the image (created later) might be not able to get a DHCP IP, when using to create a new vm. vm1.check() test_obj_dict.add_vm(vm1) vm1.stop() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name('test_create_image_template') bs_type = backup_storage_list[0].type if bs_type == 'Ceph': origin_interval = conf_ops.change_global_config('ceph', 'imageCache.cleanup.interval', '1') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image) image.check() test_util.test_dsc('Use new created Image to create a VM') new_img_uuid = image.image.uuid vm_creation_option = vm1.get_creation_option() vm_creation_option.set_image_uuid(new_img_uuid) vm2 = test_vm.ZstackTestVm() vm2.set_creation_option(vm_creation_option) vm2.create() test_obj_dict.add_vm(vm2) vm2.check() vm1.start() vm1.check() vm2.destroy() vm1.destroy() image.delete() if bs_type == 'Ceph': time.sleep(60) image.check() if bs_type == 'Ceph': conf_ops.change_global_config('ceph', 'imageCache.cleanup.interval', origin_interval) test_util.test_pass('Create Image Template Test Success')
def test(): global vm, exist_users, cur_usr, cur_passwd test_util.test_dsc('change VM with assigned password test') vm = test_stub.create_vm(vm_name='ckvmpswd-c6-32', image_name="imageName_i_c6_32") vm.check() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') cur_usr = "******" cur_passwd = "password" for (usr, passwd) in zip(users, passwds): #When vm is running: vm_ops.change_vm_password(vm.get_vm().uuid, usr, passwd, skip_stopped_vm=None, session_uuid=None) cur_usr = usr cur_passwd = passwd if not test_lib.lib_check_login_in_vm(vm.get_vm(), usr, passwd): test_util.test_fail("create vm with user:%s password: %s failed", usr, passwd) #When vm is stopped: #vm.stop() vm_ops.change_vm_password(vm.get_vm().uuid, "root", test_stub.original_root_password) cur_usr = "******" cur_passwd = "password" #vm.start() vm.check() vm.destroy() vm.check() vm.expunge() vm.check() test_util.test_pass('Set password when VM is creating is successful.')
def test(): global origin_interval global bs_type test_util.test_dsc('Create test vm and check') vm1 = test_stub.create_vlan_vm() #Without this checking, the image (created later) might be not able to get a DHCP IP, when using to create a new vm. vm1.check() test_obj_dict.add_vm(vm1) vm1.stop() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) image_creation_option.set_backup_storage_uuid_list( [backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name('test_create_image_template') bs_type = backup_storage_list[0].type if bs_type == 'Ceph': origin_interval = conf_ops.change_global_config( 'ceph', 'imageCache.cleanup.interval', '1') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image) image.check() test_util.test_dsc('Use new created Image to create a VM') new_img_uuid = image.image.uuid vm_creation_option = vm1.get_creation_option() vm_creation_option.set_image_uuid(new_img_uuid) vm2 = test_vm.ZstackTestVm() vm2.set_creation_option(vm_creation_option) vm2.create() test_obj_dict.add_vm(vm2) vm2.check() vm1.start() vm1.check() vm2.destroy() vm1.destroy() image.delete() if bs_type == 'Ceph': time.sleep(60) image.check() if bs_type == 'Ceph': conf_ops.change_global_config('ceph', 'imageCache.cleanup.interval', origin_interval) test_util.test_pass('Create Image Template Test Success')
def test(): allow_ps_list = [inventory.CEPH_PRIMARY_STORAGE_TYPE, "SharedBlock"] test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list) flavor = case_flavor[os.environ.get('CASE_FLAVOR')] test_util.test_dsc('Create test vm and check') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) test_util.test_dsc('Create volume and check') disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume_creation_option.set_system_tags(['ephemeral::shareable', 'capability::virtio-scsi']) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) test_util.test_dsc('Attach volume and check') #vm.check() volume.attach(vm) if flavor['vm_running'] == False: vm.stop() if flavor['vm_running'] == True: allow_ps_list = [inventory.CEPH_PRIMARY_STORAGE_TYPE] test_lib.skip_test_when_ps_type_not_in_list(allow_ps_list) ps_uuid = volume.get_volume().primaryStorageUuid ps = test_lib.lib_get_primary_storage_by_uuid(ps_uuid) test_util.test_dsc('Create volume template and check') bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.get_vm()) bs_uuid_list = [] for bs in bs_list: bs_uuid_list.append(bs.uuid) vol_tmpt = volume.create_template(bs_uuid_list, 'new_data_template') test_obj_dict.add_image(vol_tmpt) vol_tmpt.check() volume.check() volume.delete() test_obj_dict.rm_volume(volume) test_util.test_dsc('Create volume from template and check') volume2 = vol_tmpt.create_data_volume(ps_uuid, 'new_volume_from_template') test_obj_dict.add_volume(volume2) vol_tmpt.delete() test_obj_dict.rm_image(vol_tmpt) volume2.check() volume2.attach(vm) vm.check() volume2.check() volume2.detach() volume2.delete() test_obj_dict.rm_volume(volume2) vm.destroy() test_util.test_pass('Create Sharable Data Volume Template from Data Volume Success.')
def test(): vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break #if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: # break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('rootDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) #volume_creation_option.set_system_tags(['ephemeral::shareable', 'capability::virtio-scsi']) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() volume.attach(vm) vm.stop() vm.check() new_vms = vm.clone(vm_names) for new_vm in new_vms: test_obj_dict.add_vm(new_vm) if len(new_vms) != len(vm_names): test_util.test_fail( 'only %s VMs have been cloned, which is less than required: %s' % (len(new_vms), vm_names)) for new_vm in new_vms: new_vm = new_vm.get_vm() try: vm_names.remove(new_vm.name) test_util.test_logger('VM:%s name: %s is found' % (new_vm.uuid, new_vm.name)) except: test_util.test_fail('%s vm name: %s is not in list: %s' % (new_vm.uuid, new_vm.name, vm_names)) if test_lib.lib_get_data_volumes(new_vms[0].vm) != []: test_util.test_fail( 'The cloned vm is still have data volume, the expected behavior is only clone root volume.' ) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Clone VM Test Success')
def test(): global vm, vm2, image_uuid test_util.test_dsc('create VM with setting password') for root_password in root_password_list: test_util.test_dsc("root_password: \"%s\"" %(root_password)) vm = test_stub.create_vm(vm_name = 'c7-vm-no-sys-tag', image_name = "imageName_i_c7_no_tag") backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') vm.check() #add tag to vm tag_ops.create_system_tag('VmInstanceVO', vm.get_vm().uuid, "qemuga") vm_ops.change_vm_password(vm.get_vm().uuid, "root", root_password) #create image by the vm with tag vm_root_volume_inv = test_lib.lib_get_root_volume(vm.get_vm()) root_volume_uuid = vm_root_volume_inv.uuid image_option1 = test_util.ImageOption() image_option1.set_root_volume_uuid(root_volume_uuid) image_option1.set_name('add_tag_vm_to_image') image_option1.set_format('qcow2') image_option1.set_backup_storage_uuid_list([bs.uuid]) vm.stop() image = img_ops.create_root_volume_template(image_option1) #create vm by new image vm2 = test_stub.create_vm(vm_name = 'c7-vm-add-tag-from-previous-vm', image_name = "add_tag_vm_to_image") if not test_lib.lib_check_login_in_vm(vm2.get_vm(), "root", root_password): test_util.test_fail("create vm with user:%s password: %s failed", "root", root_password) vm_ops.change_vm_password(vm2.get_vm().uuid, "root", root_password) image_uuid = image.uuid if not image_uuid: img_ops.delete_image(image_uuid) img_ops.expunge_image(image_uuid) test_util.test_pass('add system tag on a no system tag image test passed')
def test(): global vm, test_account_uuid, test_account_session, image_uuid import uuid account_name = uuid.uuid1().get_hex() account_pass = uuid.uuid1().get_hex() account_pass = hashlib.sha512(account_name).hexdigest() test_account = acc_ops.create_normal_account(account_name, account_pass) test_account_uuid = test_account.uuid test_account_session = acc_ops.login_by_account(account_name, account_pass) test_stub.share_admin_resource([test_account_uuid]) img_cond = res_ops.gen_query_conditions("name", '=', "centos7-installation-no-system-tag") img_inv = res_ops.query_resource_fields(res_ops.IMAGE, img_cond, None) image_uuid = img_inv[0].uuid #res_ops.enable_change_vm_password("true", image_uuid, 'ImageVO', session_uuid = test_account_session) img_ops.set_image_qga_enable(image_uuid, session_uuid = test_account_session) vm = test_stub.create_vm(vm_name = 'c7-vm-no-sys-tag', image_name = "imageName_i_c7_no_tag", session_uuid = test_account_session) vm.check() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') for (usr,passwd) in zip(users, passwds): if usr not in exist_users: test_stub.create_user_in_vm(vm.get_vm(), usr, passwd) exist_users.append(usr) #When vm is running: vm_ops.change_vm_password(vm.get_vm().uuid, usr, passwd, skip_stopped_vm = None, session_uuid = test_account_session) if not test_lib.lib_check_login_in_vm(vm.get_vm(), usr, passwd): test_util.test_fail("create vm with user:%s password: %s failed", usr, passwd) vm_ops.change_vm_password(vm.get_vm().uuid, "root", test_stub.original_root_password, session_uuid = test_account_session) vm.check() #res_ops.enable_change_vm_password("false", img_inv[0].uuid, 'ImageVO', session_uuid = test_account_session) img_ops.set_image_qga_disable(img_inv[0].uuid, session_uuid = test_account_session) vm.destroy(test_account_session) vm.check() vm.expunge(test_account_session) vm.check() acc_ops.delete_account(test_account_uuid) test_util.test_pass('enable and change vm password by normal user account Success')
def test(): global vms global images global threads global checker_threads global origin_interval global bs_type test_util.test_dsc('Create test vm and check') script_file = tempfile.NamedTemporaryFile(delete=False) script_file.write('dd if=/dev/zero of=/home/dd bs=1M count=100') script_file.close() for i in range(0, threads_num): vms[i] = test_stub.create_vlan_vm() vms[i].check() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm( vms[i].vm) if backup_storage_list[0].type != 'ImageStoreBackupStorage': test_util.test_skip("Requires imagestore BS to test, skip testing") if not test_lib.lib_execute_shell_script_in_vm(vms[i].get_vm(), script_file.name): test_util.test_fail("fail to create data in [vm:] %s" % (vms[i].get_vm().uuid)) test_obj_dict.add_vm(vms[i]) vms[i].stop() os.unlink(script_file.name) for i in range(0, threads_num): threads[i] = threading.Thread(target=create_temp_image, args=(i, )) threads[i].start() for i in range(0, threads_num): checker_threads[i] = threading.Thread( target=check_create_temp_image_progress, args=(i, )) checker_threads[i].start() for i in range(0, threads_num): checker_threads[i].join() threads[i].join() images[i].check() vms[i].destroy() images[i].delete() if bs_type == 'Ceph': time.sleep(60) if bs_type == 'Ceph': conf_ops.change_global_config('ceph', 'imageCache.cleanup.interval', origin_interval) test_util.test_pass('Create Image Template Test Success')
def test(): global vm, exist_users, cur_usr, cur_passwd test_util.test_dsc('change VM with assigned password test') vm = test_stub.create_vm(vm_name = 'ckvmpswd-c7-64', image_name = "imageName_i_c7") vm.check() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') cur_usr = "******" cur_passwd = "password" for (usr,passwd) in zip(users, passwds): #When vm is running: vm_ops.change_vm_password(vm.get_vm().uuid, usr, passwd, skip_stopped_vm = None, session_uuid = None) cur_usr = usr cur_passwd = passwd if not test_lib.lib_check_login_in_vm(vm.get_vm(), usr, passwd): test_util.test_fail("create vm with user:%s password: %s failed", usr, passwd) #When vm is stopped: #vm.stop() vm_ops.change_vm_password(vm.get_vm().uuid, "root", test_stub.original_root_password) cur_usr = "******" cur_passwd = "password" #vm.start() vm.check() vm.destroy() vm.check() vm.expunge() vm.check() test_util.test_pass('Set password when VM is creating is successful.')
def test(): global vms global images global threads global checker_threads global origin_interval global bs_type test_util.test_dsc('Create test vm and check') script_file = tempfile.NamedTemporaryFile(delete=False) script_file.write('dd if=/dev/zero of=/home/dd bs=1M count=100') script_file.close() for i in range(0, threads_num): vms[i] = test_stub.create_vlan_vm() vms[i].check() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vms[i].vm) if backup_storage_list[0].type != 'ImageStoreBackupStorage': test_util.test_skip("Requires imagestore BS to test, skip testing") if not test_lib.lib_execute_shell_script_in_vm(vms[i].get_vm(), script_file.name): test_util.test_fail("fail to create data in [vm:] %s" % (vms[i].get_vm().uuid)) test_obj_dict.add_vm(vms[i]) vms[i].stop() os.unlink(script_file.name) for i in range(0, threads_num): threads[i] = threading.Thread(target=create_temp_image, args=(i, )) threads[i].start() for i in range(0, threads_num): checker_threads[i] = threading.Thread(target=check_create_temp_image_progress, args=(i, )) checker_threads[i].start() for i in range(0, threads_num): checker_threads[i].join() threads[i].join() images[i].check() vms[i].destroy() images[i].delete() for i in range(0, threads_num): if checker_results[i] == None: test_util.test_fail("Image checker thread %s fail" % (i)) if bs_type == 'Ceph': time.sleep(60) if bs_type == 'Ceph': conf_ops.change_global_config('ceph', 'imageCache.cleanup.interval', origin_interval) test_util.test_pass('Create Image Template Test Success')
def create_image(vm_obj): volume_uuid = test_lib.lib_get_root_volume(vm_obj.get_vm()).uuid bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm_obj.vm) image_option = test_util.ImageOption() image_option.set_root_volume_uuid(volume_uuid) image_option.set_name('image_resize_template') image_option.set_backup_storage_uuid_list([bs_list[0].uuid]) image = img_ops.create_root_volume_template(image_option) new_image = zstack_image_header.ZstackTestImage() new_image.set_creation_option(image_option) new_image.set_image(image) new_image.check() new_image.clean()
def test(): global vm, test_account_uuid, test_account_session import uuid account_name = uuid.uuid1().get_hex() account_pass = uuid.uuid1().get_hex() account_pass = hashlib.sha512(account_name).hexdigest() test_account = acc_ops.create_normal_account(account_name, account_pass) test_account_uuid = test_account.uuid test_account_session = acc_ops.login_by_account(account_name, account_pass) test_stub.share_admin_resource([test_account_uuid]) vm = test_stub.create_vm(vm_name = 'c7-vm', image_name = "imageName_i_c7", session_uuid = test_account_session) vm.check() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') for (usr,passwd) in zip(users, passwds): if usr not in exist_users: test_stub.create_user_in_vm(vm.get_vm(), usr, passwd) exist_users.append(usr) #When vm is running: vm_ops.change_vm_password(vm.get_vm().uuid, usr, passwd, skip_stopped_vm = None, session_uuid = test_account_session) if not test_lib.lib_check_login_in_vm(vm.get_vm(), usr, passwd): test_util.test_fail("create vm with user:%s password: %s failed", usr, passwd) #When vm is stopped: #vm.stop(session_uuid = test_account_session) vm_ops.change_vm_password(vm.get_vm().uuid, "root", test_stub.original_root_password, session_uuid = test_account_session) #vm.start(session_uuid = test_account_session) vm.check() vm.destroy(test_account_session) vm.check() vm.expunge(test_account_session) vm.check() acc_ops.delete_account(test_account_uuid) test_util.test_pass('change vm password by normal user account Success')
def test(): vm1 = test_stub.create_vr_vm('vm_imagecache', 'imageName_net', 'l3VlanNetwork3') test_obj_dict.add_vm(vm1) vm1.check() vm1.stop() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm( vm1.get_vm()) image_creation_option.set_backup_storage_uuid_list( [backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.get_vm().rootVolumeUuid) image_creation_option.set_name('test_create_image_template_imagecache') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image) image.check() vm2 = test_stub.create_vm('vm_imagecache2', 'test_create_image_template_imagecache', os.environ.get('l3VlanNetwork3')) test_obj_dict.add_vm(vm2) host = test_lib.lib_find_host_by_vm(vm2.get_vm()) ps = test_lib.lib_get_primary_storage_by_vm(vm2.get_vm()) image = test_lib.lib_get_image_by_name( 'test_create_image_template_imagecache') img_ops.sync_image_size(image.uuid) image = test_lib.lib_get_image_by_name( 'test_create_image_template_imagecache') img_ops.delete_image(image.uuid) if ps.type == inventory.LOCAL_STORAGE_TYPE or ps.type == inventory.NFS_PRIMARY_STORAGE_TYPE or ps.type == 'SharedMountPoint': image_cache_path = "%s/imagecache/template/%s/" % (ps.mountPath, image.uuid) imagecache_file_size = int( test_lib.lib_get_file_size(host, image_cache_path)) image_actual_size = int(image.actualSize) if imagecache_file_size < image.actualSize * 0.99 or imagecache_file_size > image.actualSize * 1.01: test_util.test_fail( 'image cache size (%s) not match image actual size(%s)' % (imagecache_file_size, image_actual_size)) else: test_util.test_skip( "Skip test when primary storage is not local or NFS") # elif ps.type == inventory.CEPH_PRIMARY_STORAGE_TYPE: test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('imagecache cleanup Pass.')
def test(): test_util.test_dsc('Create test vm and check') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) test_util.test_dsc('Create volume and check') disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) test_util.test_dsc('Attach volume and check') #vm.check() volume.attach(vm) test_util.test_dsc('Detach volume and check') volume.detach() test_util.test_dsc('Create volume template and check') bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.get_vm()) bs_uuid_list = [] for bs in bs_list: bs_uuid_list.append(bs.uuid) vol_tmpt = volume.create_template(bs_uuid_list, 'new_data_template') test_obj_dict.add_image(vol_tmpt) vol_tmpt.check() volume.check() volume.delete() test_obj_dict.rm_volume(volume) test_util.test_dsc('Create volume from template and check') ps_uuid = vm.get_vm().allVolumes[0].primaryStorageUuid volume2 = vol_tmpt.create_data_volume(ps_uuid, 'new_volume_from_template') test_obj_dict.add_volume(volume2) vol_tmpt.delete() test_obj_dict.rm_image(vol_tmpt) volume2.check() volume2.attach(vm) vm.check() volume2.check() volume2.detach() volume2.delete() test_obj_dict.rm_volume(volume2) vm.destroy() test_util.test_pass('Create Data Volume Template from Data Volume Success')
def test(): #vm1 = test_stub.create_vm(vm_name = 'basic-test-vm', image_name = 'test-sft') vm1 = test_stub.create_vm(vm_name='basic-test-vm') test_obj_dict.add_vm(vm1) #vm1.check() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: image_creation_option.set_backup_storage_uuid_list( [backup_storage_list[0].uuid]) break else: test_util.test_skip('Not find image store type backup storage.') image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name(image1_name) #image_creation_option.set_platform('Linux') bs_type = backup_storage_list[0].type if bs_type == 'Ceph': origin_interval = conf_ops.change_global_config( 'ceph', 'imageCache.cleanup.interval', '1') image1 = test_image.ZstackTestImage() image1.set_creation_option(image_creation_option) #vm1.stop() image1.create() image1.check() test_obj_dict.add_image(image1) vm2 = test_stub.create_vm(image_name=image1_name) test_obj_dict.add_vm(vm2) image_creation_option.set_root_volume_uuid(vm2.vm.rootVolumeUuid) image_creation_option.set_name(image2_name) image2 = test_image.ZstackTestImage() image2.set_creation_option(image_creation_option) #vm2.stop() image2.create() test_obj_dict.add_image(image2) image2.check() vm3 = test_stub.create_vm(image_name=image2_name) test_obj_dict.add_vm(vm3) vm2.check() vm3.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create VM Image in Image Store Success')
def create_dvol_image(vm_obj): global dvol volume_uuid = dvol.volume.uuid bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm_obj.vm) image_option = test_util.ImageOption() image_option.set_data_volume_uuid(volume_uuid) image_option.set_name('image_resize_template') image_option.set_backup_storage_uuid_list([bs_list[0].uuid]) image = img_ops.create_data_volume_template(image_option) new_image = zstack_image_header.ZstackTestImage() new_image.set_creation_option(image_option) new_image.set_image(image) new_image.check() new_image.delete() new_image.expunge()
def test(): vm = test_stub.create_vlan_vm() #test_obj_dict.add_vm(vm) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break #if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: # break #if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: # break else: vm.destroy() vm.expunge() test_util.test_skip('Not find image store type backup storage.') new_vms = vm.clone(vm_names) for new_vm in new_vms: test_obj_dict.add_vm(new_vm) if len(new_vms) != len(vm_names): test_util.test_fail('only %s VMs have been cloned, which is less than required: %s' % (len(new_vms), vm_names)) for new_vm in new_vms: new_vm = new_vm.get_vm() try: vm_names.remove(new_vm.name) test_util.test_logger('VM:%s name: %s is found' % (new_vm.uuid, new_vm.name)) except: test_util.test_fail('%s vm name: %s is not in list: %s' % (new_vm.uuid, new_vm.name, vm_names)) vm.destroy() check_imf2_cmd = "find /|grep imf|grep %s" % (test_lib.lib_get_root_volume_uuid(vm.get_vm())) host = test_lib.lib_find_host_by_vm(vm.get_vm()) ret, output, stderr = ssh.execute(check_imf2_cmd, host.managementIp, "root", "password", False, 22) test_util.test_logger('expect imf2 exist: %s,%s' % (output, ret)) if ret != 0: test_util.test_fail('imf2 is expected to exist') vm.expunge() ret, output, stderr = ssh.execute(check_imf2_cmd, host.managementIp, "root", "password", False, 22) test_util.test_logger('expect imf2 not exist: %s,%s' % (output, ret)) if ret == 0: test_util.test_fail('imf2 is expected to be deleted') test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Clone VM Test Success')
def test(): vm1 = test_stub.create_vm(vm_name='basic-test-vm') test_obj_dict.add_vm(vm1) #vm1.check() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) for bs in backup_storage_list: if bs.type in [ inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE, inventory.CEPH_BACKUP_STORAGE_TYPE ]: image_creation_option.set_backup_storage_uuid_list( [backup_storage_list[0].uuid]) break else: vm1.destroy() test_util.test_skip( 'Not find image store or ceph type backup storage.') vm2 = test_stub.create_vm(vm_name='basic-test-vm') test_obj_dict.add_vm(vm2) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name('test_create_vm_images_with_same_name') #image_creation_option.set_platform('Linux') image1 = test_image.ZstackTestImage() image1.set_creation_option(image_creation_option) image1.create() test_obj_dict.add_image(image1) image1.check() vm1.destroy() image_creation_option.set_root_volume_uuid(vm2.vm.rootVolumeUuid) image_creation_option.set_name('test_create_vm_images_with_same_name') image2 = test_image.ZstackTestImage() image2.set_creation_option(image_creation_option) image2.create() test_obj_dict.add_image(image2) image2.check() vm3 = test_stub.create_vm( image_name='test_create_vm_images_with_same_name') test_obj_dict.add_vm(vm3) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass( 'Create 2 VM images from same origin Image Successfully')
def test(): vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break #if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: # break if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('rootDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) #volume_creation_option.set_system_tags(['ephemeral::shareable', 'capability::virtio-scsi']) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() volume.attach(vm) vm.stop() vm.check() new_vms = vm.clone(vm_names) for new_vm in new_vms: test_obj_dict.add_vm(new_vm) if len(new_vms) != len(vm_names): test_util.test_fail('only %s VMs have been cloned, which is less than required: %s' % (len(new_vms), vm_names)) for new_vm in new_vms: new_vm = new_vm.get_vm() try: vm_names.remove(new_vm.name) test_util.test_logger('VM:%s name: %s is found' % (new_vm.uuid, new_vm.name)) except: test_util.test_fail('%s vm name: %s is not in list: %s' % (new_vm.uuid, new_vm.name, vm_names)) if test_lib.lib_get_data_volumes(new_vms[0].vm) != []: test_util.test_fail('The cloned vm is still have data volume, the expected behavior is only clone root volume.') test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Clone VM Test Success')
def create_temp_image(index): global vms global images image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vms[index].vm) image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vms[index].vm.rootVolumeUuid) image_creation_option.set_name('test_create_image_template_progress%s' % (index)) bs_type = backup_storage_list[0].type if bs_type == 'Ceph': origin_interval = conf_ops.change_global_config('ceph', 'imageCache.cleanup.interval', '1') images[index] = test_image.ZstackTestImage() images[index].set_creation_option(image_creation_option) images[index].create() test_obj_dict.add_image(images[index])
def test(): #vm1 = test_stub.create_vm(vm_name = 'basic-test-vm', image_name = 'test-sft') vm1 = test_stub.create_vm(vm_name = 'basic-test-vm') test_obj_dict.add_vm(vm1) #vm1.check() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) break else: test_util.test_skip('Not find image store type backup storage.') image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name(image1_name) #image_creation_option.set_platform('Linux') bs_type = backup_storage_list[0].type if bs_type == 'Ceph': origin_interval = conf_ops.change_global_config('ceph', 'imageCache.cleanup.interval', '1') image1 = test_image.ZstackTestImage() image1.set_creation_option(image_creation_option) #vm1.stop() image1.create() image1.check() test_obj_dict.add_image(image1) vm2 = test_stub.create_vm(image_name = image1_name) test_obj_dict.add_vm(vm2) image_creation_option.set_root_volume_uuid(vm2.vm.rootVolumeUuid) image_creation_option.set_name(image2_name) image2 = test_image.ZstackTestImage() image2.set_creation_option(image_creation_option) #vm2.stop() image2.create() test_obj_dict.add_image(image2) image2.check() vm3 = test_stub.create_vm(image_name = image2_name) test_obj_dict.add_vm(vm3) vm2.check() vm3.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create VM Image in Image Store Success')
def test(): global test_obj_dict volume_creation_option = test_util.VolumeOption() test_util.test_dsc('Create volume and check') disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('smallDiskOfferingName')) volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() volume_uuid = volume.volume.uuid vol_size = volume.volume.size image_name = os.environ.get('imageName_net') l3_name = os.environ.get('l3VlanNetworkName1') vm = test_stub.create_vm("test_resize_vm", image_name, l3_name) vm.check() test_obj_dict.add_vm(vm) volume.attach(vm) vm.stop() vm.check() set_size = 1024 * 1024 * 1024 * 5 vol_ops.resize_data_volume(volume_uuid, set_size) vm.update() vol_size_after = test_lib.lib_get_data_volumes(vm.get_vm())[0].size if set_size != vol_size_after: test_util.test_fail('Resize Data Volume failed, size = %s' % vol_size_after) bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) image_option = test_util.ImageOption() image_option.set_data_volume_uuid(volume_uuid) image_option.set_name('data_resize_template') image_option.set_backup_storage_uuid_list([bs_list[0].uuid]) data_image = img_ops.create_data_volume_template(image_option) target_host = test_lib.lib_find_random_host(vm.get_vm()) new_data = vol_ops.create_volume_from_template( data_image.uuid, volume.volume.primaryStorageUuid, host_uuid=target_host.uuid) if set_size != new_data.size: test_util.test_fail('Resize Data Volume failed, size = %s' % new_data.size) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Resize Data Volume Test Success')
def create_temp_image(index): global vms global images image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vms[index].vm) image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vms[index].vm.rootVolumeUuid) image_creation_option.set_name('test_create_image_template_progress%s' % (index)) bs_type = backup_storage_list[0].type if bs_type == 'Ceph': origin_interval = conf_ops.change_global_config('ceph', 'imageCache.cleanup.interval', '1') images[index] = test_image.ZstackTestImage() images[index].set_creation_option(image_creation_option) image_jobs[index] = str(uuid.uuid4()).replace('-', '') images[index].create(image_jobs[index]) test_obj_dict.add_image(images[index])
def create_temp_image(): global vm1 global image image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) image_creation_option.set_backup_storage_uuid_list( [backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name('test_create_image_template_progress') bs_type = backup_storage_list[0].type if bs_type == 'Ceph': origin_interval = conf_ops.change_global_config( 'ceph', 'imageCache.cleanup.interval', '1') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image)
def test(): global test_obj_dict global vm import signal def handler(signum, frame): raise Exception() signal.signal(signal.SIGALRM, handler) signal.alarm(300) test_util.test_dsc('Create test clone windows vm boot option') image_name = os.environ.get('imageName_windows') vm = test_stub.create_vm(image_name=image_name) test_obj_dict.add_vm(vm) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type in [ inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE, inventory.CEPH_BACKUP_STORAGE_TYPE ]: break else: vm.destroy() test_util.test_skip( 'Not find image store or ceph type backup storage.') new_vm = vm.clone(vm_name)[0] test_obj_dict.add_vm(new_vm) console = test_lib.lib_get_vm_console_address(new_vm.get_vm().uuid) test_util.test_logger('[vm:] %s console is on %s:%s' % (new_vm.get_vm().uuid, console.hostIp, console.port)) display = str(int(console.port) - 5900) client = api.connect(console.hostIp + ":" + display) client.keyPress('esc') time.sleep(2) client.expectRegion(boot_option_picture, 0, 100) vm.destroy() new_vm.destroy() test_util.test_pass('VM With Volumes Boot Option Test Success')
def test(): test_util.test_dsc("Create test vm and check") vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) test_util.test_dsc("Create volume and check") print os.environ.get("smallDiskOfferingName") disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get("smallDiskOfferingName")) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) test_util.test_dsc("Attach volume and check") # vm.check() volume.attach(vm) test_util.test_dsc("Detach volume and check") volume.detach() test_util.test_dsc("Create volume template and check") bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.get_vm()) bs_uuid_list = [] for bs in bs_list: bs_uuid_list.append(bs.uuid) vol_tmpt1 = volume.create_template(bs_uuid_list, "new_data_template1") test_obj_dict.add_image(vol_tmpt1) vol_tmpt2 = volume.create_template(bs_uuid_list, "new_data_template2") test_obj_dict.add_image(vol_tmpt2) vol_tmpt1.check() vol_tmpt2.check() vol_tmpt1.delete() test_obj_dict.rm_image(vol_tmpt1) vol_tmpt1.check() vol_tmpt2.check() vol_tmpt2.delete() test_obj_dict.rm_image(vol_tmpt2) volume.delete() test_obj_dict.rm_volume(volume) vm.destroy() test_util.test_pass("Create Duplicated Data Volume Template from Same Data Volume Success")
def test(): global test_obj_dict global ps_uuid global host_uuid global vr_uuid test_util.test_dsc('Create test vm and check') vm = test_stub.create_vr_vm('vm1', 'imageName_net', 'l3VlanNetwork3') test_obj_dict.add_vm(vm) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find ceph type backup storage.') l3_1_name = os.environ.get('l3VlanNetwork3') l3_1 = test_lib.lib_get_l3_by_name(l3_1_name) vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0] vr_uuid = vr.uuid host = test_lib.lib_get_vm_host(vm.get_vm()) host_uuid = host.uuid test_obj_dict.add_vm(vm) vm.check() ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm()) ps_uuid = ps.uuid ps_ops.change_primary_storage_state(ps_uuid, 'disable') if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 90): test_util.test_fail( 'VM is expected to stop when PS change to disable state') vm.set_state(vm_header.STOPPED) vm.check() test_stub.migrate_vm_to_random_host(vm) vm.check() volume.check() ps_ops.change_primary_storage_state(ps_uuid, 'Enabled') host_ops.reconnect_host(host_uuid) vm_ops.reconnect_vr(vr_uuid) test_util.test_pass('PS disable mode Test Success')
def test(): global test_obj_dict global ps_uuid global host_uuid global vr_uuid test_util.test_dsc('Create test vm and check') vm = test_stub.create_vr_vm('vm1', 'imageName_net', 'l3VlanNetwork3') test_obj_dict.add_vm(vm) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: break else: vm.destroy() test_util.test_skip('Not find ceph type backup storage.') l3_1_name = os.environ.get('l3VlanNetwork3') l3_1 = test_lib.lib_get_l3_by_name(l3_1_name) vr = test_lib.lib_find_vr_by_l3_uuid(l3_1.uuid)[0] vr_uuid = vr.uuid host = test_lib.lib_get_vm_host(vm.get_vm()) host_uuid = host.uuid test_obj_dict.add_vm(vm) vm.check() ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm()) ps_uuid = ps.uuid ps_ops.change_primary_storage_state(ps_uuid, 'disable') if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 90): test_util.test_fail('VM is expected to stop when PS change to disable state') vm.set_state(vm_header.STOPPED) vm.check() test_stub.migrate_vm_to_random_host(vm) vm.check() volume.check() ps_ops.change_primary_storage_state(ps_uuid, 'Enabled') host_ops.reconnect_host(host_uuid) vm_ops.reconnect_vr(vr_uuid) test_util.test_pass('PS disable mode Test Success')
def test(): global test_obj_dict test_util.test_dsc('Create test vm and check') vm1 = test_stub.create_vm() test_obj_dict.add_vm(vm1) vm1.stop() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) image_creation_option.set_backup_storage_uuid_list( [backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name('test_create_image_template') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image) image.check() test_util.test_dsc('Use new created Image to create a VM') new_img_uuid = image.image.uuid vm_creation_option = vm1.get_creation_option() vm_creation_option.set_image_uuid(new_img_uuid) vm2 = test_vm.ZstackTestVm() vm2.set_creation_option(vm_creation_option) vm2.create() test_obj_dict.add_vm(vm2) vm2.check() vm1.start() vm1.check() vm2.destroy() vm1.destroy() image.delete() image.check() test_util.test_pass('Create Image Template Test Success')
def test(): test_util.test_dsc('Create test vm and check') vm1 = test_stub.create_vlan_vm() #Without this checking, the image (created later) might be not able to get a DHCP IP, when using to create a new vm. vm1.check() test_obj_dict.add_vm(vm1) vm1.stop() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image) image.check() test_util.test_dsc('Use new created Image to create a VM') new_img_uuid = image.image.uuid vm_creation_option = vm1.get_creation_option() vm_creation_option.set_image_uuid(new_img_uuid) vm2 = test_vm.ZstackTestVm() vm2.set_creation_option(vm_creation_option) vm2.create() test_obj_dict.add_vm(vm2) vm2.check() vm1.start() vm1.check() vm2.destroy() vm1.destroy() image.delete() image.check() test_util.test_pass('Create Image Template Test Success')
def test(): global test_obj_dict test_util.test_dsc('Create test vm and check') vm1 = test_stub.create_vm() test_obj_dict.add_vm(vm1) vm1.stop() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name('test_create_image_template') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image) image.check() test_util.test_dsc('Use new created Image to create a VM') new_img_uuid = image.image.uuid vm_creation_option = vm1.get_creation_option() vm_creation_option.set_image_uuid(new_img_uuid) vm2 = test_vm.ZstackTestVm() vm2.set_creation_option(vm_creation_option) vm2.create() test_obj_dict.add_vm(vm2) vm2.check() vm1.start() vm1.check() vm2.destroy() vm1.destroy() image.delete() image.check() test_util.test_pass('Create Image Template Test Success')
def test(): test_util.test_dsc('Create test vm and check') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) vm.stop() r_volume = zstack_volume_header.ZstackTestVolume() r_volume.set_volume(test_lib.lib_get_root_volume(vm.get_vm())) r_volume.set_state(volume_header.ATTACHED) test_util.test_dsc('Create volume template and check') bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.get_vm()) vol_tmpt = r_volume.create_template([bs_list[0].uuid], 'new_data_template') test_obj_dict.add_image(vol_tmpt) vol_tmpt.check() test_util.test_dsc('Create volume from template and check') ps_uuid = vm.get_vm().allVolumes[0].primaryStorageUuid volume = vol_tmpt.create_data_volume(ps_uuid, 'new_volume_from_template1') test_obj_dict.add_volume(volume) volume2 = vol_tmpt.create_data_volume(ps_uuid, 'new_volume_from_template2') test_obj_dict.add_volume(volume2) volume2.check() volume.attach(vm) vm.start() volume2.attach(vm) vm.check() volume.check() volume2.check() volume.detach() volume.delete() test_obj_dict.rm_volume(volume) volume2.detach() volume2.delete() test_obj_dict.rm_volume(volume2) vol_tmpt.delete() test_obj_dict.rm_image(vol_tmpt) vm.destroy() test_util.test_pass('Create Data Volume Template from Data Volume Success')
def test(): global test_obj_dict volume_creation_option = test_util.VolumeOption() test_util.test_dsc('Create volume and check') disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() volume_uuid = volume.volume.uuid vol_size = volume.volume.size image_name = os.environ.get('imageName_net') l3_name = os.environ.get('l3VlanNetworkName1') vm = test_stub.create_vm("test_resize_vm", image_name, l3_name) vm.check() test_obj_dict.add_vm(vm) volume.attach(vm) vm.stop() vm.check() set_size = 1024*1024*1024*5 vol_ops.resize_data_volume(volume_uuid, set_size) vm.update() vol_size_after = test_lib.lib_get_data_volumes(vm.get_vm())[0].size if set_size != vol_size_after: test_util.test_fail('Resize Data Volume failed, size = %s' % vol_size_after) bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) image_option = test_util.ImageOption() image_option.set_data_volume_uuid(volume_uuid) image_option.set_name('data_resize_template') image_option.set_backup_storage_uuid_list([bs_list[0].uuid]) data_image = img_ops.create_data_volume_template(image_option) target_host = test_lib.lib_find_random_host(vm.get_vm()) new_data = vol_ops.create_volume_from_template(data_image.uuid, volume.volume.primaryStorageUuid, host_uuid = target_host.uuid) if set_size != new_data.size: test_util.test_fail('Resize Data Volume failed, size = %s' % new_data.size) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Resize Data Volume Test Success')
def test(): vm1 = test_stub.create_vm(vm_name = 'basic-test-vm') test_obj_dict.add_vm(vm1) #vm1.check() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.vm) for bs in backup_storage_list: if bs.type in [inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE, inventory.CEPH_BACKUP_STORAGE_TYPE]: image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) break else: vm1.destroy() test_util.test_skip('Not find image store or ceph type backup storage.') vm2 = test_stub.create_vm(vm_name = 'basic-test-vm') test_obj_dict.add_vm(vm2) image_creation_option.set_root_volume_uuid(vm1.vm.rootVolumeUuid) image_creation_option.set_name('test_create_vm_images_with_same_name') #image_creation_option.set_platform('Linux') image1 = test_image.ZstackTestImage() image1.set_creation_option(image_creation_option) image1.create() test_obj_dict.add_image(image1) image1.check() vm1.destroy() image_creation_option.set_root_volume_uuid(vm2.vm.rootVolumeUuid) image_creation_option.set_name('test_create_vm_images_with_same_name') image2 = test_image.ZstackTestImage() image2.set_creation_option(image_creation_option) image2.create() test_obj_dict.add_image(image2) image2.check() vm3 = test_stub.create_vm(image_name = 'test_create_vm_images_with_same_name') test_obj_dict.add_vm(vm3) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create 2 VM images from same origin Image Successfully')
def test(): global vm vm_creation_option = test_util.VmOption() image_name = os.environ.get('imageName_net') l3_name = os.environ.get('l3VlanNetworkName1') vm = test_stub.create_vm("test_resize_vm", image_name, l3_name) test_obj_dict.add_vm(vm) vm.check() vm.stop() vm.check() vol_size = test_lib.lib_get_root_volume(vm.get_vm()).size volume_uuid = test_lib.lib_get_root_volume(vm.get_vm()).uuid set_size = 1024 * 1024 * 1024 * 5 vol_ops.resize_volume(volume_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) bs_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) image_option = test_util.ImageOption() image_option.set_root_volume_uuid(volume_uuid) image_option.set_name('image_resize_template') image_option.set_backup_storage_uuid_list([bs_list[0].uuid]) image = img_ops.create_root_volume_template(image_option) new_vm = test_stub.create_vm("test_vm_after_resize", 'image_resize_template', l3_name) test_obj_dict.add_vm(new_vm) new_vm.check() new_vm.stop() new_vm.check() new_volume_uuid = test_lib.lib_get_root_volume_uuid(new_vm.get_vm()) vol_size_after = test_lib.lib_get_root_volume(new_vm.get_vm()).size if set_size != vol_size_after: test_util.test_fail('Resize Root Volume failed, size = %s' % vol_size_after) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Create Template for Resize VM Test Success')
def test(): vm1 = test_stub.create_vr_vm('vm_imagecache', 'imageName_net', 'l3VlanNetwork3') test_obj_dict.add_vm(vm1) vm1.check() vm1.stop() image_creation_option = test_util.ImageOption() backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm1.get_vm()) image_creation_option.set_backup_storage_uuid_list([backup_storage_list[0].uuid]) image_creation_option.set_root_volume_uuid(vm1.get_vm().rootVolumeUuid) image_creation_option.set_name('test_create_image_template_imagecache') image = test_image.ZstackTestImage() image.set_creation_option(image_creation_option) image.create() test_obj_dict.add_image(image) image.check() vm2 = test_stub.create_vm('vm_imagecache2', 'test_create_image_template_imagecache', os.environ.get('l3VlanNetwork3')) test_obj_dict.add_vm(vm2) host = test_lib.lib_find_host_by_vm(vm2.get_vm()) ps = test_lib.lib_get_primary_storage_by_vm(vm2.get_vm()) image = test_lib.lib_get_image_by_name('test_create_image_template_imagecache') img_ops.sync_image_size(image.uuid) image = test_lib.lib_get_image_by_name('test_create_image_template_imagecache') img_ops.delete_image(image.uuid) if ps.type == inventory.LOCAL_STORAGE_TYPE or ps.type == inventory.NFS_PRIMARY_STORAGE_TYPE or ps.type == 'SharedMountPoint': image_cache_path = "%s/imagecache/template/%s/" % (ps.mountPath, image.uuid) imagecache_file_size = int(test_lib.lib_get_file_size(host, image_cache_path)) image_actual_size = int(image.actualSize) if imagecache_file_size < image.actualSize*0.99 or imagecache_file_size > image.actualSize*1.01: test_util.test_fail('image cache size (%s) not match image actual size(%s)' % (imagecache_file_size, image_actual_size)) else: test_util.test_skip("Skip test when primary storage is not local or NFS") # elif ps.type == inventory.CEPH_PRIMARY_STORAGE_TYPE: test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('imagecache cleanup Pass.')
def test(): global vm, exist_users test_util.test_dsc('cloned vm change password test') vm = test_stub.create_vm(vm_name='1st-created-vm-u12', image_name="imageName_i_u12") test_obj_dict.add_vm(vm) vm.check() force_vm_auto_boot(vm) test_util.test_logger("change vm password for initial created vm") vm_ops.change_vm_password(vm.get_vm().uuid, "root", "password", skip_stopped_vm=None, session_uuid=None) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break #if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: # break #if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: # break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') for (usr, passwd) in zip(users, passwds): if usr not in exist_users: test_util.test_logger("find new account: <%s:%s>" % (usr, passwd)) test_stub.create_user_in_vm(vm.get_vm(), usr, passwd) exist_users.append(usr) #new vm->cloned new_vm1/new_vm2 test_util.test_logger("1st clone") new_vms = vm.clone(vm_names) if len(new_vms) != len(vm_names): test_util.test_fail( 'only %s VMs have been cloned, which is less than required: %s' % (len(new_vms), vm_names)) for new_vm in new_vms: new_vm.update() #new_vm.check() test_obj_dict.add_vm(new_vm) #When vm is running: test_util.test_logger( "vm running && change 1st cloned vm password:<%s:%s:%s>" % (new_vm, usr, passwd)) vm_ops.change_vm_password(new_vm.get_vm().uuid, usr, passwd, skip_stopped_vm=None, session_uuid=None) if not test_lib.lib_check_login_in_vm(new_vm.get_vm(), usr, passwd): test_util.test_fail( "check login cloned vm with user:%s password: %s failed", usr, passwd) #When vm is stopped: #new_vm.stop() test_util.test_logger( "vm stopped && change 1st cloned vm password:<%s:%s:%s>" % (new_vm, usr, passwd)) vm_ops.change_vm_password(new_vm.get_vm().uuid, "root", test_stub.original_root_password) #new_vm.start() new_vm.check() #test use the cloned vm change password to clone new vm and then change password test_util.test_logger("2nd cloned") in_new_vms = new_vm.clone(in_vm_names) new_vm.destroy() new_vm.check() new_vm.expunge() new_vm.check() for in_new_vm in in_new_vms: in_new_vm.update() test_obj_dict.add_vm(in_new_vm) test_util.test_logger( "vm running && change 2nd cloned vm password:<%s:%s:%s>" % (new_vm, usr, passwd)) vm_ops.change_vm_password(in_new_vm.get_vm().uuid, usr, passwd, skip_stopped_vm=None, session_uuid=None) if not test_lib.lib_check_login_in_vm(in_new_vm.get_vm(), usr, passwd): test_util.test_fail( "check login cloned in_vm with user:%s password: %s failed", usr, passwd) #When vm is stopped: #in_new_vm.stop() test_util.test_logger( "vm stopped && change 2nd cloned vm password:<%s:%s:%s>" % (new_vm, usr, passwd)) vm_ops.change_vm_password(in_new_vm.get_vm().uuid, "root", test_stub.original_root_password) #in_new_vm.start() in_new_vm.check() in_new_vm.destroy() in_new_vm.check() in_new_vm.expunge() in_new_vm.check() vm.destroy() vm.check() vm.expunge() vm.check() test_util.test_pass('Set password when VM is creating is successful.')
def test(): global vm, exist_users test_util.test_dsc('cloned vm change password test') vm = test_stub.create_vm(vm_name = '1st-created-vm-u13', image_name = "imageName_i_u13") test_obj_dict.add_vm(vm) vm.check() force_vm_auto_boot(vm) test_util.test_logger("change vm password for initial created vm") vm_ops.change_vm_password(vm.get_vm().uuid, "root", "password", skip_stopped_vm = None, session_uuid = None) backup_storage_list = test_lib.lib_get_backup_storage_list_by_vm(vm.vm) for bs in backup_storage_list: if bs.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break #if bs.type == inventory.SFTP_BACKUP_STORAGE_TYPE: # break #if bs.type == inventory.CEPH_BACKUP_STORAGE_TYPE: # break else: vm.destroy() test_util.test_skip('Not find image store type backup storage.') for (usr,passwd) in zip(users, passwds): if usr not in exist_users: test_util.test_logger("find new account: <%s:%s>" %(usr, passwd)) test_stub.create_user_in_vm(vm.get_vm(), usr, passwd) exist_users.append(usr) #new vm->cloned new_vm1/new_vm2 test_util.test_logger("1st clone") new_vms = vm.clone(vm_names) if len(new_vms) != len(vm_names): test_util.test_fail('only %s VMs have been cloned, which is less than required: %s' % (len(new_vms), vm_names)) for new_vm in new_vms: new_vm.update() #new_vm.check() test_obj_dict.add_vm(new_vm) #When vm is running: test_util.test_logger("vm running && change 1st cloned vm password:<%s:%s:%s>" %(new_vm, usr, passwd)) vm_ops.change_vm_password(new_vm.get_vm().uuid, usr, passwd, skip_stopped_vm = None, session_uuid = None) if not test_lib.lib_check_login_in_vm(new_vm.get_vm(), usr, passwd): test_util.test_fail("check login cloned vm with user:%s password: %s failed", usr, passwd) #When vm is stopped: #new_vm.stop() test_util.test_logger("vm stopped && change 1st cloned vm password:<%s:%s:%s>" %(new_vm, usr, passwd)) vm_ops.change_vm_password(new_vm.get_vm().uuid, "root", test_stub.original_root_password) #new_vm.start() new_vm.check() #test use the cloned vm change password to clone new vm and then change password test_util.test_logger("2nd cloned") in_new_vms = new_vm.clone(in_vm_names) new_vm.destroy() new_vm.check() new_vm.expunge() new_vm.check() for in_new_vm in in_new_vms: in_new_vm.update() test_obj_dict.add_vm(in_new_vm) test_util.test_logger("vm running && change 2nd cloned vm password:<%s:%s:%s>" %(new_vm, usr, passwd)) vm_ops.change_vm_password(in_new_vm.get_vm().uuid, usr, passwd, skip_stopped_vm = None, session_uuid = None) if not test_lib.lib_check_login_in_vm(in_new_vm.get_vm(), usr, passwd): test_util.test_fail("check login cloned in_vm with user:%s password: %s failed", usr, passwd) #When vm is stopped: #in_new_vm.stop() test_util.test_logger("vm stopped && change 2nd cloned vm password:<%s:%s:%s>" %(new_vm, usr, passwd)) vm_ops.change_vm_password(in_new_vm.get_vm().uuid, "root", test_stub.original_root_password) #in_new_vm.start() in_new_vm.check() in_new_vm.destroy() in_new_vm.check() in_new_vm.expunge() in_new_vm.check() vm.destroy() vm.check() vm.expunge() vm.check() test_util.test_pass('Set password when VM is creating is successful.')