def revert():
LOG.fixture_step("Manage {} if unmanaged".format(subcloud))
dc_helper.manage_subcloud(subcloud)
LOG.fixture_step("Revert DNS config if changed")
system_helper.set_dns_servers(nameservers=dns_servers,
auth_info=sc_auth)
def revert():
LOG.fixture_step("Revert network quotas to original values.")
for tenant_id_, quotas in tenants_quotas.items():
network_quota_, subnet_quota_ = quotas
vm_helper.set_quotas(tenant=tenant_id,
networks=network_quota_,
subnets=subnet_quota_)
def cleanup_app():
if container_helper.get_apps(application=HELM_APP_NAME):
LOG.fixture_step("Remove {} app if applied".format(HELM_APP_NAME))
container_helper.remove_app(app_name=HELM_APP_NAME)
LOG.fixture_step("Delete {} app".format(HELM_APP_NAME))
container_helper.delete_app(app_name=HELM_APP_NAME)
def sys_config_pg(admin_home_pg):
LOG.fixture_step('Go to Admin > Platform > System Configuration')
system_configuration_pg = systemconfigurationpage.SystemConfigurationPage(
admin_home_pg.driver)
system_configuration_pg.go_to_target_page()
return system_configuration_pg
def setup_qos(request, avs_required):
LOG.fixture_step("Creating new QoS")
scheduler = {'weight': 100}
qos_new = network_helper.create_qos(scheduler=scheduler,
description="Test QoS",
cleanup='function')[1]
LOG.fixture_step("Retrieving network ids and Qos'")
internal_net_id = network_helper.get_internal_net_id()
mgmt_net_id = network_helper.get_mgmt_net_id()
qos_internal = network_helper.get_network_values(network=internal_net_id,
fields='wrs-tm:qos')[0]
qos_mgmt = network_helper.get_network_values(network=mgmt_net_id,
fields='wrs-tm:qos')[0]
def reset():
LOG.fixture_step("Resetting QoS for tenant and internal networks")
network_helper.update_net_qos(net_id=internal_net_id,
qos_id=qos_internal)
network_helper.update_net_qos(net_id=mgmt_net_id, qos_id=qos_mgmt)
LOG.fixture_step("Deleting created QoS")
network_helper.delete_qos(qos_new)
request.addfinalizer(reset)
return internal_net_id, mgmt_net_id, qos_new
def fix_usefixture(request):
LOG.fixture_step("I'm a usefixture fixture step")
def fix_teardown():
LOG.fixture_step("I'm a usefixture teardown")
request.addfinalizer(fix_teardown)
def add_route_for_vm_access(compliance_client):
"""
Add ip route on compliance test node to access vm from it
Args:
compliance_client:
Returns:
"""
LOG.fixture_step(
"Add routes to access VM from compliance server if not already done")
cidrs = network_helper.get_subnets(
name="tenant[1|2].*-mgmt0-subnet0|external-subnet0",
regex=True,
field='cidr',
auth_info=Tenant.get('admin'))
cidrs_to_add = [
r'{}.0/24'.format(re.findall(r'(.*).\d+/\d+', item)[0])
for item in cidrs
]
for cidr in cidrs_to_add:
if compliance_client.exec_cmd(
'ip route | grep "{}"'.format(cidr))[0] != 0:
compliance_client.exec_sudo_cmd('ip route add {} via {}'.format(
cidr, VM_ROUTE_VIA))
def setup_alias(request):
LOG.fixture_step("Create nova device list for gpu device")
nova_gpu_alias = _get_nova_alias(class_id=DevClassID.GPU, dev_type='gpu')
LOG.fixture_step("Create nova device list for usb device")
nova_usb_alias = _get_nova_alias(class_id=DevClassID.USB,
dev_type='user',
regex=True)
def revert_alias_setup():
service = 'nova'
gpu_uuid = system_helper.get_service_parameter_values(
field='uuid', service=service, section='pci_alias', name='gpu')[0]
user_uuid = system_helper.get_service_parameter_values(
field='uuid', service=service, section='pci_alias', name='user')[0]
LOG.fixture_step("Delete service parameter uuid {} ".format(gpu_uuid))
system_helper.delete_service_parameter(uuid=gpu_uuid)
LOG.fixture_step("Delete service parameter uuid {} ".format(user_uuid))
system_helper.delete_service_parameter(uuid=user_uuid)
system_helper.apply_service_parameters(service, wait_for_config=True)
# CGTS-9637 cpu usage high
time.sleep(120)
request.addfinalizer(revert_alias_setup)
return nova_gpu_alias, nova_usb_alias
def _recover_hosts(hostnames, scope):
if system_helper.is_aio_simplex():
LOG.fixture_step('{} Recover simplex host'.format(scope))
host_helper.recover_simplex(fail_ok=False)
return
# Recover hosts for non-simplex system
hostnames = sorted(set(hostnames))
table_ = table_parser.table(cli.system('host-list')[1])
table_ = table_parser.filter_table(table_, hostname=hostnames)
# unlocked_hosts = table_parser.get_values(table_, 'hostname',
# administrative='unlocked')
locked_hosts = table_parser.get_values(table_,
'hostname',
administrative='locked')
err_msg = []
if locked_hosts:
LOG.fixture_step("({}) Unlock hosts: {}".format(
scope, locked_hosts))
# Hypervisor state will be checked later in wait_for_hosts_ready
# which handles platform only deployment
res1 = host_helper.unlock_hosts(hosts=locked_hosts,
fail_ok=True,
check_hypervisor_up=False)
for host in res1:
if res1[host][0] not in [0, 4]:
err_msg.append(
"Not all host(s) unlocked successfully. Detail: "
"{}".format(res1))
host_helper.wait_for_hosts_ready(hostnames)
def deploy_delete_kubectl_app(request):
app_name = 'resource-consumer'
app_params = \
'--image=gcr.io/kubernetes-e2e-test-images/resource-consumer:1.4' \
+ ' --expose' \
+ ' --service-overrides=' \
+ "'{ " + '"spec": { "type": "LoadBalancer" } }' \
+ "' --port 8080 --requests='cpu=1000m,memory=1024Mi'"
LOG.fixture_step("Create {} test app by kubectl run".format(app_name))
sub_cmd = "run {}".format(app_name)
kube_helper.exec_kube_cmd(sub_cmd=sub_cmd, args=app_params, fail_ok=False)
LOG.fixture_step("Check {} test app is created ".format(app_name))
pod_name = kube_helper.get_pods(field='NAME',
namespace='default',
name=app_name,
strict=False)[0]
def delete_app():
LOG.fixture_step("Delete {} pod if exists after test "
"run".format(app_name))
kube_helper.delete_resources(resource_names=app_name,
resource_types=('deployment', 'service'),
namespace='default',
post_check=False)
kube_helper.wait_for_resources_gone(resource_names=pod_name,
namespace='default')
request.addfinalizer(delete_app)
kube_helper.wait_for_pods_status(pod_names=pod_name,
namespace='default',
fail_ok=False)
return app_name, pod_name
def setup_host_install(request, get_patch_name):
con_ssh = ControllerClient.get_active_controller()
hosts = host_helper.get_up_hypervisors()
host = hosts[len(hosts) - 1]
if host == system_helper.get_active_controller_name():
host = hosts[len(hosts) - 2]
host_helper.lock_host(host)
patch_name = get_patch_name
LOG.fixture_step("Applying {} to patching controller".format(patch_name))
con_ssh.exec_sudo_cmd('sw-patch upload test_patches/{}.patch'.format(
patch_name))
con_ssh.exec_sudo_cmd('sw-patch apply {}'.format(patch_name))
def delete_patch():
LOG.fixture_step("Removing {} from patching controller".format(
patch_name))
con_ssh.exec_sudo_cmd('sw-patch remove {}'.format(patch_name))
con_ssh.exec_sudo_cmd('sw-patch delete {}'.format(patch_name))
LOG.fixture_step("Reinstalling {} to revert the patch".format(patch_name))
con_ssh.exec_sudo_cmd('sw-patch host-install {}'.format(host),
expect_timeout=timeout.CLI_TIMEOUT)
host_helper.unlock_host(host)
request.addfinalizer(delete_patch)
return patch_name, host
def list_status():
LOG.fixture_step("Listing heat resources and nova migrations")
stacks = heat_helper.get_stacks(auth_info=Tenant.get('admin'))
for stack in stacks:
heat_helper.get_stack_resources(stack=stack, auth_info=Tenant.get('admin'))
nova_helper.get_migration_list_table()
def verify_vms():
LOG.fixture_step("Verifying system VMs after test ended...")
after_vms_status = vm_helper.get_vms_info(
fields=['status'],
long=False,
all_projects=True,
auth_info=Tenant.get('admin'))
# compare status between the status of each VMs before/after the test
common_vms = set(before_vms_status) & set(after_vms_status)
LOG.debug("VMs to verify: {}".format(common_vms))
failure_msgs = []
for vm in common_vms:
before_status = before_vms_status[vm][0]
post_status = after_vms_status[vm][0]
if post_status.lower(
) != 'active' and post_status != before_status:
msg = "VM {} is not in good state. Previous status: {}. " \
"Current status: {}". \
format(vm, before_status, post_status)
failure_msgs.append(msg)
assert not failure_msgs, '\n'.join(failure_msgs)
LOG.info("VMs status verified.")
def __get_system_crash_and_coredumps(scope):
LOG.fixture_step(
"({}) Getting existing system crash reports and coredumps before test "
"{} begins.".format(scope, scope))
core_dumps_and_reports = host_helper.get_coredumps_and_crashreports()
return core_dumps_and_reports
def router_info(request):
global result_
result_ = False
LOG.fixture_step(
"Disable SNAT and update router to DVR if not already done.")
router_id = network_helper.get_tenant_router()
network_helper.set_router_gateway(router_id, enable_snat=False)
is_dvr = network_helper.get_router_values(router_id,
fields='distributed',
auth_info=Tenant.get('admin'))[0]
def teardown():
post_dvr = network_helper.get_router_values(
router_id, fields='distributed', auth_info=Tenant.get('admin'))[0]
if post_dvr != is_dvr:
network_helper.set_router_mode(router_id, distributed=is_dvr)
request.addfinalizer(teardown)
if not is_dvr:
network_helper.set_router_mode(router_id,
distributed=True,
enable_on_failure=False)
result_ = True
return router_id
def modify_system_backing(request):
"""
Issues in this fixture:
- Hardcoded compute name
- compute could be in bad state
- Does not work for CPE lab
- Lock unlock 6 times (could be only 3 times)
- Did not check original storage backing (lab could be configured with local_lvm by default)
"""
hostname, storage_backing = request.param
LOG.fixture_step("Modify {} storage backing to {}".format(
hostname, storage_backing))
host_helper.lock_host(hostname)
host_helper.set_host_storage_backing(hostname,
inst_backing=storage_backing,
lock=False)
host_helper.unlock_hosts(hostname)
def revert_host():
LOG.fixture_step(
"Revert {} storage backing to local_image".format(hostname))
host_helper.lock_host(hostname)
host_helper.set_host_storage_backing(hostname,
inst_backing='local_image',
lock=False)
host_helper.unlock_hosts(hostname)
request.addfinalizer(revert_host)
return storage_backing
def setup_test_session(global_setup):
"""
Setup primary tenant and Nax Box ssh before the first test gets executed.
STX ssh was already set up at collecting phase.
"""
LOG.fixture_step("(session) Setting up test session...")
setups.setup_primary_tenant(ProjVar.get_var('PRIMARY_TENANT'))
global con_ssh
if not con_ssh:
con_ssh = ControllerClient.get_active_controller()
# set build id to be used to upload/write test results
setups.set_build_info(con_ssh)
# Ensure tis and natbox (if applicable) ssh are connected
con_ssh.connect(retry=True, retry_interval=3, retry_timeout=300)
# set up natbox connection and copy keyfile
natbox_dict = ProjVar.get_var('NATBOX')
global natbox_ssh
natbox_ssh = setups.setup_natbox_ssh(natbox_dict, con_ssh=con_ssh)
# set global var for sys_type
setups.set_sys_type(con_ssh=con_ssh)
# rsync files between controllers
setups.copy_test_files()
def base_setup(self):
flavor_id = nova_helper.create_flavor(name='dedicated')[1]
ResourceCleanup.add('flavor', flavor_id, scope='class')
extra_specs = {FlavorSpec.CPU_POLICY: 'dedicated'}
nova_helper.set_flavor(flavor=flavor_id, **extra_specs)
mgmt_net_id = network_helper.get_mgmt_net_id()
tenant_net_id = network_helper.get_tenant_net_id()
internal_net_id = network_helper.get_internal_net_id()
nics = [{'net-id': mgmt_net_id},
{'net-id': tenant_net_id},
{'net-id': internal_net_id}]
LOG.fixture_step(
"(class) Boot a base vm with following nics: {}".format(nics))
base_vm = vm_helper.boot_vm(name='multiports_base',
flavor=flavor_id, nics=nics,
cleanup='class',
reuse_vol=False)[1]
vm_helper.wait_for_vm_pingable_from_natbox(base_vm)
vm_helper.ping_vms_from_vm(base_vm, base_vm, net_types='data')
return base_vm, flavor_id, mgmt_net_id, tenant_net_id, internal_net_id
def disable_snat():
LOG.fixture_step("Disable SNAT on tenant router")
try:
network_helper.set_router_gateway(enable_snat=False)
finally:
LOG.fixture_step("Revert primary tenant to {}".format(primary_tenant['tenant']))
Tenant.set_primary(primary_tenant)
def teardown():
if home_pg:
LOG.fixture_step('Logout')
home_pg.log_out()
recorder.stop()
if horizon.test_result:
recorder.clear()
def __create_image(img_os, scope):
if not img_os:
img_os = GuestImages.DEFAULT['guest']
LOG.fixture_step(
"({}) Get or create a glance image with {} guest OS".format(
scope, img_os))
img_info = GuestImages.IMAGE_FILES[img_os]
img_id = glance_helper.get_image_id_from_name(img_os, strict=True)
if not img_id:
if img_info[0] is not None:
image_path = glance_helper.scp_guest_image(img_os=img_os)
else:
img_dir = GuestImages.DEFAULT['image_dir']
image_path = "{}/{}".format(img_dir, img_info[2])
disk_format = 'raw' if img_os in [
'cgcs-guest', 'tis-centos-guest', 'vxworks'
] else 'qcow2'
img_id = glance_helper.create_image(name=img_os,
source_image_file=image_path,
disk_format=disk_format,
container_format='bare',
cleanup=scope)[1]
return img_id
def teardown():
LOG.fixture_step('Back to Volumes page')
volumes_pg.go_to_target_page()
LOG.fixture_step('Delete volume {}'.format(volume_name))
volumes_pg.delete_volume(volume_name)
assert volumes_pg.is_volume_deleted(volume_name)
def configure_tis(hosts, request):
"""
- Modify host ssh configs to allow root access
- Update system quotas
Args:
hosts
request:
Returns (tuple): (controllers(list), computes(list))
"""
LOG.fixture_step(
"Modify sshd_config on hosts to allow root access: {}".format(hosts))
hosts_configured = []
try:
__config_sshd(hosts=hosts, hosts_configured=hosts_configured)
finally:
if hosts_configured:
def _revert_sshd():
LOG.fixture_step(
"Revert sshd configs on: {}".format(hosts_configured))
__config_sshd(hosts=hosts, revert=True)
request.addfinalizer(_revert_sshd)
LOG.fixture_step("Update quotas for admin project")
compliance_helper.create_tenants_and_update_quotas(new_tenants_index=None)
return hosts_configured
def _flavors(hosts_pci_device_info):
"""
Creates all flavors required for this test module
"""
# Create flavor using first device.
pci_alias = list(hosts_pci_device_info.values())[0][0]['pci_alias']
flavor_parms = {'flavor_qat_vf_1': [2, 1024, 2, 1],
'flavor_resize_qat_vf_1': [4, 2048, 2, 1],
'flavor_qat_vf_4': [2, 1024, 2, 4],
'flavor_resize_qat_vf_4': [2, 2048, 2, 4],
'flavor_qat_vf_32': [2, 1024, 2, 32],
'flavor_qat_vf_33': [2, 1024, 2, 33],
'flavor_none': [1, 1024, 2, 0],
'flavor_resize_none': [2, 2048, 2, 0],
'flavor_resize_qat_vf_32': [4, 2048, 2, 32],
}
flavors = {}
for k, v in flavor_parms.items():
vf = v[3]
LOG.fixture_step("Create a flavor with {} Coletro Creek crypto VF....".format(vf))
flavor_id = nova_helper.create_flavor(name=k, vcpus=v[0], ram=v[1], root_disk=v[2])[1]
ResourceCleanup.add('flavor', flavor_id, scope='module')
if vf > 0:
extra_spec = {FlavorSpec.PCI_PASSTHROUGH_ALIAS: '{}:{}'.format(pci_alias, vf),
# FlavorSpec.NUMA_NODES: '2',
# feature deprecated. May need to update test case as well.
FlavorSpec.CPU_POLICY: 'dedicated'}
nova_helper.set_flavor(flavor_id, **extra_spec)
flavors[k] = flavor_id
return flavors
def keyfile_setup(request):
"""
setup the public key file on the lab under /home/root/.ssh/authorized_keys
Args:
request: pytset arg
Returns (str):
"""
# copy the authorized key from test server to lab under /home/root/.ssh/authorized_keys
LOG.fixture_step("copy id_rsa.pub key file from test server to lab")
source = '/folk/svc-cgcsauto/.ssh/id_rsa.pub'
destination = HostLinuxUser.get_home()
common.scp_from_test_server_to_active_controller(source_path=source,
dest_dir=destination)
con_ssh = ControllerClient.get_active_controller()
sysadmin_keyfile = HostLinuxUser.get_home() + '/id_rsa.pub'
LOG.fixture_step("Logging in as root")
with con_ssh.login_as_root() as root_ssh:
LOG.info("Logged in as root")
root_ssh.exec_cmd('mkdir -p /home/root/.ssh')
root_ssh.exec_cmd('touch /home/root/.ssh/authorized_keys')
root_ssh.exec_cmd('cat ' + sysadmin_keyfile +
' >> /home/root/.ssh/authorized_keys')
def delete_keyfile():
LOG.fixture_step("cleanup files from the lab as root")
# clean up id_rsa.pub from sysadmin folder and authorized_keys in /home/root/.ssh/
con_ssh.exec_cmd('rm {}/id_rsa.pub'.format(HostLinuxUser.get_home()))
con_ssh.exec_sudo_cmd('rm -f /home/root/.ssh/authorized_keys')
request.addfinalizer(delete_keyfile)
def delete_edgex():
LOG.fixture_step("Destroying EdgeX-on-Kubernetes")
con_ssh.exec_cmd(EDGEX_STOP, 180)
LOG.fixture_step("Removing EdgeX-on-Kubernetes")
con_ssh.exec_cmd('rm -rf {} {}'.format(os.path.join(WRSROOT_HOME, EDGEX_ARCHIVE),
os.path.join(WRSROOT_HOME, EDGEX_HOME)))
def generate_alarms(request):
alarm_id = '300.005'
def del_alarms():
LOG.fixture_step(
"Delete 300.005 alarms and ensure they are removed from alarm-list"
)
alarms_tab = system_helper.get_alarms_table(uuid=True)
alarm_uuids = table_parser.get_values(table_=alarms_tab,
target_header='UUID',
**{'Alarm ID': alarm_id})
if alarm_uuids:
system_helper.delete_alarms(alarms=alarm_uuids)
post_del_alarms = system_helper.get_alarms(alarm_id=alarm_id)
assert not post_del_alarms, "300.005 alarm still exits after deletion"
request.addfinalizer(del_alarms)
LOG.fixture_step("Generate 10 active alarms with alarm_id 900.00x")
alarm_gen_base = "fmClientCli -c '### ###300.005###set###system.vm###host=autohost-{}### ###critical###" \
"Automation test###processing-error###cpu-cycles-limit-exceeded### ###True###True###'"
con_ssh = ControllerClient.get_active_controller()
for i in range(10):
LOG.info("Create an critical alarm with id {}".format(alarm_id))
alarm_gen_cmd = alarm_gen_base.format(i)
con_ssh.exec_cmd(alarm_gen_cmd, fail_ok=False)
time.sleep(1)
return alarm_id
def verify_alarms():
LOG.fixture_step(
"({}) Verifying system alarms in central region after test {} ended."
.format(scope, scope))
check_helper.check_alarms(before_alarms=before_alarms,
auth_info=auth_info,
con_ssh=con_ssh)
LOG.info("({}) fm alarms verified in central region.".format(scope))
def remove_on_teardown():
LOG.info("Check vm status and delete if in bad state")
for vm_ in vms:
if vm_helper.get_vm_status(vm_) != VMStatus.ACTIVE:
vm_helper.delete_vms(vm_, remove_cleanup='module')
LOG.fixture_step("Remove test patches")
remove_test_patches()
def fix_testparam(request):
LOG.fixture_step("I'm a testparam fixture step")
def fix_teardown():
LOG.fixture_step("I'm a testparam teardown")
request.addfinalizer(fix_teardown)
return "testparam returned"
