def test_ha_recovery(prefix): engine = prefix.virt_env.engine_vm().get_api_v4().system_service() with test_utils.TestEvent(engine, [119, 9602, 506]): # VM_DOWN_ERROR event(119) # HA_VM_FAILED event event(9602) # VDS_INITIATED_RUN_VM event(506) vm_host = _vm_host(prefix, VM2_NAME) pid = vm_host.ssh(['pgrep', '-f', 'qemu.*guest=vm2']) vm_host.ssh(['kill', '-KILL', pid.out.decode('utf-8')]) vm_service = test_utils.get_vm_service(engine, VM2_NAME) testlib.assert_true_within_long( lambda: vm_service.get().status == types.VmStatus.UP) with test_utils.TestEvent(engine, 33): # USER_STOP_VM event vm_service.stop()
def add_directlun(prefix): luns = test_utils.get_luns(prefix, SD_ISCSI_HOST_NAME, SD_ISCSI_PORT, SD_ISCSI_TARGET, from_lun=SD_ISCSI_NR_LUNS + 1) dlun_params = sdk4.types.Disk( name=DLUN_DISK_NAME, format=sdk4.types.DiskFormat.RAW, lun_storage=sdk4.types.HostStorage( type=sdk4.types.StorageType.ISCSI, logical_units=luns, ), ) api = prefix.virt_env.engine_vm().get_api_v4() engine = api.system_service() disk_attachments_service = test_utils.get_disk_attachments_service( engine, VM0_NAME) with test_utils.TestEvent(engine, 97): disk_attachments_service.add( sdk4.types.DiskAttachment( disk=dlun_params, interface=sdk4.types.DiskInterface.VIRTIO_SCSI)) disk_service = test_utils.get_disk_service(engine, DLUN_DISK_NAME) attachment_service = disk_attachments_service.attachment_service( disk_service.get().id) nt.assert_not_equal( attachment_service.get(), None, 'Failed to attach Direct LUN disk to {}'.format(VM0_NAME))
def verify_engine_backup(prefix): engine_vm = prefix.virt_env.engine_vm() engine_vm.ssh([ 'mkdir', '/var/log/ost-engine-backup', ], ) api = prefix.virt_env.engine_vm().get_api_v4() engine = api.system_service() with test_utils.TestEvent(engine, [9024, 9025]): #backup started event, completed result = engine_vm.ssh([ 'engine-backup', '--mode=backup', '--file=/var/log/ost-engine-backup/backup.tgz', '--log=/var/log/ost-engine-backup/log.txt', ], ) nt.eq_( result.code, 0, 'Failed to run engine-backup with code {0}. Output: {1}'.format( result.code, result.out)) result = engine_vm.ssh([ 'engine-backup', '--mode=verify', '--file=/var/log/ost-engine-backup/backup.tgz', '--log=/var/log/ost-engine-backup/verify-log.txt', ], ) nt.eq_( result.code, 0, 'Failed to verify backup with code {0}. Output: {1}'.format( result.code, result.out))
def add_cluster(api): engine = api.system_service() clusters_service = engine.clusters_service() provider_id = network_utils_v4.get_default_ovn_provider_id(engine) with test_utils.TestEvent(engine, 809): nt.assert_true( clusters_service.add( sdk4.types.Cluster( name=CLUSTER_NAME, description='APIv4 Cluster', data_center=sdk4.types.DataCenter(name=DC_NAME, ), version=sdk4.types.Version(major=DC_VER_MAJ, minor=DC_VER_MIN), ballooning_enabled=True, ksm=sdk4.types.Ksm( enabled=True, merge_across_nodes=False, ), scheduling_policy=sdk4.types.SchedulingPolicy( name='evenly_distributed', ), optional_reason=True, memory_policy=sdk4.types.MemoryPolicy( ballooning=True, over_commit=sdk4.types.MemoryOverCommit(percent=150, ), ), ha_reservation=True, external_network_providers=[ sdk4.types.ExternalProvider(id=provider_id, ) ], ), ))
def test_add_snapshot_for_backup(api_v4): engine = api_v4.system_service() vm2_disk_attachments_service = test_utils.get_disk_attachments_service( engine, VM2_NAME) disk = vm2_disk_attachments_service.list()[0] backup_snapshot_params = types.Snapshot( description=SNAPSHOT_FOR_BACKUP_VM, persist_memorystate=False, disk_attachments=[types.DiskAttachment(disk=types.Disk(id=disk.id))]) vm2_snapshots_service = test_utils.get_vm_snapshots_service( engine, VM2_NAME) correlation_id = uuid.uuid4() with test_utils.TestEvent(engine, [45, 68]): # USER_CREATE_SNAPSHOT(41) event # USER_CREATE_SNAPSHOT_FINISHED_SUCCESS(68) event vm2_snapshots_service.add(backup_snapshot_params, query={'correlation_id': correlation_id}) testlib.assert_true_within_long( lambda: test_utils.all_jobs_finished(engine, correlation_id)) testlib.assert_true_within_long( lambda: vm2_snapshots_service.list()[-1].snapshot_status == types. SnapshotStatus.OK, )
def hotplug_memory(api): engine = api.system_service() vm_service = test_utils.get_vm_service(engine, VM0_NAME) new_memory = vm_service.get().memory * 2 with test_utils.TestEvent(engine, 2039): # HOT_SET_MEMORY(2,039) vm_service.update(vm=types.Vm(memory=new_memory)) nt.assert_true(vm_service.get().memory == new_memory)
def list_glance_images(api): global GLANCE_AVAIL search_query = 'name={}'.format(SD_GLANCE_NAME) engine = api.system_service() storage_domains_service = engine.storage_domains_service() glance_domain_list = storage_domains_service.list(search=search_query) if not glance_domain_list: openstack_glance = add_glance(api) if not openstack_glance: raise SkipTest('GLANCE storage domain is not available.') glance_domain_list = storage_domains_service.list(search=search_query) if not check_glance_connectivity(engine): raise SkipTest('GLANCE connectivity test failed') glance_domain = glance_domain_list.pop() glance_domain_service = storage_domains_service.storage_domain_service( glance_domain.id) try: with test_utils.TestEvent(engine, 998): all_images = glance_domain_service.images_service().list() if len(all_images): GLANCE_AVAIL = True except sdk4.Error: raise SkipTest('GLANCE is not available: client request error')
def test_sparsify_disk1(api_v4): engine = api_v4.system_service() disk_service = test_utils.get_disk_service(engine, DISK1_NAME) with test_utils.TestEvent(engine, 1325): # USER_SPARSIFY_IMAGE_START event disk_service.sparsify() testlib.assert_true_within_short( lambda: disk_service.get().status == types.DiskStatus.OK)
def add_ldap_group(api): engine = api.system_service() groups_service = engine.groups_service() with test_utils.TestEvent(engine, 149): # USER_ADD(149) groups_service.add( types.Group( name=AAA_LDAP_GROUP, domain=types.Domain(name=AAA_LDAP_AUTHZ_PROVIDER), ), )
def test_hotplug_memory(prefix): api_v4 = prefix.virt_env.engine_vm().get_api_v4() engine = api_v4.system_service() vm_service = test_utils.get_vm_service(engine, VM0_NAME) new_memory = vm_service.get().memory + 256 * MB with test_utils.TestEvent(engine, 2039): # HOT_SET_MEMORY(2,039) vm_service.update(vm=types.Vm(memory=new_memory)) assert vm_service.get().memory == new_memory assert_vm0_is_alive(prefix)
def test_template_export(api_v4): engine = api_v4.system_service() template_guest = test_utils.get_template_service(engine, TEMPLATE_GUEST) if template_guest is None: pytest.skip('{0}: template {1} is missing'.format( template_export.__name__, TEMPLATE_GUEST)) storage_domain = engine.storage_domains_service().list( search='name={}'.format(SD_TEMPLATES_NAME))[0] with test_utils.TestEvent(engine, 1164): # IMPORTEXPORT_STARTING_EXPORT_TEMPLATE event template_guest.export(storage_domain=types.StorageDomain( id=storage_domain.id, ), ) with test_utils.TestEvent(engine, 1156): # IMPORTEXPORT_EXPORT_TEMPLATE event testlib.assert_true_within_long( lambda: template_guest.get().status == types.TemplateStatus.OK, )
def add_glance_storage(prefix, api): engine = api.system_service() vt = utils.VectorThread([ functools.partial(import_non_template_from_glance, prefix), functools.partial(import_template_from_glance, prefix), ], ) vt.start_all() vt.join_all() with test_utils.TestEvent(engine, 3018): print('done adding disk')
def test_export_vm1(api_v4): engine = api_v4.system_service() vm_service = test_utils.get_vm_service(engine, VM1_NAME) sd = engine.storage_domains_service().list( search='name={}'.format(SD_TEMPLATES_NAME))[0] with test_utils.TestEvent(engine, 1162): # IMPORTEXPORT_STARTING_EXPORT_VM event vm_service.export(storage_domain=types.StorageDomain(id=sd.id, ), discard_snapshots=True, async=True)
def test_remove_backup_vm_and_backup_snapshot(api_v4): engine = api_v4.system_service() backup_vm_service = test_utils.get_vm_service(engine, BACKUP_VM_NAME) vm2_snapshots_service = test_utils.get_vm_snapshots_service( engine, VM2_NAME) vm2_snapshot = vm2_snapshots_service.list()[-1] # power-off backup-vm with test_utils.TestEvent(engine, [33, 61]): # VM_DOWN(61) event # USER_STOP_VM(33) event backup_vm_service.stop() testlib.assert_true_within_long( lambda: backup_vm_service.get().status == types.VmStatus.DOWN) # remove backup_vm num_of_vms = len(engine.vms_service().list()) backup_vm_service.remove() assert len(engine.vms_service().list()) == (num_of_vms - 1) with test_utils.TestEvent(engine, 342): # USER_REMOVE_SNAPSHOT event # remove vm2 snapshot vm2_snapshots_service.snapshot_service(vm2_snapshot.id).remove()
def upgrade_hosts(api): engine = api.system_service() hosts = engine.hosts_service() host_list = hosts.list() for host in host_list: host_service = hosts.host_service(host.id) with test_utils.TestEvent(engine, [884, 885]): # HOST_AVAILABLE_UPDATES_STARTED(884) # HOST_AVAILABLE_UPDATES_FINISHED(885) host_service.upgrade_check() with test_utils.TestEvent(engine, [840, 15]): # HOST_UPGRADE_STARTED(840) # VDS_MAINTENANCE(15) host_service.upgrade(reboot=True) verify_all_hosts _wait_datacenter_up(api)
def test_add_ldap_user(api_v4): engine = api_v4.system_service() users_service = engine.users_service() with test_utils.TestEvent(engine, 149): # USER_ADD(149) users_service.add( types.User( user_name=AAA_LDAP_USER, domain=types.Domain( name=AAA_LDAP_AUTHZ_PROVIDER ), ), )
def test_remove_vm_pool(api_v4): engine = api_v4.system_service() pool_service = test_utils.get_pool_service(engine, VMPOOL_NAME) correlation_id = uuid.uuid4() with test_utils.TestEvent(engine, [321, 304]): # USER_REMOVE_VM_POOL_INITIATED(321) event # USER_REMOVE_VM_POOL(304) event pool_service.remove(query={'correlation_id': correlation_id}) vm_pools_service = api_v4.system_service().vm_pools_service() assert len(vm_pools_service.list()) == 0 testlib.assert_true_within_long( lambda: test_utils.all_jobs_finished(engine, correlation_id))
def test_hotplug_cpu(prefix): api_v4 = prefix.virt_env.engine_vm().get_api_v4() engine = api_v4.system_service() vm_service = test_utils.get_vm_service(engine, VM0_NAME) new_cpu = vm_service.get().cpu new_cpu.topology.sockets = 2 with test_utils.TestEvent(engine, 2033): # HOT_SET_NUMBER_OF_CPUS(2,033) vm_service.update(vm=types.Vm(cpu=new_cpu)) assert vm_service.get().cpu.topology.sockets == 2 ret = _vm_ssh(test_utils.get_vm0_ip_address(prefix), ['lscpu']) assert ret.code == 0 match = re.search(r'CPU\(s\):\s+(?P<cpus>[0-9]+)', ret.out.decode('utf-8')) assert match.group('cpus') == '2'
def add_dc(api): engine = api.system_service() dcs_service = engine.data_centers_service() with test_utils.TestEvent(engine, 950): # USER_ADD_STORAGE_POOL nt.assert_true( dcs_service.add( sdk4.types.DataCenter( name=DC_NAME, description='APIv4 DC', local=False, version=sdk4.types.Version(major=DC_VER_MAJ, minor=DC_VER_MIN), ), ))
def _add_storage_domain(api, p): system_service = api.system_service() sds_service = system_service.storage_domains_service() with test_utils.TestEvent(system_service, 956): # USER_ADD_STORAGE_DOMAIN(956) sd = sds_service.add(p) sd_service = sds_service.storage_domain_service(sd.id) testlib.assert_true_within_long(lambda: sd_service.get().status == sdk4 .types.StorageDomainStatus.UNATTACHED) dc_service = test_utils.data_center_service(system_service, DC_NAME) attached_sds_service = dc_service.storage_domains_service() with test_utils.TestEvent(system_service, [966, 962]): # USER_ACTIVATED_STORAGE_DOMAIN(966) # USER_ATTACH_STORAGE_DOMAIN_TO_POOL(962) attached_sds_service.add(sdk4.types.StorageDomain(id=sd.id, ), ) attached_sd_service = attached_sds_service.storage_domain_service( sd.id) testlib.assert_true_within_long(lambda: attached_sd_service.get( ).status == sdk4.types.StorageDomainStatus.ACTIVE)
def next_run_unplug_cpu(api): engine = api.system_service() vm_service = test_utils.get_vm_service(engine, VM0_NAME) new_cpu = vm_service.get().cpu new_cpu.topology.sockets = 1 vm_service.update(vm=types.Vm(cpu=new_cpu, ), next_run=True) nt.assert_true(vm_service.get().cpu.topology.sockets == 2) nt.assert_true(vm_service.get(next_run=True).cpu.topology.sockets == 1) with test_utils.TestEvent(engine, 157): # USER_REBOOT_VM(157) vm_service.reboot() testlib.assert_true_within_long( lambda: vm_service.get().status == types.VmStatus.UP) nt.assert_true(vm_service.get().cpu.topology.sockets == 1)
def hotplug_cpu(prefix): api = prefix.virt_env.engine_vm().get_api_v4() engine = api.system_service() vm_service = test_utils.get_vm_service(engine, VM0_NAME) new_cpu = vm_service.get().cpu new_cpu.topology.sockets = 2 with test_utils.TestEvent(engine, 2033): # HOT_SET_NUMBER_OF_CPUS(2,033) vm_service.update(vm=types.Vm(cpu=new_cpu)) nt.assert_true(vm_service.get().cpu.topology.sockets == 2) ret = _vm_ssh(prefix, VM0_NAME, ['lscpu']) nt.assert_equals(ret.code, 0) match = re.search(r'CPU\(s\):\s+(?P<cpus>[0-9]+)', ret.out) nt.assert_true(match.group('cpus') == '2')
def test_hotunplug_disk(api_v4): engine = api_v4.system_service() disk_service = test_utils.get_disk_service(engine, DISK0_NAME) disk_attachments_service = test_utils.get_disk_attachments_service( engine, VM0_NAME) disk_attachment = disk_attachments_service.attachment_service( disk_service.get().id) with test_utils.TestEvent(engine, 2002): # USER_HOTUNPLUG_DISK(2,002) assert disk_attachment.update(types.DiskAttachment(active=False)) testlib.assert_true_within_short( lambda: disk_attachment.get().active == False)
def add_vm_network(api): engine = api.system_service() network = network_utils_v4.create_network_params( VM_NETWORK, DC_NAME, description='VM Network (originally on VLAN {})'.format( VM_NETWORK_VLAN_ID), vlan=sdk4.types.Vlan(id=VM_NETWORK_VLAN_ID, ), ) with test_utils.TestEvent(engine, 942): # NETWORK_ADD_NETWORK event nt.assert_true(engine.networks_service().add(network)) cluster_service = test_utils.get_cluster_service(engine, CLUSTER_NAME) nt.assert_true(cluster_service.networks_service().add(network))
def cold_storage_migration(api_v4): engine = api_v4.system_service() disk_service = test_utils.get_disk_service(engine, DISK2_NAME) # Cold migrate the disk to ISCSI storage domain and then migrate it back # to the NFS domain because it is used by other cases that assume the # disk found on that specific domain for domain in [SD_ISCSI_NAME, SD_SECOND_NFS_NAME]: with test_utils.TestEvent(engine, 2008): # USER_MOVED_DISK(2,008) disk_service.move(async=False, storage_domain=types.StorageDomain(name=domain)) testlib.assert_true_within_long(lambda: api_v4.follow_link( disk_service.get().storage_domains[0]).name == domain) testlib.assert_true_within_long( lambda: disk_service.get().status == types.DiskStatus.OK)
def add_non_vm_network(api): engine = api.system_service() network = network_utils_v4.create_network_params( MIGRATION_NETWORK, DC_NAME, description='Non VM Network on VLAN 200, MTU 9000', vlan=sdk4.types.Vlan(id='200', ), usages=[], mtu=9000, ) with test_utils.TestEvent(engine, 942): # NETWORK_ADD_NETWORK event nt.assert_true(engine.networks_service().add(network)) cluster_service = test_utils.get_cluster_service(engine, CLUSTER_NAME) nt.assert_true(cluster_service.networks_service().add(network))
def test_add_vm_pool(api_v4): engine = api_v4.system_service() pools_service = engine.vm_pools_service() pool_cluster = engine.clusters_service().list( search='name={}'.format(TEST_CLUSTER))[0] pool_template = engine.templates_service().list( search='name={}'.format(TEMPLATE_GUEST))[0] with test_utils.TestEvent(engine, 302): pools_service.add(pool=types.VmPool( name=VMPOOL_NAME, cluster=pool_cluster, template=pool_template, use_latest_template_version=True, )) vm_service = test_utils.get_vm_service(engine, VMPOOL_NAME + '-1') testlib.assert_true_within_short( lambda: vm_service.get().status == types.VmStatus.DOWN, allowed_exceptions=[IndexError])
def test_extend_disk1(api_v4): engine = api_v4.system_service() disk_attachments_service = test_utils.get_disk_attachments_service( engine, VM1_NAME) for disk_attachment in disk_attachments_service.list(): disk = api_v4.follow_link(disk_attachment.disk) if disk.name == DISK1_NAME: attachment_service = disk_attachments_service.attachment_service( disk_attachment.id) with test_utils.TestEvent(engine, 371): # USER_EXTEND_DISK_SIZE_SUCCESS(371) attachment_service.update( types.DiskAttachment(disk=types.Disk(provisioned_size=2 * GB, ))) disk_service = test_utils.get_disk_service(engine, DISK1_NAME) testlib.assert_true_within_short( lambda: disk_service.get().status == types.DiskStatus.OK) testlib.assert_true_within_short( lambda: disk_service.get().provisioned_size == 2 * GB)
def test_make_snapshot_with_memory(api_v4): engine = api_v4.system_service() vm_service = test_utils.get_vm_service(engine, VM0_NAME) disks_service = engine.disks_service() vm_disks_service = \ test_utils.get_disk_attachments_service(engine, VM0_NAME) vm_disks = [ disks_service.disk_service(attachment.disk.id).get() for attachment in vm_disks_service.list() ] disk_attachments = [ types.DiskAttachment(disk=types.Disk(id=disk.id)) for disk in vm_disks if disk.storage_type != types.DiskStorageType.LUN ] snapshots_service = vm_service.snapshots_service() snapshot_params = types.Snapshot(description=SNAPSHOT_DESC_MEM, persist_memorystate=True, disk_attachments=disk_attachments) with test_utils.TestEvent(engine, 45): # USER_CREATE_SNAPSHOT event snapshots_service.add(snapshot_params)
def test_import_vm_as_clone(api_v4): engine = api_v4.system_service() storage_domain_service = test_utils.get_storage_domain_service( engine, SD_TEMPLATES_NAME) vm_to_import = test_utils.get_storage_domain_vm_service_by_name( storage_domain_service, VM1_NAME) if vm_to_import is None: pytest.skip("VM: '%s' not found on export domain: '%s'" % (VM1_NAME, SD_TEMPLATES_NAME)) with test_utils.TestEvent(engine, 1165): # IMPORTEXPORT_STARTING_IMPORT_VM event vm_to_import.import_(storage_domain=types.StorageDomain( name=SD_ISCSI_NAME, ), cluster=types.Cluster(name=TEST_CLUSTER, ), vm=types.Vm(name=IMPORTED_VM_NAME, ), clone=True, collapse_snapshots=True, async=True)