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)
