# Copyright 2024 Red Hat, Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import base64 from functools import partial import json from multiprocessing import Process import os import random import re import time import yaml import netaddr from netifaces import AF_INET from netifaces import ifaddresses from netifaces import interfaces from neutron_lib import constants from neutron_tempest_plugin.common import shell from neutron_tempest_plugin.common import ssh from neutron_tempest_plugin.common import utils as common_utils from neutron_tempest_plugin import exceptions from neutron_tempest_plugin.scenario import base from oslo_log import log from tempest.common import utils from tempest.common import waiters from tempest import config from tempest.lib.common import fixed_network from tempest.lib.common.utils import data_utils from tempest.lib.common.utils import test_utils from whitebox_neutron_tempest_plugin.common import constants as local_constants from whitebox_neutron_tempest_plugin.common import tcpdump_capture as capture from whitebox_neutron_tempest_plugin.common import utils as local_utils CONF = config.CONF LOG = log.getLogger(__name__) WB_CONF = CONF.whitebox_neutron_plugin_options class BaseTempestWhiteboxTestCase(base.BaseTempestTestCase): credentials = ['primary', 'admin'] @classmethod def resource_setup(cls): super(BaseTempestWhiteboxTestCase, cls).resource_setup() uri = CONF.identity.uri cls.is_ipv6 = True if netaddr.valid_ipv6( uri[uri.find("[") + 1:uri.find("]")]) else False cls.image_ref = CONF.compute.image_ref cls.flavor_ref = CONF.compute.flavor_ref cls.username = CONF.validation.image_ssh_user agents = cls.os_admin.network.AgentsClient().list_agents()['agents'] ovn_agents = [agent for agent in agents if 'ovn' in agent['binary']] cls.has_ovn_support = True if ovn_agents else False sriov_agents = [ agent for agent in agents if 'sriov' in agent['binary']] cls.has_sriov_support = True if sriov_agents else False cls.ext_bridge = json.loads(WB_CONF.ext_bridge) # deployer tool dependent variables if WB_CONF.openstack_type == 'devstack': cls.master_node_client = cls.get_node_client('localhost') cls.master_cont_cmd_executor = cls.run_on_master_controller cls.neutron_api_prefix = '' elif WB_CONF.openstack_type == 'podified': cls.OC = "oc -n openstack " cls.proxy_host_client = cls.get_node_client( host=WB_CONF.proxy_host_address, username=WB_CONF.proxy_host_user, key_filename=WB_CONF.proxy_host_key_file) if WB_CONF.kubeconfig_path: cls.proxy_host_client.exec_command( "ln -s {} /home/{}/.kube/config || true".format( WB_CONF.kubeconfig_path, WB_CONF.proxy_host_user)) cls.master_node_client = cls.proxy_host_client cls.master_cont_cmd_executor = cls.proxy_host_client.exec_command cls.neutron_api_prefix = '{} rsh {} '.format( cls.OC, cls.get_pod_of_service()) else: LOG.warning(("Unrecognized deployer tool '{}', plugin supports " "openstack_type as devstack/podified.".format( WB_CONF.openstack_type))) @classmethod def run_on_master_controller(cls, cmd): if WB_CONF.openstack_type == 'podified': output = cls.proxy_host_client.exec_command(cmd) if WB_CONF.openstack_type == 'devstack': output, errors = local_utils.run_local_cmd(cmd) LOG.debug("Stderr: {}".format(errors.decode())) output = output.decode() LOG.debug("Output: {}".format(output)) return output.strip() def get_host_for_server(self, server_id): server_details = self.os_admin.servers_client.show_server(server_id) return server_details['server']['OS-EXT-SRV-ATTR:host'] @classmethod def get_external_gateway(cls): if CONF.network.public_network_id: subnets = cls.os_admin.network_client.list_subnets( network_id=CONF.network.public_network_id) for subnet in subnets['subnets']: if (subnet['gateway_ip'] and subnet['ip_version'] == constants.IP_VERSION_4): return subnet['gateway_ip'] def get_external_bridge(self, client): commands = [ "sudo ip -o link show type bridge | cut -d ' ' -f 2 | tr -d ':'", "sudo ovs-vsctl list-br"] for cmd in commands: result = client.exec_command(cmd).strip().split() if self.ext_bridge['default'] in result: return self.ext_bridge['default'] return self.ext_bridge['alt'] @staticmethod def get_node_client( host, username=WB_CONF.overcloud_ssh_user, pkey=None, key_filename=WB_CONF.overcloud_key_file): if pkey: return ssh.Client(host=host, username=username, pkey=pkey) else: return ssh.Client(host=host, username=username, key_filename=key_filename) def get_local_ssh_client(self, network): return ssh.Client( host=self._get_local_ip_from_network( self.get_subnet_cidr(network, 4)), username=shell.execute_local_command('whoami').stdout.rstrip(), key_filename=WB_CONF.overcloud_key_file) def get_subnet_cidr(self, network, ip_version): for subnet_id in network['subnets']: subnet = self.os_admin.network_client.show_subnet( subnet_id)['subnet'] if subnet['ip_version'] == ip_version: return subnet['cidr'] def find_node_client(self, node_name): for node in self.nodes: if node['name'] == node_name: return node['client'] def find_different_compute_host(self, exclude_hosts): for node in self.nodes: if not node['is_compute']: continue if node['is_compute'] and not node['name'] in exclude_hosts: return node['name'] raise self.skipException( "Not able to find a different compute than: {}".format( exclude_hosts)) @classmethod def get_full_name(cls, hostname): compute_hosts = [ host['hypervisor_hostname'] for host in cls.os_admin.hv_client.list_hypervisors()['hypervisors']] for host_name in compute_hosts: if hostname in host_name: return host_name return hostname @staticmethod def _get_local_ip_from_network(network): host_ip_addresses = [ifaddresses(iface)[AF_INET][0]['addr'] for iface in interfaces() if AF_INET in ifaddresses(iface)] for ip_address in host_ip_addresses: if netaddr.IPAddress(ip_address) in netaddr.IPNetwork(network): return ip_address def get_fip_port_details(self, fip): fip_ports = self.os_admin.network_client.list_ports( network_id=CONF.network.public_network_id, device_owner=constants.DEVICE_OWNER_FLOATINGIP)['ports'] for fp in fip_ports: if (fp.get('fixed_ips') and len(fp['fixed_ips']) != 0 and fp['fixed_ips'][0]['ip_address'] == fip['floating_ip_address']): return fp @classmethod def get_podified_nodes_data(cls): def append_node_data(node, is_crc): if 'controller' in node: return if 'ocp' in node and not is_crc: # a specific ssh key is used for accessing ocp nodes key = 'ansible_ssh_private_key_file' # meaning dict key here # save path of ocp nodes key (if not yet), we'll need it later if not hasattr(cls, 'ocp_nodes_key_path'): cls.ocp_nodes_key_path = ( hosts_data[node][key].replace( '~', '/home/{}'.format(WB_CONF.proxy_host_user))) node_key = hosts_data[node][key].split('/')[-1] else: node_key = 'id_cifw_key' node_data = { 'ip': hosts_data[node]['ansible_host'], 'user': hosts_data[node]['ansible_user'], 'key': node_key} nodes.append(node_data) nodes = [] inventory_data = yaml.safe_load( cls.proxy_host_client.exec_command( 'cat ' + WB_CONF.proxy_host_inventory_path)) is_crc = False ocps = inventory_data['all']['children']['ocps'] if 'hosts' in ocps and 'crc' in ocps['hosts'].keys(): is_crc = True LOG.debug("Environment is{} based on CRC".format( "" if is_crc else "n't")) items = inventory_data['all']['children'] hosts_data = {} host_names = [] for host_type in items.keys(): if is_crc: host_names.extend( list(items[host_type]['hosts'].keys())) for host_name in host_names: hosts_data[host_name] = ( inventory_data['all']['hosts'][host_name]) else: hosts_data.update(inventory_data[host_type]['hosts']) for host in hosts_data: append_node_data(host, is_crc) return nodes @classmethod def discover_nodes(cls): agents = cls.os_admin.network.AgentsClient().list_agents()['agents'] if cls.has_ovn_support: l3_agent_hosts = [ agent['host'] for agent in agents if agent['agent_type'] == 'OVN Controller Gateway agent'] else: l3_agent_hosts = [ agent['host'] for agent in agents if agent['binary'] == 'neutron-l3-agent'] compute_hosts = [ host['hypervisor_hostname'] for host in cls.os_admin.hv_client.list_hypervisors()['hypervisors']] if WB_CONF.openstack_type == 'podified': cls.nodes = cls.get_podified_nodes_data() with open(WB_CONF.proxy_host_key_file, 'r') as file: id_cifw_key = file.read() cls.keys_data = { 'id_cifw_key': id_cifw_key} if hasattr(cls, 'ocp_nodes_key_path'): devscripts_key = cls.proxy_host_client.exec_command( 'cat ' + cls.ocp_nodes_key_path) cls.keys_data['devscripts_key'] = devscripts_key for host in cls.nodes: client = cls.get_node_client( host=host['ip'], username=host['user'], pkey=f"{cls.keys_data[host['key']]}") host['client'] = client else: cls.nodes = [] for host in set([*l3_agent_hosts, *compute_hosts]): cls.nodes.append( {'ip': host, 'client': cls.get_node_client(host)}) for host in cls.nodes: host['name'] = cls.get_full_name( host['client'].exec_command('hostname').strip()) # Here we are checking if there are controller-specific # processes running on the node output = host['client'].exec_command( r"ps ax | grep 'rabbit\|galera' | grep -v grep || true") host['is_controller'] = True if output.strip() != "" else False host['is_compute'] = ( True if host['name'] in compute_hosts else False) host['is_networker'] = ( True if host['name'] in l3_agent_hosts else False) @classmethod def is_setup_single_node(cls): if not hasattr(cls, 'nodes'): cls.discover_nodes() return len(cls.nodes) == 1 def get_node_setting(self, node_name, setting): for node in self.nodes: if node_name == node['name']: return node[setting] @classmethod def get_pod_of_service(cls, service='neutron'): pods_list = ("{} get pods -o=name " "--field-selector=status.phase=Running".format(cls.OC)) if service == 'neutron': filters = "cut -d'/' -f 2 | grep ^neutron | grep -v meta" else: filters = "cut -d'/' -f 2 | grep {}".format(service) return cls.proxy_host_client.exec_command( "{} | {}".format(pods_list, filters)).strip() @classmethod def get_configs_of_service(cls, service='neutron'): # (rsafrono) at this moment only neutron configs were handled # since it's the only service that existing tests are using if service == 'neutron': pod = cls.get_pod_of_service(service) return cls.proxy_host_client.exec_command( '{} rsh {} find {} -type f'.format( cls.OC, pod, os.path.split( WB_CONF.neutron_config)[0])).strip().split('\n') # TODO(mblue): next gen computes configuration set should be done too, # 'oc patch' for data plane would need more steps and triggers deployment @classmethod def set_service_setting(cls, node_type='controller', file='', service='neutron', section='DEFAULT', param='', value=''): """Set configuration for service :param node_type(str): Node type for change, ex: controller/compute (currently only controllers). :param file(str): File for configuration change (except in podified). :param service(str): Podified service name (only podified). :param section(str): Section in the config file. :param param(str): Parameter in section to change. :param value(str): Value to set. """ assert param, "'param' must be supplied" if WB_CONF.openstack_type == 'podified': if node_type == 'compute': raise cls.skipException( "Setting computes configuration not supported yet on " "podified setups (TODO).") patch_buffer = ''' spec: {}: template: customServiceConfig: | [{}] {} = {}'''.format( service, section, param, value) cmd = ("{0} patch $({0} get oscp -o name) --type=merge " "--patch '".format(cls.OC) + patch_buffer + "'") LOG.debug("Set configuration command:\n%s", cmd) output = cls.proxy_host_client.exec_command(cmd) LOG.debug("Output:\n%s", output) else: cls.run_group_cmd( 'sudo crudini --set {} {} {} {} && sudo sync'.format( file, section, param, value), node_type) @classmethod def check_service_setting( cls, host, service='neutron', config_files=None, section='DEFAULT', param='', value='true', msg='Required config value is missing', skip_if_fails=True): """Check if a service on a node has a setting with a value in config :param host(dict): Dictionary with host-related parameters, host['client'] is a required parameter. :param service(str): Name of the containerized service. :param config_files(list): List with paths to config files. List makes sense on podified where e.g. neutron has 2 config files with same sections. :param section(str): Section in the config file. :param param(str): Parameter in section to check. :param value(str): Expected value, case insensitive. :param msg(str): Message to print in case of expected value not found :param skip_if_fails(bool): skip if the check fails - if it fails and skip_if_fails is False, return False. """ if WB_CONF.openstack_type == 'podified': service_prefix = "{} rsh {}".format( cls.OC, cls.get_pod_of_service(service)) else: service_prefix = "" cmd_prefix = "crudini --get" # If we have config file with defaults and second one with overrides, # the latter has the config that wins for config_file in reversed(config_files): setting = "{} {} {}".format(config_file, section, param) cmd = "{} {} {} || true".format( service_prefix, cmd_prefix, setting) LOG.debug("Command = '{}'".format(cmd)) result = host['client'].exec_command(cmd).strip() LOG.debug("Result = '{}'".format(result)) # Since we are checking files in reverse order, # if we've found a value than it's an override and we # should ignore values in other files if result: if value.lower() in result.lower(): return True else: break if skip_if_fails: raise cls.skipException(msg) else: return False @classmethod def is_service_on_node(cls, service_name, ssh_client): """Checks systemctl service existence on node using pattern. Any non a-z char could be any char. """ # NOTE(mblue): regex used to fit podified/devstack/tripleo # different service names. service_regex = re.sub(r'[^a-zA-Z]', '.', service_name) host_ip = ssh_client.host LOG.debug("Checking for service '%s' (regex) existence on host '%s'.", service_regex, host_ip) catch = ssh_client.exec_command( "systemctl --type=service | grep '{}'".format( service_regex)).strip if catch: LOG.debug("Service found on host '%s':\n%s", host_ip, catch) return True LOG.debug("Service not found on host '%s' using glob '%s'.", host_ip, service_regex) return False @classmethod def reset_node_service(cls, service_alias, ssh_client, wait_until_active=True, timeout=30): host_ip = ssh_client.host service_name = ssh_client.exec_command( "systemctl list-unit-files --type service | grep {} | " "cut -d' ' -f1".format( service_alias.replace(" ", ".*"))).strip() LOG.debug("Restarting service '%s' on host '%s'.", service_name, host_ip) ssh_client.exec_command( 'sudo systemctl restart {}'.format(service_name)) if not wait_until_active: return def _is_service_active(): return 'active' in ssh_client.exec_command( 'sudo systemctl is-active {}; true'.format(service_name)) LOG.debug("Waiting for service '%s' to become active on host '%s'.", service_name, host_ip) common_utils.wait_until_true( _is_service_active, timeout=timeout, sleep=5, exception=RuntimeError( "Timed out {} seconds, service {} " "didn't become active after restart.\n\n'''\n{}\n'''".format( timeout, service_name, ssh_client.exec_command( 'sudo systemctl status {}; true'.format( service_name))))) LOG.debug("Service '%s' active on host '%s'.", service_name, host_ip) def _create_server( self, create_floating_ip=True, exclude_hosts=None, network=None, **kwargs): network = network or self.network kwargs.setdefault('name', data_utils.rand_name('server-test')) kwargs['flavorRef'] = self.flavor_ref kwargs['imageRef'] = self.image_ref kwargs['networks'] = [{'uuid': network['id']}] if not kwargs.get('key_name'): kwargs['key_name'] = self.keypair['name'] if not kwargs.get('security_groups'): kwargs['security_groups'] = [{ 'name': self.security_groups[-1]['name']}] # (rsafrono) delete scheduler_hints from kwargs if it's set to empty # dict. This prevents 'scheduler_hints was unexpected' error. if not kwargs.get('scheduler_hints'): kwargs.pop("scheduler_hints", None) if exclude_hosts: exclude_hosts_ignored = False if kwargs.get('host') and (kwargs['host'] in exclude_hosts): exclude_hosts_ignored = True LOG.debug("'exclude_hosts' parameter contains same value as " "'host' so it will be ignored, i.e. 'host' will be " "used") else: kwargs['host'] = self.find_different_compute_host( exclude_hosts) if kwargs.get('host'): servers_client = self.os_admin.servers_client network_client = self.os_admin.network_client else: servers_client = self.os_primary.servers_client network_client = self.os_primary.network_client server = servers_client.create_server(**kwargs)['server'] self.addCleanup(test_utils.call_and_ignore_notfound_exc, waiters.wait_for_server_termination, servers_client, server['id']) self.addCleanup(test_utils.call_and_ignore_notfound_exc, servers_client.delete_server, server['id']) if exclude_hosts and not exclude_hosts_ignored: if self.get_host_for_server(server['id']) in exclude_hosts: self.fail("Failed to spawn a server on a host other than in " "this list: '{}'. Can not proceed.".format( ' '.join(exclude_hosts))) self.wait_for_server_active(server, client=servers_client) port = self.client.list_ports( network_id=network['id'], device_id=server['id'])['ports'][0] if create_floating_ip: fip = network_client.create_floatingip( floating_network_id=CONF.network.public_network_id, port_id=port['id'])['floatingip'] self.addCleanup(test_utils.call_and_ignore_notfound_exc, network_client.delete_floatingip, fip['id']) else: fip = None return {'port': port, 'fip': fip, 'server': server} def _create_server_for_topology( self, network_id=None, port_type=None, different_host=None, port_qos_policy_id=None): if not network_id: network_id = self.network['id'] if port_type: kwargs = {'binding:vnic_type': port_type, 'qos_policy_id': port_qos_policy_id} port = self.create_port( network={'id': network_id}, **kwargs) networks = [{'port': port['id']}] else: networks = [{'uuid': network_id}] params = { 'flavor_ref': self.flavor_ref, 'image_ref': self.image_ref, 'key_name': self.keypair['name'], 'networks': networks, 'security_groups': [ {'name': self.secgroup['security_group']['name']}], 'name': data_utils.rand_name(self._testMethodName) } if port_type == 'direct-physical': net_vlan = self.client.show_network( network_id)['network']['provider:segmentation_id'] params['user_data'] = build_user_data(net_vlan) params['config_drive'] = True if (different_host and CONF.compute.min_compute_nodes > 1): params['scheduler_hints'] = { 'different_host': different_host['id']} server = self.create_server(**params)['server'] if different_host and CONF.compute.min_compute_nodes > 1: if (self.get_host_for_server(different_host['id']) == self.get_host_for_server(server['id'])): raise self.skipException( 'Failed to run the VM on a different hypervisor, make ' 'sure that DifferentHostFilter is in the list of ' 'enabled nova scheduler filters') port = self.client.list_ports(device_id=server['id'])['ports'][0] if network_id == CONF.network.public_network_id: access_ip_address = port['fixed_ips'][0]['ip_address'] else: access_ip_address = self.create_floatingip( port=port)['floating_ip_address'] server['ssh_client'] = ssh.Client(access_ip_address, self.username, pkey=self.keypair['private_key']) return server def _create_vms_by_topology( self, topology='internal', port_type=None, ipv6=False, different_host=True, num_vms_created=2): """Function for creating desired topology for the test Available topologies: * internal(default): sender and receiver are on tenant network * external: sender and receiver are on external(public) network * east-west: sender and receiver are on different tenant networks * north-south: sender is on external and receiver on tenant network :param topology(str): one of 4 available topologies to use (see list above) :param port_type(str): type of port to use. If omitted, default port type will be used. Can be set to 'direct' or 'direct-physical' for SR-IOV environments. :param different_host(bool): whether to force vms to run on different host. :param num_vms_created(int): number of vms to create, 1 or 2. default is 2. :returns: sender if num_vms_created is 1, else server and receiver """ # num_vms_created can be 1 or 2 self.assertIn(num_vms_created, [1, 2], "num_vms_created can be 1 or 2") def _create_local_network(): network = self.create_network() subnet_index = len(self.reserved_subnet_cidrs) cidr = '192.168.%d.0/24' % subnet_index subnet = self.create_subnet(network, cidr=cidr) self.create_router_interface(router['id'], subnet['id']) if ipv6: ipv6_cidr = '2001:{:x}::/64'.format(200 + subnet_index) ra_address_mode = 'dhcpv6-stateless' ipv6_subnet = self.create_subnet( network, cidr=ipv6_cidr, ip_version=6, ipv6_ra_mode=ra_address_mode, ipv6_address_mode=ra_address_mode) self.create_router_interface(router['id'], ipv6_subnet['id']) return network if topology != 'external': if hasattr(self, "router") and self.router: router = self.router else: router = self.create_router_by_client() if topology == 'external' or topology == 'north-south': external_network = self.client.show_network( CONF.network.public_network_id)['network'] if not external_network['shared']: skip_reason = "External network is not shared" self.skipTest(skip_reason) src_network = external_network else: src_network = _create_local_network() sender = self._create_server_for_topology( network_id=src_network['id'], port_type=port_type) if topology == 'external' or topology == 'internal': dst_network = src_network else: dst_network = _create_local_network() different_host = sender if different_host else None if num_vms_created == 1: return sender receiver = self._create_server_for_topology( different_host=different_host, network_id=dst_network['id'], port_type=port_type) return sender, receiver @classmethod def get_osp_cmd_prefix(cls, admin=True): # TODO(mblue): figure how admin used in podified setup when needed if WB_CONF.openstack_type == 'podified': prefix = '{} rsh openstackclient '.format(cls.OC) elif WB_CONF.openstack_type == 'devstack': prefix = '. /opt/stack/devstack/openrc{} && '.format( ' admin' if admin else '') else: prefix = '. ~/overcloudrc && ' return prefix @staticmethod def validate_command(cmd, pattern='', timeout=60, ssh_client=None, ret_bool_status=False, ret_bool_pattern=False): """Run a command on a given host. Optional: validation of output by regex, and exit status. :param cmd: Command to execute on given host. :type cmd: str :param pattern: Optional regex pattern to validate each commands output. :type pattern: str, optional :param timeout: Timeout for command to finish. :type timeout: int, optional :param ssh_client: Ssh client to execute command, default UC. :type ssh_client: SSHClient, optional :param ret_bool_pattern: Return boolean instead of error raise in pattern verification (Default False). Without any boolean option, returns all output. :type ret_bool_pattern: bool, optional :param ret_bool_status: Return boolean instead of error raise in exit status verification (Default False). Without any boolean option, returns all output. :type ret_bool_status: bool, optional :returns: all output of command as str, or boolean if either of return boolean options is True (ret_bool_pattern or ret_bool_status). """ # execute on tester node or other, according to CI configuration if ssh_client is None and not WB_CONF.exec_on_tester: ssh_client = ssh.Client( host=WB_CONF.tester_ip, username=WB_CONF.tester_user, password=WB_CONF.tester_pass, key_filename=WB_CONF.tester_key_file) # verify command success using exception try: result = shell.execute( cmd, timeout=timeout, check=(not ret_bool_status), ssh_client=ssh_client) except exceptions.ShellCommandFailed: LOG.exception( 'Tested command failed (raising error) -> "{}":'.format(cmd)) # verify command success using boolean if ret_bool_status and result.exit_status != 0: LOG.debug( 'Tested command failed (returning False) -> "{}":'.format(cmd)) return False # verify desired output using exception/boolean all_output = (result.stderr if result.stderr else '') + \ (result.stdout if result.stdout else '') if pattern: fail_msg = 'Pattern "{}" not found in output of "{}" command.' try: if not re.search(pattern, all_output): raise AssertionError(fail_msg.format(pattern, cmd)) except AssertionError as err: if ret_bool_pattern: return False raise err if ret_bool_status or ret_bool_pattern: return True return all_output @classmethod def run_group_cmd(cls, cmd, group='', pattern='', timeout=60, check_status=True, parallel=True): """Run a command on a group of overcloud nodes, either in parallel/sequential. Optional: validation of output by regex, and exit status. :param cmd: Command to execute on nodes group. :type cmd: str :param group: Initial name to fit group, ex: controller (Default all overcloud nodes). :type group: str, optional :param pattern: Optional regex pattern to validate each commands output. :type pattern: str, optional :param timeout: Timeout for all commands to finish. :type timeout: int, optional :param check_status: Whether to verify commands exit status. :type check_status: bool, optional :param parallel: Run commands in parallel or sequential. :type parallel: bool, optional """ tasks = [] group = group.lower() group_name = group if group else 'all' for node in cls.nodes: if node['is_' + group]: LOG.info('Running command in %s "%s" on "%s" from group "%s"', 'parallel' if parallel else 'sequence', cmd, node['name'], group_name) # functools.partial instead of lambda for "freezed" arguments # (figure values in definition time rather than execution time) call = partial(cls.validate_command, cmd, pattern, timeout, node['client'], not check_status) tasks.append(Process(target=call)) if parallel else call() if parallel and tasks: for task in tasks: task.start() for task in tasks: task.join() # NOTE(mblue): guarantee wait for exit, or proper error common_utils.wait_until_true( lambda: None not in [t.exitcode for t in tasks], timeout=timeout, sleep=min(5, timeout), exception=RuntimeError( ('Timed out: waiting for command "{}" on "{}" nodes\n' '({}/{} processes not finished)').format( cmd, group_name, len([t for t in tasks if t.exitcode is None]), len(tasks)))) if check_status: if sum([t.exitcode for t in tasks]) != 0: raise AssertionError( 'Command failure "{}" on "{}" nodes.'.format( cmd, group_name)) @classmethod def cli_create_resource(cls, cmd, cleanup_method=None, cleanup_args=None, env_prefix=None, no_id_cmd=False, cleanup=True): """Wrapper for OSP resource creation using commands. Includes sourcing commonly used credentials and common cleanup command call after test class is done/failed. :param cmd: Creation command to execute. Example: 'openstack ... create ...' :type cmd: str :param cleanup_method: Cleanup function to handle resource after test class is finished/failed. Default method is validate_command from base class in combination with a default delete command deduced from given create command. :type cleanup_method: function, optional :param cleanup_args: Arguments passed to cleanup method. Default arguments work in combination with default cleanup_method, which is a single argument, a figured delete appropriate command. :type cleanup_args: tuple, optional :param env_prefix: Prefix added to create command. Default prefix sources test user rc file, usually ~/openrc . :type env_prefix: str, optional :param no_id_cmd: When set to True omits command suffix to return uuid of created resource, then returns all output. (Useful for non ordinary creation commands, or extra output parsing). Default is False. :type no_id_cmd: bool, optional :param cleanup: When set to False, skips adding cleanup in stack (therefore not using cleanup_method and cleanup_args). Default is True. :type cleanup: bool, optional :returns: uuid of resource, or all output according to no_id_cmd boolean. Default is uuid. """ # default to overcloudrc credentials _env_prefix = env_prefix or cls.get_osp_cmd_prefix() _get_id_suffix = '' if no_id_cmd else ' -f value -c id' _cmd = _env_prefix + cmd + _get_id_suffix _id = cls.validate_command(_cmd).strip() # default to delete using CLI, and common arguments figured from cmd if cleanup: _cleanup_method = cleanup_method or cls.validate_command _cleanup_args = cleanup_args or ( _cmd.partition('create ')[0] + 'delete {}'.format(_id),) cls.addClassResourceCleanup(_cleanup_method, *_cleanup_args) # length of uuid with dashes, as seen in CLI output if not no_id_cmd and len(_id) != 36: raise AssertionError( "Command for resource creation failed: '{}'".format(_cmd)) LOG.debug('Command for resource creation succeeded') return _id @classmethod def find_host_virsh_name(cls, host): cmd = ("timeout 10 ssh {} sudo virsh list --name | grep -w {}").format( WB_CONF.hypervisor_host, host) return cls.proxy_host_client.exec_command(cmd).strip() @classmethod def is_host_state_is_shut_off(cls, host): cmd = ("timeout 10 ssh {} virsh list --state-shutoff | grep -w {} " "|| true".format(WB_CONF.hypervisor_host, host)) output = cls.proxy_host_client.exec_command(cmd) return True if host in output else False @classmethod def is_host_loginable(cls, host): cmd = "timeout 10 ssh {} ssh {} hostname || true".format( WB_CONF.hypervisor_host, host) output = cls.proxy_host_client.exec_command(cmd) return True if host in output else False @classmethod def power_off_host(cls, host): if not WB_CONF.run_power_operations_tests: raise cls.skipException("Power operations are not allowed") cmd = "timeout 10 ssh {} sudo virsh destroy {}".format( WB_CONF.hypervisor_host, cls.find_host_virsh_name()) cls.proxy_host_client.exec_command(cmd) common_utils.wait_until_true( lambda: cls.is_host_state_is_shut_off(host), timeout=30, sleep=5) @classmethod def power_on_host(cls, host): if not WB_CONF.run_power_operations_tests: raise cls.skipException("Power operations are not allowed") cmd = "timeout 10 ssh {} sudo virsh start {}".format( WB_CONF.hypervisor_host, cls.find_host_virsh_name()) cls.proxy_host_client.exec_command(cmd) # TODO(rsafrono): implement and apply additional health checks common_utils.wait_until_true( lambda: cls.is_host_loginable(host), timeout=120, sleep=5) @classmethod def reboot_host(cls, host): if not WB_CONF.run_power_operations_tests: raise cls.skipException("Power operations are not allowed") cmd = "timeout 10 ssh {} sudo virsh reboot {}".format( WB_CONF.hypervisor_host, cls.find_host_virsh_name()) cls.proxy_host_client.exec_command(cmd) common_utils.wait_until_true( lambda: cls.is_host_loginable(host), timeout=120, sleep=5) def ensure_overcloud_nodes_active(self): """Checks all openstack nodes are up, otherwise activates them. """ # get overcloud nodes info if it doesn't exist if not hasattr(self, 'nodes'): self.discover_nodes() for node in self.nodes: if self.is_host_state_is_shut_off(node['name']): self.power_on_host(node['name']) class BaseTempestTestCaseAdvanced(BaseTempestWhiteboxTestCase): """Base class skips test suites unless advanced image is available, also defines handy test settings for advanced image use. """ @classmethod def skip_checks(cls): super(BaseTempestTestCaseAdvanced, cls).skip_checks() advanced_image_available = ( CONF.neutron_plugin_options.advanced_image_ref or CONF.neutron_plugin_options.default_image_is_advanced) if not advanced_image_available: skip_reason = "This test requires advanced image and tools" raise cls.skipException(skip_reason) @classmethod def resource_setup(cls): super(BaseTempestTestCaseAdvanced, cls).resource_setup() if CONF.neutron_plugin_options.default_image_is_advanced: cls.flavor_ref = CONF.compute.flavor_ref cls.image_ref = CONF.compute.image_ref cls.username = CONF.validation.image_ssh_user else: cls.flavor_ref = ( CONF.neutron_plugin_options.advanced_image_flavor_ref) cls.image_ref = CONF.neutron_plugin_options.advanced_image_ref cls.username = CONF.neutron_plugin_options.advanced_image_ssh_user class TrafficFlowTest(BaseTempestWhiteboxTestCase): force_tenant_isolation = False @classmethod @utils.requires_ext(extension="router", service="network") def skip_checks(cls): super(TrafficFlowTest, cls).skip_checks() if not CONF.network.public_network_id: raise cls.skipException( 'The public_network_id option must be specified.') if not WB_CONF.run_traffic_flow_tests: raise cls.skipException( "CONF.whitebox_neutron_plugin_options." "run_traffic_flow_tests set to False.") @classmethod def resource_setup(cls): super(TrafficFlowTest, cls).resource_setup() cls.gateway_external_ip = cls.get_external_gateway() if not cls.gateway_external_ip: raise cls.skipException("IPv4 gateway is not configured " "for public network or public_network_id " "is not configured.") cls.discover_nodes() def _start_captures(self, interface, filters): def get_interface(client): # (rsafrono) discover interfaces, useful when capturing on # nodes and different types of nodes have different interfaces, # e.g. on podified environment ocp and compute have different # names of interfaces connected to external network bridge = self.get_external_bridge(client) filters = [r"| grep 'eth\|enp\|ens' | grep -v veth ", "| cut -f2 -d ' ' | tr -d ':'"] commands = [ "sudo ovs-vsctl list-ports " + bridge + filters[0], "sudo ip -o link show master " + bridge + filters[0] + filters[1]] for cmd in commands: interfaces = client.exec_command( cmd + " || true").strip().split() if interfaces: return ','.join(interfaces) for node in self.nodes: if interface: node_interface = interface else: node_interface = get_interface(node['client']) node['capture'] = capture.TcpdumpCapture( node['client'], node_interface, filters) self.useFixture(node['capture']) time.sleep(5) def _stop_captures(self): for node in self.nodes: node['capture'].stop() def check_east_west_icmp_flow( self, dst_ip, expected_routing_nodes, expected_macs, ssh_client): """Check that traffic routed as expected within a tenant network Both directions are supported. Traffic is captured on OVN-specific genev_sys_6081 interface :param dst_ip(str): Destination IP address that we check route to :param expected_routing_nodes(list): Hostnames of expected gateways, nodes on tunnel interface of which we expect to find ethernet frames with packets that we send :param expected_macs(tuple): pair of MAC addresses of ports that we expect to find on the captured packets :param ssh_client(Client): SSH client object of the origin of traffic (the one that we send traffic from) """ interface = local_constants.NODE_TUNNEL_INTERFACE # create filters if type(expected_macs) is tuple: filters = 'icmp and ether host {0} and ether host {1}'.format( expected_macs[0], expected_macs[1]) elif type(expected_macs) is list: filters = ('"icmp and ((ether host {0} and ether host {1}) ' 'or (ether host {2} and ether host {3}))"').format( expected_macs[0][0], expected_macs[0][1], expected_macs[1][0], expected_macs[1][1]) else: raise TypeError(expected_macs) self._start_captures(interface, filters) self.check_remote_connectivity(ssh_client, dst_ip, ping_count=2) self._stop_captures() LOG.debug('Expected routing nodes: {}'.format( ','.join(expected_routing_nodes))) actual_routing_nodes = [node['name'] for node in self.nodes if not node['capture'].is_empty()] LOG.debug('Actual routing nodes: {}'.format( ','.join(actual_routing_nodes))) self.assertCountEqual(expected_routing_nodes, actual_routing_nodes) def check_north_south_icmp_flow( self, dst_ip, expected_routing_nodes, expected_mac, ssh_client, ignore_outbound=False): """Check that traffic routed as expected between internal and external networks. Both directions are supported. :param dst_ip(str): Destination IP address that we check route to :param expected_routing_nodes(list): Hostnames of expected gateways, nodes on external interface of which we expect to find ethernet frames with packets that we send :param expected_mac(str): MAC address of a port that we expect to find on the expected gateway external interface :param ssh_client(Client): SSH client object of the origin of traffic (the one that we send traffic from) :param ignore_outbound(bool): Whether to ignore outbound packets. This helps to avoid false positives. """ interface = WB_CONF.node_ext_interface inbound = '-Qin' if ignore_outbound else '' size = None if not WB_CONF.bgp: filters = '{} icmp and ether host {}'.format(inbound, expected_mac) else: filters = "{} icmp and icmp[0] == 8".format(inbound) size = random.randint(0, 50) # Adjust payload size adding icmp header size if netaddr.valid_ipv6(dst_ip): size += 44 else: size += 28 # Filter including ip size packet filters += " and ip[2:2]=={} and ip dst {}".format(size, dst_ip) self._start_captures(interface, filters) # if the host is localhost, don't use remote connectivity, # ping directly on the host if ssh_client.host in ( 'localhost', '127.0.0.1', '0:0:0:0:0:0:0:1', '::1'): self.ping_ip_address(dst_ip, mtu=size, should_succeed=True) # tcpdump requires a delay between capturing packets and writing # them to its file. time.sleep(2) else: self.check_remote_connectivity( ssh_client, dst_ip, mtu=size, ping_count=2) self._stop_captures() LOG.debug('Expected routing nodes: {}'.format(expected_routing_nodes)) actual_routing_nodes = [node['name'] for node in self.nodes if not node['capture'].is_empty()] LOG.debug('Actual routing nodes: {}'.format( ','.join(actual_routing_nodes))) self.assertCountEqual(expected_routing_nodes, actual_routing_nodes) class BaseTempestTestCaseOvn(BaseTempestWhiteboxTestCase): @classmethod def resource_setup(cls): super(BaseTempestTestCaseOvn, cls).resource_setup() if not cls.has_ovn_support: raise cls.skipException( "OVN agents not found. This test is supported only on " "openstack environments with OVN support.") cls.nbctl, cls.sbctl = cls._get_ovn_dbs() cls.nbmonitorcmd, cls.sbmonitorcmd = cls._get_ovn_db_monitor_cmds() @classmethod def _get_ovn_db_monitor_cmds(cls): monitorcmdprefix = 'sudo timeout 300 ovsdb-client monitor -f json ' if WB_CONF.openstack_type == 'podified': # (rsafrono) still need to re-check if works properly nb_monitor_connection_opts = cls.nbctl.replace( 'ovn-nbctl', '{} punix:/tmp/ovnnb_db.sock'.format( monitorcmdprefix.replace('sudo', ''))) sb_monitor_connection_opts = cls.sbctl.replace( 'ovn-sbctl', '{} punix:/tmp/ovsnb_db.sock'.format( monitorcmdprefix.replace('sudo', ''))) return (nb_monitor_connection_opts, sb_monitor_connection_opts) if WB_CONF.openstack_type == 'devstack': regex = r'--db=(.*)$' # this regex search will return the connection string # (tcp:IP:port or ssl:IP:port) and in case of TLS, # will also include the TLS options nb_monitor_connection_opts = re.search(regex, cls.nbctl).group(1) sb_monitor_connection_opts = re.search(regex, cls.sbctl).group(1) return (monitorcmdprefix + nb_monitor_connection_opts, monitorcmdprefix + sb_monitor_connection_opts) @classmethod def _get_ovn_dbs(cls): if WB_CONF.openstack_type == 'podified': sb_pod = cls.proxy_host_client.exec_command( "{} get pods | grep ovsdbserver-sb | " "cut -f1 -d' '".format(cls.OC)).strip() sb_prefix = '{} rsh {}'.format(cls.OC, sb_pod) nb_prefix = sb_prefix.replace('sb', 'nb') cmd = "{} ovn-{}ctl" return [cmd.format(nb_prefix, 'nb'), cmd.format(sb_prefix, 'sb')] if WB_CONF.openstack_type == 'devstack': sbdb = "unix:/usr/local/var/run/ovn/ovnsb_db.sock" nbdb = sbdb.replace('sb', 'nb') cmd = "sudo ovn-{}ctl --db={}" return [cmd.format('nb', nbdb), cmd.format('sb', sbdb)] def get_router_gateway_chassis(self, router_port_id): cmd = "{} get port_binding cr-lrp-{} chassis".format( self.sbctl, router_port_id) LOG.debug("Waiting until port is bound to chassis") self.chassis_id = None def _port_binding_exist(): self.chassis_id = self.run_on_master_controller(cmd) LOG.debug("chassis_id = '{}'".format(self.chassis_id)) if self.chassis_id != '[]': return True return False try: common_utils.wait_until_true(lambda: _port_binding_exist(), timeout=30, sleep=5) except common_utils.WaitTimeout: self.fail("Port is not bound to chassis") cmd = "{} get chassis {} hostname".format(self.sbctl, self.chassis_id) LOG.debug("Running '{}' on the master node".format(cmd)) res = self.run_on_master_controller(cmd) return res.replace('"', '').split('.')[0] def get_router_gateway_chassis_list(self, router_port_id): cmd = (self.nbctl + " lrp-get-gateway-chassis lrp-" + router_port_id) data = self.run_on_master_controller(cmd) return [re.sub(r'.*_(.*?)\s.*', r'\1', s) for s in data.splitlines()] def get_router_gateway_chassis_by_id(self, chassis_id): res = self.run_on_master_controller( self.sbctl + " get chassis " + chassis_id + " hostname").rstrip() return res.replace('"', '').split('.')[0] def get_router_port_gateway_mtu(self, router_port_id): cmd = (self.nbctl + " get logical_router_port lrp-" + router_port_id + " options:gateway_mtu") return int( self.run_on_master_controller(cmd).rstrip().strip('"')) def get_item_uuid(self, db, item, search_string): ovn_db = self.sbctl if db == 'sb' else self.nbctl cmd = (ovn_db + " find " + item + " " + search_string + " | grep _uuid | awk '{print $3}'") return self.run_on_master_controller(cmd) def get_datapath_tunnel_key(self, search_string): cmd = (self.sbctl + " find datapath_binding " + search_string + " | grep tunnel_key | awk '{print $3}'") return self.run_on_master_controller(cmd) def get_logical_switch(self, port): """Returns logical switch name that port is connected to Fuction gets the logical switch name without its ID from the `ovn-nbctl lsp-get-ls ` command """ cmd = '{cmd} lsp-get-ls {port}'.format(cmd=self.nbctl, port=port) output = self.run_on_master_controller(cmd) ls_name = re.search('neutron-[^)]*', output) if ls_name: return ls_name.group() else: return '' def get_physical_net(self, port): """Returns physical network name that port has configured with Physical network name is saved as option in the logical switch port record in OVN north database. It can be queried with `ovn-nbctl lsp-get-options ` command but this output may contain more than one option so it is better to get the value with `ovn-nbctl get Logical_Switch_Port options:network_name` command """ cmd = '{cmd} get Logical_Switch_Port {port} '\ 'options:network_name'.format(cmd=self.nbctl, port=port) return self.run_on_master_controller(cmd) def verify_that_segment_deleted(self, segment_id): """Checks that the segment id is not in the OVN database There shouldn't be 'provnet-' port in the OVN database after the segment has been deleted """ cmd = '{cmd} find Logical_Switch_Port '\ 'name=provnet-{sid}'.format(cmd=self.nbctl, sid=segment_id) output = self.run_on_master_controller(cmd) self.assertEqual(output, '') # user_data_cmd is used to generate a VLAN interface on VM instances with PF # ports user_data_cmd = """ #cloud-config write_files: - path: "/etc/sysconfig/network-scripts/ifcfg-%s" owner: "root" permissions: "777" content: | DEVICE="%s" BOOTPROTO="dhcp" ONBOOT="yes" VLAN="yes" PERSISTENT_DHCLIENT="yes" runcmd: - [ sh, -c , "systemctl restart NetworkManager" ] """ user_data_cmd = user_data_cmd.replace('\t', '') def build_user_data(net_vlan): """user_data is required when direct-physical (PF) ports are used """ if_full_name = '%s.%s' % \ (WB_CONF.default_instance_interface, net_vlan) user_data = base64.b64encode(( user_data_cmd % (if_full_name, if_full_name)).encode("utf-8")) return user_data class ProviderBaseTest(BaseTempestWhiteboxTestCase): """Base class for tests using provider networks, such as provider routed networks or sriov scenarios Admin user is needed to create ports on the existing provisioning network """ servers = [] keypairs_client = None secgroup_client = None servers_client = None extra_dhcp_opts = None @classmethod def create_loginable_secgroup_rule(cls, secgroup_id=None, client=None): """This rule is intended to permit inbound IPv4 and IPv6 ssh """ cls.create_security_group_rule( security_group_id=secgroup_id, client=client, protocol='tcp', direction='ingress', ip_version=6, port_range_min=22, port_range_max=22) cls.create_security_group_rule( security_group_id=secgroup_id, client=client, protocol='tcp', direction='ingress', port_range_min=22, port_range_max=22) @classmethod def create_pingable_secgroup_rule(cls, secgroup_id=None, client=None): """This rule is intended to permit inbound IPv4 and IPv6 ping """ cls.create_security_group_rule( security_group_id=secgroup_id, client=client, protocol='icmp', direction='ingress') cls.create_security_group_rule( security_group_id=secgroup_id, client=client, protocol='icmpv6', ip_version=6, direction='ingress') @classmethod def resource_setup(cls): super(ProviderBaseTest, cls).resource_setup() # setup basic topology for servers we can log into it cls.keypair = cls.create_keypair(client=cls.keypairs_client) secgroup_name = data_utils.rand_name('secgroup') if cls.secgroup_client: cls.secgroup = cls.secgroup_client.create_security_group( name=secgroup_name)['security_group'] else: cls.secgroup = cls.client.create_security_group( name=secgroup_name)['security_group'] cls.security_groups.append(cls.secgroup) cls.create_loginable_secgroup_rule( secgroup_id=cls.secgroup['id'], client=cls.client) cls.create_pingable_secgroup_rule( secgroup_id=cls.secgroup['id'], client=cls.client) @classmethod def resource_cleanup(cls): client = cls.servers_client or cls.os_primary.servers_client for server in cls.servers: cls._try_delete_resource(client.delete_server, server['id']) waiters.wait_for_server_termination(client, server['id']) super(ProviderBaseTest, cls).resource_cleanup() @classmethod def create_network_with_port(cls, cidr, gateway=True, **kwargs): cls.network = cls.create_network() if not gateway: # some subnets need to be created without a default gateway # e.g.: when a server is created with two ports, one of them should # not include a default gateway cls.subnet = cls.create_subnet( cls.network, cidr=cidr, gateway=None) else: cls.subnet = cls.create_subnet(cls.network, cidr=cidr) cls.port_id = cls.create_port(network=cls.network, **kwargs)['id'] return {'port': cls.port_id} def build_create_port_body_and_secgroups(self, port_type, secgroup): """create_port_body and security_groups are needed to create ports, whatever their types are (normal, macvtap, direct or direct-physical) """ create_port_body = {} security_groups = [] if port_type not in ('direct', 'direct-physical', 'macvtap'): create_port_body['security_groups'] = [secgroup['id']] security_groups = [{'name': secgroup['name']}] create_port_body['binding:vnic_type'] = port_type create_port_body['name'] = "_".join(['port', port_type]) if self.extra_dhcp_opts is not None: create_port_body['extra_dhcp_opts'] = self.extra_dhcp_opts return (create_port_body, security_groups) def _create_server(self, **kwargs): kwargs['client'] = \ self.servers_client or self.os_primary.servers_client kwargs['flavor_ref'] = self.flavor_ref kwargs['image_ref'] = self.image_ref kwargs['key_name'] = self.keypair['name'] server = self.create_server(**kwargs) self.servers.append(server['server']) return server['server'] def _create_network_port(self, port_type, reuse_port=False, use_provider_net=True, subnet_id=None, reused_tenant_net=None, cidr=None, gateway=True): create_port_body, security_groups = \ self.build_create_port_body_and_secgroups( port_type, self.secgroup) if subnet_id: subnet_name = 'segment' + subnet_id if use_provider_net: self.network = fixed_network.get_network_from_name( CONF.network.floating_network_name, self.client) if not reuse_port: if not subnet_id: self.create_port( network=self.network, fixed_ips=[{'subnet_id': self.network['subnets'][-1]}], **create_port_body) else: subnets = self.client.list_subnets(name=subnet_name) subnet_id = {'subnet_id': subnets['subnets'][-1]['id']} self.create_port( network=self.network, fixed_ips=[subnet_id], **create_port_body) port = {'port': self.ports[-1]['id']} elif not reused_tenant_net: port = self.create_network_with_port( cidr=cidr, gateway=gateway, **create_port_body) else: self.network = reused_tenant_net port = {'port': self.create_port(network=self.network, **create_port_body)['id']} if not subnet_id: net_id = self.network['id'] nc = self.admin_manager.network_client net_vlan = nc.show_network(net_id)['network'][ 'provider:segmentation_id'] else: segments = self.client.list_segments(name=subnet_name) net_vlan = segments['segments'][-1]['segmentation_id'] user_data = "" config_drive = False if port_type == 'direct-physical': user_data = build_user_data(net_vlan) config_drive = True return (security_groups, port, user_data, config_drive) def check_port_status(self, port_type, port_index=-1, server_index=-1): # by default, use last created port (-1) and last created server (-1) port_id = self.ports[port_index]['id'] server_id = self.servers[server_index]['id'] waiters.wait_for_interface_status(self.os_adm.interfaces_client, server_id, port_id, constants.PORT_STATUS_ACTIVE) port_details = self.client.show_port(port_id)['port'] network = fixed_network.get_network_from_name( CONF.network.floating_network_name, self.client) self.assertEqual(port_details['network_id'], network['id']) self.assertEqual(port_details['admin_state_up'], True) self.assertEqual(port_details['binding:vnic_type'], port_type) return port_details