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 tag_fixme_vpp_workers
16 from framework import VppTestCase, VppTestRunner, running_extended_tests
17 from framework import tag_run_solo
18 from vpp_object import VppObject
19 from vpp_pg_interface import CaptureTimeoutError
21 from ipfix import IPFIX, Set, Template, Data, IPFIXDecoder
22 from vpp_ip_route import VppIpRoute, VppRoutePath
23 from vpp_papi.macaddress import mac_ntop
24 from socket import inet_ntop
25 from vpp_papi import VppEnum
28 class VppCFLOW(VppObject):
29 """CFLOW object for IPFIX exporter and Flowprobe feature"""
31 def __init__(self, test, intf='pg2', active=0, passive=0, timeout=100,
32 mtu=1024, datapath='l2', layer='l2 l3 l4'):
36 if passive == 0 or passive < active:
37 self._passive = active+1
39 self._passive = passive
40 self._datapath = datapath # l2 ip4 ip6
41 self._collect = layer # l2 l3 l4
42 self._timeout = timeout
44 self._configured = False
46 def add_vpp_config(self):
47 self.enable_exporter()
51 if 'l2' in self._collect.lower():
52 l2_flag = (VppEnum.vl_api_flowprobe_record_flags_t.
53 FLOWPROBE_RECORD_FLAG_L2)
54 if 'l3' in self._collect.lower():
55 l3_flag = (VppEnum.vl_api_flowprobe_record_flags_t.
56 FLOWPROBE_RECORD_FLAG_L3)
57 if 'l4' in self._collect.lower():
58 l4_flag = (VppEnum.vl_api_flowprobe_record_flags_t.
59 FLOWPROBE_RECORD_FLAG_L4)
60 self._test.vapi.flowprobe_params(
61 record_flags=(l2_flag | l3_flag | l4_flag),
62 active_timer=self._active, passive_timer=self._passive)
63 self.enable_flowprobe_feature()
64 self._test.vapi.cli("ipfix flush")
65 self._configured = True
67 def remove_vpp_config(self):
68 self.disable_exporter()
69 self.disable_flowprobe_feature()
70 self._test.vapi.cli("ipfix flush")
71 self._configured = False
73 def enable_exporter(self):
74 self._test.vapi.set_ipfix_exporter(
75 collector_address=self._test.pg0.remote_ip4,
76 src_address=self._test.pg0.local_ip4,
78 template_interval=self._timeout)
80 def enable_flowprobe_feature(self):
81 self._test.vapi.ppcli("flowprobe feature add-del %s %s" %
82 (self._intf, self._datapath))
84 def disable_exporter(self):
85 self._test.vapi.cli("set ipfix exporter collector 0.0.0.0")
87 def disable_flowprobe_feature(self):
88 self._test.vapi.cli("flowprobe feature add-del %s %s disable" %
89 (self._intf, self._datapath))
92 return "ipfix-collector-%s-%s" % (self._src, self.dst)
94 def query_vpp_config(self):
95 return self._configured
97 def verify_templates(self, decoder=None, timeout=1, count=3):
99 self._test.assertIn(count, (1, 2, 3))
100 for _ in range(count):
101 p = self._test.wait_for_cflow_packet(self._test.collector, 2,
103 self._test.assertTrue(p.haslayer(IPFIX))
104 if decoder is not None and p.haslayer(Template):
105 templates.append(p[Template].templateID)
106 decoder.add_template(p.getlayer(Template))
110 class MethodHolder(VppTestCase):
111 """ Flow-per-packet plugin: test L2, IP4, IP6 reporting """
115 max_number_of_packets = 10
121 Perform standard class setup (defined by class method setUpClass in
122 class VppTestCase) before running the test case, set test case related
123 variables and configure VPP.
125 super(MethodHolder, cls).setUpClass()
127 # Create pg interfaces
128 cls.create_pg_interfaces(range(9))
131 cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
133 # Create BD with MAC learning and unknown unicast flooding disabled
134 # and put interfaces to this BD
135 cls.vapi.bridge_domain_add_del(bd_id=1, uu_flood=1, learn=1)
136 cls.vapi.sw_interface_set_l2_bridge(
137 rx_sw_if_index=cls.pg1._sw_if_index, bd_id=1)
138 cls.vapi.sw_interface_set_l2_bridge(
139 rx_sw_if_index=cls.pg2._sw_if_index, bd_id=1)
141 # Set up all interfaces
142 for i in cls.pg_interfaces:
146 cls.pg0.configure_ipv4_neighbors()
147 cls.collector = cls.pg0
150 cls.pg1.resolve_arp()
152 cls.pg2.resolve_arp()
154 cls.pg3.resolve_arp()
156 cls.pg4.resolve_arp()
159 cls.pg8.configure_ipv4_neighbors()
162 cls.pg5.resolve_ndp()
163 cls.pg5.disable_ipv6_ra()
165 cls.pg6.resolve_ndp()
166 cls.pg6.disable_ipv6_ra()
168 super(MethodHolder, cls).tearDownClass()
172 def tearDownClass(cls):
173 super(MethodHolder, cls).tearDownClass()
175 def create_stream(self, src_if=None, dst_if=None, packets=None,
176 size=None, ip_ver='v4'):
177 """Create a packet stream to tickle the plugin
179 :param VppInterface src_if: Source interface for packet stream
180 :param VppInterface src_if: Dst interface for packet stream
188 packets = random.randint(1, self.max_number_of_packets)
190 for p in range(0, packets):
192 pkt_size = random.choice(self.pg_if_packet_sizes)
193 info = self.create_packet_info(src_if, dst_if)
194 payload = self.info_to_payload(info)
195 p = Ether(src=src_if.remote_mac, dst=src_if.local_mac)
197 p /= IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4)
199 p /= IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6)
200 p /= UDP(sport=1234, dport=4321)
203 self.extend_packet(p, pkt_size)
206 def verify_cflow_data(self, decoder, capture, cflow):
212 if cflow.haslayer(Data):
213 data = decoder.decode_data_set(cflow.getlayer(Set))
215 self.assertEqual(int(binascii.hexlify(record[1]), 16), octets)
216 self.assertEqual(int(binascii.hexlify(record[2]), 16), packets)
218 def send_packets(self, src_if=None, dst_if=None):
223 self.pg_enable_capture([dst_if])
224 src_if.add_stream(self.pkts)
226 return dst_if.get_capture(len(self.pkts))
228 def verify_cflow_data_detail(self, decoder, capture, cflow,
229 data_set={1: 'octets', 2: 'packets'},
232 print(capture[0].show())
233 if cflow.haslayer(Data):
234 data = decoder.decode_data_set(cflow.getlayer(Set))
238 ip_layer = capture[0][IP]
240 ip_layer = capture[0][IPv6]
241 if data_set is not None:
243 # skip flow if ingress/egress interface is 0
244 if int(binascii.hexlify(record[10]), 16) == 0:
246 if int(binascii.hexlify(record[14]), 16) == 0:
249 for field in data_set:
250 if field not in record.keys():
252 value = data_set[field]
253 if value == 'octets':
256 value += 40 # ??? is this correct
257 elif value == 'packets':
259 elif value == 'src_ip':
261 ip = socket.inet_pton(socket.AF_INET,
264 ip = socket.inet_pton(socket.AF_INET6,
266 value = int(binascii.hexlify(ip), 16)
267 elif value == 'dst_ip':
269 ip = socket.inet_pton(socket.AF_INET,
272 ip = socket.inet_pton(socket.AF_INET6,
274 value = int(binascii.hexlify(ip), 16)
275 elif value == 'sport':
276 value = int(capture[0][UDP].sport)
277 elif value == 'dport':
278 value = int(capture[0][UDP].dport)
279 self.assertEqual(int(binascii.hexlify(
283 def verify_cflow_data_notimer(self, decoder, capture, cflows):
286 if cflow.haslayer(Data):
287 data = decoder.decode_data_set(cflow.getlayer(Set))
289 raise Exception("No CFLOW data")
294 self.assertEqual(p[IP].len, int(
295 binascii.hexlify(rec[1]), 16))
296 self.assertEqual(1, int(
297 binascii.hexlify(rec[2]), 16))
298 self.assertEqual(len(capture), idx)
300 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1):
301 """ wait for CFLOW packet and verify its correctness
303 :param timeout: how long to wait
306 self.logger.info("IPFIX: Waiting for CFLOW packet")
307 # self.logger.debug(self.vapi.ppcli("show flow table"))
308 p = collector_intf.wait_for_packet(timeout=timeout)
309 self.assertEqual(p[Set].setID, set_id)
310 # self.logger.debug(self.vapi.ppcli("show flow table"))
311 self.logger.debug(ppp("IPFIX: Got packet:", p))
316 @tag_fixme_vpp_workers
317 class Flowprobe(MethodHolder):
318 """Template verification, timer tests"""
322 super(Flowprobe, cls).setUpClass()
325 def tearDownClass(cls):
326 super(Flowprobe, cls).tearDownClass()
329 """ timer less than template timeout"""
330 self.logger.info("FFP_TEST_START_0001")
331 self.pg_enable_capture(self.pg_interfaces)
334 ipfix = VppCFLOW(test=self, active=2)
335 ipfix.add_vpp_config()
337 ipfix_decoder = IPFIXDecoder()
338 # template packet should arrive immediately
339 templates = ipfix.verify_templates(ipfix_decoder)
341 self.create_stream(packets=1)
343 capture = self.pg2.get_capture(1)
345 # make sure the one packet we expect actually showed up
346 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
347 self.verify_cflow_data(ipfix_decoder, capture, cflow)
349 ipfix.remove_vpp_config()
350 self.logger.info("FFP_TEST_FINISH_0001")
353 """ timer greater than template timeout"""
354 self.logger.info("FFP_TEST_START_0002")
355 self.pg_enable_capture(self.pg_interfaces)
358 ipfix = VppCFLOW(test=self, timeout=3, active=4)
359 ipfix.add_vpp_config()
361 ipfix_decoder = IPFIXDecoder()
362 # template packet should arrive immediately
363 ipfix.verify_templates()
365 self.create_stream(packets=2)
367 capture = self.pg2.get_capture(2)
369 # next set of template packet should arrive after 20 seconds
370 # template packet should arrive within 20 s
371 templates = ipfix.verify_templates(ipfix_decoder, timeout=5)
373 # make sure the one packet we expect actually showed up
374 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
375 self.verify_cflow_data(ipfix_decoder, capture, cflow)
377 ipfix.remove_vpp_config()
378 self.logger.info("FFP_TEST_FINISH_0002")
380 def test_cflow_packet(self):
381 """verify cflow packet fields"""
382 self.logger.info("FFP_TEST_START_0000")
383 self.pg_enable_capture(self.pg_interfaces)
386 ipfix = VppCFLOW(test=self, intf='pg8', datapath="ip4",
387 layer='l2 l3 l4', active=2)
388 ipfix.add_vpp_config()
390 route_9001 = VppIpRoute(self, "9.0.0.0", 24,
391 [VppRoutePath(self.pg8._remote_hosts[0].ip4,
392 self.pg8.sw_if_index)])
393 route_9001.add_vpp_config()
395 ipfix_decoder = IPFIXDecoder()
396 templates = ipfix.verify_templates(ipfix_decoder, count=1)
398 self.pkts = [(Ether(dst=self.pg7.local_mac,
399 src=self.pg7.remote_mac) /
400 IP(src=self.pg7.remote_ip4, dst="9.0.0.100") /
401 TCP(sport=1234, dport=4321, flags=80) /
404 nowUTC = int(time.time())
405 nowUNIX = nowUTC+2208988800
406 self.send_packets(src_if=self.pg7, dst_if=self.pg8)
408 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 10)
409 self.collector.get_capture(2)
411 if cflow[0].haslayer(IPFIX):
412 self.assertEqual(cflow[IPFIX].version, 10)
413 self.assertEqual(cflow[IPFIX].observationDomainID, 1)
414 self.assertEqual(cflow[IPFIX].sequenceNumber, 0)
415 self.assertAlmostEqual(cflow[IPFIX].exportTime, nowUTC, delta=5)
416 if cflow.haslayer(Data):
417 record = ipfix_decoder.decode_data_set(cflow[0].getlayer(Set))[0]
419 self.assertEqual(int(binascii.hexlify(record[10]), 16), 8)
421 self.assertEqual(int(binascii.hexlify(record[14]), 16), 9)
423 self.assertEqual(int(binascii.hexlify(record[2]), 16), 1)
425 self.assertEqual(mac_ntop(record[56]), self.pg8.local_mac)
427 self.assertEqual(mac_ntop(record[80]), self.pg8.remote_mac)
428 flowTimestamp = int(binascii.hexlify(record[156]), 16) >> 32
429 # flow start timestamp
430 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
431 flowTimestamp = int(binascii.hexlify(record[157]), 16) >> 32
433 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
435 self.assertEqual(int(binascii.hexlify(record[256]), 16), 8)
437 self.assertEqual(inet_ntop(socket.AF_INET, record[8]),
440 self.assertEqual(inet_ntop(socket.AF_INET, record[12]),
443 self.assertEqual(int(binascii.hexlify(record[4]), 16), 6)
445 self.assertEqual(int(binascii.hexlify(record[7]), 16), 1234)
447 self.assertEqual(int(binascii.hexlify(record[11]), 16), 4321)
449 self.assertEqual(int(binascii.hexlify(record[6]), 16), 80)
451 ipfix.remove_vpp_config()
452 self.logger.info("FFP_TEST_FINISH_0000")
455 @tag_fixme_vpp_workers
456 class Datapath(MethodHolder):
457 """collect information on Ethernet, IP4 and IP6 datapath (no timers)"""
461 super(Datapath, cls).setUpClass()
464 def tearDownClass(cls):
465 super(Datapath, cls).tearDownClass()
467 def test_templatesL2(self):
468 """ verify template on L2 datapath"""
469 self.logger.info("FFP_TEST_START_0000")
470 self.pg_enable_capture(self.pg_interfaces)
472 ipfix = VppCFLOW(test=self, layer='l2')
473 ipfix.add_vpp_config()
475 # template packet should arrive immediately
476 self.vapi.ipfix_flush()
477 ipfix.verify_templates(timeout=3, count=1)
478 self.collector.get_capture(1)
480 ipfix.remove_vpp_config()
481 self.logger.info("FFP_TEST_FINISH_0000")
483 def test_L2onL2(self):
484 """ L2 data on L2 datapath"""
485 self.logger.info("FFP_TEST_START_0001")
486 self.pg_enable_capture(self.pg_interfaces)
489 ipfix = VppCFLOW(test=self, layer='l2')
490 ipfix.add_vpp_config()
492 ipfix_decoder = IPFIXDecoder()
493 # template packet should arrive immediately
494 templates = ipfix.verify_templates(ipfix_decoder, count=1)
496 self.create_stream(packets=1)
497 capture = self.send_packets()
499 # make sure the one packet we expect actually showed up
500 self.vapi.ipfix_flush()
501 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
502 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
503 {2: 'packets', 256: 8})
504 self.collector.get_capture(2)
506 ipfix.remove_vpp_config()
507 self.logger.info("FFP_TEST_FINISH_0001")
509 def test_L3onL2(self):
510 """ L3 data on L2 datapath"""
511 self.logger.info("FFP_TEST_START_0002")
512 self.pg_enable_capture(self.pg_interfaces)
515 ipfix = VppCFLOW(test=self, layer='l3')
516 ipfix.add_vpp_config()
518 ipfix_decoder = IPFIXDecoder()
519 # template packet should arrive immediately
520 templates = ipfix.verify_templates(ipfix_decoder, count=2)
522 self.create_stream(packets=1)
523 capture = self.send_packets()
525 # make sure the one packet we expect actually showed up
526 self.vapi.ipfix_flush()
527 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
528 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
529 {2: 'packets', 4: 17,
530 8: 'src_ip', 12: 'dst_ip'})
532 self.collector.get_capture(3)
534 ipfix.remove_vpp_config()
535 self.logger.info("FFP_TEST_FINISH_0002")
537 def test_L4onL2(self):
538 """ L4 data on L2 datapath"""
539 self.logger.info("FFP_TEST_START_0003")
540 self.pg_enable_capture(self.pg_interfaces)
543 ipfix = VppCFLOW(test=self, layer='l4')
544 ipfix.add_vpp_config()
546 ipfix_decoder = IPFIXDecoder()
547 # template packet should arrive immediately
548 templates = ipfix.verify_templates(ipfix_decoder, count=2)
550 self.create_stream(packets=1)
551 capture = self.send_packets()
553 # make sure the one packet we expect actually showed up
554 self.vapi.ipfix_flush()
555 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
556 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
557 {2: 'packets', 7: 'sport', 11: 'dport'})
559 self.collector.get_capture(3)
561 ipfix.remove_vpp_config()
562 self.logger.info("FFP_TEST_FINISH_0003")
564 def test_templatesIp4(self):
565 """ verify templates on IP4 datapath"""
566 self.logger.info("FFP_TEST_START_0000")
568 self.pg_enable_capture(self.pg_interfaces)
570 ipfix = VppCFLOW(test=self, datapath='ip4')
571 ipfix.add_vpp_config()
573 # template packet should arrive immediately
574 self.vapi.ipfix_flush()
575 ipfix.verify_templates(timeout=3, count=1)
576 self.collector.get_capture(1)
578 ipfix.remove_vpp_config()
580 self.logger.info("FFP_TEST_FINISH_0000")
582 def test_L2onIP4(self):
583 """ L2 data on IP4 datapath"""
584 self.logger.info("FFP_TEST_START_0001")
585 self.pg_enable_capture(self.pg_interfaces)
588 ipfix = VppCFLOW(test=self, intf='pg4', layer='l2', datapath='ip4')
589 ipfix.add_vpp_config()
591 ipfix_decoder = IPFIXDecoder()
592 # template packet should arrive immediately
593 templates = ipfix.verify_templates(ipfix_decoder, count=1)
595 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
596 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
598 # make sure the one packet we expect actually showed up
599 self.vapi.ipfix_flush()
600 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
601 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
602 {2: 'packets', 256: 8})
604 # expected two templates and one cflow packet
605 self.collector.get_capture(2)
607 ipfix.remove_vpp_config()
608 self.logger.info("FFP_TEST_FINISH_0001")
610 def test_L3onIP4(self):
611 """ L3 data on IP4 datapath"""
612 self.logger.info("FFP_TEST_START_0002")
613 self.pg_enable_capture(self.pg_interfaces)
616 ipfix = VppCFLOW(test=self, intf='pg4', layer='l3', datapath='ip4')
617 ipfix.add_vpp_config()
619 ipfix_decoder = IPFIXDecoder()
620 # template packet should arrive immediately
621 templates = ipfix.verify_templates(ipfix_decoder, count=1)
623 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
624 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
626 # make sure the one packet we expect actually showed up
627 self.vapi.ipfix_flush()
628 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
629 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
630 {1: 'octets', 2: 'packets',
631 8: 'src_ip', 12: 'dst_ip'})
633 # expected two templates and one cflow packet
634 self.collector.get_capture(2)
636 ipfix.remove_vpp_config()
637 self.logger.info("FFP_TEST_FINISH_0002")
639 def test_L4onIP4(self):
640 """ L4 data on IP4 datapath"""
641 self.logger.info("FFP_TEST_START_0003")
642 self.pg_enable_capture(self.pg_interfaces)
645 ipfix = VppCFLOW(test=self, intf='pg4', layer='l4', datapath='ip4')
646 ipfix.add_vpp_config()
648 ipfix_decoder = IPFIXDecoder()
649 # template packet should arrive immediately
650 templates = ipfix.verify_templates(ipfix_decoder, count=1)
652 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
653 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
655 # make sure the one packet we expect actually showed up
656 self.vapi.ipfix_flush()
657 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
658 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
659 {2: 'packets', 7: 'sport', 11: 'dport'})
661 # expected two templates and one cflow packet
662 self.collector.get_capture(2)
664 ipfix.remove_vpp_config()
665 self.logger.info("FFP_TEST_FINISH_0003")
667 def test_templatesIP6(self):
668 """ verify templates on IP6 datapath"""
669 self.logger.info("FFP_TEST_START_0000")
670 self.pg_enable_capture(self.pg_interfaces)
672 ipfix = VppCFLOW(test=self, datapath='ip6')
673 ipfix.add_vpp_config()
675 # template packet should arrive immediately
676 ipfix.verify_templates(count=1)
677 self.collector.get_capture(1)
679 ipfix.remove_vpp_config()
681 self.logger.info("FFP_TEST_FINISH_0000")
683 def test_L2onIP6(self):
684 """ L2 data on IP6 datapath"""
685 self.logger.info("FFP_TEST_START_0001")
686 self.pg_enable_capture(self.pg_interfaces)
689 ipfix = VppCFLOW(test=self, intf='pg6', layer='l2', datapath='ip6')
690 ipfix.add_vpp_config()
692 ipfix_decoder = IPFIXDecoder()
693 # template packet should arrive immediately
694 templates = ipfix.verify_templates(ipfix_decoder, count=1)
696 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
698 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
700 # make sure the one packet we expect actually showed up
701 self.vapi.ipfix_flush()
702 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
703 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
704 {2: 'packets', 256: 56710},
707 # expected two templates and one cflow packet
708 self.collector.get_capture(2)
710 ipfix.remove_vpp_config()
711 self.logger.info("FFP_TEST_FINISH_0001")
713 def test_L3onIP6(self):
714 """ L3 data on IP6 datapath"""
715 self.logger.info("FFP_TEST_START_0002")
716 self.pg_enable_capture(self.pg_interfaces)
719 ipfix = VppCFLOW(test=self, intf='pg6', layer='l3', datapath='ip6')
720 ipfix.add_vpp_config()
722 ipfix_decoder = IPFIXDecoder()
723 # template packet should arrive immediately
724 templates = ipfix.verify_templates(ipfix_decoder, count=1)
726 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
728 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
730 # make sure the one packet we expect actually showed up
731 self.vapi.ipfix_flush()
732 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
733 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
735 27: 'src_ip', 28: 'dst_ip'},
738 # expected two templates and one cflow packet
739 self.collector.get_capture(2)
741 ipfix.remove_vpp_config()
742 self.logger.info("FFP_TEST_FINISH_0002")
744 def test_L4onIP6(self):
745 """ L4 data on IP6 datapath"""
746 self.logger.info("FFP_TEST_START_0003")
747 self.pg_enable_capture(self.pg_interfaces)
750 ipfix = VppCFLOW(test=self, intf='pg6', layer='l4', datapath='ip6')
751 ipfix.add_vpp_config()
753 ipfix_decoder = IPFIXDecoder()
754 # template packet should arrive immediately
755 templates = ipfix.verify_templates(ipfix_decoder, count=1)
757 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
759 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
761 # make sure the one packet we expect actually showed up
762 self.vapi.ipfix_flush()
763 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
764 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
765 {2: 'packets', 7: 'sport', 11: 'dport'},
768 # expected two templates and one cflow packet
769 self.collector.get_capture(2)
771 ipfix.remove_vpp_config()
772 self.logger.info("FFP_TEST_FINISH_0003")
775 """ no timers, one CFLOW packet, 9 Flows inside"""
776 self.logger.info("FFP_TEST_START_0001")
777 self.pg_enable_capture(self.pg_interfaces)
780 ipfix = VppCFLOW(test=self)
781 ipfix.add_vpp_config()
783 ipfix_decoder = IPFIXDecoder()
784 # template packet should arrive immediately
785 templates = ipfix.verify_templates(ipfix_decoder)
787 self.create_stream(packets=9)
788 capture = self.send_packets()
790 # make sure the one packet we expect actually showed up
791 self.vapi.ipfix_flush()
792 cflow = self.wait_for_cflow_packet(self.collector, templates[1])
793 self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow])
794 self.collector.get_capture(4)
796 ipfix.remove_vpp_config()
797 self.logger.info("FFP_TEST_FINISH_0001")
800 """ no timers, two CFLOW packets (mtu=256), 3 Flows in each"""
801 self.logger.info("FFP_TEST_START_0002")
802 self.pg_enable_capture(self.pg_interfaces)
805 ipfix = VppCFLOW(test=self, mtu=256)
806 ipfix.add_vpp_config()
808 ipfix_decoder = IPFIXDecoder()
809 # template packet should arrive immediately
810 self.vapi.ipfix_flush()
811 templates = ipfix.verify_templates(ipfix_decoder)
813 self.create_stream(packets=6)
814 capture = self.send_packets()
816 # make sure the one packet we expect actually showed up
818 self.vapi.ipfix_flush()
819 cflows.append(self.wait_for_cflow_packet(self.collector,
821 cflows.append(self.wait_for_cflow_packet(self.collector,
823 self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows)
824 self.collector.get_capture(5)
826 ipfix.remove_vpp_config()
827 self.logger.info("FFP_TEST_FINISH_0002")
830 @unittest.skipUnless(running_extended_tests, "part of extended tests")
831 class DisableIPFIX(MethodHolder):
836 super(DisableIPFIX, cls).setUpClass()
839 def tearDownClass(cls):
840 super(DisableIPFIX, cls).tearDownClass()
843 """ disable IPFIX after first packets"""
844 self.logger.info("FFP_TEST_START_0001")
845 self.pg_enable_capture(self.pg_interfaces)
848 ipfix = VppCFLOW(test=self)
849 ipfix.add_vpp_config()
851 ipfix_decoder = IPFIXDecoder()
852 # template packet should arrive immediately
853 templates = ipfix.verify_templates(ipfix_decoder)
858 # make sure the one packet we expect actually showed up
859 self.vapi.ipfix_flush()
860 self.wait_for_cflow_packet(self.collector, templates[1])
861 self.collector.get_capture(4)
864 ipfix.disable_exporter()
865 self.pg_enable_capture([self.collector])
869 # make sure no one packet arrived in 1 minute
870 self.vapi.ipfix_flush()
871 self.sleep(1, "wait before verifying no packets sent")
872 self.collector.assert_nothing_captured()
874 ipfix.remove_vpp_config()
875 self.logger.info("FFP_TEST_FINISH_0001")
878 @unittest.skipUnless(running_extended_tests, "part of extended tests")
879 class ReenableIPFIX(MethodHolder):
880 """Re-enable IPFIX"""
884 super(ReenableIPFIX, cls).setUpClass()
887 def tearDownClass(cls):
888 super(ReenableIPFIX, cls).tearDownClass()
891 """ disable IPFIX after first packets and re-enable after few packets
893 self.logger.info("FFP_TEST_START_0001")
894 self.pg_enable_capture(self.pg_interfaces)
897 ipfix = VppCFLOW(test=self)
898 ipfix.add_vpp_config()
900 ipfix_decoder = IPFIXDecoder()
901 # template packet should arrive immediately
902 templates = ipfix.verify_templates(ipfix_decoder)
904 self.create_stream(packets=5)
907 # make sure the one packet we expect actually showed up
908 self.vapi.ipfix_flush()
909 self.wait_for_cflow_packet(self.collector, templates[1])
910 self.collector.get_capture(4)
913 ipfix.disable_exporter()
914 self.vapi.ipfix_flush()
915 self.pg_enable_capture([self.collector])
919 # make sure no one packet arrived in active timer span
920 self.vapi.ipfix_flush()
921 self.sleep(1, "wait before verifying no packets sent")
922 self.collector.assert_nothing_captured()
923 self.pg2.get_capture(5)
926 ipfix.enable_exporter()
928 capture = self.collector.get_capture(4)
932 self.assertTrue(p.haslayer(IPFIX))
933 if p.haslayer(Template):
935 self.assertTrue(nr_templates, 3)
937 self.assertTrue(p.haslayer(IPFIX))
940 self.assertTrue(nr_templates, 1)
942 ipfix.remove_vpp_config()
943 self.logger.info("FFP_TEST_FINISH_0001")
946 @unittest.skipUnless(running_extended_tests, "part of extended tests")
947 class DisableFP(MethodHolder):
948 """Disable Flowprobe feature"""
952 super(DisableFP, cls).setUpClass()
955 def tearDownClass(cls):
956 super(DisableFP, cls).tearDownClass()
959 """ disable flowprobe feature after first packets"""
960 self.logger.info("FFP_TEST_START_0001")
961 self.pg_enable_capture(self.pg_interfaces)
963 ipfix = VppCFLOW(test=self)
964 ipfix.add_vpp_config()
966 ipfix_decoder = IPFIXDecoder()
967 # template packet should arrive immediately
968 templates = ipfix.verify_templates(ipfix_decoder)
973 # make sure the one packet we expect actually showed up
974 self.vapi.ipfix_flush()
975 self.wait_for_cflow_packet(self.collector, templates[1])
976 self.collector.get_capture(4)
979 ipfix.disable_flowprobe_feature()
980 self.pg_enable_capture([self.collector])
984 # make sure no one packet arrived in active timer span
985 self.vapi.ipfix_flush()
986 self.sleep(1, "wait before verifying no packets sent")
987 self.collector.assert_nothing_captured()
989 ipfix.remove_vpp_config()
990 self.logger.info("FFP_TEST_FINISH_0001")
993 @unittest.skipUnless(running_extended_tests, "part of extended tests")
994 class ReenableFP(MethodHolder):
995 """Re-enable Flowprobe feature"""
999 super(ReenableFP, cls).setUpClass()
1002 def tearDownClass(cls):
1003 super(ReenableFP, cls).tearDownClass()
1005 def test_0001(self):
1006 """ disable flowprobe feature after first packets and re-enable
1007 after few packets """
1008 self.logger.info("FFP_TEST_START_0001")
1009 self.pg_enable_capture(self.pg_interfaces)
1012 ipfix = VppCFLOW(test=self)
1013 ipfix.add_vpp_config()
1015 ipfix_decoder = IPFIXDecoder()
1016 # template packet should arrive immediately
1017 self.vapi.ipfix_flush()
1018 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1020 self.create_stream()
1023 # make sure the one packet we expect actually showed up
1024 self.vapi.ipfix_flush()
1025 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1026 self.collector.get_capture(4)
1028 # disable FPP feature
1029 ipfix.disable_flowprobe_feature()
1030 self.pg_enable_capture([self.collector])
1034 # make sure no one packet arrived in active timer span
1035 self.vapi.ipfix_flush()
1036 self.sleep(5, "wait before verifying no packets sent")
1037 self.collector.assert_nothing_captured()
1039 # enable FPP feature
1040 ipfix.enable_flowprobe_feature()
1041 self.vapi.ipfix_flush()
1042 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1046 # make sure the next packets (templates and data) we expect actually
1048 self.vapi.ipfix_flush()
1049 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1050 self.collector.get_capture(4)
1052 ipfix.remove_vpp_config()
1053 self.logger.info("FFP_TEST_FINISH_0001")
1056 if __name__ == '__main__':
1057 unittest.main(testRunner=VppTestRunner)