def copp_test(self, packet, count, send_intf, recv_intf):
'''
Pre-send some packets for a second to absorb the CBS capacity.
'''
if self.needPreSend:
sendInFirst=0
endTime = datetime.datetime.now() + datetime.timedelta(seconds=1)
while datetime.datetime.now() < endTime:
testutils.send_packet(self, send_intf, packet)
sendInFirst += 1
rcv_pkt_cnt = testutils.count_matched_packets(self, packet, recv_intf[1], recv_intf[0],timeout=0.01)
self.log("Send %d and receive %d packets in the first second (PolicyTest)" % (sendInFirst, rcv_pkt_cnt))
self.dataplane.flush()
b_c_0 = self.dataplane.get_counters(*send_intf)
b_c_1 = self.dataplane.get_counters(*recv_intf)
b_n_0 = self.dataplane.get_nn_counters(*send_intf)
b_n_1 = self.dataplane.get_nn_counters(*recv_intf)
start_time=datetime.datetime.now()
for i in xrange(count):
testutils.send_packet(self, send_intf, packet)
end_time=datetime.datetime.now()
total_rcv_pkt_cnt = testutils.count_matched_packets(self, packet, recv_intf[1], recv_intf[0])
e_c_0 = self.dataplane.get_counters(*send_intf)
e_c_1 = self.dataplane.get_counters(*recv_intf)
e_n_0 = self.dataplane.get_nn_counters(*send_intf)
e_n_1 = self.dataplane.get_nn_counters(*recv_intf)
self.log("", True)
self.log("Counters before the test:", True)
self.log("If counter (0, n): %s" % str(b_c_0), True)
self.log("NN counter (0, n): %s" % str(b_n_0), True)
self.log("If counter (1, n): %s" % str(b_c_1), True)
self.log("NN counter (1, n): %s" % str(b_n_1), True)
self.log("", True)
self.log("Counters after the test:", True)
self.log("If counter (0, n): %s" % str(e_c_0), True)
self.log("NN counter (0, n): %s" % str(e_n_0), True)
self.log("If counter (1, n): %s" % str(e_c_1), True)
self.log("NN counter (1, n): %s" % str(e_n_1), True)
self.log("")
self.log("Sent through NN to local ptf_nn_agent: %d" % int(e_c_0[1] - b_c_0[1]))
self.log("Sent through If to remote ptf_nn_agent: %d" % int(e_n_0[1] - b_n_0[1]))
self.log("Recv from If on remote ptf_nn_agent: %d" % int(e_c_1[0] - b_c_1[0]))
self.log("Recv from NN on from remote ptf_nn_agent: %d" % int(e_n_1[0] - b_n_1[0]))
time_delta = end_time - start_time
time_delta_ms = (time_delta.microseconds + time_delta.seconds * 10**6) / 10**3
tx_pps = int(count/(float(time_delta_ms)/1000))
rx_pps = int(total_rcv_pkt_cnt/(float(time_delta_ms)/1000))
return total_rcv_pkt_cnt, time_delta, time_delta_ms, tx_pps, rx_pps
def checkRegularRegularLAGtoVLAN(self, acc_port, net_port, test):
src_mac = self.random_mac
dst_mac = self.dut_mac
src_ip = test['src_ip']
dst_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.ptf_mac_addrs['eth%d' % acc_port],
eth_src=dst_mac,
ip_src=src_ip,
ip_dst=dst_ip,
ip_ttl=63,
)
for i in xrange(self.nr):
testutils.send_packet(self, net_port, packet)
nr_rcvd = testutils.count_matched_packets(self,
exp_packet,
acc_port,
timeout=0.2)
rv = nr_rcvd == self.nr
out = ""
if not rv:
arg = self.nr, nr_rcvd, str(net_port), str(
acc_port), src_mac, dst_mac, src_ip, dst_ip
out = "sent = %d rcvd = %d | src_port=%s dst_port=%s | src_mac=%s dst_mac=%s src_ip=%s dst_ip=%s" % arg
return rv, out
def checkVxlan(self, acc_port, net_port, test):
rv = True
inner_dst_mac = self.ptf_mac_addrs['eth%d' % acc_port]
inner_src_mac = self.dut_mac
inner_src_ip = test['vlan_gw']
inner_dst_ip = test['vlan_ip_prefix'] % acc_port
dst_mac = self.dut_mac
src_mac = self.random_mac
ip_dst = self.loopback_ip
inpacket = simple_arp_packet(eth_dst=inner_dst_mac,
eth_src=inner_src_mac,
arp_op=2,
ip_snd=inner_src_ip,
ip_tgt=inner_dst_ip,
hw_snd=inner_src_mac,
hw_tgt=inner_dst_mac)
packet = simple_vxlan_packet(eth_dst=dst_mac,
eth_src=src_mac,
ip_src=test['src_ip'],
ip_dst=ip_dst,
vxlan_vni=test['vni'],
inner_frame=inpacket)
for i in xrange(self.nr):
testutils.send_packet(self, net_port, packet)
nr_rcvd = testutils.count_matched_packets(self,
inpacket,
acc_port,
timeout=0.1)
rv = rv and (nr_rcvd == self.nr)
return rv
def checkRegularRegularLAGtoVLAN(self, acc_port, net_port, test):
rv = True
src_mac = self.random_mac
dst_mac = self.dut_mac
src_ip = test['src_ip']
dst_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.ptf_mac_addrs['eth%d' % acc_port],
eth_src=dst_mac,
ip_src=src_ip,
ip_dst=dst_ip,
ip_ttl=63,
)
for i in xrange(self.nr):
testutils.send_packet(self, net_port, packet)
if self.nr == 1:
rv = rv and verify_packet_any_port(self, exp_packet, [acc_port])
else:
rv = rv and self.nr == testutils.count_matched_packets(
self, exp_packet, acc_port, timeout=0.1)
return rv
def testPort(self, port):
pkt, exp_pkt = self.gen_pkts[port]
testutils.send_packet(self, port, pkt)
nr_rcvd = testutils.count_matched_packets(self,
exp_pkt,
port,
timeout=0.2)
return nr_rcvd
def copp_test(self, packet, count, send_intf, recv_intf):
b_c_0 = self.dataplane.get_counters(*send_intf)
b_c_1 = self.dataplane.get_counters(*recv_intf)
b_n_0 = self.dataplane.get_nn_counters(*send_intf)
b_n_1 = self.dataplane.get_nn_counters(*recv_intf)
start_time = datetime.datetime.now()
for i in xrange(count):
testutils.send_packet(self, send_intf, packet)
end_time = datetime.datetime.now()
total_rcv_pkt_cnt = testutils.count_matched_packets(
self, packet, recv_intf[1], recv_intf[0])
e_c_0 = self.dataplane.get_counters(*send_intf)
e_c_1 = self.dataplane.get_counters(*recv_intf)
e_n_0 = self.dataplane.get_nn_counters(*send_intf)
e_n_1 = self.dataplane.get_nn_counters(*recv_intf)
self.log("", True)
self.log("Counters before the test:", True)
self.log("If counter (0, n): %s" % str(b_c_0), True)
self.log("NN counter (0, n): %s" % str(b_n_0), True)
self.log("If counter (1, n): %s" % str(b_c_1), True)
self.log("NN counter (1, n): %s" % str(b_n_1), True)
self.log("", True)
self.log("Counters after the test:", True)
self.log("If counter (0, n): %s" % str(e_c_0), True)
self.log("NN counter (0, n): %s" % str(e_n_0), True)
self.log("If counter (1, n): %s" % str(e_c_1), True)
self.log("NN counter (1, n): %s" % str(e_n_1), True)
self.log("")
self.log("Sent through NN to local ptf_nn_agent: %d" %
int(e_c_0[1] - b_c_0[1]))
self.log("Sent through If to remote ptf_nn_agent: %d" %
int(e_n_0[1] - b_n_0[1]))
self.log("Recv from If on remote ptf_nn_agent: %d" %
int(e_c_1[0] - b_c_1[0]))
self.log("Recv from NN on from remote ptf_nn_agent: %d" %
int(e_n_1[0] - b_n_1[0]))
time_delta = end_time - start_time
time_delta_ms = (time_delta.microseconds +
time_delta.seconds * 10**6) / 10**3
tx_pps = int(count / (float(time_delta_ms) / 1000))
rx_pps = int(total_rcv_pkt_cnt / (float(time_delta_ms) / 1000))
return total_rcv_pkt_cnt, time_delta, time_delta_ms, tx_pps, rx_pps
def checkVxlan(self, acc_port, net_port, test):
inner_dst_mac = self.ptf_mac_addrs['eth%d' % acc_port]
inner_src_mac = self.dut_mac
inner_src_ip = test['vlan_gw']
inner_dst_ip = test['vlan_ip_prefixes'][acc_port]
dst_mac = self.dut_mac
src_mac = self.random_mac
ip_dst = self.loopback_ip
inpacket = simple_arp_packet(eth_dst=inner_dst_mac,
eth_src=inner_src_mac,
arp_op=2,
ip_snd=inner_src_ip,
ip_tgt=inner_dst_ip,
hw_snd=inner_src_mac,
hw_tgt=inner_dst_mac)
packet = simple_vxlan_packet(eth_dst=dst_mac,
eth_src=src_mac,
ip_src=test['src_ip'],
ip_dst=ip_dst,
vxlan_vni=test['vni'],
inner_frame=inpacket)
self.dataplane.flush()
for i in xrange(self.nr):
testutils.send_packet(self, net_port, packet)
nr_rcvd = testutils.count_matched_packets(self,
inpacket,
acc_port,
timeout=0.5)
rv = nr_rcvd == self.nr
out = ""
if not rv:
arg = self.nr, nr_rcvd, str(net_port), str(
acc_port
), src_mac, dst_mac, test[
'src_ip'], ip_dst, inner_src_mac, inner_dst_mac, inner_src_ip, inner_dst_ip, test[
'vni']
out = "sent = %d rcvd = %d | src_port=%s dst_port=%s | src_mac=%s dst_mac=%s src_ip=%s dst_ip=%s | Inner: src_mac=%s dst_mac=%s src_ip=%s dst_ip=%s vni=%s" % arg
return rv, out
def copp_counter_test(self, packet, send_intf, recv_intf):
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)
send_count = 0
start_time = datetime.datetime.now()
send_window = float(self.send_duration) / float(
self.expect_send_pkt_number)
while send_count < self.expect_send_pkt_number:
begin = time.time()
testutils.send_packet(self, send_intf, packet)
send_count += 1
elapse = time.time() - begin
# 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.
if elapse > 0:
time.sleep(send_window - elapse)
end_time = datetime.datetime.now()
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(self, packet,
recv_intf[1],
recv_intf[0])
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
self.log("Sent out %d packets in %ds" %
(send_count, time_delta.seconds))
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
def copp_test(self, packet, send_intf, recv_intf):
'''
Pre-send some packets for a second to absorb the CBS capacity.
'''
if self.is_counter_test:
return self.copp_counter_test(packet, send_intf, recv_intf)
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(self,
packet,
recv_intf[1],
recv_intf[0],
timeout=0.01)
self.log(
"Send %d and receive %d packets in the first second (PolicyTest)"
% (pre_send_count, rcv_pkt_cnt))
self.dataplane.flush()
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
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(self, packet,
recv_intf[1],
recv_intf[0])
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
