def _perform_nova_actions(vms_dict, flavors, vfs=None):
for vm_name, vm_id in vms_dict.items():
LOG.tc_step("Cold migrate VM {} ....".format(vm_name))
vm_helper.cold_migrate_vm(vm_id=vm_id)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
LOG.tc_step("Live migrate VM {} ....".format(vm_name))
expt_codes = [0] if 'vm_no_crypto' in vm_name else [1, 6]
code, msg = vm_helper.live_migrate_vm(vm_id=vm_id, fail_ok=True)
assert code in expt_codes, "Expect live migrate to fail for vm with pci device attached. Actual: {}".format(msg)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
LOG.tc_step("Suspend/Resume VM {} ....".format(vm_name))
vm_helper.suspend_vm(vm_id)
vm_helper.resume_vm(vm_id)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
if vfs is None:
resize_flavor_id = flavors["flavor_resize_qat_vf_1"] if "no_crypto" not in vm_name else \
flavors["flavor_resize_none"]
else:
resize_flavor_id = flavors['flavor_resize_qat_vf_{}'.format(vfs)]
LOG.info("Resizing VM {} to new flavor {} ...".format(vm_name, resize_flavor_id))
vm_helper.resize_vm(vm_id, resize_flavor_id)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id=vm_id)
def obsolete_test_fip(fip_setups):
"""
Test VM Floating IP over VM launch, live-migration, cold-migration, pause/unpause, etc
Args:
fip_setups: test fixture
Test Setups (module):
- Create a floating ip
- boot a vm
- Attach floating ip to vm
Test Steps:
- Ping VM FIP
- Live-migrate the VM and verify ping from VM
- Cold-migrate the VM and verify ping from VM
- Pause and un-pause the VM and verify ping from VM
- Suspend and resume the VM and verify ping from VM
- Stop and start the VM and verify ping from VM
- Reboot the VM and verify ping from VM
- Ping VM FIP
Test Teardown:
- Delete created FIP and vm (module)
"""
vm_id, fip = fip_setups
LOG.tc_step("Ping VM with Floating IP ")
vm_helper.ping_ext_from_vm(vm_id, use_fip=True)
LOG.tc_step("Live-migrate the VM and verify ping from VM")
vm_helper.live_migrate_vm(vm_id)
vm_helper.ping_ext_from_vm(vm_id, use_fip=True)
LOG.tc_step("Cold-migrate the VM and verify ping from VM")
vm_helper.cold_migrate_vm(vm_id)
vm_helper.ping_ext_from_vm(vm_id, use_fip=True)
LOG.tc_step("Pause and un-pause the VM and verify ping from VM")
vm_helper.pause_vm(vm_id)
vm_helper.unpause_vm(vm_id)
vm_helper.ping_ext_from_vm(vm_id, use_fip=True)
LOG.tc_step("Suspend and resume the VM and verify ping from VM")
vm_helper.suspend_vm(vm_id)
vm_helper.resume_vm(vm_id)
vm_helper.ping_ext_from_vm(vm_id, use_fip=True)
LOG.tc_step("Stop and start the VM and verify ping from VM")
vm_helper.stop_vms(vm_id)
vm_helper.start_vms(vm_id)
vm_helper.ping_ext_from_vm(vm_id, use_fip=True)
LOG.tc_step("Reboot the VM and verify ping from VM")
vm_helper.reboot_vm(vm_id)
vm_helper.ping_ext_from_vm(vm_id, use_fip=True)
LOG.tc_step("Ping VM with Floating IP Ensure FIP reachable ")
vm_helper.ping_ext_from_vm(vm_id, use_fip=True)
def _test_ea_max_vms_with_crypto_vfs(_flavors, hosts_pci_device_info):
"""
Verify maximum number of guests with Crypto VFs can be launched and
stabilized
Args:
_flavors:
hosts_pci_device_info:
Returns:
"""
LOG.info("Pci device {}".format(hosts_pci_device_info))
flavor_id = _flavors['flavor_qat_vf_4']
# Assume we only have 1 coleto creek pci device on system
crypto_hosts = list(hosts_pci_device_info.keys())
host = crypto_hosts[0]
vf_info = hosts_pci_device_info[host][0]
vf_device_id = vf_info['vf_device_id']
vf_count = vf_info['vf_count']
LOG.info("Vf_device_id {}, count: {}".format(vf_device_id, vf_count))
# number of vms to launch to max out the total configured device VFs. Each VM is launched with 4 Vfs. 4 Vfs in each
# compute are reserved for resize nova action.
number_of_vms = int((vf_count - 4 * len(crypto_hosts)) / 4)
mgmt_net_id = network_helper.get_mgmt_net_id()
tenant_net_id = network_helper.get_tenant_net_id()
vif_type = get_vif_type()
nics = [{'net-id': mgmt_net_id},
{'net-id': tenant_net_id, 'vif-model': vif_type}]
vm_helper.ensure_vms_quotas(number_of_vms + 10)
vms = {}
LOG.tc_step("Launch {} vms using flavor flavor_qat_vf_4 and nics {}".format(number_of_vms, nics))
for i in range(1, number_of_vms + 1):
vm_name = 'vm_crypto_{}'.format(i)
vm_id = vm_helper.boot_vm(cleanup='function', name='vm_crypto_{}'.format(i), nics=nics, flavor=flavor_id)[1]
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
vms[vm_name] = vm_id
for vm_name_, vm_id_ in vms.items():
vm_host = vm_helper.get_vm_host(vm_id_)
host_dev_name = hosts_pci_device_info[vm_host][0]['device_name']
expt_qat_devs = {host_dev_name: 4}
check_helper.check_qat_service(vm_id=vm_id_, qat_devs=expt_qat_devs)
LOG.info("Checking if other host has room for cold migrate vm {}".format(vm_name_))
for host_ in crypto_hosts:
if host_ != vm_host:
total_vfs, used_vfs = network_helper.get_pci_device_vfs_counts_for_host(
host_, device_id=vf_device_id, fields=('pci_vfs_configured', 'pci_vfs_used'))
if int(total_vfs) - int(used_vfs) >= 4:
LOG.info("Migrate to other host is possible")
expt_res = 0
break
else:
LOG.info("Migrate to other host is not possible")
expt_res = 2
LOG.tc_step("Attempt to cold migrate {} and ensure it {}".format(vm_name_,
'succeeds' if expt_res == '0' else 'fails'))
rc, msg = vm_helper.cold_migrate_vm(vm_id=vm_id_, fail_ok=True)
assert expt_res == rc, "Expected: {}. Actual: {}".format(expt_res, msg)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id_)
LOG.tc_step("Suspend/resume VM {} ....".format(vm_name_))
vm_helper.suspend_vm(vm_id_)
vm_helper.resume_vm(vm_id_)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id_)
# vm_host = nova_helper.get_vm_host(vm_id_)
# total, used = network_helper.get_pci_device_vfs_counts_for_host(vm_host, vf_device_id)[0]
# if (total - int(used)) >= 4:
# expt_res = 0
flavor_resize_id = _flavors['flavor_resize_qat_vf_4']
LOG.tc_step("Resize VM {} to new flavor {} with increased memory...".format(vm_name_, flavor_resize_id))
vm_helper.resize_vm(vm_id_, flavor_resize_id)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id_)
# else:
# expt_res = 1
# LOG.info("Resizing of vm {} skipped; host {} max out vfs; used vfs = {}".format(vm_name_, vm_host, used))
LOG.tc_step("Attempt to live migrate {} and ensure it's rejected".format(vm_name_))
rc, msg = vm_helper.live_migrate_vm(vm_id=vm_id_, fail_ok=True)
assert 6 == rc, "Expect live migration to fail on vm with pci alias device. Actual: {}".format(msg)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id_)
check_helper.check_qat_service(vm_id=vm_id_, qat_devs=expt_qat_devs)
def test_suspend_resume_instances(launch_instances):
vm_helper.suspend_vm(vm_id=launch_instances)
vm_helper.resume_vm(vm_id=launch_instances)
def test_pci_vm_nova_actions(self, pci_numa_affinity,
pci_irq_affinity_mask, pci_alias,
vif_model_check, pci_dev_numa_nodes):
"""
Test vm actions on vm with multiple ports with given vif models on the same tenant network
Args:
Setups:
- create a flavor with dedicated cpu policy (module)
- choose one tenant network and one internal network to be used by test (module)
- boot a base vm - vm1 with above flavor and networks, and ping it from NatBox (module)
- Boot a vm under test - vm2 with above flavor and with multiple ports on same tenant network with base vm,
and ping it from NatBox (class)
- Ping vm2's own data network ips (class)
- Ping vm2 from vm1 to verify management and data networks connection (class)
Test Steps:
- Perform given actions on vm2 (migrate, start/stop, etc)
- Verify ping from vm1 to vm2 over management and data networks still works
- Verify the correct number of PCI devices are created, in correct types,
the numa node of the PCI devices aligns with that of CPUs, and affined CPUs for PCI devices
are same as specified by 'pci_alias' (if applicable)
Teardown:
- Delete created vms and flavor
"""
pci_irq_affinity_mask, pci_alias = _convert_irqmask_pcialias(
pci_irq_affinity_mask, pci_alias)
boot_forbidden = False
migrate_forbidden = False
if pci_numa_affinity == 'required' and pci_alias is not None:
host_count = pci_dev_numa_nodes
if host_count == 0:
boot_forbidden = True
elif host_count == 1:
migrate_forbidden = True
LOG.tc_step(
"Expected result - Disallow boot: {}; Disallow migrate: {}".format(
boot_forbidden, migrate_forbidden))
self.pci_numa_affinity = pci_numa_affinity
self.pci_alias = pci_alias
self.pci_irq_affinity_mask = pci_irq_affinity_mask
if pci_alias is not None:
LOG.info('Check if PCI-Alias devices existing')
self.is_pci_device_supported(pci_alias)
self.vif_model, self.base_vm, self.base_flavor_id, self.nics_to_test, self.seg_id, \
self.pnet_name, self.extra_pcipt_net = vif_model_check
LOG.tc_step(
"Create a flavor with specified extra-specs and dedicated cpu policy"
)
flavor_id = self.create_flavor_for_pci()
LOG.tc_step("Boot a vm with {} vif model on internal net".format(
self.vif_model))
# TODO: feature unavailable atm. Update required
# resource_param = 'pci_vfs_used' if 'sriov' in self.vif_model else 'pci_pfs_used'
# LOG.tc_step("Get resource usage for {} interface before booting VM(s)".format(self.vif_model))
# pre_resource_value = nova_helper.get_provider_net_info(self.pnet_name, field=resource_param)
res, vm_id, err = vm_helper.boot_vm(name=self.vif_model,
flavor=flavor_id,
cleanup='function',
nics=self.nics_to_test,
fail_ok=boot_forbidden)
if boot_forbidden:
assert res > 0, "VM booted successfully while it numa node for pcipt/sriov and pci alias mismatch"
return
self.vm_id = vm_id
if 'pci-passthrough' == self.vif_model:
LOG.tc_step("Add vlan to pci-passthrough interface for VM.")
vm_helper.add_vlan_for_vm_pcipt_interfaces(vm_id=vm_id,
net_seg_id=self.seg_id,
init_conf=True)
LOG.tc_step("Ping vm over mgmt and internal nets from base vm")
vm_helper.ping_vms_from_vm(to_vms=self.vm_id,
from_vm=self.vm_id,
net_types=['mgmt', 'internal'])
vm_helper.ping_vms_from_vm(to_vms=self.vm_id,
from_vm=self.base_vm,
net_types=['mgmt', 'internal'])
self.vm_topology = vm_helper.get_vm_values(
vm_id=self.vm_id, fields='wrs-res:topology')[0]
vnic_type = 'direct' if self.vif_model == 'pci-sriov' else 'direct-physical'
self.pci_nics = vm_helper.get_vm_nics_info(vm_id=self.vm_id,
vnic_type=vnic_type)
assert self.pci_nics
self.wait_check_vm_states(step='boot')
# TODO: feature unavailable atm. Update required
# LOG.tc_step("Check {} usage is incremented by 1".format(resource_param))
# post_resource_value = nova_helper.get_provider_net_info(self.pnet_name, field=resource_param)
# expt_change = 2 if self.vif_model == 'pci-passthrough' and self.extra_pcipt_net else 1
# assert pre_resource_value + expt_change == post_resource_value, "{} usage is not incremented by {} as " \
# "expected".format(resource_param, expt_change)
LOG.tc_step('Pause/Unpause {} vm'.format(self.vif_model))
vm_helper.pause_vm(self.vm_id)
vm_helper.unpause_vm(self.vm_id)
LOG.tc_step(
"Check vm still pingable over mgmt and internal nets after pause/unpause"
)
self.wait_check_vm_states(step='pause/unpause')
LOG.tc_step('Suspend/Resume {} vm'.format(self.vif_model))
vm_helper.suspend_vm(self.vm_id)
vm_helper.resume_vm(self.vm_id)
LOG.tc_step(
"Check vm still pingable over mgmt and internal nets after suspend/resume"
)
self.wait_check_vm_states(step='suspend/resume')
if 'pci-passthrough' == self.vif_model:
LOG.tc_step(
"Add/Check vlan interface is added to pci-passthrough device for vm {}."
.format(self.vm_id))
vm_helper.add_vlan_for_vm_pcipt_interfaces(vm_id=self.vm_id,
net_seg_id=self.seg_id)
vm_helper.ping_vms_from_vm(to_vms=self.vm_id,
from_vm=self.base_vm,
net_types=['mgmt', 'internal'])
LOG.tc_step('Cold migrate {} vm'.format(self.vif_model))
code, msg = vm_helper.cold_migrate_vm(self.vm_id,
fail_ok=migrate_forbidden)
if migrate_forbidden:
assert code > 0, "Expect migrate fail due to no other host has pcipt/sriov and pci-alias on same numa. " \
"Actual: {}".format(msg)
self.wait_check_vm_states(step='cold-migrate')
if 'pci-passthrough' == self.vif_model:
LOG.tc_step(
"Add/Check vlan interface is added to pci-passthrough device for vm {}."
.format(self.vm_id))
vm_helper.add_vlan_for_vm_pcipt_interfaces(vm_id=self.vm_id,
net_seg_id=self.seg_id)
LOG.tc_step(
"Check vm still pingable over mgmt and internal nets after cold migration"
)
vm_helper.ping_vms_from_vm(to_vms=self.vm_id,
from_vm=self.base_vm,
net_types=['mgmt', 'internal'])
LOG.tc_step('Set vm to error and wait for it to be auto recovered')
vm_helper.set_vm_state(vm_id=self.vm_id,
error_state=True,
fail_ok=False)
vm_helper.wait_for_vm_values(vm_id=self.vm_id,
status=VMStatus.ACTIVE,
fail_ok=False,
timeout=600)
LOG.tc_step(
"Check vm still pingable over mgmt and internal nets after auto recovery"
)
self.wait_check_vm_states(step='set-error-state-recover')
if 'pci-passthrough' == self.vif_model:
LOG.tc_step(
"Add/Check vlan interface is added to pci-passthrough device for vm {}."
.format(self.vm_id))
vm_helper.add_vlan_for_vm_pcipt_interfaces(vm_id=self.vm_id,
net_seg_id=self.seg_id)
vm_helper.ping_vms_from_vm(to_vms=self.vm_id,
from_vm=self.base_vm,
net_types=['mgmt', 'internal'])
LOG.tc_step("Hard reboot {} vm".format(self.vif_model))
vm_helper.reboot_vm(self.vm_id, hard=True)
LOG.tc_step(
"Check vm still pingable over mgmt and internal nets after nova reboot hard"
)
self.wait_check_vm_states(step='hard-reboot')
if 'pci-passthrough' == self.vif_model:
LOG.tc_step(
"Add/Check vlan interface is added to pci-passthrough device for vm {}."
.format(self.vm_id))
vm_helper.add_vlan_for_vm_pcipt_interfaces(vm_id=self.vm_id,
net_seg_id=self.seg_id)
vm_helper.ping_vms_from_vm(to_vms=self.vm_id,
from_vm=self.base_vm,
net_types=['mgmt', 'internal'])
LOG.tc_step(
"Create a flavor with dedicated cpu policy and resize vm to new flavor"
)
resize_flavor = nova_helper.create_flavor(name='dedicated',
ram=2048,
cleanup='function')[1]
extra_specs = {FlavorSpec.CPU_POLICY: 'dedicated'}
nova_helper.set_flavor(flavor=resize_flavor, **extra_specs)
vm_helper.resize_vm(self.vm_id, resize_flavor)
LOG.tc_step("Check vm still reachable after resize")
self.wait_check_vm_states(step='resize')
if 'pci-passthrough' == self.vif_model:
LOG.tc_step(
"Add/Check vlan interface is added to pci-passthrough device for vm {}."
.format(self.vm_id))
vm_helper.add_vlan_for_vm_pcipt_interfaces(vm_id=self.vm_id,
net_seg_id=self.seg_id)
vm_helper.ping_vms_from_vm(to_vms=self.vm_id,
from_vm=self.base_vm,
net_types=['mgmt', 'internal'])
def test_cpu_pol_vm_actions(flv_vcpus, cpu_pol, pol_source, boot_source):
LOG.tc_step("Create flavor with {} vcpus".format(flv_vcpus))
flavor_id = nova_helper.create_flavor(name='cpu_pol', vcpus=flv_vcpus)[1]
ResourceCleanup.add('flavor', flavor_id)
image_id = glance_helper.get_image_id_from_name(
GuestImages.DEFAULT['guest'], strict=True)
if cpu_pol is not None:
if pol_source == 'flavor':
specs = {FlavorSpec.CPU_POLICY: cpu_pol}
LOG.tc_step("Set following extra specs: {}".format(specs))
nova_helper.set_flavor(flavor_id, **specs)
else:
image_meta = {ImageMetadata.CPU_POLICY: cpu_pol}
LOG.tc_step(
"Create image with following metadata: {}".format(image_meta))
image_id = glance_helper.create_image(
name='cpu_pol_{}'.format(cpu_pol),
cleanup='function',
**image_meta)[1]
if boot_source == 'volume':
LOG.tc_step("Create a volume from image")
source_id = cinder_helper.create_volume(name='cpu_pol'.format(cpu_pol),
source_id=image_id)[1]
ResourceCleanup.add('volume', source_id)
else:
source_id = image_id
prev_cpus = host_helper.get_vcpus_for_computes(field='used_now')
LOG.tc_step(
"Boot a vm from {} with above flavor and check vm topology is as "
"expected".format(boot_source))
vm_id = vm_helper.boot_vm(name='cpu_pol_{}_{}'.format(cpu_pol, flv_vcpus),
flavor=flavor_id,
source=boot_source,
source_id=source_id,
cleanup='function')[1]
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
vm_host = vm_helper.get_vm_host(vm_id)
check_helper.check_topology_of_vm(vm_id,
vcpus=flv_vcpus,
cpu_pol=cpu_pol,
vm_host=vm_host,
prev_total_cpus=prev_cpus[vm_host])
LOG.tc_step("Suspend/Resume vm and check vm topology stays the same")
vm_helper.suspend_vm(vm_id)
vm_helper.resume_vm(vm_id)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
check_helper.check_topology_of_vm(vm_id,
vcpus=flv_vcpus,
cpu_pol=cpu_pol,
vm_host=vm_host,
prev_total_cpus=prev_cpus[vm_host])
LOG.tc_step("Stop/Start vm and check vm topology stays the same")
vm_helper.stop_vms(vm_id)
vm_helper.start_vms(vm_id)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
prev_siblings = check_helper.check_topology_of_vm(
vm_id,
vcpus=flv_vcpus,
cpu_pol=cpu_pol,
vm_host=vm_host,
prev_total_cpus=prev_cpus[vm_host])[1]
LOG.tc_step("Live migrate vm and check vm topology stays the same")
vm_helper.live_migrate_vm(vm_id=vm_id)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
vm_host = vm_helper.get_vm_host(vm_id)
prev_siblings = prev_siblings if cpu_pol == 'dedicated' else None
check_helper.check_topology_of_vm(vm_id,
vcpus=flv_vcpus,
cpu_pol=cpu_pol,
vm_host=vm_host,
prev_total_cpus=prev_cpus[vm_host],
prev_siblings=prev_siblings)
LOG.tc_step("Cold migrate vm and check vm topology stays the same")
vm_helper.cold_migrate_vm(vm_id=vm_id)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
vm_host = vm_helper.get_vm_host(vm_id)
check_helper.check_topology_of_vm(vm_id,
vcpus=flv_vcpus,
cpu_pol=cpu_pol,
vm_host=vm_host,
prev_total_cpus=prev_cpus[vm_host])
def _test_basic_swift_provisioning(pool_size, pre_swift_check):
"""
Verifies basic swift provisioning works as expected
Args:
pool_size:
pre_swift_check:
Returns:
"""
ceph_backend_info = get_ceph_backend_info()
if pool_size == 'default' and pre_swift_check[0]:
skip("Swift is already provisioned")
if pool_size == 'fixed_size' and pre_swift_check[0]:
skip("Swift is already provisioned and set to non-default pool value")
object_pool_gib = None
cinder_pool_gib = ceph_backend_info['cinder_pool_gib']
if pool_size == 'default':
if not ceph_backend_info['object_gateway']:
LOG.tc_step("Enabling SWIFT object store .....")
else:
if not ceph_backend_info['object_gateway']:
skip("Swift is not provisioned")
total_gib = ceph_backend_info['ceph_total_space_gib']
unallocated_gib = (total_gib - cinder_pool_gib -
ceph_backend_info['glance_pool_gib'] -
ceph_backend_info['ephemeral_pool_gib'])
if unallocated_gib == 0:
unallocated_gib = int(int(cinder_pool_gib) / 4)
cinder_pool_gib = str(int(cinder_pool_gib) - unallocated_gib)
elif unallocated_gib < 0:
skip("Unallocated gib < 0. System is in unknown state.")
object_pool_gib = str(unallocated_gib)
LOG.tc_step(
"Enabling SWIFT object store and setting object pool size to {}....."
.format(object_pool_gib))
rc, updated_backend_info = storage_helper.modify_storage_backend(
'ceph',
object_gateway=False,
cinder=cinder_pool_gib,
object_gib=object_pool_gib,
services='cinder,glance,nova,swift')
LOG.info("Verifying if swift object gateway is enabled...")
assert str(updated_backend_info['object_gateway']).lower() == 'true', "Fail to enable Swift object gateway: {}"\
.format(updated_backend_info)
LOG.info("Swift object gateway is enabled.")
LOG.info("Verifying ceph task ...")
state = storage_helper.get_storage_backends(backend='ceph',
field='state')[0]
if system_helper.wait_for_alarm(alarm_id=EventLogID.CONFIG_OUT_OF_DATE,
timeout=10,
fail_ok=True,
entity_id='controller-')[0]:
LOG.info("Verifying ceph task is set to 'add-object-gateway'...")
assert BackendState.CONFIGURING == state, \
"Unexpected ceph state '{}' after swift object gateway update ".format(state)
LOG.info("Lock/Unlock controllers...")
active_controller, standby_controller = system_helper.get_active_standby_controllers(
)
LOG.info("Active Controller is {}; Standby Controller is {}...".format(
active_controller, standby_controller))
for controller in [standby_controller, active_controller]:
if not controller:
continue
HostsToRecover.add(controller)
host_helper.lock_host(controller, swact=True)
storage_helper.wait_for_storage_backend_vals(
backend='ceph-store',
**{
'task': BackendTask.RECONFIG_CONTROLLER,
'state': BackendState.CONFIGURING
})
host_helper.unlock_host(controller)
system_helper.wait_for_alarm_gone(
alarm_id=EventLogID.CONFIG_OUT_OF_DATE, fail_ok=False)
else:
assert BackendState.CONFIGURED == state, \
"Unexpected ceph state '{}' after swift object gateway update ".format(state)
LOG.info("Verifying Swift provisioning setups...")
assert verify_swift_object_setup(), "Failure in swift setups"
for i in range(3):
vm_name = 'vm_swift_api_{}'.format(i)
LOG.tc_step(
"Boot vm {} and perform nova actions on it".format(vm_name))
vm_id = vm_helper.boot_vm(name=vm_name, cleanup='function')[1]
vm_helper.wait_for_vm_pingable_from_natbox(
vm_id, timeout=VMTimeout.DHCP_RETRY)
LOG.info("Cold migrate VM {} ....".format(vm_name))
rc = vm_helper.cold_migrate_vm(vm_id=vm_id)[0]
assert rc == 0, "VM {} failed to cold migrate".format(vm_name)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
LOG.info("Live migrate VM {} ....".format(vm_name))
rc = vm_helper.live_migrate_vm(vm_id=vm_id)[0]
assert rc == 0, "VM {} failed to live migrate".format(vm_name)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
LOG.info("Suspend/Resume VM {} ....".format(vm_name))
vm_helper.suspend_vm(vm_id)
vm_helper.resume_vm(vm_id)
vm_helper.wait_for_vm_pingable_from_natbox(vm_id)
LOG.info("Checking overall system health...")
assert system_helper.get_system_health_query(
), "System health not OK after VMs"
LOG.tc_step("Create Swift container using swift post cli command ...")
container_names = [
"test_container_1", "test_container_2", "test_container_3"
]
for container in container_names:
LOG.info("Creating swift object container {}".format(container))
rc, out = swift_helper.create_swift_container(container)
assert rc == 0, "Fail to create swift container {}".format(container)
LOG.info(
"Create swift object container {} successfully".format(container))
LOG.tc_step("Verify swift list to list containers ...")
container_list = swift_helper.get_swift_containers()[1]
assert set(container_names) <= set(container_list), "Swift containers {} not listed in {}"\
.format(container_names, container_list)
LOG.tc_step("Verify swift delete a container...")
container_to_delete = container_names[2]
rc, out = swift_helper.delete_swift_container(container_to_delete)
assert rc == 0, "Swift delete container rejected: {}".format(out)
assert container_to_delete not in swift_helper.get_swift_containers()[1], "Unable to delete swift container {}"\
.format(container_to_delete)
LOG.tc_step("Verify swift stat to show info of a single container...")
container_to_stat = container_names[0]
out = swift_helper.get_swift_container_stat_info(container_to_stat)
assert out["Container"] == container_to_stat, "Unable to stat swift container {}"\
.format(container_to_stat)
assert out["Objects"] == '0', "Incorrect number of objects container {}. Expected O objects, but has {} objects"\
.format(container_to_stat, out["Objects"])
def test_snat_vm_actions(snat_setups, snat):
"""
Test VM external access over VM launch, live-migration, cold-migration, pause/unpause, etc
Args:
snat_setups (tuple): returns vm id and fip. Enable snat, create vm and attach floating ip.
Test Setups (module):
- Find a tenant router that is dvr or non-dvr based on the parameter
- Enable SNAT on tenant router
- boot a vm and attach a floating ip
- Ping vm from NatBox
Test Steps:
- Enable/Disable SNAT based on snat param
- Ping from VM to 8.8.8.8
- wget <lab_fip> to VM
- scp from NatBox to VM
- Live-migrate the VM and verify ping from VM
- Cold-migrate the VM and verify ping from VM
- Pause and un-pause the VM and verify ping from VM
- Suspend and resume the VM and verify ping from VM
- Stop and start the VM and verify ping from VM
- Reboot the VM and verify ping from VM
Test Teardown:
- Enable snat for next test in the same module (function)
- Delete the created vm (module)
- Disable snat (module)
"""
vm_ = snat_setups[0]
snat = True if snat == 'snat_enabled' else False
LOG.tc_step("Update tenant router external gateway to set SNAT to {}".format(snat))
network_helper.set_router_gateway(enable_snat=snat)
# Allow router update to complete, since we've seen cases where ping vm pass but ssh fail
time.sleep(30)
vm_helper.wait_for_vm_pingable_from_natbox(vm_, timeout=60, use_fip=snat)
LOG.tc_step("Ping from VM {} to 8.8.8.8".format(vm_))
vm_helper.ping_ext_from_vm(vm_, use_fip=True)
LOG.tc_step("wget to VM {}".format(vm_))
with vm_helper.ssh_to_vm_from_natbox(vm_id=vm_, use_fip=True) as vm_ssh:
vm_ssh.exec_cmd('wget google.ca', fail_ok=False)
LOG.tc_step("scp from NatBox to VM {}".format(vm_))
vm_fip = network_helper.get_external_ips_for_vms(vms=vm_)[0]
natbox_ssh = NATBoxClient.get_natbox_client()
natbox_ssh.scp_on_source(source_path='test', dest_user='******', dest_ip=vm_fip, dest_path='/tmp/',
dest_password='******', timeout=30)
LOG.tc_step("Live-migrate the VM and verify ping from VM")
vm_helper.live_migrate_vm(vm_)
vm_helper.wait_for_vm_pingable_from_natbox(vm_, use_fip=snat)
vm_helper.ping_ext_from_vm(vm_, use_fip=True)
LOG.tc_step("Cold-migrate the VM and verify ping from VM")
vm_helper.cold_migrate_vm(vm_)
vm_helper.wait_for_vm_pingable_from_natbox(vm_, use_fip=snat)
vm_helper.ping_ext_from_vm(vm_, use_fip=True)
LOG.tc_step("Pause and un-pause the VM and verify ping from VM")
vm_helper.pause_vm(vm_)
vm_helper.unpause_vm(vm_)
vm_helper.wait_for_vm_pingable_from_natbox(vm_, use_fip=snat)
vm_helper.ping_ext_from_vm(vm_, use_fip=True)
LOG.tc_step("Suspend and resume the VM and verify ping from VM")
vm_helper.suspend_vm(vm_)
vm_helper.resume_vm(vm_)
vm_helper.wait_for_vm_pingable_from_natbox(vm_, use_fip=snat)
vm_helper.ping_ext_from_vm(vm_, use_fip=True)
LOG.tc_step("Stop and start the VM and verify ping from VM")
vm_helper.stop_vms(vm_)
vm_helper.start_vms(vm_)
vm_helper.wait_for_vm_pingable_from_natbox(vm_, use_fip=snat)
vm_helper.ping_ext_from_vm(vm_, use_fip=True)
LOG.tc_step("Reboot the VM and verify ping from VM")
vm_helper.reboot_vm(vm_)
vm_helper.wait_for_vm_pingable_from_natbox(vm_, use_fip=snat)
vm_helper.ping_ext_from_vm(vm_, use_fip=True)
LOG.tc_step("Resize the vm to a flavor with 2 dedicated cpus and verify ping from VM")
new_flv = nova_helper.create_flavor(name='ded', vcpus=2)[1]
ResourceCleanup.add('flavor', new_flv, scope='module')
nova_helper.set_flavor(new_flv, **{FlavorSpec.CPU_POLICY: 'dedicated'})
vm_helper.resize_vm(vm_, new_flv)
vm_helper.wait_for_vm_pingable_from_natbox(vm_, use_fip=snat)
vm_helper.ping_ext_from_vm(vm_, use_fip=True)
def perform_vm_operation(vm_type,
vm_id,
op='live_migration',
extra_specs='vtpm'):
LOG.info('Perform action:{} to the VM, extra specs:{}'.format(
op, extra_specs))
op_table = {
'live_migration':
lambda x, y: vm_helper.live_migrate_vm(y),
'cold_migration':
lambda x, y: vm_helper.cold_migrate_vm(y),
'stop_start':
lambda x, y: (vm_helper.stop_vms(y), vm_helper.start_vms(y)),
'suspend_resume':
lambda x, y: (vm_helper.suspend_vm(y), vm_helper.resume_vm(y)),
'pause_unpause':
lambda x, y: (vm_helper.pause_vm(y), vm_helper.unpause_vm(y)),
'reboot_host':
lambda x, y: reboot_hosting_node(x, y, force_reboot=False),
'soft_reboot':
lambda x, y: vm_helper.reboot_vm(y, hard=False),
'hard_reboot':
lambda x, y: vm_helper.reboot_vm(y, hard=True),
'lock_unlock':
lambda x, y: lock_unlock_hosting_node(x, y, force_lock=False),
'evacuate':
lambda x, y: reboot_hosting_node(x, y, force_reboot=True),
}
if op in op_table:
LOG.info('Perform action: {}'.format(op))
op_table[op](vm_type, vm_id)
return True
elif op == 'resize_to_autorc':
if vm_type == 'autorc':
LOG.info(
'resize from AUTO-RECOVERY to another AUTO-RECOVER flavor')
to_flavor_id = get_flavor_id(vm_type, 'autorc2')
LOG.info('TODO: {}, m_type={}, to_flavor_id={}'.format(
to_flavor_id, vm_type, to_flavor_id))
vm_helper.resize_vm(vm_id, to_flavor_id)
elif op == 'resize_to_non_autorc':
LOG.info('perform {} on type:{}, id:{}'.format(op, vm_type, vm_id))
if vm_type == 'non_autorc2':
LOG.warn(
'resize from AUTO-RECOVERY to another AUTO-RECOVER flavor')
to_flavor_id = get_flavor_id(vm_type, 'non_autorc2')
vm_helper.resize_vm(vm_id, to_flavor_id)
elif op == 'resize_to_non_vtpm':
LOG.info('perform {} on type:{}, id:{}'.format(op, vm_type, vm_id))
to_flavor_id = get_flavor_id(vm_type, 'non_vtpm')
vm_helper.resize_vm(vm_id, to_flavor_id)
else:
LOG.fatal('Unsupported action: {}'.format(op))
return False