diff --git a/tests/common/multi_servers_utils.py b/tests/common/multi_servers_utils.py new file mode 120000 index 00000000000..83b3b0ce4c0 --- /dev/null +++ b/tests/common/multi_servers_utils.py @@ -0,0 +1 @@ +../../ansible/module_utils/multi_servers_utils.py \ No newline at end of file diff --git a/tests/common/plugins/ptfadapter/__init__.py b/tests/common/plugins/ptfadapter/__init__.py index e9ebcef8061..81d216cb46e 100644 --- a/tests/common/plugins/ptfadapter/__init__.py +++ b/tests/common/plugins/ptfadapter/__init__.py @@ -3,7 +3,7 @@ import pytest import time -from .ptfadapter import PtfTestAdapter +from .ptfadapter import PtfTestAdapter, PtfAgent import ptf.testutils from tests.common import constants @@ -112,7 +112,7 @@ def get_ifaces_map(ifaces, ptf_port_mapping_mode, need_backplane=False): @pytest.fixture(scope='module') -def ptfadapter(ptfhost, tbinfo, request, duthost): +def ptfadapter(ptfhosts, tbinfo, request, duthost): """return ptf test adapter object. The fixture is module scope, because usually there is not need to restart PTF nn agent and reinitialize data plane thread on every @@ -127,22 +127,13 @@ def ptfadapter(ptfhost, tbinfo, request, duthost): else: ptf_port_mapping_mode = 'use_orig_interface' - need_backplane = False - if 'ciscovs-7nodes' in tbinfo['topo']['name']: - need_backplane = True - - # get the eth interfaces from PTF and initialize ifaces_map - res = ptfhost.command('cat /proc/net/dev') - ifaces = get_ifaces(res['stdout']) - ifaces_map = get_ifaces_map(ifaces, ptf_port_mapping_mode, need_backplane) - - def start_ptf_nn_agent(): + def start_ptf_nn_agent(device_num): for i in range(MAX_RETRY_TIME): ptf_nn_port = random.randint(*DEFAULT_PTF_NN_PORT_RANGE) # generate supervisor configuration for ptf_nn_agent ptfhost.host.options['variable_manager'].extra_vars.update({ - 'device_num': DEFAULT_DEVICE_NUM, + 'device_num': device_num, 'ptf_nn_port': ptf_nn_port, 'ifaces_map': ifaces_map, }) @@ -163,8 +154,17 @@ def start_ptf_nn_agent(): return ptf_nn_port return None - ptf_nn_agent_port = start_ptf_nn_agent() - assert ptf_nn_agent_port is not None + need_backplane = False + if 'ciscovs-7nodes' in tbinfo['topo']['name']: + need_backplane = True + ptfagents = [] + for seq, ptfhost in enumerate(ptfhosts): + res = ptfhost.command('cat /proc/net/dev') + ifaces = get_ifaces(res['stdout']) + ifaces_map = get_ifaces_map(ifaces, ptf_port_mapping_mode, need_backplane) + ptf_nn_agent_port = start_ptf_nn_agent(seq) + ptfagents.append(PtfAgent(ptfhost.mgmt_ip, ptfhost.mgmt_ipv6, ptf_nn_agent_port, seq, ifaces_map)) + assert ptf_nn_agent_port is not None def check_if_use_minigraph_from_tbinfo(tbinfo): if 'properties' in tbinfo['topo'] and "init_cfg_profile" in tbinfo['topo']['properties']: @@ -174,8 +174,7 @@ def check_if_use_minigraph_from_tbinfo(tbinfo): return False return True - with PtfTestAdapter(tbinfo['ptf_ip'], tbinfo['ptf_ipv6'], - ptf_nn_agent_port, 0, list(ifaces_map.keys()), ptfhost) as adapter: + with PtfTestAdapter(ptfagents, ptfhosts) as adapter: if not request.config.option.keep_payload: override_ptf_functions() node_id = request.module.__name__ @@ -189,12 +188,12 @@ def check_if_use_minigraph_from_tbinfo(tbinfo): @pytest.fixture(scope='module') -def nbr_device_numbers(nbrhosts): +def nbr_device_numbers(nbrhosts, ptfhosts): """return the mapping of neighbor devices name to ptf device number. """ numbers = sorted(nbrhosts.keys()) device_numbers = { - nbr_name: numbers.index(nbr_name) + DEFAULT_DEVICE_NUM + 1 + nbr_name: numbers.index(nbr_name) + len(ptfhosts) for nbr_name in list(nbrhosts.keys())} return device_numbers diff --git a/tests/common/plugins/ptfadapter/ptfadapter.py b/tests/common/plugins/ptfadapter/ptfadapter.py index e1075fc0ca5..47bbffbbafb 100644 --- a/tests/common/plugins/ptfadapter/ptfadapter.py +++ b/tests/common/plugins/ptfadapter/ptfadapter.py @@ -11,6 +11,15 @@ import logging +class PtfAgent: + def __init__(self, ptf_ip, ptf_ipv6, ptf_nn_port, device_num, ptf_port_set): + self.ptf_ip = ptf_ip + self.ptf_ipv6 = ptf_ipv6 + self.ptf_nn_port = ptf_nn_port + self.device_num = device_num + self.ptf_port_set = ptf_port_set + + class PtfAdapterNNConnectionError(Exception): def __init__(self, remote_sock_addr): @@ -30,21 +39,17 @@ class PtfTestAdapter(BaseTest): # the number of currently established connections NN_STAT_CURRENT_CONNECTIONS = 201 - def __init__(self, ptf_ip, ptf_ipv6, ptf_nn_port, device_num, ptf_port_set, ptfhost): + def __init__(self, ptfagents, ptfhosts): """ initialize PtfTestAdapter - :param ptf_ip: PTF host IP - :param ptf_ipv6: PTF host IPv6 address - :param ptf_nn_port: PTF nanomessage agent port - :param device_num: device number - :param ptf_port_set: PTF ports - :return: """ self.runTest = lambda: None # set a no op runTest attribute to satisfy BaseTest interface super(PtfTestAdapter, self).__init__() self.payload_pattern = "" self.connected = False - self.ptfhost = ptfhost - self._init_ptf_dataplane(ptf_ip, ptf_ipv6, ptf_nn_port, device_num, ptf_port_set) + self.ptfhosts = ptfhosts + self.ptfagents = ptfagents + self.ptf_port_set = [k for a in ptfagents for k in a.ptf_port_set.keys()] + self._init_ptf_dataplane() def __enter__(self): """ enter in 'with' block """ @@ -65,42 +70,33 @@ def _check_ptf_nn_agent_availability(self, socket_addr): finally: sock.close() - def _init_ptf_dataplane(self, ptf_ip, ptf_ipv6, ptf_nn_port, device_num, ptf_port_set, ptf_config=None): + def _init_ptf_dataplane(self, ptf_config=None): """ initialize ptf framework and establish connection to ptf_nn_agent running on PTF host - :param ptf_ip: PTF host IP - :param ptf_ipv6: PTF host IPv6 address - :param ptf_nn_port: PTF nanomessage agent port - :param device_num: device number - :param ptf_port_set: PTF ports :return: """ - self.ptf_ip = ptf_ip - self.ptf_ipv6 = ptf_ipv6 - self.ptf_nn_port = ptf_nn_port - self.device_num = device_num - self.ptf_port_set = ptf_port_set self.connected = False ptfutils.default_timeout = self.DEFAULT_PTF_TIMEOUT ptfutils.default_negative_timeout = self.DEFAULT_PTF_NEG_TIMEOUT - ptf_nn_sock_addr = 'tcp://{}:{}'.format(ptf_ip, ptf_nn_port) - ptf.config.update({ 'platform': 'nn', - 'device_sockets': [ - (device_num, ptf_port_set, ptf_nn_sock_addr) - ], + 'device_sockets': [], 'qlen': self.DEFAULT_PTF_QUEUE_LEN, 'relax': True, }) + if ptf_config is not None: ptf.config.update(ptf_config) - if not self._check_ptf_nn_agent_availability(ptf_nn_sock_addr): - raise PtfAdapterNNConnectionError(ptf_nn_sock_addr) + for ptfagent in self.ptfagents: + ptf_nn_sock_addr = 'tcp://{}:{}'.format(ptfagent.ptf_ip, ptfagent.ptf_nn_port) + ptf.config['device_sockets'].append((ptfagent.device_num, ptfagent.ptf_port_set, ptf_nn_sock_addr)) + + if not self._check_ptf_nn_agent_availability(ptf_nn_sock_addr): + raise PtfAdapterNNConnectionError(ptf_nn_sock_addr) # update ptf.config based on NN platform and create dataplane instance nn.platform_config_update(ptf.config) @@ -112,6 +108,26 @@ def _init_ptf_dataplane(self, ptf_ip, ptf_ipv6, ptf_nn_port, device_num, ptf_por device_id, port_id = id ptf.dataplane_instance.port_add(ifname, device_id, port_id) self.connected = True + ptf.dataplane_instance.port_device_map = {p: d for d, p in ptf.dataplane_instance.ports.keys()} + ptf.dataplane_instance.port_to_device = lambda port: ptf.dataplane_instance.port_device_map[port] + ptf.dataplane_instance.port_to_tuple = lambda port: (ptf.dataplane_instance.port_device_map[port], port) + ptf.dataplane_instance._poll = ptf.dataplane_instance.poll + ptf.dataplane_instance.poll = lambda device_number, port_number=None, timeout=None, exp_pkt=None, filters=[]: \ + ptf.dataplane_instance._poll( + ptf.dataplane_instance.port_to_device(port_number) + if port_number is not None else device_number if device_number is not None else None, + port_number, + timeout, + exp_pkt, + filters + ) + ptf.dataplane_instance._send = ptf.dataplane_instance.send + ptf.dataplane_instance.send = lambda device_number, port_number, packet: \ + ptf.dataplane_instance._send( + ptf.dataplane_instance.port_to_device(port_number), + port_number, + packet + ) self.dataplane = ptf.dataplane_instance def kill(self): @@ -136,12 +152,12 @@ def reinit(self, ptf_config=None): # Restart ptf_nn_agent to close any TCP connection from the server side logging.info("Restarting ptf_nn_agent") - self.ptfhost.command('supervisorctl reread') - self.ptfhost.command('supervisorctl update') - self.ptfhost.command('supervisorctl restart ptf_nn_agent') + for ptfhost in self.ptfhosts: + ptfhost.command('supervisorctl reread') + ptfhost.command('supervisorctl update') + ptfhost.command('supervisorctl restart ptf_nn_agent') - self._init_ptf_dataplane(self.ptf_ip, self.ptf_ipv6, self.ptf_nn_port, - self.device_num, self.ptf_port_set, ptf_config) + self._init_ptf_dataplane(ptf_config) def update_payload(self, pkt): """Update the payload of packet to the default pattern when certain conditions are met. diff --git a/tests/common/ptf_agent_updater.py b/tests/common/ptf_agent_updater.py index 0656cea21f6..cef09968f98 100644 --- a/tests/common/ptf_agent_updater.py +++ b/tests/common/ptf_agent_updater.py @@ -5,61 +5,66 @@ class PtfAgentUpdater(object): """ PtfAgentUpdater class for updating ptf_nn_agent on PTF host """ - def __init__(self, ptfhost, ptfadapter, ptf_nn_agent_template): + def __init__(self, ptfhosts, ptfadapter, ptf_nn_agent_template): """ Initialize an object for updating ptf_nn_agent Args: - ptfhost: PTF host object + ptfhosts: PTF hosts object ptfadapter: PTF adapter ptf_nn_agent_template: ptf_nn_agent template """ - self.ptfhost = ptfhost + self.ptfhosts = ptfhosts self.ptfadapter = ptfadapter self.ptf_nn_agent_template = ptf_nn_agent_template - def configure_ptf_nn_agent(self, ifaces): + def configure_ptf_nn_agent(self, ifaces, ptf_index=0): """ Add new interfaces to interfaces map of ptfadapter Args: ifaces: List of interface names + ptf_index: The index of ptfhost in ptfhosts to configure ptf_nn_agent """ + ptfhost = self.ptfhosts[ptf_index] ifaces = [ifaces] if not isinstance(ifaces, list) else ifaces - last_iface_id = sorted(self.ptfhost.host.options['variable_manager'].extra_vars['ifaces_map'].keys())[-1] + last_iface_id = sorted(ptfhost.host.options['variable_manager'].extra_vars['ifaces_map'].keys())[-1] for iface_id, iface in enumerate(ifaces, last_iface_id+1): - self.ptfhost.host.options['variable_manager'].extra_vars['ifaces_map'][iface_id] = iface + ptfhost.host.options['variable_manager'].extra_vars['ifaces_map'][iface_id] = iface self.ptfadapter.ptf_port_set.append(iface_id) - self._restart_ptf_nn_agent() + self._restart_ptf_nn_agent(ptf_index) self.ptfadapter.reinit() - def cleanup_ptf_nn_agent(self, ifaces): + def cleanup_ptf_nn_agent(self, ifaces, ptf_index=0): """ Remove interfaces from interfaces map of ptfadapter Args: ifaces: List of interface names + ptf_index: The index of ptfhost in ptfhosts to configure ptf_nn_agent """ + ptfhost = self.ptfhosts[ptf_index] ifaces = [ifaces] if not isinstance(ifaces, list) else ifaces - ifaces_map = self.ptfhost.host.options['variable_manager'].extra_vars['ifaces_map'] + ifaces_map = ptfhost.host.options['variable_manager'].extra_vars['ifaces_map'] config_port_indices = {v: k for k, v in list(ifaces_map.items())} for iface in ifaces: - self.ptfhost.host.options['variable_manager'].extra_vars['ifaces_map'].pop(config_port_indices[iface]) + ptfhost.host.options['variable_manager'].extra_vars['ifaces_map'].pop(config_port_indices[iface]) self.ptfadapter.ptf_port_set.remove(config_port_indices[iface]) - self._restart_ptf_nn_agent() + self._restart_ptf_nn_agent(ptf_index) self.ptfadapter.reinit() - def _restart_ptf_nn_agent(self): + def _restart_ptf_nn_agent(self, ptf_index=0): """ Restart ptf_nn_agent """ - self.ptfhost.template(src=self.ptf_nn_agent_template, dest=PTF_NN_AGENT_CONF) - self.ptfhost.command('supervisorctl reread') - self.ptfhost.command('supervisorctl update') - self.ptfhost.command('supervisorctl restart ptf_nn_agent') + ptfhost = self.ptfhosts[ptf_index] + ptfhost.template(src=self.ptf_nn_agent_template, dest=PTF_NN_AGENT_CONF) + ptfhost.command('supervisorctl reread') + ptfhost.command('supervisorctl update') + ptfhost.command('supervisorctl restart ptf_nn_agent') diff --git a/tests/common/testbed.py b/tests/common/testbed.py index cb5e89f6e32..935e5b6fa4c 100644 --- a/tests/common/testbed.py +++ b/tests/common/testbed.py @@ -107,10 +107,10 @@ def _read_testbed_topo_from_yaml(self): with open(self.testbed_filename) as f: tb_info = yaml.safe_load(f) for tb in tb_info: - if tb["ptf_ip"]: + if "ptf_ip" in tb and tb["ptf_ip"]: tb["ptf_ip"], tb["ptf_netmask"] = \ self._cidr_to_ip_mask(tb["ptf_ip"]) - if tb["ptf_ipv6"]: + if "ptf_ipv6" in tb and tb["ptf_ipv6"]: tb["ptf_ipv6"], tb["ptf_netmask_v6"] = \ self._cidr_to_ip_mask(tb["ptf_ipv6"]) tb["duts"] = tb.pop("dut") diff --git a/tests/conftest.py b/tests/conftest.py index c16a4b025e7..8eebdcccb90 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -15,6 +15,7 @@ from datetime import datetime from ipaddress import ip_interface, IPv4Interface +from tests.common.multi_servers_utils import MultiServersUtils from tests.common.fixtures.conn_graph_facts import conn_graph_facts # noqa F401 from tests.common.devices.local import Localhost from tests.common.devices.ptf import PTFHost @@ -658,19 +659,35 @@ def localhost(ansible_adhoc): @pytest.fixture(scope="session") -def ptfhost(enhance_inventory, ansible_adhoc, tbinfo, duthost, request): +def ptfhost(ptfhosts): + if not ptfhosts: + return ptfhosts + return ptfhosts[0] # For backward compatibility, this is for single ptfhost testbed. + + +@pytest.fixture(scope="session") +def ptfhosts(enhance_inventory, ansible_adhoc, tbinfo, duthost, request): + _hosts = [] if 'ptp' in tbinfo['topo']['name']: return None if "ptf_image_name" in tbinfo and "docker-keysight-api-server" in tbinfo["ptf_image_name"]: return None if "ptf" in tbinfo: - return PTFHost(ansible_adhoc, tbinfo["ptf"], duthost, tbinfo, - macsec_enabled=request.config.option.enable_macsec) + _hosts.append(PTFHost(ansible_adhoc, tbinfo["ptf"], duthost, tbinfo, + macsec_enabled=request.config.option.enable_macsec)) + elif "servers" in tbinfo: + for server in tbinfo["servers"].values(): + if "ptf" in server and server["ptf"]: + _host = PTFHost(ansible_adhoc, server["ptf"], duthost, tbinfo, + macsec_enabled=request.config.option.enable_macsec) + _hosts.append(_host) else: # when no ptf defined in testbed.csv # try to parse it from inventory ptf_host = duthost.host.options["inventory_manager"].get_host(duthost.hostname).get_vars()["ptf_host"] - return PTFHost(ansible_adhoc, ptf_host, duthost, tbinfo, macsec_enabled=request.config.option.enable_macsec) + _hosts.apend(PTFHost(ansible_adhoc, ptf_host, duthost, tbinfo, + macsec_enabled=request.config.option.enable_macsec)) + return _hosts @pytest.fixture(scope="module") @@ -713,15 +730,13 @@ def nbrhosts(enhance_inventory, ansible_adhoc, tbinfo, creds, request): """ logger.info("Fixture nbrhosts started") devices = {} - if (not tbinfo['vm_base'] and 'tgen' in tbinfo['topo']['name']) or 'ptf' in tbinfo['topo']['name'] or \ - 'ixia' in tbinfo['topo']['name']: + if ('vm_base' in tbinfo and not tbinfo['vm_base'] and 'tgen' in tbinfo['topo']['name']) or \ + 'ptf' in tbinfo['topo']['name'] or \ + 'ixia' in tbinfo['topo']['name']: logger.info("No VMs exist for this topology: {}".format(tbinfo['topo']['name'])) return devices - vm_base = int(tbinfo['vm_base'][2:]) - vm_name_fmt = 'VM%0{}d'.format(len(tbinfo['vm_base']) - 2) neighbor_type = request.config.getoption("--neighbor_type") - if 'VMs' not in tbinfo['topo']['properties']['topology']: logger.info("No VMs exist for this topology: {}".format(tbinfo['topo']['properties']['topology'])) return devices @@ -773,9 +788,23 @@ def initial_neighbor(neighbor_name, vm_name): executor = concurrent.futures.ThreadPoolExecutor(max_workers=8) futures = [] - for neighbor_name, neighbor in list(tbinfo['topo']['properties']['topology']['VMs'].items()): - vm_name = vm_name_fmt % (vm_base + neighbor['vm_offset']) - futures.append(executor.submit(initial_neighbor, neighbor_name, vm_name)) + servers = [] + if 'servers' in tbinfo: + servers.extend(tbinfo['servers'].values()) + elif 'server' in tbinfo: + servers.append(tbinfo) + else: + logger.warning("Unknown testbed schema for setup nbrhosts") + for server in servers: + vm_base = int(server['vm_base'][2:]) + vm_name_fmt = 'VM%0{}d'.format(len(server['vm_base']) - 2) + vms = MultiServersUtils.parse_topology_vms( + tbinfo['topo']['properties']['topology']['VMs'], + server['dut_interfaces'] + ) if 'dut_interfaces' in server else tbinfo['topo']['properties']['topology']['VMs'] + for neighbor_name, neighbor in vms.items(): + vm_name = vm_name_fmt % (vm_base + neighbor['vm_offset']) + futures.append(executor.submit(initial_neighbor, neighbor_name, vm_name)) for future in as_completed(futures): # if exception caught in the sub-thread, .result() will raise it in the main thread @@ -879,13 +908,29 @@ def fanouthosts(enhance_inventory, ansible_adhoc, conn_graph_facts, creds, dutho @pytest.fixture(scope="session") -def vmhost(enhance_inventory, ansible_adhoc, request, tbinfo): +def vmhost(vmhosts): + if not vmhosts: + return vmhosts + return vmhosts[0] # For backward compatibility, this is for single vmhost testbed. + + +@pytest.fixture(scope="session") +def vmhosts(enhance_inventory, ansible_adhoc, request, tbinfo): + hosts = [] + inv_files = get_inventory_files(request) if 'ptp' in tbinfo['topo']['name']: return None - server = tbinfo["server"] - inv_files = get_inventory_files(request) - vmhost = get_test_server_host(inv_files, server) - return VMHost(ansible_adhoc, vmhost.name) + elif "servers" in tbinfo: + for server in tbinfo["servers"].keys(): + vmhost = get_test_server_host(inv_files, server) + hosts.append(VMHost(ansible_adhoc, vmhost.name)) + elif "server" in tbinfo: + server = tbinfo["server"] + vmhost = get_test_server_host(inv_files, server) + hosts.append(VMHost(ansible_adhoc, vmhost.name)) + else: + logger.info("No VM host exist for this topology: {}".format(tbinfo['topo']['name'])) + return hosts @pytest.fixture(scope='session') diff --git a/tests/mclag/conftest.py b/tests/mclag/conftest.py index c9687ac2b1b..d66b382d648 100644 --- a/tests/mclag/conftest.py +++ b/tests/mclag/conftest.py @@ -33,7 +33,7 @@ def pytest_addoption(parser): @pytest.fixture(scope='module') def mclag_intf_num(request): argument = request.config.getoption("--amount_mclag_intf") - assert(argument <= MAX_MCLAG_INTF) + assert (argument <= MAX_MCLAG_INTF) return argument @@ -144,7 +144,7 @@ def update_and_clean_ptf_agent(duthost1, ptfhost, ptfadapter, collect): ptfadapter: PTF adapter collect: Fixture which collects main info about link connection """ - ptf_agent_updater = PtfAgentUpdater(ptfhost=ptfhost, + ptf_agent_updater = PtfAgentUpdater(ptfhosts=[ptfhost], ptfadapter=ptfadapter, ptf_nn_agent_template=os.path.join(TEMPLATE_DIR, PTF_NN_AGENT_TEMPLATE)) mclag_interfaces = collect[duthost1.hostname]['mclag_interfaces'] diff --git a/tests/srv6/test_srv6_dataplane.py b/tests/srv6/test_srv6_dataplane.py index 56d93d7eb89..91b47ca7974 100644 --- a/tests/srv6/test_srv6_dataplane.py +++ b/tests/srv6/test_srv6_dataplane.py @@ -44,7 +44,7 @@ def get_ptf_src_port_and_dut_port_and_neighbor(dut, tbinfo): @pytest.mark.parametrize("with_srh", [True, False]) def test_srv6_uN_forwarding(duthosts, enum_frontend_dut_hostname, enum_frontend_asic_index, - ptfadapter, tbinfo, nbrhosts, with_srh): + ptfadapter, ptfhost, tbinfo, nbrhosts, with_srh): duthost = duthosts[enum_frontend_dut_hostname] asic_index = enum_frontend_asic_index @@ -94,7 +94,7 @@ def test_srv6_uN_forwarding(duthosts, enum_frontend_dut_hostname, enum_frontend_ injected_pkt = simple_ipv6_sr_packet( eth_dst=dut_mac, eth_src=ptfadapter.dataplane.get_mac(0, ptf_src_port).decode(), - ipv6_src=ptfadapter.ptf_ipv6, + ipv6_src=ptfhost.mgmt_ipv6, ipv6_dst="fcbb:bbbb:1:2::", srh_seg_left=1, srh_nh=41, @@ -102,7 +102,7 @@ def test_srv6_uN_forwarding(duthosts, enum_frontend_dut_hostname, enum_frontend_ ) else: injected_pkt = Ether(dst=dut_mac, src=ptfadapter.dataplane.get_mac(0, ptf_src_port).decode()) \ - / IPv6(src=ptfadapter.ptf_ipv6, dst="fcbb:bbbb:1:2::") \ + / IPv6(src=ptfhost.mgmt_ipv6, dst="fcbb:bbbb:1:2::") \ / IPv6() / UDP(dport=4791) / Raw(load=payload) expected_pkt = injected_pkt.copy() @@ -121,7 +121,7 @@ def test_srv6_uN_forwarding(duthosts, enum_frontend_dut_hostname, enum_frontend_ @pytest.mark.parametrize("with_srh", [True, False]) def test_srv6_uN_decap_pipe_mode(duthosts, enum_frontend_dut_hostname, enum_frontend_asic_index, - ptfadapter, tbinfo, nbrhosts, with_srh): + ptfadapter, ptfhost, tbinfo, nbrhosts, with_srh): duthost = duthosts[enum_frontend_dut_hostname] asic_index = enum_frontend_asic_index @@ -159,19 +159,19 @@ def test_srv6_uN_decap_pipe_mode(duthosts, enum_frontend_dut_hostname, enum_fron injected_pkt = simple_ipv6_sr_packet( eth_dst=dut_mac, eth_src=ptfadapter.dataplane.get_mac(0, ptf_src_port).decode(), - ipv6_src=ptfadapter.ptf_ipv6, + ipv6_src=ptfhost.mgmt_ipv6, ipv6_dst="fcbb:bbbb:1::", srh_seg_left=1, srh_nh=41, - inner_frame=IPv6(dst=neighbor_ip, src=ptfadapter.ptf_ipv6, tc=0x1, hlim=64)/ICMPv6EchoRequest(seq=i) + inner_frame=IPv6(dst=neighbor_ip, src=ptfhost.mgmt_ipv6, tc=0x1, hlim=64)/ICMPv6EchoRequest(seq=i) ) else: injected_pkt = Ether(dst=dut_mac, src=ptfadapter.dataplane.get_mac(0, ptf_src_port).decode()) \ - / IPv6(src=ptfadapter.ptf_ipv6, dst="fcbb:bbbb:1::") \ - / IPv6(dst=neighbor_ip, src=ptfadapter.ptf_ipv6) / ICMPv6EchoRequest(seq=i) + / IPv6(src=ptfhost.mgmt_ipv6, dst="fcbb:bbbb:1::") \ + / IPv6(dst=neighbor_ip, src=ptfhost.mgmt_ipv6) / ICMPv6EchoRequest(seq=i) expected_pkt = Ether(dst=get_neighbor_info(neighbor_ip, nbrhosts)['mac'], src=dut_mac) / \ - IPv6(dst=neighbor_ip, src=ptfadapter.ptf_ipv6, tc=0x1, hlim=63)/ICMPv6EchoRequest(seq=i) + IPv6(dst=neighbor_ip, src=ptfhost.mgmt_ipv6, tc=0x1, hlim=63)/ICMPv6EchoRequest(seq=i) logger.debug("Expected packet #{}: {}".format(i, expected_pkt.summary())) runSendReceive(injected_pkt, ptf_src_port, expected_pkt, [ptf_src_port], True, ptfadapter) diff --git a/tests/sub_port_interfaces/conftest.py b/tests/sub_port_interfaces/conftest.py index ef4c88be633..ae05e45e7e7 100644 --- a/tests/sub_port_interfaces/conftest.py +++ b/tests/sub_port_interfaces/conftest.py @@ -504,7 +504,7 @@ def apply_balancing_config(duthost, ptfhost, ptfadapter, define_sub_ports_config dut_ports = define_sub_ports_configuration['dut_ports'] ptf_ports = define_sub_ports_configuration['ptf_ports'] - ptf_agent_updater = PtfAgentUpdater(ptfhost=ptfhost, + ptf_agent_updater = PtfAgentUpdater(ptfhosts=[ptfhost], ptfadapter=ptfadapter, ptf_nn_agent_template=os.path.join(TEMPLATE_DIR, PTF_NN_AGENT_TEMPLATE))