def test_bgpmon_no_resolve_via_default(duthost, common_setup_teardown,
ptfadapter):
"""
Verify no syn for BGP is sent when 'ip nht resolve-via-default' is disabled.
"""
local_addr, peer_addr, peer_ports, asn = common_setup_teardown
exp_packet = build_syn_pkt(local_addr, peer_addr)
# Load bgp monitor config
logger.info(
"Configured bgpmon and verifying no packet on {} when resolve-via-default is disabled"
.format(peer_ports))
try:
# Disable resolve-via-default
duthost.command("vtysh -c \"configure terminal\" \
-c \"no ip nht resolve-via-default\"")
# Flush dataplane
ptfadapter.dataplane.flush()
duthost.command("sonic-cfggen -j {} -w".format(BGPMON_CONFIG_FILE))
# Verify no syn packet is received
pytest_assert(
0 == testutils.count_matched_packets_all_ports(
test=ptfadapter,
exp_packet=exp_packet,
ports=peer_ports,
timeout=BGP_CONNECT_TIMEOUT),
"Syn packets is captured when resolve-via-default is disabled")
finally:
# Re-enable resolve-via-default
duthost.command("vtysh -c \"configure terminal\" \
-c \"ip nht resolve-via-default\"")
def checkRegularRegularVLANtoLAG(self, acc_port, pc_ports, dst_ip, test):
rv = True
src_mac = self.ptf_mac_addrs['eth%d' % acc_port]
dst_mac = self.dut_mac
src_ip = test['vlan_ip_prefix'] % acc_port
packet = simple_tcp_packet(
eth_dst=dst_mac,
eth_src=src_mac,
ip_src=src_ip,
ip_dst=dst_ip,
)
exp_packet = simple_tcp_packet(
eth_dst=self.random_mac,
eth_src=dst_mac,
ip_src=src_ip,
ip_dst=dst_ip,
ip_ttl=63,
)
exp_packet = Mask(exp_packet)
exp_packet.set_do_not_care_scapy(scapy.Ether, "dst")
for i in xrange(self.nr):
testutils.send_packet(self, acc_port, packet)
if self.nr == 1:
rv = rv and verify_packet_any_port(self, exp_packet, pc_ports)
else:
rv = rv and self.nr == testutils.count_matched_packets_all_ports(
self, exp_packet, pc_ports, timeout=0.1)
return rv
def verify_relayed_request_relay_forward(self):
# Create a packet resembling a DHCPv6 RELAY-FORWARD encapsulating REQUEST packet
request_relay_forward_packet = self.create_dhcp_request_relay_forward_packet(
)
# Mask off fields we don't care about matching
masked_packet = Mask(request_relay_forward_packet)
masked_packet.set_do_not_care_scapy(packet.Ether, "dst")
masked_packet.set_do_not_care_scapy(IPv6, "src")
masked_packet.set_do_not_care_scapy(IPv6, "dst")
masked_packet.set_do_not_care_scapy(IPv6, "fl")
masked_packet.set_do_not_care_scapy(IPv6, "tc")
masked_packet.set_do_not_care_scapy(IPv6, "plen")
masked_packet.set_do_not_care_scapy(IPv6, "nh")
masked_packet.set_do_not_care_scapy(packet.UDP, "chksum")
masked_packet.set_do_not_care_scapy(packet.UDP, "len")
masked_packet.set_do_not_care_scapy(DHCP6OptClientLinkLayerAddr,
"clladdr")
masked_packet.set_do_not_care_scapy(
scapy.layers.dhcp6.DHCP6_RelayForward, "linkaddr")
# Count the number of these packets received on the ports connected to our leaves
request_count = testutils.count_matched_packets_all_ports(
self, masked_packet, self.server_port_indices)
self.assertTrue(request_count >= 1,
"Failed: Request count of %d" % request_count)
def ping0(self, eth_dst, ip_src, ip_dst, from_port, to_ports, msg):
packet = simple_tcp_packet(eth_dst=eth_dst,
ip_src=ip_src,
ip_dst=ip_dst,
tcp_dport=5000)
exp_packet = simple_tcp_packet(
ip_src=ip_src,
ip_dst=ip_dst,
ip_ttl=63,
tcp_dport=5000,
)
exp_packet = Mask(exp_packet)
exp_packet.set_do_not_care_scapy(scapy.Ether, "src")
exp_packet.set_do_not_care_scapy(scapy.Ether, "dst")
for i in xrange(self.nr_pkts):
testutils.send_packet(self, from_port, str(packet))
total_rcv_pkt_cnt = testutils.count_matched_packets_all_ports(
self, exp_packet, to_ports)
self.log(
"Send %5d Received %5d %s" %
(self.nr_pkts, total_rcv_pkt_cnt, msg), True)
return total_rcv_pkt_cnt
def pingFromServers(self):
packet = simple_tcp_packet(
eth_dst=self.dut_mac,
ip_src=self.from_server_src_addr,
ip_dst=self.from_server_dst_addr,
tcp_dport=5000
)
exp_packet = simple_tcp_packet(
ip_src=self.from_server_src_addr,
ip_dst=self.from_server_dst_addr,
ip_ttl=63,
tcp_dport=5000,
)
exp_packet = Mask(exp_packet)
exp_packet.set_do_not_care_scapy(scapy.Ether,"src")
exp_packet.set_do_not_care_scapy(scapy.Ether,"dst")
raw_packet = str(packet)
for i in xrange(self.nr_pc_pkts):
testutils.send_packet(self, self.from_server_src_port, raw_packet)
total_rcv_pkt_cnt = testutils.count_matched_packets_all_ports(self, exp_packet, self.from_server_dst_ports, timeout=self.TIMEOUT)
self.log("Send %5d Received %5d servers->t1" % (self.nr_pc_pkts, total_rcv_pkt_cnt), True)
return total_rcv_pkt_cnt
def verify_relayed_request(self):
# Create a packet resembling a relayed DCHPREQUEST packet
dhcp_request_relayed = self.create_dhcp_request_relayed_packet()
# Mask off fields we don't care about matching
masked_request = Mask(dhcp_request_relayed)
masked_request.set_do_not_care_scapy(scapy.Ether, "dst")
masked_request.set_do_not_care_scapy(scapy.IP, "version")
masked_request.set_do_not_care_scapy(scapy.IP, "ihl")
masked_request.set_do_not_care_scapy(scapy.IP, "tos")
masked_request.set_do_not_care_scapy(scapy.IP, "len")
masked_request.set_do_not_care_scapy(scapy.IP, "id")
masked_request.set_do_not_care_scapy(scapy.IP, "flags")
masked_request.set_do_not_care_scapy(scapy.IP, "frag")
masked_request.set_do_not_care_scapy(scapy.IP, "ttl")
masked_request.set_do_not_care_scapy(scapy.IP, "proto")
masked_request.set_do_not_care_scapy(scapy.IP, "chksum")
masked_request.set_do_not_care_scapy(scapy.IP, "src")
masked_request.set_do_not_care_scapy(scapy.IP, "dst")
masked_request.set_do_not_care_scapy(scapy.IP, "options")
masked_request.set_do_not_care_scapy(scapy.UDP, "chksum")
masked_request.set_do_not_care_scapy(scapy.UDP, "len")
masked_request.set_do_not_care_scapy(scapy.BOOTP, "sname")
masked_request.set_do_not_care_scapy(scapy.BOOTP, "file")
# Count the number of these packets received on the ports connected to our leaves
num_expected_packets = self.num_dhcp_servers
request_count = testutils.count_matched_packets_all_ports(self, masked_request, self.server_port_indices)
self.assertTrue(request_count == num_expected_packets,
"Failed: Request count of %d != %d" % (request_count, num_expected_packets))
def checkRegularRegularVLANtoLAG(self, acc_port, pc_ports, dst_ip, test):
src_mac = self.ptf_mac_addrs['eth%d' % acc_port]
dst_mac = self.dut_mac
src_ip = test['vlan_ip_prefix'] % acc_port
packet = simple_tcp_packet(
eth_dst=dst_mac,
eth_src=src_mac,
ip_src=src_ip,
ip_dst=dst_ip,
)
exp_packet = simple_tcp_packet(
eth_dst=self.random_mac,
eth_src=dst_mac,
ip_src=src_ip,
ip_dst=dst_ip,
ip_ttl=63,
)
exp_packet = Mask(exp_packet)
exp_packet.set_do_not_care_scapy(scapy.Ether, "dst")
for i in xrange(self.nr):
testutils.send_packet(self, acc_port, packet)
nr_rcvd = testutils.count_matched_packets_all_ports(self,
exp_packet,
pc_ports,
timeout=0.2)
rv = nr_rcvd == self.nr
out = ""
if not rv:
arg = self.nr, nr_rcvd, str(acc_port), str(
pc_ports), src_mac, dst_mac, src_ip, dst_ip
out = "sent = %d rcvd = %d | src_port=%s dst_ports=%s | src_mac=%s dst_mac=%s src_ip=%s dst_ip=%s" % arg
return rv, out
def pingDut(self):
for i in xrange(self.ping_dut_pkts):
testutils.send_packet(self, self.random_port(self.vlan_ports), self.ping_dut_packet)
total_rcv_pkt_cnt = testutils.count_matched_packets_all_ports(self, self.ping_dut_exp_packet, self.vlan_ports, timeout=self.TIMEOUT)
self.log("Send %5d Received %5d ping DUT" % (self.ping_dut_pkts, total_rcv_pkt_cnt), True)
return total_rcv_pkt_cnt
def pingFromUpperTier(self):
for entry in self.from_t1:
testutils.send_packet(self, *entry)
total_rcv_pkt_cnt = testutils.count_matched_packets_all_ports(self, self.from_t1_exp_packet, self.vlan_ports, timeout=self.TIMEOUT)
self.log("Send %5d Received %5d t1->servers" % (self.nr_vl_pkts, total_rcv_pkt_cnt), True)
return total_rcv_pkt_cnt
def pingFromServers(self):
for i in xrange(self.nr_pc_pkts):
testutils.send_packet(self, self.from_server_src_port, self.from_vlan_packet)
total_rcv_pkt_cnt = testutils.count_matched_packets_all_ports(self, self.from_vlan_exp_packet, self.from_server_dst_ports, timeout=self.TIMEOUT)
self.log("Send %5d Received %5d servers->t1" % (self.nr_pc_pkts, total_rcv_pkt_cnt), True)
return total_rcv_pkt_cnt
def test_forward_ip_packet_recomputed_0xffff_chksum(self, duthost, ptfadapter, common_param):
# GIVEN a ip packet, after forwarded(ttl-1) by DUT,
# it's checksum will be 0xffff after wrongly incrementally recomputed
# ref to https://datatracker.ietf.org/doc/html/rfc1624
# HC' = HC(0xff00) + m(0x7a2f) + ~m'(~0x792f)= 0xffff
# WHEN send the packet to DUT
# THEN DUT recompute new checksum correctly and forward packet as expected.
(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),
pktlen=1246,
ip_src="10.250.40.40",
ip_dst="10.156.190.188",
ip_proto=47,
ip_tos=0x84,
ip_id=0,
ip_ihl=5,
ip_ttl=122,
)
pkt.payload.flags = 2
exp_pkt = pkt.copy()
exp_pkt.payload.ttl = 121
exp_pkt.payload.chksum = 0x0001
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')
out_ifaces = TestIPPacket.parse_interfaces(duthost.command("show ip route 10.156.190.188")["stdout_lines"],
pc_ports_map)
out_ptf_indices = map(lambda iface: ptf_indices[iface], out_ifaces)
duthost.command("portstat -c")
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, ptf_port_idx, pkt, self.PKT_NUM)
time.sleep(5)
match_cnt = testutils.count_matched_packets_all_ports(ptfadapter, exp_pkt, ports=out_ptf_indices)
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(match_cnt == self.PKT_NUM, "Packet lost")
pytest_assert(self.PKT_NUM_MIN <= rx_ok <= self.PKT_NUM_MAX, "rx_ok unexpected")
pytest_assert(self.PKT_NUM_MIN <= tx_ok <= self.PKT_NUM_MAX, "tx_ok unexpected")
pytest_assert(rx_drp <= self.PKT_NUM_ZERO, "rx_drp unexpected")
pytest_assert(tx_drp <= self.PKT_NUM_ZERO, "tx_drp unexpected")
def test_forward_ip_packet_with_0xffff_chksum_drop(self, duthost, ptfadapter, common_param):
# GIVEN a ip packet with checksum 0x0000(compute from scratch)
# WHEN manually set checksum as 0xffff and send the packet to DUT
# THEN DUT should drop packet with 0xffff 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),
pktlen=1246,
ip_src="10.250.136.195",
ip_dst="10.156.94.34",
ip_proto=47,
ip_tos=0x84,
ip_id=0,
ip_ihl=5,
ip_ttl=121,
)
pkt.payload.flags = 2
pkt.payload.chksum = 0xffff
exp_pkt = pkt.copy()
exp_pkt.payload.ttl = 120
exp_pkt.payload.chksum = 0x0100
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')
out_ifaces = TestIPPacket.parse_interfaces(duthost.command("show ip route 10.156.94.34")["stdout_lines"],
pc_ports_map)
out_ptf_indices = map(lambda iface: ptf_indices[iface], out_ifaces)
duthost.command("portstat -c")
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, ptf_port_idx, pkt, self.PKT_NUM)
time.sleep(5)
match_cnt = testutils.count_matched_packets_all_ports(ptfadapter, exp_pkt, ports=out_ptf_indices)
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(match_cnt == 0, "Packet not dropped")
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_drp <= self.PKT_NUM_ZERO, "tx_drp unexpected")
pytest_assert(tx_ok <= self.PKT_NUM_ZERO, "tx_ok unexpected")
def verify_isc_relayed_request_relay_forward(self):
global isc_request_count
isc_request_relay_forward_packet = self.isc_create_dhcp_request_relay_forward_packet(
)
# Temporary for isc-dhcp
isc_masked_packet = Mask(isc_request_relay_forward_packet)
isc_masked_packet.set_do_not_care_scapy(packet.Ether, "dst")
isc_masked_packet.set_do_not_care_scapy(IPv6, "src")
isc_masked_packet.set_do_not_care_scapy(IPv6, "dst")
isc_masked_packet.set_do_not_care_scapy(IPv6, "fl")
isc_masked_packet.set_do_not_care_scapy(IPv6, "tc")
isc_masked_packet.set_do_not_care_scapy(IPv6, "plen")
isc_masked_packet.set_do_not_care_scapy(IPv6, "nh")
isc_masked_packet.set_do_not_care_scapy(packet.UDP, "chksum")
isc_masked_packet.set_do_not_care_scapy(packet.UDP, "len")
# Count number of packets relayed by isc-dhcp
isc_request_count = testutils.count_matched_packets_all_ports(
self, isc_masked_packet, self.server_port_indices)
def test_forward_normal_ip_packet(self, duthost, ptfadapter, common_param):
# GIVEN a random normal ip packet
# WHEN send the packet to DUT
# THEN DUT should forward it as normal ip packet, nothing change but ttl-1
(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])
exp_pkt = pkt.copy()
exp_pkt.payload.ttl = pkt.payload.ttl - 1
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')
out_ifaces = TestIPPacket.parse_interfaces(
duthost.command("show ip route %s" % peer_ip_ifaces_pair[1][0])["stdout_lines"],
pc_ports_map)
out_ptf_indices = map(lambda iface: ptf_indices[iface], out_ifaces)
duthost.command("portstat -c")
ptfadapter.dataplane.flush()
testutils.send(ptfadapter, ptf_port_idx, pkt, self.PKT_NUM)
time.sleep(5)
match_cnt = testutils.count_matched_packets_all_ports(ptfadapter, exp_pkt, ports=out_ptf_indices)
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(match_cnt == self.PKT_NUM, "Packet lost")
pytest_assert(self.PKT_NUM_MIN <= rx_ok <= self.PKT_NUM_MAX, "rx_ok unexpected")
pytest_assert(self.PKT_NUM_MIN <= tx_ok <= self.PKT_NUM_MAX, "tx_ok unexpected")
pytest_assert(rx_drp <= self.PKT_NUM_ZERO, "rx_drp unexpected")
pytest_assert(tx_drp <= self.PKT_NUM_ZERO, "tx_drp unexpected")
def verify_relayed_relay_forward(self):
# Create a packet resembling a DHCPv6 RELAYED RELAY FORWARD packet
relayed_relay_forward_count = self.create_dhcp_relayed_relay_packet()
# Mask off fields we don't care about matching
masked_packet = Mask(relayed_relay_forward_count)
masked_packet.set_do_not_care_scapy(packet.Ether, "dst")
masked_packet.set_do_not_care_scapy(IPv6, "src")
masked_packet.set_do_not_care_scapy(IPv6, "dst")
masked_packet.set_do_not_care_scapy(IPv6, "fl")
masked_packet.set_do_not_care_scapy(IPv6, "tc")
masked_packet.set_do_not_care_scapy(IPv6, "plen")
masked_packet.set_do_not_care_scapy(IPv6, "nh")
masked_packet.set_do_not_care_scapy(packet.UDP, "chksum")
masked_packet.set_do_not_care_scapy(packet.UDP, "len")
relayed_relay_forward_count = testutils.count_matched_packets_all_ports(
self, masked_packet, self.server_port_indices, timeout=4.0)
self.assertTrue(
relayed_relay_forward_count >= 1,
"Failed: Relayed Relay Forward count of %d" %
relayed_relay_forward_count)
def verify_relayed_discover(self):
# Create a packet resembling a relayed DCHPDISCOVER packet
dhcp_discover_relayed = self.create_dhcp_discover_relayed_packet()
# Mask off fields we don't care about matching
masked_discover = Mask(dhcp_discover_relayed)
masked_discover.set_do_not_care_scapy(scapy.Ether, "dst")
masked_discover.set_do_not_care_scapy(scapy.IP, "version")
masked_discover.set_do_not_care_scapy(scapy.IP, "ihl")
masked_discover.set_do_not_care_scapy(scapy.IP, "tos")
masked_discover.set_do_not_care_scapy(scapy.IP, "len")
masked_discover.set_do_not_care_scapy(scapy.IP, "id")
masked_discover.set_do_not_care_scapy(scapy.IP, "flags")
masked_discover.set_do_not_care_scapy(scapy.IP, "frag")
masked_discover.set_do_not_care_scapy(scapy.IP, "ttl")
masked_discover.set_do_not_care_scapy(scapy.IP, "proto")
masked_discover.set_do_not_care_scapy(scapy.IP, "chksum")
masked_discover.set_do_not_care_scapy(scapy.IP, "src")
masked_discover.set_do_not_care_scapy(scapy.IP, "dst")
masked_discover.set_do_not_care_scapy(scapy.IP, "options")
masked_discover.set_do_not_care_scapy(scapy.UDP, "chksum")
masked_discover.set_do_not_care_scapy(scapy.UDP, "len")
masked_discover.set_do_not_care_scapy(scapy.BOOTP, "sname")
masked_discover.set_do_not_care_scapy(scapy.BOOTP, "file")
masked_discover.set_do_not_care_scapy(scapy.PADDING, "load")
# Count the number of these packets received on the ports connected to our leaves
discover_count = testutils.count_matched_packets_all_ports(
self, masked_discover, self.server_port_indices)
self.assertTrue(
discover_count == self.num_dhcp_servers,
"Failed: Discover count of %d != %d (num_dhcp_servers)" %
(discover_count, self.num_dhcp_servers))
def test_po_update_io_no_loss(duthosts,
enum_rand_one_per_hwsku_frontend_hostname,
enum_frontend_asic_index, tbinfo, reload_testbed,
ptfadapter):
# GIVEN a lag topology, keep sending packets between 2 port channels
# WHEN delete/add different members of a port channel
# THEN no packets shall loss
duthost = duthosts[enum_rand_one_per_hwsku_frontend_hostname]
asichost = duthost.asic_instance(enum_frontend_asic_index)
mg_facts = duthost.get_extended_minigraph_facts(tbinfo)
if len(mg_facts["minigraph_portchannel_interfaces"]) < 2:
pytest.skip(
"Skip test due to there isn't enough port channel exists in current topology."
)
# generate ip-pc pairs, be like:[("10.0.0.56", "10.0.0.57", "PortChannel0001")]
peer_ip_pc_pair = [(pc["addr"], pc["peer_addr"], pc["attachto"])
for pc in mg_facts["minigraph_portchannel_interfaces"]
if ipaddress.ip_address(pc['peer_addr']).version == 4]
# generate pc tuples, fill in members,
# be like:[("10.0.0.56", "10.0.0.57", "PortChannel0001", ["Ethernet48", "Ethernet52"])]
pcs = [(pair[0], pair[1], pair[2],
mg_facts["minigraph_portchannels"][pair[2]]["members"])
for pair in peer_ip_pc_pair
if len(mg_facts["minigraph_portchannels"][pair[2]]["members"]) >= 2]
if len(pcs) < 2:
pytest.skip(
"Skip test due to there is no enough port channel with at least 2 members exists in current topology."
)
selected_pcs = random.sample(pcs, k=2)
in_pc = selected_pcs[0]
out_pc = selected_pcs[1]
# use first port of in_pc as input port
# all ports in out_pc will be output/forward ports
pc, pc_members = out_pc[2], out_pc[3]
in_ptf_index = mg_facts["minigraph_ptf_indices"][in_pc[3][0]]
out_ptf_indices = map(lambda port: mg_facts["minigraph_ptf_indices"][port],
out_pc[3])
logging.info(
"selected_pcs is: %s, in_ptf_index is %s, out_ptf_indices is %s" %
(selected_pcs, in_ptf_index, out_ptf_indices))
tmp_pc = "PortChannel999"
pc_ip = out_pc[0]
in_peer_ip = in_pc[1]
out_peer_ip = out_pc[1]
# Step 1: Remove port channel members from port channel
for member in pc_members:
asichost.config_portchannel_member(pc, member, "del")
# Step 2: Remove port channel ip from port channel
asichost.config_ip_intf(pc, pc_ip + "/31", "remove")
time.sleep(30)
int_facts = asichost.interface_facts()['ansible_facts']
pytest_assert(not int_facts['ansible_interface_facts'][pc]['link'])
pytest_assert(
wait_until(120, 10, 0, asichost.check_bgp_statistic, 'ipv4_idle', 1))
# Step 3: Create tmp port channel with default min-links(1)
asichost.config_portchannel(tmp_pc, "add")
# Step 4: Add port channel members to tmp port channel
for member in pc_members:
asichost.config_portchannel_member(tmp_pc, member, "add")
# Step 5: Add port channel ip to tmp port channel
asichost.config_ip_intf(tmp_pc, pc_ip + "/31", "add")
int_facts = asichost.interface_facts()['ansible_facts']
pytest_assert(int_facts['ansible_interface_facts'][tmp_pc]['ipv4']
['address'] == pc_ip)
time.sleep(30)
int_facts = asichost.interface_facts()['ansible_facts']
pytest_assert(int_facts['ansible_interface_facts'][tmp_pc]['link'])
pytest_assert(
wait_until(120, 10, 0, asichost.check_bgp_statistic, 'ipv4_idle', 0))
# Keep sending packets, and add/del different members during that time, observe whether packets lose
pkt = testutils.simple_ip_packet(eth_dst=duthost.facts["router_mac"],
eth_src=ptfadapter.dataplane.get_mac(
0, in_ptf_index),
ip_src=in_peer_ip,
ip_dst=out_peer_ip)
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')
exp_pkt.set_do_not_care_scapy(packet.IP, 'chksum')
exp_pkt.set_do_not_care_scapy(packet.IP, 'ttl')
ptfadapter.dataplane.flush()
member_update_finished_flag = Queue(1)
packet_sending_flag = Queue(1)
def del_add_members():
# wait for packets sending started, then starts to update pc members
while packet_sending_flag.empty() or (not packet_sending_flag.get()):
time.sleep(0.5)
asichost.config_portchannel_member(tmp_pc, pc_members[0], "del")
time.sleep(2)
asichost.config_portchannel_member(tmp_pc, pc_members[0], "add")
time.sleep(2)
asichost.config_portchannel_member(tmp_pc, pc_members[1], "del")
time.sleep(2)
asichost.config_portchannel_member(tmp_pc, pc_members[1], "add")
time.sleep(5)
member_update_finished_flag.put(True)
t = threading.Thread(target=del_add_members, name="del_add_members_thread")
t.start()
t_max = time.time() + 60
send_count = 0
stop_sending = False
while not stop_sending:
# After 100 packets send, awake del_add_members thread, it happens only once.
if send_count == 100:
packet_sending_flag.put(True)
testutils.send(ptfadapter, in_ptf_index, pkt)
send_count += 1
member_update_thread_finished = (not member_update_finished_flag.empty(
)) and member_update_finished_flag.get()
reach_max_time = time.time() > t_max
stop_sending = reach_max_time or member_update_thread_finished
t.join(20)
match_cnt = testutils.count_matched_packets_all_ports(
ptfadapter, exp_pkt, ports=out_ptf_indices)
pytest_assert(match_cnt > 0, "Packets not send")
pytest_assert(match_cnt == send_count,
"Packets lost during pc members add/removal")
def copp_test(self, packet, send_intf, recv_intf):
'''
Pre-send some packets for a second to absorb the CBS capacity.
'''
if self.needPreSend:
pre_send_count = 0
end_time = datetime.datetime.now() + datetime.timedelta(seconds=self.DEFAULT_PRE_SEND_INTERVAL_SEC)
while datetime.datetime.now() < end_time:
testutils.send_packet(self, send_intf, packet)
pre_send_count += 1
rcv_pkt_cnt = testutils.count_matched_packets_all_ports(self, packet, [recv_intf[1]], recv_intf[0], timeout=5)
self.log("Send %d and receive %d packets in the first second (PolicyTest)" % (pre_send_count, rcv_pkt_cnt))
pre_test_ptf_tx_counter = self.dataplane.get_counters(*send_intf)
pre_test_ptf_rx_counter = self.dataplane.get_counters(*recv_intf)
pre_test_nn_tx_counter = self.dataplane.get_nn_counters(*send_intf)
pre_test_nn_rx_counter = self.dataplane.get_nn_counters(*recv_intf)
start_time = datetime.datetime.now()
end_time = datetime.datetime.now() + datetime.timedelta(seconds=self.DEFAULT_SEND_INTERVAL_SEC)
send_count = 0
self.dataplane.flush()
while datetime.datetime.now() < end_time:
testutils.send_packet(self, send_intf, packet)
send_count += 1
# Depending on the server/platform combination it is possible for the server to
# overwhelm the DUT, so we add an artificial delay here to rate-limit the server.
time.sleep(1.0 / float(self.default_server_send_rate_limit_pps))
self.log("Sent out %d packets in %ds" % (send_count, self.DEFAULT_SEND_INTERVAL_SEC))
time.sleep(self.DEFAULT_RECEIVE_WAIT_TIME) # Wait a little bit for all the packets to make it through
recv_count = testutils.count_matched_packets_all_ports(self, packet, [recv_intf[1]], recv_intf[0], timeout=10)
self.log("Received %d packets after sleep %ds" % (recv_count, self.DEFAULT_RECEIVE_WAIT_TIME))
post_test_ptf_tx_counter = self.dataplane.get_counters(*send_intf)
post_test_ptf_rx_counter = self.dataplane.get_counters(*recv_intf)
post_test_nn_tx_counter = self.dataplane.get_nn_counters(*send_intf)
post_test_nn_rx_counter = self.dataplane.get_nn_counters(*recv_intf)
ptf_tx_count = int(post_test_ptf_tx_counter[1] - pre_test_ptf_tx_counter[1])
nn_tx_count = int(post_test_nn_tx_counter[1] - pre_test_nn_tx_counter[1])
ptf_rx_count = int(post_test_ptf_rx_counter[0] - pre_test_ptf_rx_counter[0])
nn_rx_count = int(post_test_nn_rx_counter[0] - pre_test_nn_rx_counter[0])
self.log("", True)
self.log("Counters before the test:", True)
self.log("If counter (0, n): %s" % str(pre_test_ptf_tx_counter), True)
self.log("NN counter (0, n): %s" % str(pre_test_nn_tx_counter), True)
self.log("If counter (1, n): %s" % str(pre_test_ptf_rx_counter), True)
self.log("NN counter (1, n): %s" % str(pre_test_nn_rx_counter), True)
self.log("", True)
self.log("Counters after the test:", True)
self.log("If counter (0, n): %s" % str(post_test_ptf_tx_counter), True)
self.log("NN counter (0, n): %s" % str(post_test_nn_tx_counter), True)
self.log("If counter (1, n): %s" % str(post_test_ptf_rx_counter), True)
self.log("NN counter (1, n): %s" % str(post_test_nn_rx_counter), True)
self.log("")
self.log("Sent through NN to local ptf_nn_agent: %d" % ptf_tx_count)
self.log("Sent through If to remote ptf_nn_agent: %d" % nn_tx_count)
self.log("Recv from If on remote ptf_nn_agent: %d" % ptf_rx_count)
self.log("Recv from NN on from remote ptf_nn_agent: %d" % nn_rx_count)
time_delta = end_time - start_time
time_delta_ms = (time_delta.microseconds + time_delta.seconds * 10**6) / 1000
tx_pps = int(send_count / (float(time_delta_ms) / 1000))
rx_pps = int(recv_count / (float(time_delta_ms) / 1000))
return send_count, recv_count, time_delta, time_delta_ms, tx_pps, rx_pps
