2 from __future__ import print_function
10 from scapy.packet import Raw
11 from scapy.layers.l2 import Ether
12 from scapy.layers.inet import IP, TCP, UDP
13 from scapy.layers.inet6 import IPv6
15 from framework import VppTestCase, VppTestRunner, running_extended_tests
16 from vpp_object import VppObject
17 from vpp_pg_interface import CaptureTimeoutError
19 from ipfix import IPFIX, Set, Template, Data, IPFIXDecoder
20 from vpp_ip_route import VppIpRoute, VppRoutePath
21 from vpp_papi.macaddress import mac_ntop
22 from socket import inet_ntop
25 class VppCFLOW(VppObject):
26 """CFLOW object for IPFIX exporter and Flowprobe feature"""
28 def __init__(self, test, intf='pg2', active=0, passive=0, timeout=100,
29 mtu=1024, datapath='l2', layer='l2 l3 l4'):
33 if passive == 0 or passive < active:
34 self._passive = active+1
36 self._passive = passive
37 self._datapath = datapath # l2 ip4 ip6
38 self._collect = layer # l2 l3 l4
39 self._timeout = timeout
41 self._configured = False
43 def add_vpp_config(self):
44 self.enable_exporter()
45 self._test.vapi.flowprobe_params(
46 record_l2=1 if 'l2' in self._collect.lower() else 0,
47 record_l3=1 if 'l3' in self._collect.lower() else 0,
48 record_l4=1 if 'l4' in self._collect.lower() else 0,
49 active_timer=self._active, passive_timer=self._passive)
50 self.enable_flowprobe_feature()
51 self._test.vapi.cli("ipfix flush")
52 self._configured = True
54 def remove_vpp_config(self):
55 self.disable_exporter()
56 self.disable_flowprobe_feature()
57 self._test.vapi.cli("ipfix flush")
58 self._configured = False
60 def enable_exporter(self):
61 self._test.vapi.set_ipfix_exporter(
62 collector_address=self._test.pg0.remote_ip4,
63 src_address=self._test.pg0.local_ip4,
65 template_interval=self._timeout)
67 def enable_flowprobe_feature(self):
68 self._test.vapi.ppcli("flowprobe feature add-del %s %s" %
69 (self._intf, self._datapath))
71 def disable_exporter(self):
72 self._test.vapi.cli("set ipfix exporter collector 0.0.0.0")
74 def disable_flowprobe_feature(self):
75 self._test.vapi.cli("flowprobe feature add-del %s %s disable" %
76 (self._intf, self._datapath))
79 return "ipfix-collector-%s-%s" % (self._src, self.dst)
81 def query_vpp_config(self):
82 return self._configured
84 def verify_templates(self, decoder=None, timeout=1, count=3):
86 p = self._test.wait_for_cflow_packet(self._test.collector, 2, timeout)
87 self._test.assertTrue(p.haslayer(IPFIX))
88 if decoder is not None and p.haslayer(Template):
89 templates.append(p[Template].templateID)
90 decoder.add_template(p.getlayer(Template))
92 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
93 self._test.assertTrue(p.haslayer(IPFIX))
94 if decoder is not None and p.haslayer(Template):
95 templates.append(p[Template].templateID)
96 decoder.add_template(p.getlayer(Template))
98 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
99 self._test.assertTrue(p.haslayer(IPFIX))
100 if decoder is not None and p.haslayer(Template):
101 templates.append(p[Template].templateID)
102 decoder.add_template(p.getlayer(Template))
106 class MethodHolder(VppTestCase):
107 """ Flow-per-packet plugin: test L2, IP4, IP6 reporting """
111 max_number_of_packets = 10
117 Perform standard class setup (defined by class method setUpClass in
118 class VppTestCase) before running the test case, set test case related
119 variables and configure VPP.
121 super(MethodHolder, cls).setUpClass()
123 # Create pg interfaces
124 cls.create_pg_interfaces(range(9))
127 cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
129 # Create BD with MAC learning and unknown unicast flooding disabled
130 # and put interfaces to this BD
131 cls.vapi.bridge_domain_add_del(bd_id=1, uu_flood=1, learn=1)
132 cls.vapi.sw_interface_set_l2_bridge(
133 rx_sw_if_index=cls.pg1._sw_if_index, bd_id=1)
134 cls.vapi.sw_interface_set_l2_bridge(
135 rx_sw_if_index=cls.pg2._sw_if_index, bd_id=1)
137 # Set up all interfaces
138 for i in cls.pg_interfaces:
142 cls.pg0.configure_ipv4_neighbors()
143 cls.collector = cls.pg0
146 cls.pg1.resolve_arp()
148 cls.pg2.resolve_arp()
150 cls.pg3.resolve_arp()
152 cls.pg4.resolve_arp()
155 cls.pg8.configure_ipv4_neighbors()
158 cls.pg5.resolve_ndp()
159 cls.pg5.disable_ipv6_ra()
161 cls.pg6.resolve_ndp()
162 cls.pg6.disable_ipv6_ra()
164 super(MethodHolder, cls).tearDownClass()
168 def tearDownClass(cls):
169 super(MethodHolder, cls).tearDownClass()
171 def create_stream(self, src_if=None, dst_if=None, packets=None,
172 size=None, ip_ver='v4'):
173 """Create a packet stream to tickle the plugin
175 :param VppInterface src_if: Source interface for packet stream
176 :param VppInterface src_if: Dst interface for packet stream
184 packets = random.randint(1, self.max_number_of_packets)
186 for p in range(0, packets):
188 pkt_size = random.choice(self.pg_if_packet_sizes)
189 info = self.create_packet_info(src_if, dst_if)
190 payload = self.info_to_payload(info)
191 p = Ether(src=src_if.remote_mac, dst=src_if.local_mac)
193 p /= IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4)
195 p /= IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6)
196 p /= UDP(sport=1234, dport=4321)
199 self.extend_packet(p, pkt_size)
202 def verify_cflow_data(self, decoder, capture, cflow):
208 if cflow.haslayer(Data):
209 data = decoder.decode_data_set(cflow.getlayer(Set))
211 self.assertEqual(int(binascii.hexlify(record[1]), 16), octets)
212 self.assertEqual(int(binascii.hexlify(record[2]), 16), packets)
214 def send_packets(self, src_if=None, dst_if=None):
219 self.pg_enable_capture([dst_if])
220 src_if.add_stream(self.pkts)
222 return dst_if.get_capture(len(self.pkts))
224 def verify_cflow_data_detail(self, decoder, capture, cflow,
225 data_set={1: 'octets', 2: 'packets'},
228 print(capture[0].show())
229 if cflow.haslayer(Data):
230 data = decoder.decode_data_set(cflow.getlayer(Set))
234 ip_layer = capture[0][IP]
236 ip_layer = capture[0][IPv6]
237 if data_set is not None:
239 # skip flow if ingress/egress interface is 0
240 if int(binascii.hexlify(record[10]), 16) == 0:
242 if int(binascii.hexlify(record[14]), 16) == 0:
245 for field in data_set:
246 if field not in record.keys():
248 value = data_set[field]
249 if value == 'octets':
252 value += 40 # ??? is this correct
253 elif value == 'packets':
255 elif value == 'src_ip':
257 ip = socket.inet_pton(socket.AF_INET,
260 ip = socket.inet_pton(socket.AF_INET6,
262 value = int(binascii.hexlify(ip), 16)
263 elif value == 'dst_ip':
265 ip = socket.inet_pton(socket.AF_INET,
268 ip = socket.inet_pton(socket.AF_INET6,
270 value = int(binascii.hexlify(ip), 16)
271 elif value == 'sport':
272 value = int(capture[0][UDP].sport)
273 elif value == 'dport':
274 value = int(capture[0][UDP].dport)
275 self.assertEqual(int(binascii.hexlify(
279 def verify_cflow_data_notimer(self, decoder, capture, cflows):
282 if cflow.haslayer(Data):
283 data = decoder.decode_data_set(cflow.getlayer(Set))
285 raise Exception("No CFLOW data")
290 self.assertEqual(p[IP].len, int(
291 binascii.hexlify(rec[1]), 16))
292 self.assertEqual(1, int(
293 binascii.hexlify(rec[2]), 16))
294 self.assertEqual(len(capture), idx)
296 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1,
298 """ wait for CFLOW packet and verify its correctness
300 :param timeout: how long to wait
302 :returns: tuple (packet, time spent waiting for packet)
304 self.logger.info("IPFIX: Waiting for CFLOW packet")
305 deadline = time.time() + timeout
307 # self.logger.debug(self.vapi.ppcli("show flow table"))
311 self.assert_in_range(counter, 0, 100, "number of packets ignored")
312 time_left = deadline - time.time()
314 if time_left < 0 and expected:
315 # self.logger.debug(self.vapi.ppcli("show flow table"))
316 raise CaptureTimeoutError(
317 "Packet did not arrive within timeout")
318 p = collector_intf.wait_for_packet(timeout=time_left)
319 except CaptureTimeoutError:
321 # self.logger.debug(self.vapi.ppcli("show flow table"))
322 raise CaptureTimeoutError(
323 "Packet did not arrive within timeout")
327 raise CaptureTimeoutError("Packet arrived even not expected")
328 self.assertEqual(p[Set].setID, set_id)
329 # self.logger.debug(self.vapi.ppcli("show flow table"))
330 self.logger.debug(ppp("IPFIX: Got packet:", p))
335 class Flowprobe(MethodHolder):
336 """Template verification, timer tests"""
340 super(Flowprobe, cls).setUpClass()
343 def tearDownClass(cls):
344 super(Flowprobe, cls).tearDownClass()
347 """ timer less than template timeout"""
348 self.logger.info("FFP_TEST_START_0001")
349 self.pg_enable_capture(self.pg_interfaces)
352 ipfix = VppCFLOW(test=self, active=2)
353 ipfix.add_vpp_config()
355 ipfix_decoder = IPFIXDecoder()
356 # template packet should arrive immediately
357 templates = ipfix.verify_templates(ipfix_decoder)
359 self.create_stream(packets=1)
361 capture = self.pg2.get_capture(1)
363 # make sure the one packet we expect actually showed up
364 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
365 self.verify_cflow_data(ipfix_decoder, capture, cflow)
367 ipfix.remove_vpp_config()
368 self.logger.info("FFP_TEST_FINISH_0001")
371 """ timer greater than template timeout"""
372 self.logger.info("FFP_TEST_START_0002")
373 self.pg_enable_capture(self.pg_interfaces)
376 ipfix = VppCFLOW(test=self, timeout=3, active=4)
377 ipfix.add_vpp_config()
379 ipfix_decoder = IPFIXDecoder()
380 # template packet should arrive immediately
381 ipfix.verify_templates()
383 self.create_stream(packets=2)
385 capture = self.pg2.get_capture(2)
387 # next set of template packet should arrive after 20 seconds
388 # template packet should arrive within 20 s
389 templates = ipfix.verify_templates(ipfix_decoder, timeout=5)
391 # make sure the one packet we expect actually showed up
392 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
393 self.verify_cflow_data(ipfix_decoder, capture, cflow)
395 ipfix.remove_vpp_config()
396 self.logger.info("FFP_TEST_FINISH_0002")
398 def test_cflow_packet(self):
399 """verify cflow packet fields"""
400 self.logger.info("FFP_TEST_START_0000")
401 self.pg_enable_capture(self.pg_interfaces)
404 ipfix = VppCFLOW(test=self, intf='pg8', datapath="ip4",
405 layer='l2 l3 l4', active=2)
406 ipfix.add_vpp_config()
408 route_9001 = VppIpRoute(self, "9.0.0.0", 24,
409 [VppRoutePath(self.pg8._remote_hosts[0].ip4,
410 self.pg8.sw_if_index)])
411 route_9001.add_vpp_config()
413 ipfix_decoder = IPFIXDecoder()
414 templates = ipfix.verify_templates(ipfix_decoder, count=1)
416 self.pkts = [(Ether(dst=self.pg7.local_mac,
417 src=self.pg7.remote_mac) /
418 IP(src=self.pg7.remote_ip4, dst="9.0.0.100") /
419 TCP(sport=1234, dport=4321, flags=80) /
422 nowUTC = int(time.time())
423 nowUNIX = nowUTC+2208988800
424 self.send_packets(src_if=self.pg7, dst_if=self.pg8)
426 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 10)
427 self.collector.get_capture(2)
429 if cflow[0].haslayer(IPFIX):
430 self.assertEqual(cflow[IPFIX].version, 10)
431 self.assertEqual(cflow[IPFIX].observationDomainID, 1)
432 self.assertEqual(cflow[IPFIX].sequenceNumber, 0)
433 self.assertAlmostEqual(cflow[IPFIX].exportTime, nowUTC, delta=5)
434 if cflow.haslayer(Data):
435 record = ipfix_decoder.decode_data_set(cflow[0].getlayer(Set))[0]
437 self.assertEqual(int(binascii.hexlify(record[10]), 16), 8)
439 self.assertEqual(int(binascii.hexlify(record[14]), 16), 9)
441 self.assertEqual(int(binascii.hexlify(record[2]), 16), 1)
443 self.assertEqual(mac_ntop(record[56]), self.pg8.local_mac)
445 self.assertEqual(mac_ntop(record[80]), self.pg8.remote_mac)
446 flowTimestamp = int(binascii.hexlify(record[156]), 16) >> 32
447 # flow start timestamp
448 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
449 flowTimestamp = int(binascii.hexlify(record[157]), 16) >> 32
451 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
453 self.assertEqual(int(binascii.hexlify(record[256]), 16), 8)
455 self.assertEqual(inet_ntop(socket.AF_INET, record[8]),
458 self.assertEqual(inet_ntop(socket.AF_INET, record[12]),
461 self.assertEqual(int(binascii.hexlify(record[4]), 16), 6)
463 self.assertEqual(int(binascii.hexlify(record[7]), 16), 1234)
465 self.assertEqual(int(binascii.hexlify(record[11]), 16), 4321)
467 self.assertEqual(int(binascii.hexlify(record[6]), 16), 80)
469 ipfix.remove_vpp_config()
470 self.logger.info("FFP_TEST_FINISH_0000")
473 class Datapath(MethodHolder):
474 """collect information on Ethernet, IP4 and IP6 datapath (no timers)"""
478 super(Datapath, cls).setUpClass()
481 def tearDownClass(cls):
482 super(Datapath, cls).tearDownClass()
484 def test_templatesL2(self):
485 """ verify template on L2 datapath"""
486 self.logger.info("FFP_TEST_START_0000")
487 self.pg_enable_capture(self.pg_interfaces)
489 ipfix = VppCFLOW(test=self, layer='l2')
490 ipfix.add_vpp_config()
492 # template packet should arrive immediately
493 self.vapi.ipfix_flush()
494 ipfix.verify_templates(timeout=3, count=1)
495 self.collector.get_capture(1)
497 ipfix.remove_vpp_config()
498 self.logger.info("FFP_TEST_FINISH_0000")
500 def test_L2onL2(self):
501 """ L2 data on L2 datapath"""
502 self.logger.info("FFP_TEST_START_0001")
503 self.pg_enable_capture(self.pg_interfaces)
506 ipfix = VppCFLOW(test=self, layer='l2')
507 ipfix.add_vpp_config()
509 ipfix_decoder = IPFIXDecoder()
510 # template packet should arrive immediately
511 templates = ipfix.verify_templates(ipfix_decoder, count=1)
513 self.create_stream(packets=1)
514 capture = self.send_packets()
516 # make sure the one packet we expect actually showed up
517 self.vapi.ipfix_flush()
518 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
519 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
520 {2: 'packets', 256: 8})
521 self.collector.get_capture(2)
523 ipfix.remove_vpp_config()
524 self.logger.info("FFP_TEST_FINISH_0001")
526 def test_L3onL2(self):
527 """ L3 data on L2 datapath"""
528 self.logger.info("FFP_TEST_START_0002")
529 self.pg_enable_capture(self.pg_interfaces)
532 ipfix = VppCFLOW(test=self, layer='l3')
533 ipfix.add_vpp_config()
535 ipfix_decoder = IPFIXDecoder()
536 # template packet should arrive immediately
537 templates = ipfix.verify_templates(ipfix_decoder, count=2)
539 self.create_stream(packets=1)
540 capture = self.send_packets()
542 # make sure the one packet we expect actually showed up
543 self.vapi.ipfix_flush()
544 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
545 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
546 {2: 'packets', 4: 17,
547 8: 'src_ip', 12: 'dst_ip'})
549 self.collector.get_capture(3)
551 ipfix.remove_vpp_config()
552 self.logger.info("FFP_TEST_FINISH_0002")
554 def test_L4onL2(self):
555 """ L4 data on L2 datapath"""
556 self.logger.info("FFP_TEST_START_0003")
557 self.pg_enable_capture(self.pg_interfaces)
560 ipfix = VppCFLOW(test=self, layer='l4')
561 ipfix.add_vpp_config()
563 ipfix_decoder = IPFIXDecoder()
564 # template packet should arrive immediately
565 templates = ipfix.verify_templates(ipfix_decoder, count=2)
567 self.create_stream(packets=1)
568 capture = self.send_packets()
570 # make sure the one packet we expect actually showed up
571 self.vapi.ipfix_flush()
572 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
573 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
574 {2: 'packets', 7: 'sport', 11: 'dport'})
576 self.collector.get_capture(3)
578 ipfix.remove_vpp_config()
579 self.logger.info("FFP_TEST_FINISH_0003")
581 def test_templatesIp4(self):
582 """ verify templates on IP4 datapath"""
583 self.logger.info("FFP_TEST_START_0000")
585 self.pg_enable_capture(self.pg_interfaces)
587 ipfix = VppCFLOW(test=self, datapath='ip4')
588 ipfix.add_vpp_config()
590 # template packet should arrive immediately
591 self.vapi.ipfix_flush()
592 ipfix.verify_templates(timeout=3, count=1)
593 self.collector.get_capture(1)
595 ipfix.remove_vpp_config()
597 self.logger.info("FFP_TEST_FINISH_0000")
599 def test_L2onIP4(self):
600 """ L2 data on IP4 datapath"""
601 self.logger.info("FFP_TEST_START_0001")
602 self.pg_enable_capture(self.pg_interfaces)
605 ipfix = VppCFLOW(test=self, intf='pg4', layer='l2', datapath='ip4')
606 ipfix.add_vpp_config()
608 ipfix_decoder = IPFIXDecoder()
609 # template packet should arrive immediately
610 templates = ipfix.verify_templates(ipfix_decoder, count=1)
612 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
613 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
615 # make sure the one packet we expect actually showed up
616 self.vapi.ipfix_flush()
617 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
618 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
619 {2: 'packets', 256: 8})
621 # expected two templates and one cflow packet
622 self.collector.get_capture(2)
624 ipfix.remove_vpp_config()
625 self.logger.info("FFP_TEST_FINISH_0001")
627 def test_L3onIP4(self):
628 """ L3 data on IP4 datapath"""
629 self.logger.info("FFP_TEST_START_0002")
630 self.pg_enable_capture(self.pg_interfaces)
633 ipfix = VppCFLOW(test=self, intf='pg4', layer='l3', datapath='ip4')
634 ipfix.add_vpp_config()
636 ipfix_decoder = IPFIXDecoder()
637 # template packet should arrive immediately
638 templates = ipfix.verify_templates(ipfix_decoder, count=1)
640 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
641 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
643 # make sure the one packet we expect actually showed up
644 self.vapi.ipfix_flush()
645 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
646 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
647 {1: 'octets', 2: 'packets',
648 8: 'src_ip', 12: 'dst_ip'})
650 # expected two templates and one cflow packet
651 self.collector.get_capture(2)
653 ipfix.remove_vpp_config()
654 self.logger.info("FFP_TEST_FINISH_0002")
656 def test_L4onIP4(self):
657 """ L4 data on IP4 datapath"""
658 self.logger.info("FFP_TEST_START_0003")
659 self.pg_enable_capture(self.pg_interfaces)
662 ipfix = VppCFLOW(test=self, intf='pg4', layer='l4', datapath='ip4')
663 ipfix.add_vpp_config()
665 ipfix_decoder = IPFIXDecoder()
666 # template packet should arrive immediately
667 templates = ipfix.verify_templates(ipfix_decoder, count=1)
669 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
670 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
672 # make sure the one packet we expect actually showed up
673 self.vapi.ipfix_flush()
674 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
675 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
676 {2: 'packets', 7: 'sport', 11: 'dport'})
678 # expected two templates and one cflow packet
679 self.collector.get_capture(2)
681 ipfix.remove_vpp_config()
682 self.logger.info("FFP_TEST_FINISH_0003")
684 def test_templatesIP6(self):
685 """ verify templates on IP6 datapath"""
686 self.logger.info("FFP_TEST_START_0000")
687 self.pg_enable_capture(self.pg_interfaces)
689 ipfix = VppCFLOW(test=self, datapath='ip6')
690 ipfix.add_vpp_config()
692 # template packet should arrive immediately
693 ipfix.verify_templates(count=1)
694 self.collector.get_capture(1)
696 ipfix.remove_vpp_config()
698 self.logger.info("FFP_TEST_FINISH_0000")
700 def test_L2onIP6(self):
701 """ L2 data on IP6 datapath"""
702 self.logger.info("FFP_TEST_START_0001")
703 self.pg_enable_capture(self.pg_interfaces)
706 ipfix = VppCFLOW(test=self, intf='pg6', layer='l2', datapath='ip6')
707 ipfix.add_vpp_config()
709 ipfix_decoder = IPFIXDecoder()
710 # template packet should arrive immediately
711 templates = ipfix.verify_templates(ipfix_decoder, count=1)
713 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
715 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
717 # make sure the one packet we expect actually showed up
718 self.vapi.ipfix_flush()
719 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
720 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
721 {2: 'packets', 256: 56710},
724 # expected two templates and one cflow packet
725 self.collector.get_capture(2)
727 ipfix.remove_vpp_config()
728 self.logger.info("FFP_TEST_FINISH_0001")
730 def test_L3onIP6(self):
731 """ L3 data on IP6 datapath"""
732 self.logger.info("FFP_TEST_START_0002")
733 self.pg_enable_capture(self.pg_interfaces)
736 ipfix = VppCFLOW(test=self, intf='pg6', layer='l3', datapath='ip6')
737 ipfix.add_vpp_config()
739 ipfix_decoder = IPFIXDecoder()
740 # template packet should arrive immediately
741 templates = ipfix.verify_templates(ipfix_decoder, count=1)
743 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
745 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
747 # make sure the one packet we expect actually showed up
748 self.vapi.ipfix_flush()
749 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
750 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
752 27: 'src_ip', 28: 'dst_ip'},
755 # expected two templates and one cflow packet
756 self.collector.get_capture(2)
758 ipfix.remove_vpp_config()
759 self.logger.info("FFP_TEST_FINISH_0002")
761 def test_L4onIP6(self):
762 """ L4 data on IP6 datapath"""
763 self.logger.info("FFP_TEST_START_0003")
764 self.pg_enable_capture(self.pg_interfaces)
767 ipfix = VppCFLOW(test=self, intf='pg6', layer='l4', datapath='ip6')
768 ipfix.add_vpp_config()
770 ipfix_decoder = IPFIXDecoder()
771 # template packet should arrive immediately
772 templates = ipfix.verify_templates(ipfix_decoder, count=1)
774 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
776 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
778 # make sure the one packet we expect actually showed up
779 self.vapi.ipfix_flush()
780 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
781 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
782 {2: 'packets', 7: 'sport', 11: 'dport'},
785 # expected two templates and one cflow packet
786 self.collector.get_capture(2)
788 ipfix.remove_vpp_config()
789 self.logger.info("FFP_TEST_FINISH_0003")
792 """ no timers, one CFLOW packet, 9 Flows inside"""
793 self.logger.info("FFP_TEST_START_0001")
794 self.pg_enable_capture(self.pg_interfaces)
797 ipfix = VppCFLOW(test=self)
798 ipfix.add_vpp_config()
800 ipfix_decoder = IPFIXDecoder()
801 # template packet should arrive immediately
802 templates = ipfix.verify_templates(ipfix_decoder)
804 self.create_stream(packets=9)
805 capture = self.send_packets()
807 # make sure the one packet we expect actually showed up
808 self.vapi.ipfix_flush()
809 cflow = self.wait_for_cflow_packet(self.collector, templates[1])
810 self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow])
811 self.collector.get_capture(4)
813 ipfix.remove_vpp_config()
814 self.logger.info("FFP_TEST_FINISH_0001")
817 """ no timers, two CFLOW packets (mtu=256), 3 Flows in each"""
818 self.logger.info("FFP_TEST_START_0002")
819 self.pg_enable_capture(self.pg_interfaces)
822 ipfix = VppCFLOW(test=self, mtu=256)
823 ipfix.add_vpp_config()
825 ipfix_decoder = IPFIXDecoder()
826 # template packet should arrive immediately
827 self.vapi.ipfix_flush()
828 templates = ipfix.verify_templates(ipfix_decoder)
830 self.create_stream(packets=6)
831 capture = self.send_packets()
833 # make sure the one packet we expect actually showed up
835 self.vapi.ipfix_flush()
836 cflows.append(self.wait_for_cflow_packet(self.collector,
838 cflows.append(self.wait_for_cflow_packet(self.collector,
840 self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows)
841 self.collector.get_capture(5)
843 ipfix.remove_vpp_config()
844 self.logger.info("FFP_TEST_FINISH_0002")
847 @unittest.skipUnless(running_extended_tests, "part of extended tests")
848 class DisableIPFIX(MethodHolder):
853 super(DisableIPFIX, cls).setUpClass()
856 def tearDownClass(cls):
857 super(DisableIPFIX, cls).tearDownClass()
860 """ disable IPFIX after first packets"""
861 self.logger.info("FFP_TEST_START_0001")
862 self.pg_enable_capture(self.pg_interfaces)
865 ipfix = VppCFLOW(test=self)
866 ipfix.add_vpp_config()
868 ipfix_decoder = IPFIXDecoder()
869 # template packet should arrive immediately
870 templates = ipfix.verify_templates(ipfix_decoder)
875 # make sure the one packet we expect actually showed up
876 self.vapi.ipfix_flush()
877 self.wait_for_cflow_packet(self.collector, templates[1])
878 self.collector.get_capture(4)
881 ipfix.disable_exporter()
882 self.pg_enable_capture([self.collector])
886 # make sure no one packet arrived in 1 minute
887 self.vapi.ipfix_flush()
888 self.wait_for_cflow_packet(self.collector, templates[1],
890 self.collector.get_capture(0)
892 ipfix.remove_vpp_config()
893 self.logger.info("FFP_TEST_FINISH_0001")
896 @unittest.skipUnless(running_extended_tests, "part of extended tests")
897 class ReenableIPFIX(MethodHolder):
898 """Re-enable IPFIX"""
902 super(ReenableIPFIX, cls).setUpClass()
905 def tearDownClass(cls):
906 super(ReenableIPFIX, cls).tearDownClass()
909 """ disable IPFIX after first packets and re-enable after few packets
911 self.logger.info("FFP_TEST_START_0001")
912 self.pg_enable_capture(self.pg_interfaces)
915 ipfix = VppCFLOW(test=self)
916 ipfix.add_vpp_config()
918 ipfix_decoder = IPFIXDecoder()
919 # template packet should arrive immediately
920 templates = ipfix.verify_templates(ipfix_decoder)
922 self.create_stream(packets=5)
925 # make sure the one packet we expect actually showed up
926 self.vapi.ipfix_flush()
927 self.wait_for_cflow_packet(self.collector, templates[1])
928 self.collector.get_capture(4)
931 ipfix.disable_exporter()
932 self.vapi.ipfix_flush()
933 self.pg_enable_capture([self.collector])
937 # make sure no one packet arrived in active timer span
938 self.vapi.ipfix_flush()
939 self.wait_for_cflow_packet(self.collector, templates[1],
941 self.collector.get_capture(0)
942 self.pg2.get_capture(5)
945 ipfix.enable_exporter()
947 capture = self.collector.get_capture(4)
951 self.assertTrue(p.haslayer(IPFIX))
952 if p.haslayer(Template):
954 self.assertTrue(nr_templates, 3)
956 self.assertTrue(p.haslayer(IPFIX))
959 self.assertTrue(nr_templates, 1)
961 ipfix.remove_vpp_config()
962 self.logger.info("FFP_TEST_FINISH_0001")
965 @unittest.skipUnless(running_extended_tests, "part of extended tests")
966 class DisableFP(MethodHolder):
967 """Disable Flowprobe feature"""
971 super(DisableFP, cls).setUpClass()
974 def tearDownClass(cls):
975 super(DisableFP, cls).tearDownClass()
978 """ disable flowprobe feature after first packets"""
979 self.logger.info("FFP_TEST_START_0001")
980 self.pg_enable_capture(self.pg_interfaces)
982 ipfix = VppCFLOW(test=self)
983 ipfix.add_vpp_config()
985 ipfix_decoder = IPFIXDecoder()
986 # template packet should arrive immediately
987 templates = ipfix.verify_templates(ipfix_decoder)
992 # make sure the one packet we expect actually showed up
993 self.vapi.ipfix_flush()
994 self.wait_for_cflow_packet(self.collector, templates[1])
995 self.collector.get_capture(4)
998 ipfix.disable_flowprobe_feature()
999 self.pg_enable_capture([self.collector])
1003 # make sure no one packet arrived in active timer span
1004 self.vapi.ipfix_flush()
1005 self.wait_for_cflow_packet(self.collector, templates[1],
1007 self.collector.get_capture(0)
1009 ipfix.remove_vpp_config()
1010 self.logger.info("FFP_TEST_FINISH_0001")
1013 @unittest.skipUnless(running_extended_tests, "part of extended tests")
1014 class ReenableFP(MethodHolder):
1015 """Re-enable Flowprobe feature"""
1018 def setUpClass(cls):
1019 super(ReenableFP, cls).setUpClass()
1022 def tearDownClass(cls):
1023 super(ReenableFP, cls).tearDownClass()
1025 def test_0001(self):
1026 """ disable flowprobe feature after first packets and re-enable
1027 after few packets """
1028 self.logger.info("FFP_TEST_START_0001")
1029 self.pg_enable_capture(self.pg_interfaces)
1032 ipfix = VppCFLOW(test=self)
1033 ipfix.add_vpp_config()
1035 ipfix_decoder = IPFIXDecoder()
1036 # template packet should arrive immediately
1037 self.vapi.ipfix_flush()
1038 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1040 self.create_stream()
1043 # make sure the one packet we expect actually showed up
1044 self.vapi.ipfix_flush()
1045 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1046 self.collector.get_capture(4)
1048 # disable FPP feature
1049 ipfix.disable_flowprobe_feature()
1050 self.pg_enable_capture([self.collector])
1054 # make sure no one packet arrived in active timer span
1055 self.vapi.ipfix_flush()
1056 self.wait_for_cflow_packet(self.collector, templates[1], 5,
1058 self.collector.get_capture(0)
1060 # enable FPP feature
1061 ipfix.enable_flowprobe_feature()
1062 self.vapi.ipfix_flush()
1063 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1067 # make sure the next packets (templates and data) we expect actually
1069 self.vapi.ipfix_flush()
1070 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1071 self.collector.get_capture(4)
1073 ipfix.remove_vpp_config()
1074 self.logger.info("FFP_TEST_FINISH_0001")
1077 if __name__ == '__main__':
1078 unittest.main(testRunner=VppTestRunner)