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('rootDiskOfferingName')) 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) volume.check() test_util.test_dsc('Attach volume and check') #mv vm checker later, to save some time. vm.check() volume.attach(vm) volume.check() test_util.test_dsc('Detach volume and check') volume.detach() volume.check() test_util.test_dsc('Delete volume and check') volume.delete() volume.check() test_obj_dict.rm_volume(volume) vm.destroy() vm.check() test_util.test_pass('Create Data Volume for VM Test 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) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Resize Data Volume 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') l3_1_name = os.environ.get('l3VlanNetworkName1') vm = test_stub.create_vlan_vm(l3_name=l3_1_name) #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 #l3_1 = test_lib.lib_get_l3_by_name(l3_1_name) host = test_lib.lib_get_vm_host(vm.get_vm()) host_uuid = host.uuid test_obj_dict.add_vm(vm) vm.check() 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) #ps = test_lib.lib_get_primary_storage_by_vm(vm.get_vm()) #ps_uuid = ps.uuid #ps_ops.change_primary_storage_state(ps_uuid, 'maintain') test_stub.maintain_all_pss() 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 maintain state') vm.set_state(vm_header.STOPPED) vm.check() volume.detach(vm.get_vm().uuid) #ps_ops.change_primary_storage_state(ps_uuid, 'enable') test_stub.enable_all_pss() host_ops.reconnect_host(host_uuid) #vm_ops.reconnect_vr(vr_uuid) time.sleep(5) vrs = test_lib.lib_get_all_vrs() for vr in vrs: vm_ops.start_vm(vr.uuid) vm.start() vm.check() volume.delete() #volume.expunge() volume.check() vm.destroy() test_util.test_pass('Delete volume under PS maintain mode Test Success')
def test(): global test_obj_dict volume_creation_option = test_util.VolumeOption() ps_uuid = res_ops.query_resource(res_ops.PRIMARY_STORAGE, [])[0].uuid 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_creation_option.set_primary_storage_uuid(ps_uuid) if res_ops.query_resource(res_ops.PRIMARY_STORAGE, [])[0].type == "LocalStorage": host = test_lib.lib_find_random_host() volume_creation_option.set_system_tags( ["localStorage::hostUuid::%s" % host.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 set_size = 1024 * 1024 * 1024 * 5 vol_ops.resize_data_volume(volume_uuid, set_size) cond = res_ops.gen_query_conditions('type', '=', "Data") cond = res_ops.gen_query_conditions('status', '=', "Ready", cond) vol_size_after = res_ops.query_resource(res_ops.VOLUME, cond)[0].size if set_size != vol_size_after: test_util.test_fail('Resize Data Volume failed, size = %s' % vol_size_after) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Resize Data Volume 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') bs_cond = res_ops.gen_query_conditions("status", '=', "Connected") bss = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, bs_cond, \ None) if not bss: test_util.test_skip("not find available backup storage. Skip test") if bss[0].type != inventory.CEPH_BACKUP_STORAGE_TYPE: test_util.test_skip("not find available ceph backup storage. Skip test") test_lib.lib_set_delete_policy('vm', 'Delay') test_lib.lib_set_delete_policy('volume', 'Delay') l3_1_name = os.environ.get('l3VlanNetworkName1') vm = test_stub.create_vlan_vm(l3_name=l3_1_name) 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() 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) 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_up(vm.get_vm().vmNics[0].ip, '22', 90): test_util.test_fail('VM is expected to running when PS change to disable state') vm.set_state(vm_header.RUNNING) vm.check() volume.delete() #volume.expunge() volume.check() ps_ops.change_primary_storage_state(ps_uuid, 'enable') host_ops.reconnect_host(host_uuid) vm_ops.reconnect_vr(vr_uuid) vm.destroy() test_lib.lib_set_delete_policy('vm', 'Direct') test_lib.lib_set_delete_policy('volume', 'Direct') test_util.test_pass('Delete volume under PS disable mode Test Success')
def test(): test_util.test_dsc('Create Data Volume on ceph pool for VM Test') cond = res_ops.gen_query_conditions('type', '=', inventory.CEPH_PRIMARY_STORAGE_TYPE) ps = res_ops.query_resource_with_num(res_ops.PRIMARY_STORAGE, cond, limit=1) if not ps: test_util.test_skip('skip test that ceph ps not found.') ps = ps[0] vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) pool = ps_ops.create_ceph_primary_storage_pool(ps.uuid, 'woodpecker_7') test_util.test_dsc('Create shareable volume and check') disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('rootDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_primary_storage_uuid(ps.uuid) volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume_creation_option.set_system_tags([ 'ceph::pool::woodpecker_7', 'ephemeral::shareable', 'capability::virtio-scsi' ]) #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() test_util.test_dsc('Attach shareable volume to stopped VM and check') #mv vm checker later, to save some time. vm.check() vm.stop() volume.attach(vm) #volume.check() vm.start() vm.check() volume.check() if volume.get_volume().installPath.find('woodpecker') < 0: test_util.test_fail( 'data volume is expected to create on pool woodpecker, while its %s.' % (volume.get_volume().installPath)) test_util.test_dsc('Detach volume and check') volume.detach(vm.get_vm().uuid) volume.check() test_util.test_dsc('Delete volume and check') volume.delete() volume.check() test_obj_dict.rm_volume(volume) ps_ops.delete_ceph_primary_storage_pool(pool.uuid) vm.destroy() vm.check() test_util.test_pass( 'Create Shareable Data Volume on ceph pool and attach to stopped VM Test 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 test_util.test_dsc('Create vm and check') vm = test_stub.create_vr_vm('migrate_volume_vm', 'imageName_s', 'l3VlanNetwork2') test_obj_dict.add_vm(vm) vm.check() vm_uuid = vm.vm.uuid ps = test_lib.lib_get_primary_storage_by_uuid(vm.get_vm().allVolumes[0].primaryStorageUuid) if ps.type != inventory.LOCAL_STORAGE_TYPE: test_util.test_skip('Skip test on non-localstorage') test_util.test_dsc('Attach data volume to vm and check') volume.attach(vm) target_host = test_lib.lib_find_random_host_by_volume_uuid(volume_uuid) target_host_uuid = target_host.uuid test_util.test_dsc('Detach data volume from vm and check') volume.detach(vm_uuid) vol_ops.migrate_volume(volume_uuid, target_host_uuid) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Cold migrate Data Volume Test Success')
def test(): global test_obj_dict ova_image_name = os.environ['vcenterDefaultmplate'] network_pattern1 = 'L3-%s' % os.environ['dportgroup'] if not vct_ops.lib_get_vcenter_l3_by_name(network_pattern1): network_pattern1 = 'L3-%s' % os.environ['portgroup0'] disk_offering1 = test_lib.lib_get_disk_offering_by_name( os.environ.get('largeDiskOfferingName')) vm = test_stub.create_vm_in_vcenter(vm_name='test_for_sync_volume_size_vm', image_name=ova_image_name, l3_name=network_pattern1) test_obj_dict.add_vm(vm) vm.check() ps_uuid = vm.vm.allVolumes[0].primaryStorageUuid volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering1.uuid) volume_creation_option.set_name('test_for_sync_volume_size_volume') volume_creation_option.set_primary_storage_uuid(ps_uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() #SyncVolumeSize vol_ops.sync_volume_size(volume.get_volume().uuid) volume.attach(vm) volume.check() vol_ops.sync_volume_size(volume.get_volume().uuid) #cleanup test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass("Test sync volume size in vcenter passed.")
def test(): global test_obj_dict global ps_uuid global host_uuid global vr_uuid test_lib.lib_set_delete_policy('vm', 'Delay') test_lib.lib_set_delete_policy('volume', 'Delay') test_util.test_dsc('Create test vm and check') l3_1_name = os.environ.get('l3VlanNetworkName1') vm = test_stub.create_vlan_vm(l3_name=l3_1_name) 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() 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.delete() volume.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_up(vm.get_vm().vmNics[0].ip, '22', 90): test_util.test_fail( 'VM is expected to running when PS change to disable state') vm.set_state(vm_header.RUNNING) vm.check() volume.recover() volume.check() ps_ops.change_primary_storage_state(ps_uuid, 'enable') host_ops.reconnect_host(host_uuid) vm_ops.reconnect_vr(vr_uuid) volume.delete() volume.expunge() volume.check() vm.destroy() test_lib.lib_set_delete_policy('vm', 'Direct') test_lib.lib_set_delete_policy('volume', 'Direct') test_util.test_pass('Delete volume under PS disable mode Test Success')
def test(): global test_obj_dict cond = res_ops.gen_query_conditions('name', '=', 'newdatastore') ps_uuid = res_ops.query_resource(res_ops.PRIMARY_STORAGE, cond)[0].uuid cond = res_ops.gen_query_conditions('name', '=', 'newdatastore (1)') ps1_uuid = res_ops.query_resource(res_ops.PRIMARY_STORAGE, cond)[0].uuid centos_image_name = os.environ['image_dhcp_name'] if os.environ['dportgroup']: network_pattern = os.environ['dportgroup'] network_pattern = 'L3-%s' % network_pattern else: network_pattern = os.environ['portgroup0'] network_pattern = 'L3-%s' % network_pattern disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('largeDiskOfferingName')) #create vm vm = test_stub.create_vm_in_vcenter(vm_name='vm-create', image_name=centos_image_name, l3_name=network_pattern) vm.check() test_util.test_dsc('Create volume and check') volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume_creation_option.set_name('vcenter_volume') volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() volume_creation_option.set_primary_storage_uuid(ps_uuid) volume_creation_option.set_name('vcenter_volume_ps') volume_ps = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume_ps) volume_ps.check() volume_creation_option.set_primary_storage_uuid(ps1_uuid) volume_creation_option.set_name('vcenter_volume_ps1') volume_ps1 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume_ps1) volume_ps1.check() test_util.test_dsc('Attach volume and check') volume.attach(vm) volume.check() volume_ps.attach(vm) volume_ps.check() try: volume_ps1.attach(vm) except: test_util.test_logger('test for volume_ps1 pass') else: test_util.test_fail('volume_ps1 should not attach to vm') #cleanup test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass("Attach data volumes to vm test passed.")
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(): test_util.test_dsc('Create test vm as utility vm') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) test_util.test_dsc('Create volume for snapshot testing') disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name('volume for snapshot testing') volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) #make sure utility vm is starting and running vm.check() test_util.test_dsc('create snapshot and delete it') #snapshots = zstack_sp_header.ZstackVolumeSnapshot() #snapshots.set_target_volume(volume) #test_obj_dict.add_volume_snapshot(snapshots) snapshots = test_obj_dict.get_volume_snapshot(volume.get_volume().uuid) snapshots.set_utility_vm(vm) snapshots.create_snapshot('create_snapshot1') snapshot1 = snapshots.get_current_snapshot() snapshots.delete_snapshot(snapshot1) test_util.test_dsc('create 2 new snapshots, then delete the 1st one') snapshots.create_snapshot('create_snapshot2') snapshot2 = snapshots.get_current_snapshot() snapshots.create_snapshot('create_snapshot3') snapshot3 = snapshots.get_current_snapshot() snapshots.check() snapshots.delete_snapshot(snapshot2) test_util.test_dsc('create new snapshot to backup') snapshots.create_snapshot('create_snapshot4') snapshot4 = snapshots.get_current_snapshot() snapshots.create_snapshot('create_snapshot5') #snapshot4.backup() #snapshots.check() #test_util.test_dsc('use new backuped snapshot4 and delete it later. ') snapshots.use_snapshot(snapshot4) snapshots.check() snapshots.delete_snapshot(snapshot4) test_util.test_dsc('try to create last snapshot and delete it. ') snapshots.create_snapshot('create_snapshot6') snapshots.check() snapshots.delete() test_obj_dict.rm_volume_snapshot(snapshots) volume.check() test_obj_dict.rm_volume(volume) vm.check() vm.destroy() test_util.test_pass('Cleanup all Snapshots test Success')
def test(): test_util.test_dsc('Create test vm and check') vm1 = test_stub.create_vm(vm_name="vm1", image_name="ocfs2-host-image") test_obj_dict.add_vm(vm1) vm2 = test_stub.create_vm(vm_name="vm2", image_name="ocfs2-host-image") test_obj_dict.add_vm(vm2) test_util.test_dsc('Create volume and check') 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() test_util.test_dsc('Attach volume and check') #mv vm checker later, to save some time. vm1.check() vm2.check() volume.attach(vm1) volume.attach(vm2) config_ocfs2_vms(vm1, vm2) check_sharable_volume(vm1, vm2) volume.check() vm1.stop() volume.check() vm2.stop() volume.check() vm1.start() volume.check() vm2.start() volume.check() test_util.test_dsc('Detach volume and check') volume.detach(vm1.get_vm().uuid) volume.detach(vm2.get_vm().uuid) volume.check() test_util.test_dsc('Delete volume and check') volume.delete() volume.expunge() volume.check() test_obj_dict.rm_volume(volume) vm1.destroy() vm2.destroy() vm1.check() vm2.check() vm1.expunge() vm2.expunge() test_util.test_pass('Create Data Volume for VM Test Success')
def test(): global test_obj_dict, bs #judge whether BS is imagestore bs = res_ops.query_resource(res_ops.BACKUP_STORAGE) for i in bs: if i.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break else: test_util.test_skip('Skip test on non-imagestore') #Skip for AliyunNAS PS ps = res_ops.query_resource(res_ops.PRIMARY_STORAGE) for i in ps: if i.type == 'AliyunNAS': test_util.test_skip('Skip test on SharedBlock and AliyunNAS PS') 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) volume2 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) test_obj_dict.add_volume(volume2) volume.check() volume2.check() image_name = os.environ.get('imageName_s') l3_name = os.environ.get('l3PublicNetworkName') vm = test_stub.create_vm("test_vm", image_name, l3_name) #vm.check() test_obj_dict.add_vm(vm) volume.attach(vm) volume2.attach(vm) vm.suspend() new_vm = vm.clone([ 'test_vm_clone_vm1_with_two_data_volume', 'test_vm_clone_vm2_with_two_data_volume', 'test_vm_clone_vm3_with_two_data_volume' ], full=True) for i in new_vm: test_obj_dict.add_vm(i) volumes_number = len(test_lib.lib_get_all_volumes(i.vm)) if volumes_number != 3: test_util.test_fail( 'Did not find 3 volumes for [vm:] %s. But we assigned 3 data volume when create the vm. We only catch %s volumes' % (i.vm.uuid, volumes_number)) else: test_util.test_logger('Find 3 volumes for [vm:] %s.' % i.vm.uuid) vm.resume() test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Test full clone 3vms with two data volume Success')
def test(): test_util.test_dsc('Create test vm as utility vm') vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) #this test will rely on live snapshot capability supporting host_inv = test_lib.lib_find_host_by_vm(vm.get_vm()) if not test_lib.lib_check_live_snapshot_cap(host_inv): vm.destroy() test_obj_dict.rm_vm(vm) test_util.test_skip( 'Skip test, since [host:] %s does not support live snapshot.') libvirt_ver = test_lib.lib_get_host_libvirt_tag(host_inv) if not libvirt_ver or libvirt_ver < '1.2.7': vm.destroy() test_obj_dict.rm_vm(vm) test_util.test_skip( "Skip test, since [host:] %s libvert version: %s is lower than 1.2.7, which doesn't support live merge, when doing snapshot deleting." % (host_inv.uuid, libvirt_ver)) vm1 = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm1) test_util.test_dsc('Create volume for snapshot testing') disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name('volume for snapshot testing') volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) #make sure utility vm is starting and running vm.check() test_util.test_dsc('create snapshot and check') #snapshots = zstack_sp_header.ZstackVolumeSnapshot() #snapshots.set_target_volume(volume) #test_obj_dict.add_volume_snapshot(snapshots) snapshots = test_obj_dict.get_volume_snapshot(volume.get_volume().uuid) snapshots.set_utility_vm(vm) snapshots.create_snapshot('create_snapshot1') snapshots.create_snapshot('create_snapshot2') snapshots.create_snapshot('create_snapshot3') volume.attach(vm1) snapshots.delete() test_obj_dict.rm_volume_snapshot(snapshots) vm1.start() volume.check() vm.destroy() test_obj_dict.rm_vm(vm) test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Delete Snapshot on running vm test Success')
def test(): test_util.test_dsc('Create test vm and check') vm1 = test_stub.create_vm(vm_name="vm1", image_name="ocfs2-host-image") test_obj_dict.add_vm(vm1) vm2 = test_stub.create_vm(vm_name="vm2", image_name="ocfs2-host-image") test_obj_dict.add_vm(vm2) test_util.test_dsc('Create volume and check') 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() test_util.test_dsc('Attach volume and check') #mv vm checker later, to save some time. vm1.check() vm2.check() volume.attach(vm1) volume.attach(vm2) try: volume.attach(vm1) volume.attach(vm2) except: pass else: test_util.test_fail( "negative test found attach twice is allowed, which should not be expected." ) test_util.test_dsc('Detach volume and check') volume.detach(vm1.get_vm().uuid) volume.detach(vm2.get_vm().uuid) volume.check() test_util.test_dsc('Delete volume and check') volume.delete() volume.expunge() volume.check() test_obj_dict.rm_volume(volume) vm1.destroy() vm2.destroy() vm1.check() vm2.check() vm1.expunge() vm2.expunge() test_util.test_pass('Create Data Volume for VM Test Success')
def create_volume(volume_creation_option=None): if not volume_creation_option: disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('diskOfferingName-s')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume_creation_option.set_name('vr_test_volume') volume = zstack_volume_header.ZstackTestVolume() volume.set_creation_option(volume_creation_option) volume.create() return volume
def create_data_volume(self): disk_offering = test_lib.lib_get_disk_offering_by_name(os.getenv('rootDiskOfferingName')) ps_uuid = self.vm.vm.allVolumes[0].primaryStorageUuid volume_option = test_util.VolumeOption() volume_option.set_disk_offering_uuid(disk_offering.uuid) volume_option.set_name('data-volume-for-crt-image-test') # volume_option.set_primary_storage_uuid(ps_uuid) self.data_volume = create_volume(volume_option) self.set_ceph_mon_env(ps_uuid) self.data_volume.attach(self.vm) self.data_volume.check()
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(): test_util.test_dsc('Create test vm as utility vm') vm1 = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm1) #this test will rely on live snapshot capability supporting host_inv = test_lib.lib_find_host_by_vm(vm1.get_vm()) if not test_lib.lib_check_live_snapshot_cap(host_inv): vm1.destroy() test_obj_dict.rm_vm(vm1) test_util.test_skip('Skip test, since [host:] %s does not support live snapshot.' % host_inv.uuid) live_snapshot = test_lib.lib_check_live_snapshot_cap(host_inv) if not live_snapshot: vm1.destroy() test_obj_dict.rm_vm(vm1) test_util.test_skip("Skip test, since [host:] %s doesn't support live snapshot " % host_inv.uuid) vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) test_util.test_dsc('Create volume for snapshot testing') disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name('volume for snapshot testing') volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume1 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume1) volume2 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume2) #make sure utility vm is starting and running vm.check() volume1.attach(vm1) volume2.attach(vm1) test_util.test_dsc('create snapshot for root') vm_root_volume_inv = test_lib.lib_get_root_volume(vm1.get_vm()) snapshots = test_obj_dict.get_volume_snapshot(vm_root_volume_inv.uuid) snapshots.set_utility_vm(vm) snapshots.create_snapshot('create_root_volume_snapshot1') volume1.check() volume2.check() snapshots2 = test_obj_dict.get_volume_snapshot(volume1.get_volume().uuid) snapshots2.set_utility_vm(vm) snapshots2.create_snapshot('create_data_volume_snapshot1') snapshots.check() volume1.check() volume2.check() test_lib.lib_robot_cleanup(test_obj_dict) test_util.test_pass('Create root Snapshot and test data volume status test Success')
def test(): global vm global schd vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name('volume for snapshot scheduler testing') 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.attach(vm) volume.detach() test_util.test_dsc('create snapshot and check') start_date = int(time.time()) sp_option = test_util.SnapshotOption() sp_option.set_name('simple_schduler_snapshot') sp_option.set_volume_uuid(volume.get_volume().uuid) schd = vol_ops.create_snapshot_scheduler( sp_option, 'simple', 'simple_create_snapshot_scheduler', start_date + 60, 120) snapshot_num = 0 for i in range(0, 3): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 60 + 120 * i - 2) test_util.test_logger( 'check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120 * i - 2, snapshot_num)) new_snapshot_num = query_snapshot_number('simple_schduler_snapshot') if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) snapshot_num += 1 test_stub.sleep_util(start_date + 60 + 120 * i + 60) test_util.test_logger( 'check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120 * i + 65, snapshot_num + 1)) new_snapshot_num = query_snapshot_number('simple_schduler_snapshot') if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) schd_ops.delete_scheduler(schd.uuid) vm.destroy() test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
def create_volume(volume_creation_option=None, session_uuid = None): if not volume_creation_option: disk_offering_uuid = res_ops.query_resource(res_ops.DISK_OFFERING)[0].uuid volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering_uuid) volume_creation_option.set_name('vr_test_volume') volume_creation_option.set_session_uuid(session_uuid) volume = zstack_volume_header.ZstackTestVolume() volume.set_creation_option(volume_creation_option) volume.create() return volume
def deploy_scenario(scenario_config, scenario_file, deploy_config): zstack_management_ip = scenario_config.basicConfig.zstackManagementIp.text_ root_xml = etree.Element("deployerConfig") vms_xml = etree.SubElement(root_xml, 'vms') for host in xmlobject.safe_list(scenario_config.deployerConfig.hosts.host): for vm in xmlobject.safe_list(host.vms.vm): vm_creation_option = test_util.VmOption() l3_uuid_list = [] default_l3_uuid = None for l3network in xmlobject.safe_list(vm.l3Networks.l3Network): if not default_l3_uuid: default_l3_uuid = l3network.uuid_ l3_uuid_list.append(l3network.uuid_) vm_creation_option.set_instance_offering_uuid(vm.vmInstranceOfferingUuid_) vm_creation_option.set_l3_uuids(l3_uuid_list) vm_creation_option.set_image_uuid(vm.imageUuid_) vm_creation_option.set_name(vm.name_) vm_creation_option.set_host_uuid(host.uuid_) #vm_creation_option.set_data_disk_uuids(disk_offering_uuids) #vm_creation_option.set_default_l3_uuid(default_l3_uuid) #vm_creation_option.set_system_tags(system_tags) #vm_creation_option.set_ps_uuid(ps_uuid) #vm_creation_option.set_session_uuid(session_uuid) vm_inv = create_vm(zstack_management_ip, vm_creation_option) vm_ip = test_lib.lib_get_vm_nic_by_l3(vm_inv, default_l3_uuid).ip test_lib.lib_wait_target_up(vm_ip, '22', 120) vm_xml = etree.SubElement(vms_xml, 'vm') vm_xml.set('name', vm.name_) vm_xml.set('ip', vm_ip) vm_xml.set('uuid', vm_inv.uuid) if xmlobject.has_element(vm, 'nodeRef'): setup_node_vm(vm_inv, vm, deploy_config) if xmlobject.has_element(vm, 'hostRef'): setup_host_vm(vm_inv, vm, deploy_config) vm_xml.set('managementIp', vm_ip) if xmlobject.has_element(vm, 'backupStorageRef'): volume_option = test_util.VolumeOption() volume_option.set_name('debug_scenario') for bs_ref in xmlobject.safe_list(vm.backupStorageRef): if bs_ref.type_ == 'ceph': disk_offering_uuid = bs_ref.offering_uuid_ volume_option.set_disk_offering_uuid(disk_offering_uuid) volume_inv = create_volume_from_offering(zstack_management_ip, volume_option) attach_volume(zstack_management_ip, volume_inv.uuid, vm_inv.uuid) break setup_backupstorage_vm(vm_inv, vm, deploy_config) if xmlobject.has_element(vm, 'primaryStorageRef'): setup_primarystorage_vm(vm_inv, vm, deploy_config) xml_string = etree.tostring(root_xml, 'utf-8') xml_string = minidom.parseString(xml_string).toprettyxml(indent=" ") open(scenario_file, 'w+').write(xml_string)
def create_vol(vol_name, disk_offering_uuid, host_uuid, ps_uuid, session_uuid=None): vol_option = test_util.VolumeOption() vol_option.set_name(vol_name) vol_option.set_disk_offering_uuid(disk_offering_uuid) vol_option.set_primary_storage_uuid(ps_uuid) vol_option.set_system_tags(['localStorage::hostUuid::%s' % host_uuid]) if session_uuid: vol_option.set_session_uuid(session_uuid) test_stub.create_volume(vol_option)
def create_volume(volume_creation_option = None, session_uuid = None): if not volume_creation_option: 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_name('test_volume') if session_uuid: volume_creation_option.set_session_uuid(session_uuid) volume = test_volume.ZstackTestVolume() volume.set_creation_option(volume_creation_option) volume.create() return volume
def test(): global test_obj_dict, bs, ps #judge whether BS is imagestore bs = res_ops.query_resource(res_ops.BACKUP_STORAGE) for i in bs: if i.type == inventory.IMAGE_STORE_BACKUP_STORAGE_TYPE: break else: test_util.test_logger('BS is type %s.' % i.type) test_util.test_skip('Skip test on non-imagestore') #judge whether PS is SharedBlock ps = res_ops.query_resource(res_ops.PRIMARY_STORAGE) for i in ps: # if i.type == 'SharedBlock': if i.type in ['SharedBlock', 'AliyunNAS']: test_util.test_skip('Skip test on SharedBlock PS') 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_s') #l3_name = os.environ.get('l3PublicNetworkName') vm = test_stub.create_vlan_vm() #vm.check() test_obj_dict.add_vm(vm) volume.attach(vm) new_vm = vm.clone(['test_vm_clone_with_one_data_volume'], full=True)[0] test_obj_dict.add_vm(new_vm) volumes_number = len(test_lib.lib_get_all_volumes(new_vm.vm)) if volumes_number != 2: test_util.test_fail( 'Did not find 2 volumes for [vm:] %s. But we assigned 2 data volume when create the vm. We only catch %s volumes' % (new_vm.vm.uuid, volumes_number)) else: test_util.test_logger('Find 2 volumes for [vm:] %s.' % new_vm.vm.uuid) test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass('Test clone vm with one data volume 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') 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(): global test_obj_dict ova_image_name = os.environ['vcenterDefaultmplate'] network_pattern1 = os.environ['l3vCenterNoVlanNetworkName'] disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('largeDiskOfferingName')) test_util.test_dsc('Create vm and check') vm = test_stub.create_vm_in_vcenter(vm_name='test_for_instantiated_vm', image_name=ova_image_name, l3_name=network_pattern1) test_obj_dict.add_vm(vm) ps_uuid = vm.vm.allVolumes[0].primaryStorageUuid vm.check() test_util.test_dsc('Create volumes and check') volume_creation_option = test_util.VolumeOption() volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume_creation_option.set_name('vcenter_volume') volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.check() volume_creation_option.set_name('vcenter_volume1') volume_creation_option.set_primary_storage_uuid(ps_uuid) volume1 = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume1) volume1.check() test_util.test_dsc('Attach volumes and check') volume.attach(vm) volume.check() vm.stop() volume1.attach(vm) if volume.volume.installPath == "vcenter://empty" or volume1.volume.installPath != "vcenter://empty": test_util.test_fail("check data volumes fail") vm.start() test_util.test_logger( test_lib.lib_get_volume_by_uuid(volume1.get_volume().uuid)) db_volume1 = test_lib.lib_get_volume_by_uuid(volume1.get_volume().uuid) if db_volume1.installPath == "vcenter://empty": test_util.test_fail("check data volumes fail") #cleanup test_lib.lib_error_cleanup(test_obj_dict) test_util.test_pass( "Test data volume will be instantiated at vm startup in vcenter passed." )
def test(): test_util.test_dsc('Create test vm and check') vm1 = test_stub.create_vm(vm_name="vm1", image_name="ocfs2-host-image") test_obj_dict.add_vm(vm1) vm2 = test_stub.create_vm(vm_name="vm2", image_name="ocfs2-host-image") test_obj_dict.add_vm(vm2) vm1.check() vm2.check() test_util.test_dsc('Create volume and check') 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']) vol_lst = [] for i in xrange(24): volume = test_stub.create_volume(volume_creation_option) volume.check() test_obj_dict.add_volume(volume) vol_lst.append(volume) volume.attach(vm1) volume.attach(vm2) volume.check() volume.detach(vm1.get_vm().uuid) volume.detach(vm2.get_vm().uuid) volume.check() for vol in vol_lst: vol.delete() vol.expunge() vol.check() test_obj_dict.rm_volume(vol) vm1.destroy() vm2.destroy() vm1.check() vm2.check() vm1.expunge() vm2.expunge() test_util.test_pass('Create Max Sharable Volume for VM Test 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')