def send_recv_eth(ptfadapter, source_ports, source_mac, dest_ports, dest_mac, src_vlan, dst_vlan):
"""
send ethernet packet and verify it on dest_port
:param ptfadapter: PTF adapter object
:param source_port: source port
:param source_mac: source MAC
:param dest_port: destination port to receive packet on
:param dest_mac: destination MAC
:param vlan_id: VLAN id
:return:
"""
pkt = simple_eth_packet(
eth_dst=dest_mac,
eth_src=source_mac,
vlan_vid=src_vlan
)
exp_pkt = simple_eth_packet(
eth_dst=dest_mac,
eth_src=source_mac,
vlan_vid=dst_vlan
)
if dst_vlan:
# expect to receive tagged packet:
# sonic device might modify the 802.1p field,
# need to use Mask to ignore the priority field.
exp_pkt = Mask(exp_pkt)
exp_pkt.set_do_not_care_scapy(scapy.Dot1Q, "prio")
logger.debug('send packet src port {} smac: {} dmac: {} vlan: {} verifying on dst port {}'.format(
source_ports, source_mac, dest_mac, src_vlan, dest_ports))
testutils.send(ptfadapter, source_ports[0], pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, dest_ports, timeout=FDB_WAIT_EXPECTED_PACKET_TIMEOUT)
def test_decap_standby_tor(apply_standby_state_to_orchagent,
build_encapsulated_packet, rand_selected_interface,
ptfadapter, tbinfo, rand_selected_dut,
tunnel_traffic_monitor):
def verify_downstream_packet_to_server(ptfadapter, port, exp_pkt):
"""Verify packet is passed downstream to server."""
packets = ptfadapter.dataplane.packet_queues[(0, port)]
for packet in packets:
if exp_pkt.pkt_match(packet):
return True
return False
tor = rand_selected_dut
encapsulated_packet = build_encapsulated_packet
iface, _ = rand_selected_interface
exp_ptf_port_index = get_ptf_server_intf_index(tor, tbinfo, iface)
exp_pkt = build_expected_packet_to_server(encapsulated_packet)
ptf_t1_intf = random.choice(get_t1_ptf_ports(tor, tbinfo))
logging.info("send encapsulated packet from ptf t1 interface %s",
ptf_t1_intf)
with tunnel_traffic_monitor(tor, existing=False):
testutils.send(ptfadapter,
int(ptf_t1_intf.strip("eth")),
encapsulated_packet,
count=10)
time.sleep(2)
verify_downstream_packet_to_server(ptfadapter, exp_ptf_port_index,
exp_pkt)
def _verify_acl_traffic(self, setup, direction, ptfadapter, pkt, dropped,
ip_version):
exp_pkt = self.expected_mask_routed_packet(pkt, ip_version)
if ip_version == "ipv4":
downstream_dst_port = DOWNSTREAM_IP_PORT_MAP.get(
pkt[packet.IP].dst)
else:
downstream_dst_port = DOWNSTREAM_IP_PORT_MAP.get(
pkt[packet.IPv6].dst)
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, self.src_port, pkt)
if direction == "uplink->downlink" and downstream_dst_port:
if dropped:
testutils.verify_no_packet(ptfadapter, exp_pkt,
downstream_dst_port)
else:
testutils.verify_packet(ptfadapter, exp_pkt,
downstream_dst_port)
else:
if dropped:
testutils.verify_no_packet_any(ptfadapter,
exp_pkt,
ports=self.get_dst_ports(
setup, direction))
else:
testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
ports=self.get_dst_ports(
setup, direction),
timeout=20)
def verify_traffic(duthost,
connection,
route,
is_duthost_active=True,
is_route_existed=True):
prefix = ipaddress.ip_network(route["prefix"])
dst_host = str(random.choice(list(prefix.hosts())))
pkt, exp_pkt = build_packet_to_server(duthost, ptfadapter, dst_host)
ptf_t1_intf = random.choice(get_t1_ptf_ports(duthost, tbinfo))
ptf_t1_intf_index = int(ptf_t1_intf.strip("eth"))
is_tunnel_traffic_existed = is_route_existed and not is_duthost_active
is_server_traffic_existed = is_route_existed and is_duthost_active
tunnel_monitor = tunnel_traffic_monitor(
duthost, existing=is_tunnel_traffic_existed)
server_traffic_monitor = ServerTrafficMonitor(
duthost,
ptfhost,
vmhost,
tbinfo,
connection["test_intf"],
conn_graph_facts,
exp_pkt,
existing=is_server_traffic_existed)
with tunnel_monitor, server_traffic_monitor:
testutils.send(ptfadapter, ptf_t1_intf_index, pkt, count=10)
def test_decap_active_tor(build_encapsulated_packet, request, ptfhost,
rand_selected_interface, ptfadapter, tbinfo,
rand_selected_dut, tunnel_traffic_monitor):
@contextlib.contextmanager
def stop_garp(ptfhost):
"""Temporarily stop garp service."""
ptfhost.shell("supervisorctl stop garp_service")
yield
ptfhost.shell("supervisorctl start garp_service")
if is_t0_mocked_dualtor(tbinfo):
request.getfixturevalue('apply_active_state_to_orchagent')
else:
request.getfixturevalue(
'toggle_all_simulator_ports_to_rand_selected_tor')
tor = rand_selected_dut
encapsulated_packet = build_encapsulated_packet
iface, _ = rand_selected_interface
exp_ptf_port_index = get_ptf_server_intf_index(tor, tbinfo, iface)
exp_pkt = build_expected_packet_to_server(encapsulated_packet,
decrease_ttl=True)
ptf_t1_intf = random.choice(get_t1_ptf_ports(tor, tbinfo))
logging.info("send encapsulated packet from ptf t1 interface %s",
ptf_t1_intf)
with stop_garp(ptfhost):
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, int(ptf_t1_intf.strip("eth")),
encapsulated_packet)
testutils.verify_packet(ptfadapter,
exp_pkt,
exp_ptf_port_index,
timeout=10)
def generate_and_verify_traffic(duthost1,
duthost2,
ptfadapter,
ptfhost,
src_port,
dst_ip,
router_mac,
get_routes,
collect,
down_link_on_dut=None,
pkt_action=ACTION_FORWARD):
"""
Generate traffic, send and verify it
Args:
duthost1: DUT host object
duthost2: DUT host object
ptfadapter: PTF adapter
ptfhost: PTF host object
src_port: Source port from which pkt will be sent
dst_ip: Destination ip address
get_routes: Dict with routes for each DUT
collect: Fixture which collects main info about link connection
down_link_on_dut: Name of DUT on which link is down
pkt_action: Action to verify, forward or drop
"""
router1_mac = duthost1.facts["router_mac"]
router2_mac = duthost2.facts["router_mac"]
dst_ports = get_dst_port(duthost1, duthost2, get_routes, dst_ip, collect)
src_port = get_port_number(ptfhost, src_port)
pkt = craft_pkt(ptfadapter, router_mac, src_port, dst_ip)
expected_src_mac = router1_mac if dst_ports == collect[
duthost1.hostname]['vm_link_on_ptf'] else router2_mac
exp_pkt = pkt.copy()
if down_link_on_dut:
exp_ttl = predict_exp_ttl(duthost1, duthost2, dst_ip, down_link_on_dut)
exp_pkt[packet.IP].ttl = exp_ttl
exp_pkt[packet.Ether].src = unicode(expected_src_mac)
exp_pkt = mask.Mask(exp_pkt)
exp_pkt.set_do_not_care_scapy(packet.Ether, "dst")
exp_pkt.set_do_not_care_scapy(packet.IP, "id")
exp_pkt.set_do_not_care_scapy(packet.IP, "chksum")
exp_pkt.set_do_not_care_scapy(packet.TCP, "chksum")
if not down_link_on_dut:
exp_pkt.set_do_not_care_scapy(packet.IP, "ttl")
ptfadapter.dataplane.flush()
time.sleep(2)
logger.info(
"Sending pkt from port {} to dst_ip = {}, expected dst_port = {}".
format(src_port, dst_ip, dst_ports))
logger.info(pkt.sprintf("%Ether.src% %IP.src% -> %Ether.dst% %IP.dst%"))
testutils.send(ptfadapter, src_port, pkt)
if pkt_action == ACTION_FORWARD:
testutils.verify_packet(ptfadapter, exp_pkt, dst_ports)
elif pkt_action == ACTION_DROP:
testutils.verify_no_packet(ptfadapter, exp_pkt, dst_ports)
def run_test_ipv4(ptfadapter, gather_facts):
logger.info("Running test with ipv4 packets")
dst_host_ipv4 = str(
ip_address(unicode(gather_facts['dst_router_ipv4'])) + 1)
pkt = testutils.simple_udp_packet(eth_dst=gather_facts['src_router_mac'],
eth_src=gather_facts['src_host_mac'],
ip_src=dst_host_ipv4,
ip_dst=dst_host_ipv4,
ip_ttl=DEFAULT_HLIM_TTL)
logger.info("\nSend Packet:\neth_dst: {}, eth_src: {}, ipv6 ip: {}".format(
gather_facts['src_router_mac'], gather_facts['src_host_mac'],
dst_host_ipv4))
testutils.send(ptfadapter, int(gather_facts['src_port_ids'][0]), pkt)
pkt = testutils.simple_udp_packet(eth_dst=gather_facts['dst_host_mac'],
eth_src=gather_facts['dst_router_mac'],
ip_src=dst_host_ipv4,
ip_dst=dst_host_ipv4,
ip_ttl=DEFAULT_HLIM_TTL - 1)
logger.info(
"\nExpect Packet:\neth_dst: {}, eth_src: {}, ipv6 ip: {}".format(
gather_facts['dst_host_mac'], gather_facts['dst_router_mac'],
dst_host_ipv4))
port_list = [int(port) for port in gather_facts['dst_port_ids']]
testutils.verify_packet_any_port(ptfadapter,
pkt,
port_list,
timeout=WAIT_EXPECTED_PACKET_TIMEOUT)
def test_swap_labelstack(self, setup, ptfadapter):
""" test swap labelstack """
dst_pid = setup['dst_pid']
src_pid = setup['src_pid']
self.config_interface_mpls(setup, LABEL_SWAP_ROUTES)
time.sleep(2)
pkt = self.mpls_stack_packet(setup, ptfadapter)
exp_pkt = self.expected_mask_mpls_swap_packet(pkt, 1000002)
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, src_pid, pkt)
try:
res = testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
ports=[dst_pid])
logger.info(res)
except Exception as e:
self.teardown_labels(setup)
pytest.fail('MPLS swap labelstack test failed \n' + str(e))
self.teardown_labels(setup)
def send_and_verify_traffic(ptfadapter,
pkt,
exp_pkt,
src_port,
dst_port,
pkt_action=ACTION_FORWARD):
"""
Send traffic and verify that traffic was received
Args:
ptfadapter: PTF adapter
pkt: Packet that should be sent
exp_pkt: Expected packet
src_port: Source port
dst_port: Destination port
pkt_action: Packet action (forward or drop)
"""
ptfadapter.dataplane.flush()
logger.info("Send packet from port {} to port {}".format(
src_port, dst_port))
testutils.send(ptfadapter, src_port, pkt)
if pkt_action == ACTION_FORWARD:
testutils.verify_packet(ptfadapter, exp_pkt, dst_port)
elif pkt_action == ACTION_DROP:
testutils.verify_no_packet(ptfadapter, exp_pkt, dst_port)
def send_and_verify_packet(ptfadapter, packet, expected_packet, tx_port, rx_ports, exp_recv):
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, pkt=packet, port_id=tx_port)
if exp_recv:
testutils.verify_packet_any_port(ptfadapter, pkt=expected_packet, ports=rx_ports, timeout=5)
else:
testutils.verify_no_packet_any(ptfadapter, pkt=expected_packet, ports=rx_ports)
def test_push_label(self, setup, ptfadapter):
""" test push label """
dst_pid = setup['dst_pid']
src_pid = setup['src_pid']
self.config_interface_mpls(setup, LABEL_PUSH_ROUTES)
time.sleep(2)
pkt = self.icmp_packet(setup, ptfadapter)
epkt = pkt.copy()
pkt1 = epkt['IP']
epkt['Ethernet'].type = 0x8847
epkt['Ethernet'].remove_payload()
mp = MPLS(label=1000002, s=1, ttl=255)
mp.remove_payload()
epkt /= mp
epkt /= pkt1
exp_pkt = self.expected_mask_mpls_push_packet(epkt, 1000001)
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, src_pid, pkt)
try:
res = testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
ports=[dst_pid])
logger.info(res)
except Exception as e:
self.teardown_labels(setup)
pytest.fail('MPLS push test failed \n' + str(e))
self.teardown_labels(setup)
def generate_and_verify_traffic(duthost, ptfadapter, ip_dst, expected_ports, ipv6=False):
if ipv6:
pkt = testutils.simple_tcpv6_packet(
eth_dst=duthost.facts["router_mac"],
eth_src=ptfadapter.dataplane.get_mac(0, 0),
ipv6_src='2001:db8:85a3::8a2e:370:7334',
ipv6_dst=ip_dst,
ipv6_hlim=64,
tcp_sport=1234,
tcp_dport=4321)
else:
pkt = testutils.simple_tcp_packet(
eth_dst=duthost.facts["router_mac"],
eth_src=ptfadapter.dataplane.get_mac(0, 0),
ip_src='1.1.1.1',
ip_dst=ip_dst,
ip_ttl=64,
tcp_sport=1234,
tcp_dport=4321)
exp_pkt = pkt.copy()
exp_pkt = mask.Mask(exp_pkt)
exp_pkt.set_do_not_care_scapy(packet.Ether, 'dst')
exp_pkt.set_do_not_care_scapy(packet.Ether, 'src')
if ipv6:
exp_pkt.set_do_not_care_scapy(packet.IPv6, 'hlim')
exp_pkt.set_do_not_care_scapy(packet.IPv6, 'chksum')
else:
exp_pkt.set_do_not_care_scapy(packet.IP, 'ttl')
exp_pkt.set_do_not_care_scapy(packet.IP, 'chksum')
testutils.send(ptfadapter, 5, pkt)
testutils.verify_packet_any_port(ptfadapter, exp_pkt, ports=expected_ports)
def verify_traffic(duthost,
connection,
route,
is_duthost_active=True,
is_route_existed=True):
prefix = ipaddress.ip_network(route["prefix"])
dst_host = str(next(prefix.hosts()))
pkt, exp_pkt = build_packet_to_server(duthost, ptfadapter, dst_host)
ptf_t1_intf = random.choice(get_t1_ptf_ports(duthost, tbinfo))
ptf_t1_intf_index = int(ptf_t1_intf.strip("eth"))
is_tunnel_traffic_existed = is_route_existed and not is_duthost_active
is_server_traffic_existed = is_route_existed and is_duthost_active
if isinstance(prefix, ipaddress.IPv4Network):
tunnel_innner_pkt = pkt[scapyall.IP].copy()
tunnel_innner_pkt[scapyall.IP].ttl -= 1
else:
tunnel_innner_pkt = pkt[scapyall.IPv6].copy()
tunnel_innner_pkt[scapyall.IPv6].hlim -= 1
tunnel_monitor = tunnel_traffic_monitor(
duthost,
existing=is_tunnel_traffic_existed,
inner_packet=tunnel_innner_pkt)
server_traffic_monitor = ServerTrafficMonitor(
duthost,
ptfhost,
vmhost,
tbinfo,
connection["test_intf"],
conn_graph_facts,
exp_pkt,
existing=is_server_traffic_existed)
with tunnel_monitor, server_traffic_monitor:
testutils.send(ptfadapter, ptf_t1_intf_index, pkt, count=10)
def test_drop_ip_packet_with_wrong_0xffff_chksum(self, duthost, ptfadapter, common_param):
# GIVEN a random normal ip packet, and manually modify checksum to 0xffff
# WHEN send the packet to DUT
# THEN DUT should drop it and add drop count
(peer_ip_ifaces_pair, ptf_port_idx, pc_ports_map, ptf_indices) = common_param
pkt = testutils.simple_ip_packet(
eth_dst=duthost.facts["router_mac"],
eth_src=ptfadapter.dataplane.get_mac(0, ptf_port_idx),
ip_src=peer_ip_ifaces_pair[0][0],
ip_dst=peer_ip_ifaces_pair[1][0])
pkt.payload.chksum = 0xffff
out_ifaces = TestIPPacket.parse_interfaces(
duthost.command("show ip route %s" % peer_ip_ifaces_pair[1][0])["stdout_lines"],
pc_ports_map)
duthost.command("portstat -c")
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, ptf_port_idx, pkt, self.PKT_NUM)
time.sleep(5)
portstat_out = parse_portstat(duthost.command("portstat")["stdout_lines"])
rx_ok = int(portstat_out[peer_ip_ifaces_pair[0][1][0]]["rx_ok"].replace(",", ""))
rx_drp = int(portstat_out[peer_ip_ifaces_pair[0][1][0]]["rx_drp"].replace(",", ""))
tx_ok = TestIPPacket.sum_portstat_ifaces_counts(portstat_out, out_ifaces, "tx_ok")
tx_drp = TestIPPacket.sum_portstat_ifaces_counts(portstat_out, out_ifaces, "tx_drp")
pytest_assert(self.PKT_NUM_MIN <= rx_ok <= self.PKT_NUM_MAX, "rx_ok unexpected")
pytest_assert(self.PKT_NUM_MIN <= rx_drp <= self.PKT_NUM_MAX, "rx_drp unexpected")
pytest_assert(tx_ok <= self.PKT_NUM_ZERO, "tx_ok unexpected")
pytest_assert(tx_drp <= self.PKT_NUM_ZERO, "tx_drp unexpected")
def test_decap_active_tor(apply_active_state_to_orchagent,
build_encapsulated_packet, rand_selected_interface,
ptfadapter, tbinfo, rand_selected_dut,
tunnel_traffic_monitor):
tor = rand_selected_dut
encapsulated_packet = build_encapsulated_packet
iface, _ = rand_selected_interface
exp_ptf_port_index = get_ptf_server_intf_index(tor, tbinfo, iface)
exp_pkt = build_expected_packet_to_server(encapsulated_packet)
ptfadapter.dataplane.flush()
ptf_t1_intf = random.choice(get_t1_ptf_ports(tor, tbinfo))
logging.info("send encapsulated packet from ptf t1 interface %s",
ptf_t1_intf)
testutils.send(ptfadapter,
int(ptf_t1_intf.strip("eth")),
encapsulated_packet,
count=10)
_, rec_pkt = testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
ports=[exp_ptf_port_index])
rec_pkt = Ether(rec_pkt)
logging.info("received decap packet:\n%s",
tunnel_traffic_monitor._dump_show_str(rec_pkt))
exp_ttl = encapsulated_packet[IP].payload[IP].ttl - 1
exp_tos = encapsulated_packet[IP].payload[IP].tos
if rec_pkt[IP].ttl != exp_ttl:
pytest.fail("the expected ttl should be %s" % exp_ttl)
if rec_pkt[IP].tos != exp_tos:
pytest.fail("the expected tos should be %s" % exp_tos)
def send_recv_ping_packet(ptfadapter, ptf_send_port, ptf_recv_ports, dst_mac,
src_ip, dst_ip):
pkt = testutils.simple_icmp_packet(eth_dst=dst_mac,
ip_src=src_ip,
ip_dst=dst_ip,
icmp_type=8,
icmp_data="")
ext_pkt = pkt.copy()
ext_pkt['Ether'].src = dst_mac
masked_exp_pkt = Mask(ext_pkt)
masked_exp_pkt.set_do_not_care_scapy(scapy.Ether, "dst")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "tos")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "len")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "id")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "flags")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "frag")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "ttl")
masked_exp_pkt.set_do_not_care_scapy(scapy.IP, "chksum")
masked_exp_pkt.set_do_not_care_scapy(scapy.ICMP, "code")
masked_exp_pkt.set_do_not_care_scapy(scapy.ICMP, "chksum")
masked_exp_pkt.set_do_not_care_scapy(scapy.ICMP, "id")
masked_exp_pkt.set_do_not_care_scapy(scapy.ICMP, "seq")
logger.info(
'send ping request packet send port {}, recv port {}, dmac: {}, dip: {}'
.format(ptf_send_port, ptf_recv_ports, dst_mac, dst_ip))
testutils.send(ptfadapter, ptf_send_port, pkt)
testutils.verify_packet_any_port(ptfadapter,
masked_exp_pkt,
ptf_recv_ports,
timeout=WAIT_EXPECTED_PACKET_TIMEOUT)
def testDhcpPacketForwarding(self, duthost, testPorts, ptfadapter,
pktInfo):
"""
Validates that DHCP Discover/Offer/Request/Ack (DORA) packets are forwarded through T1 devices
Args:
duthost(Ansible Fixture): instance of SonicHost class of DUT
testPorts(Ansible Fixture, dict): contains downstream/upstream test ports information
ptfadapter(Ansible Fixture): instance of PTF Adapter
pktInfo(Pytest Params<dict>): test parameters containing information on which ports used for
sending/receiving DHCP packet and
DHCP packet to send
"""
ptfadapter.dataplane.flush()
dhcpPacket = pktInfo["pktGen"](duthost.facts["router_mac"])
testutils.send(ptfadapter, random.choice(testPorts[pktInfo["txDir"]]),
dhcpPacket)
# Update fields of the forwarded packet
dhcpPacket[scapy.Ether].src = duthost.facts["router_mac"]
dhcpPacket[
scapy.IP].ttl = dhcpPacket[scapy.IP].ttl - duthost.ttl_decr_value
expectedDhcpPacket = Mask(dhcpPacket)
expectedDhcpPacket.set_do_not_care_scapy(scapy.Ether, "dst")
expectedDhcpPacket.set_do_not_care_scapy(scapy.IP, "chksum")
_, receivedPacket = testutils.verify_packet_any_port(
ptfadapter, expectedDhcpPacket, ports=testPorts[pktInfo["rxDir"]])
logger.info("Received packet: %s",
scapy.Ether(receivedPacket).summary())
def test_decap_standby_tor(apply_mock_dual_tor_tables,
apply_mock_dual_tor_kernel_configs,
apply_standby_state_to_orchagent,
build_encapsulated_packet, rand_selected_interface,
ptfadapter, tbinfo, rand_selected_dut,
tunnel_traffic_monitor):
tor = rand_selected_dut
encapsulated_packet = build_encapsulated_packet
iface, _ = rand_selected_interface
exp_ptf_port_index = get_ptf_server_intf_index(tor, tbinfo, iface)
exp_pkt = build_expected_packet_to_server(encapsulated_packet)
ptf_t1_intf = random.choice(get_t1_ptf_ports(tor, tbinfo))
logging.info("send encapsulated packet from ptf t1 interface %s",
ptf_t1_intf)
with tunnel_traffic_monitor(tor, existing=False):
testutils.send(ptfadapter,
int(ptf_t1_intf.strip("eth")),
encapsulated_packet,
count=1)
testutils.verify_no_packet_any(ptfadapter,
exp_pkt,
ports=[exp_ptf_port_index])
def run_test_ipv4(ptfadapter, facts):
logger.info("Running test with ipv4 packets")
pkt = testutils.simple_udp_packet(eth_dst=facts['src_router_mac'],
eth_src=facts['src_host_mac'],
ip_src=facts['dst_host_ipv4'],
ip_dst=facts['dst_host_ipv4'],
ip_ttl=DEFAULT_HLIM_TTL)
logger.info("\nSend Packet:\neth_dst: {}, eth_src: {}, ipv4 ip: {}".format(
facts['src_router_mac'], facts['src_host_mac'],
facts['dst_host_ipv4']))
testutils.send(ptfadapter, facts['src_port_ids'][0], pkt)
exp_pkt = testutils.simple_udp_packet(eth_dst=facts['dst_host_mac'],
eth_src=facts['dst_router_mac'],
ip_src=facts['dst_host_ipv4'],
ip_dst=facts['dst_host_ipv4'],
ip_ttl=DEFAULT_HLIM_TTL - 1)
logger.info(
"\nExpect Packet:\neth_dst: {}, eth_src: {}, ipv4 ip: {}".format(
facts['dst_host_mac'], facts['dst_router_mac'],
facts['dst_host_ipv4']))
testutils.verify_packet_any_port(ptfadapter,
exp_pkt,
facts['dst_port_ids'],
timeout=WAIT_EXPECTED_PACKET_TIMEOUT)
def send_arp_request(ptfadapter, source_port, source_mac, dest_mac, vlan_id):
"""
send arp request packet
:param ptfadapter: PTF adapter object
:param source_port: source port
:param source_mac: source MAC
:param dest_mac: destination MAC
:param vlan_id: VLAN id
:return:
"""
pkt = testutils.simple_arp_packet(
pktlen=60,
eth_dst=dest_mac,
eth_src=source_mac,
vlan_vid=vlan_id,
vlan_pcp=0,
arp_op=1,
ip_snd='10.10.1.3',
ip_tgt='10.10.1.2',
hw_snd=source_mac,
hw_tgt='ff:ff:ff:ff:ff:ff',
)
logger.debug(
'send ARP request packet source port id {} smac: {} dmac: {} vlan: {}'.
format(source_port, source_mac, dest_mac, vlan_id))
testutils.send(ptfadapter, source_port, pkt)
def test_ecn_during_decap_on_active(
apply_active_state_to_orchagent,
build_encapsulated_ip_packet,
rand_selected_interface,
ptfadapter,
tbinfo,
rand_selected_dut,
tunnel_traffic_monitor
):
"""
Test if the ECN stamping on inner header is matching with outer during decap on active
"""
tor = rand_selected_dut
encapsulated_packet = build_encapsulated_ip_packet
iface, _ = rand_selected_interface
exp_ptf_port_index = get_ptf_server_intf_index(tor, tbinfo, iface)
exp_pkt = build_expected_packet_to_server(encapsulated_packet)
ptfadapter.dataplane.flush()
ptf_t1_intf = random.choice(get_t1_ptf_ports(tor, tbinfo))
logging.info("send encapsulated packet from ptf t1 interface %s", ptf_t1_intf)
testutils.send(ptfadapter, int(ptf_t1_intf.strip("eth")), encapsulated_packet, count=10)
time.sleep(10)
exp_tos = encapsulated_packet[IP].payload[IP].tos
exp_ecn = exp_tos & 3
verify_ecn_on_received_packet(ptfadapter, exp_pkt, exp_ptf_port_index, exp_ecn)
def test_dscp_to_queue_during_encap_on_standby(
build_non_encapsulated_ip_packet,
rand_selected_interface, ptfadapter,
tbinfo,
rand_selected_dut,
tunnel_traffic_monitor,
duthosts,
rand_one_dut_hostname
):
"""
Test if DSCP to Q mapping for outer header is matching with inner header during encap on standby
"""
rand_selected_dut.shell("/usr/local/bin/write_standby.py")
tor = rand_selected_dut
non_encapsulated_packet = build_non_encapsulated_ip_packet
iface, _ = rand_selected_interface
exp_ptf_port_index = get_ptf_server_intf_index(tor, tbinfo, iface)
# Clear queue counters
duthost = duthosts[rand_one_dut_hostname]
duthost.shell('sonic-clear queuecounters')
logging.info("Clearing queue counters before starting traffic")
ptfadapter.dataplane.flush()
ptf_t1_intf = random.choice(get_t1_ptf_ports(tor, tbinfo))
logging.info("send IP packet from ptf t1 interface %s", ptf_t1_intf)
with tunnel_traffic_monitor(tor, existing=True):
testutils.send(ptfadapter, int(ptf_t1_intf.strip("eth")), non_encapsulated_packet, count=10)
def test_vlan_tc3_send_invalid_vid(ptfadapter, vlan_ports_list):
"""
Test case #3
Send packets with invalid VLAN ID
Verify no port can receive these pacekts
"""
logger.info("Test case #3 starting ...")
invalid_tagged_pkt = build_icmp_packet(4095)
masked_invalid_tagged_pkt = Mask(invalid_tagged_pkt)
masked_invalid_tagged_pkt.set_do_not_care_scapy(scapy.Dot1Q, "vlan")
for vlan_port in vlan_ports_list:
src_port = vlan_port["port_index"]
dst_ports = [
port["port_index"] for port in vlan_ports_list if port != vlan_port
]
logger.info("Send invalid tagged packet " + " from " + str(src_port) +
"...")
logger.info(
invalid_tagged_pkt.sprintf(
"%Ether.src% %IP.src% -> %Ether.dst% %IP.dst%"))
testutils.send(ptfadapter, src_port, invalid_tagged_pkt)
logger.info("Check on " + str(dst_ports) + "...")
testutils.verify_no_packet_any(ptfadapter, masked_invalid_tagged_pkt,
dst_ports)
def test_vlan_tc1_send_untagged(
ptfadapter, work_vlan_ports_list,
toggle_all_simulator_ports_to_rand_selected_tor_m):
"""
Test case #1
Verify packets egress without tag from ports whose PVID same with ingress port
Verify packets egress with tag from ports who include VLAN ID but PVID different from ingress port.
"""
logger.info("Test case #1 starting ...")
for vlan_port in work_vlan_ports_list:
pkt = build_icmp_packet(0)
logger.info("Send untagged packet from {} ...".format(
vlan_port["port_index"][0]))
logger.info(
pkt.sprintf("%Ether.src% %IP.src% -> %Ether.dst% %IP.dst%"))
if vlan_port['pvid'] != 0:
testutils.send(ptfadapter, vlan_port["port_index"][0], pkt)
verify_icmp_packets(ptfadapter, work_vlan_ports_list, vlan_port,
vlan_port["pvid"])
else:
exp_pkt = Mask(pkt)
exp_pkt.set_do_not_care_scapy(scapy.Dot1Q, "vlan")
dst_ports = []
for port in work_vlan_ports_list:
dst_ports += port["port_index"] if port != vlan_port else []
testutils.send(ptfadapter, vlan_port["port_index"][0], pkt)
logger.info("Check on " + str(dst_ports) + "...")
testutils.verify_no_packet_any(ptfadapter, exp_pkt, dst_ports)
def test_tagged_arp_pkt(ptfadapter, vlan_ports_list, duthosts, rand_one_dut_hostname, toggle_all_simulator_ports_to_rand_selected_tor):
"""
Send tagged GARP packets from each port.
Verify packets egress without tag from ports whose PVID same with ingress port.
Verify packets egress with tag from ports who include VLAN ID but PVID different from ingress port.
verify show arp command on DUT.
"""
duthost = duthosts[rand_one_dut_hostname]
for vlan_port in vlan_ports_list:
port_index = vlan_port["port_index"][0]
# Send GARP packets to switch to populate the arp table with dummy MACs for each port
# Totally 10 dummy MACs for each port, send 1 packet for each dummy MAC
# ARP table will be cleaned up before each iteration, so there won't be any conflict MAC and IP
dummy_macs = ['{}:{:02x}:{:02x}'.format(DUMMY_MAC_PREFIX, port_index&0xFF, i+1)
for i in range(DUMMY_ARP_COUNT)]
dummy_ips = ['{}.{:d}.{:d}'.format(DUMMY_IP_PREFIX, port_index&0xFF, i+1)
for i in range(DUMMY_ARP_COUNT)]
for permit_vlanid in map(int, vlan_port["permit_vlanid"]):
logger.info('Test ARP: interface %s, VLAN %u' % (vlan_port["dev"], permit_vlanid))
# Perform ARP clean up
arp_cleanup(duthost)
for i in range(DUMMY_ARP_COUNT):
pkt = build_arp_packet(permit_vlanid, dummy_macs[i], dummy_ips[i])
exp_untagged_pkt = build_arp_packet(0, dummy_macs[i], dummy_ips[i])
# vlan priority attached to packets is determined by the port, so we ignore it here
exp_tagged_pkt = Mask(pkt)
exp_tagged_pkt.set_do_not_care_scapy(scapy.Dot1Q, "prio")
logger.info("Send tagged({}) packet from {} ...".format(permit_vlanid, port_index))
testutils.send(ptfadapter, port_index, pkt)
verify_arp_packets(ptfadapter, vlan_ports_list, vlan_port, permit_vlanid, exp_untagged_pkt, exp_tagged_pkt)
res = duthost.command('show arp')
assert res['rc'] == 0
logger.info('"show arp" output on DUT:\n{}'.format(pprint.pformat(res['stdout_lines'])))
arp_cnt = 0
for l in res['stdout_lines']:
# Address MacAddress Iface Vlan
items = l.split()
if len(items) != 4:
continue
# Vlan must be number
if not items[3].isdigit():
continue
arp_cnt += 1
ip = items[0]
mac = items[1]
ifname = items[2]
vlan_id = int(items[3])
assert ip in dummy_ips
assert mac in dummy_macs
# 'show arp' command gets iface from FDB table,
# if 'show arp' command was earlier than FDB table update, ifname would be '-'
if ifname == '-':
logger.info('Ignore unknown iface...')
else:
assert ifname == vlan_port["dev"]
assert vlan_id == permit_vlanid
assert arp_cnt == DUMMY_ARP_COUNT
def send_recv_eth(duthost, ptfadapter, source_ports, source_mac, dest_ports,
dest_mac, src_vlan, dst_vlan):
"""
send ethernet packet and verify it on dest_port
:param ptfadapter: PTF adapter object
:param source_port: source port
:param source_mac: source MAC
:param dest_port: destination port to receive packet on
:param dest_mac: destination MAC
:param vlan_id: VLAN id
:return:
"""
pkt = simple_eth_packet(eth_dst=dest_mac,
eth_src=source_mac,
vlan_vid=src_vlan)
exp_pkt = simple_eth_packet(eth_dst=dest_mac,
eth_src=source_mac,
vlan_vid=dst_vlan)
if dst_vlan:
# expect to receive tagged packet:
# sonic device might modify the 802.1p field,
# need to use Mask to ignore the priority field.
exp_pkt = Mask(exp_pkt)
exp_pkt.set_do_not_care_scapy(scapy.Dot1Q, "prio")
logger.debug(
'send packet src port {} smac: {} dmac: {} vlan: {} verifying on dst port {}'
.format(source_ports, source_mac, dest_mac, src_vlan, dest_ports))
# fdb test will send lots of pkts between paired ports, it's hard to guarantee there is no congestion
# on server side during this period. So tolerant to retry 3 times before complain the assert.
retry_count = 3
for _ in range(retry_count):
try:
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, source_ports[0], pkt)
if len(dest_ports) == 1:
testutils.verify_packet(
ptfadapter,
exp_pkt,
dest_ports[0],
timeout=FDB_WAIT_EXPECTED_PACKET_TIMEOUT)
else:
testutils.verify_packet_any_port(
ptfadapter,
exp_pkt,
dest_ports,
timeout=FDB_WAIT_EXPECTED_PACKET_TIMEOUT)
break
except:
pass
else:
result = duthost.command("show mac", module_ignore_errors=True)
logger.debug("Show mac results {}".format(result['stdout']))
pytest_assert(
False, "Expected packet was not received on ports {}"
"Dest MAC in fdb is {}".format(
dest_ports,
dest_mac.lower() in result['stdout'].lower()))
def test_snmp_fdb_send_tagged(
ptfadapter, utils_vlan_ports_list,
toggle_all_simulator_ports_to_rand_selected_tor_m, duthost, localhost,
creds_all_duts):
"""
Send tagged packets from each port.
Verify SNMP FDB entry
"""
cfg_facts = duthost.config_facts(host=duthost.hostname,
source="persistent")['ansible_facts']
config_portchannels = cfg_facts.get('PORTCHANNEL', {})
send_cnt = 0
send_portchannels_cnt = 0
for vlan_port in utils_vlan_ports_list:
port_index = vlan_port["port_index"][0]
for permit_vlanid in map(int, vlan_port["permit_vlanid"]):
dummy_mac = '{}:{:02x}:{:02x}'.format(DUMMY_MAC_PREFIX,
(port_index >> 8) & 0xFF,
port_index & 0xFF)
pkt = build_icmp_packet(permit_vlanid, dummy_mac)
logger.info("Send tagged({}) packet from {} ...".format(
permit_vlanid, port_index))
logger.info(
pkt.sprintf("%Ether.src% %IP.src% -> %Ether.dst% %IP.dst%"))
testutils.send(ptfadapter, port_index, pkt)
send_cnt += 1
if vlan_port['dev'] in config_portchannels:
send_portchannels_cnt += 1
# Flush dataplane
ptfadapter.dataplane.flush()
hostip = duthost.host.options['inventory_manager'].get_host(
duthost.hostname).vars['ansible_host']
snmp_facts = get_snmp_facts(
localhost,
host=hostip,
version="v2c",
community=creds_all_duts[duthost]["snmp_rocommunity"],
wait=True)['ansible_facts']
assert 'snmp_fdb' in snmp_facts
assert 'snmp_interfaces' in snmp_facts
dummy_mac_cnt = 0
recv_portchannels_cnt = 0
for key in snmp_facts['snmp_fdb']:
# key is string: vlan.mac
items = key.split('.')
if len(items) != 2:
continue
logger.info("FDB entry: {}".format(items))
if DUMMY_MAC_PREFIX in items[1]:
dummy_mac_cnt += 1
idx = str(snmp_facts['snmp_fdb'][key])
assert idx in snmp_facts['snmp_interfaces']
assert 'name' in snmp_facts['snmp_interfaces'][idx]
if snmp_facts['snmp_interfaces'][idx][
'name'] in config_portchannels:
recv_portchannels_cnt += 1
assert send_cnt == dummy_mac_cnt, "Dummy MAC count does not match"
assert send_portchannels_cnt == recv_portchannels_cnt, "Portchannels count does not match"
def send_packets(pkt, duthost, ptfadapter, ptf_tx_port_id, num_packets=1):
# Clear packets buffer on PTF
ptfadapter.dataplane.flush()
time.sleep(1)
# Send packets
testutils.send(ptfadapter, ptf_tx_port_id, pkt, count=num_packets)
time.sleep(1)
def test_unmatched_blocked(self, setup, direction, ptfadapter):
""" verify that unmatched packet is dropped """
pkt = self.tcp_packet(setup, direction, ptfadapter)
exp_pkt = self.expected_mask_routed_packet(pkt)
testutils.send(ptfadapter, self.get_src_port(setup, direction), pkt)
testutils.verify_no_packet_any(ptfadapter, exp_pkt, ports=self.get_dst_ports(setup, direction))
def verify_unicast_packets(ptfadapter, send_pkt, exp_pkt, src_port, dst_ports):
testutils.send(ptfadapter, src_port, send_pkt)
try:
testutils.verify_packets_any(ptfadapter, exp_pkt, ports=dst_ports)
except AssertionError as detail:
if "Did not receive expected packet on any of ports" in str(detail):
logger.error("Expected packet was not received")
raise
