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 config import config
16 from framework import tag_fixme_vpp_workers
17 from framework import VppTestCase, VppTestRunner
18 from framework import tag_run_solo
19 from vpp_object import VppObject
20 from vpp_pg_interface import CaptureTimeoutError
22 from ipfix import IPFIX, Set, Template, Data, IPFIXDecoder
23 from vpp_ip_route import VppIpRoute, VppRoutePath
24 from vpp_papi.macaddress import mac_ntop
25 from socket import inet_ntop
26 from vpp_papi import VppEnum
29 class VppCFLOW(VppObject):
30 """CFLOW object for IPFIX exporter and Flowprobe feature"""
32 def __init__(self, test, intf='pg2', active=0, passive=0, timeout=100,
33 mtu=1024, datapath='l2', layer='l2 l3 l4'):
37 if passive == 0 or passive < active:
38 self._passive = active+1
40 self._passive = passive
41 self._datapath = datapath # l2 ip4 ip6
42 self._collect = layer # l2 l3 l4
43 self._timeout = timeout
45 self._configured = False
47 def add_vpp_config(self):
48 self.enable_exporter()
52 if 'l2' in self._collect.lower():
53 l2_flag = (VppEnum.vl_api_flowprobe_record_flags_t.
54 FLOWPROBE_RECORD_FLAG_L2)
55 if 'l3' in self._collect.lower():
56 l3_flag = (VppEnum.vl_api_flowprobe_record_flags_t.
57 FLOWPROBE_RECORD_FLAG_L3)
58 if 'l4' in self._collect.lower():
59 l4_flag = (VppEnum.vl_api_flowprobe_record_flags_t.
60 FLOWPROBE_RECORD_FLAG_L4)
61 self._test.vapi.flowprobe_params(
62 record_flags=(l2_flag | l3_flag | l4_flag),
63 active_timer=self._active, passive_timer=self._passive)
64 self.enable_flowprobe_feature()
65 self._test.vapi.cli("ipfix flush")
66 self._configured = True
68 def remove_vpp_config(self):
69 self.disable_exporter()
70 self.disable_flowprobe_feature()
71 self._test.vapi.cli("ipfix flush")
72 self._configured = False
74 def enable_exporter(self):
75 self._test.vapi.set_ipfix_exporter(
76 collector_address=self._test.pg0.remote_ip4,
77 src_address=self._test.pg0.local_ip4,
79 template_interval=self._timeout)
81 def enable_flowprobe_feature(self):
82 self._test.vapi.ppcli("flowprobe feature add-del %s %s" %
83 (self._intf, self._datapath))
85 def disable_exporter(self):
86 self._test.vapi.cli("set ipfix exporter collector 0.0.0.0")
88 def disable_flowprobe_feature(self):
89 self._test.vapi.cli("flowprobe feature add-del %s %s disable" %
90 (self._intf, self._datapath))
93 return "ipfix-collector-%s-%s" % (self._src, self.dst)
95 def query_vpp_config(self):
96 return self._configured
98 def verify_templates(self, decoder=None, timeout=1, count=3):
100 self._test.assertIn(count, (1, 2, 3))
101 for _ in range(count):
102 p = self._test.wait_for_cflow_packet(self._test.collector, 2,
104 self._test.assertTrue(p.haslayer(IPFIX))
105 if decoder is not None and p.haslayer(Template):
106 templates.append(p[Template].templateID)
107 decoder.add_template(p.getlayer(Template))
111 class MethodHolder(VppTestCase):
112 """ Flow-per-packet plugin: test L2, IP4, IP6 reporting """
116 max_number_of_packets = 10
122 Perform standard class setup (defined by class method setUpClass in
123 class VppTestCase) before running the test case, set test case related
124 variables and configure VPP.
126 super(MethodHolder, cls).setUpClass()
128 # Create pg interfaces
129 cls.create_pg_interfaces(range(9))
132 cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
134 # Create BD with MAC learning and unknown unicast flooding disabled
135 # and put interfaces to this BD
136 cls.vapi.bridge_domain_add_del(bd_id=1, uu_flood=1, learn=1)
137 cls.vapi.sw_interface_set_l2_bridge(
138 rx_sw_if_index=cls.pg1._sw_if_index, bd_id=1)
139 cls.vapi.sw_interface_set_l2_bridge(
140 rx_sw_if_index=cls.pg2._sw_if_index, bd_id=1)
142 # Set up all interfaces
143 for i in cls.pg_interfaces:
147 cls.pg0.configure_ipv4_neighbors()
148 cls.collector = cls.pg0
151 cls.pg1.resolve_arp()
153 cls.pg2.resolve_arp()
155 cls.pg3.resolve_arp()
157 cls.pg4.resolve_arp()
160 cls.pg8.configure_ipv4_neighbors()
163 cls.pg5.resolve_ndp()
164 cls.pg5.disable_ipv6_ra()
166 cls.pg6.resolve_ndp()
167 cls.pg6.disable_ipv6_ra()
169 super(MethodHolder, cls).tearDownClass()
173 def tearDownClass(cls):
174 super(MethodHolder, cls).tearDownClass()
176 def create_stream(self, src_if=None, dst_if=None, packets=None,
177 size=None, ip_ver='v4'):
178 """Create a packet stream to tickle the plugin
180 :param VppInterface src_if: Source interface for packet stream
181 :param VppInterface src_if: Dst interface for packet stream
189 packets = random.randint(1, self.max_number_of_packets)
191 for p in range(0, packets):
193 pkt_size = random.choice(self.pg_if_packet_sizes)
194 info = self.create_packet_info(src_if, dst_if)
195 payload = self.info_to_payload(info)
196 p = Ether(src=src_if.remote_mac, dst=src_if.local_mac)
198 p /= IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4)
200 p /= IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6)
201 p /= UDP(sport=1234, dport=4321)
204 self.extend_packet(p, pkt_size)
207 def verify_cflow_data(self, decoder, capture, cflow):
213 if cflow.haslayer(Data):
214 data = decoder.decode_data_set(cflow.getlayer(Set))
216 self.assertEqual(int(binascii.hexlify(record[1]), 16), octets)
217 self.assertEqual(int(binascii.hexlify(record[2]), 16), packets)
219 def send_packets(self, src_if=None, dst_if=None):
224 self.pg_enable_capture([dst_if])
225 src_if.add_stream(self.pkts)
227 return dst_if.get_capture(len(self.pkts))
229 def verify_cflow_data_detail(self, decoder, capture, cflow,
230 data_set={1: 'octets', 2: 'packets'},
233 print(capture[0].show())
234 if cflow.haslayer(Data):
235 data = decoder.decode_data_set(cflow.getlayer(Set))
239 ip_layer = capture[0][IP]
241 ip_layer = capture[0][IPv6]
242 if data_set is not None:
244 # skip flow if ingress/egress interface is 0
245 if int(binascii.hexlify(record[10]), 16) == 0:
247 if int(binascii.hexlify(record[14]), 16) == 0:
250 for field in data_set:
251 if field not in record.keys():
253 value = data_set[field]
254 if value == 'octets':
257 value += 40 # ??? is this correct
258 elif value == 'packets':
260 elif value == 'src_ip':
262 ip = socket.inet_pton(socket.AF_INET,
265 ip = socket.inet_pton(socket.AF_INET6,
267 value = int(binascii.hexlify(ip), 16)
268 elif value == 'dst_ip':
270 ip = socket.inet_pton(socket.AF_INET,
273 ip = socket.inet_pton(socket.AF_INET6,
275 value = int(binascii.hexlify(ip), 16)
276 elif value == 'sport':
277 value = int(capture[0][UDP].sport)
278 elif value == 'dport':
279 value = int(capture[0][UDP].dport)
280 self.assertEqual(int(binascii.hexlify(
284 def verify_cflow_data_notimer(self, decoder, capture, cflows):
287 if cflow.haslayer(Data):
288 data = decoder.decode_data_set(cflow.getlayer(Set))
290 raise Exception("No CFLOW data")
295 self.assertEqual(p[IP].len, int(
296 binascii.hexlify(rec[1]), 16))
297 self.assertEqual(1, int(
298 binascii.hexlify(rec[2]), 16))
299 self.assertEqual(len(capture), idx)
301 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1):
302 """ wait for CFLOW packet and verify its correctness
304 :param timeout: how long to wait
307 self.logger.info("IPFIX: Waiting for CFLOW packet")
308 # self.logger.debug(self.vapi.ppcli("show flow table"))
309 p = collector_intf.wait_for_packet(timeout=timeout)
310 self.assertEqual(p[Set].setID, set_id)
311 # self.logger.debug(self.vapi.ppcli("show flow table"))
312 self.logger.debug(ppp("IPFIX: Got packet:", p))
317 @tag_fixme_vpp_workers
318 class Flowprobe(MethodHolder):
319 """Template verification, timer tests"""
323 super(Flowprobe, cls).setUpClass()
326 def tearDownClass(cls):
327 super(Flowprobe, cls).tearDownClass()
330 """ timer less than template timeout"""
331 self.logger.info("FFP_TEST_START_0001")
332 self.pg_enable_capture(self.pg_interfaces)
335 ipfix = VppCFLOW(test=self, active=2)
336 ipfix.add_vpp_config()
338 ipfix_decoder = IPFIXDecoder()
339 # template packet should arrive immediately
340 templates = ipfix.verify_templates(ipfix_decoder)
342 self.create_stream(packets=1)
344 capture = self.pg2.get_capture(1)
346 # make sure the one packet we expect actually showed up
347 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
348 self.verify_cflow_data(ipfix_decoder, capture, cflow)
350 ipfix.remove_vpp_config()
351 self.logger.info("FFP_TEST_FINISH_0001")
354 """ timer greater than template timeout"""
355 self.logger.info("FFP_TEST_START_0002")
356 self.pg_enable_capture(self.pg_interfaces)
359 ipfix = VppCFLOW(test=self, timeout=3, active=4)
360 ipfix.add_vpp_config()
362 ipfix_decoder = IPFIXDecoder()
363 # template packet should arrive immediately
364 ipfix.verify_templates()
366 self.create_stream(packets=2)
368 capture = self.pg2.get_capture(2)
370 # next set of template packet should arrive after 20 seconds
371 # template packet should arrive within 20 s
372 templates = ipfix.verify_templates(ipfix_decoder, timeout=5)
374 # make sure the one packet we expect actually showed up
375 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
376 self.verify_cflow_data(ipfix_decoder, capture, cflow)
378 ipfix.remove_vpp_config()
379 self.logger.info("FFP_TEST_FINISH_0002")
381 def test_cflow_packet(self):
382 """verify cflow packet fields"""
383 self.logger.info("FFP_TEST_START_0000")
384 self.pg_enable_capture(self.pg_interfaces)
387 ipfix = VppCFLOW(test=self, intf='pg8', datapath="ip4",
388 layer='l2 l3 l4', active=2)
389 ipfix.add_vpp_config()
391 route_9001 = VppIpRoute(self, "9.0.0.0", 24,
392 [VppRoutePath(self.pg8._remote_hosts[0].ip4,
393 self.pg8.sw_if_index)])
394 route_9001.add_vpp_config()
396 ipfix_decoder = IPFIXDecoder()
397 templates = ipfix.verify_templates(ipfix_decoder, count=1)
399 self.pkts = [(Ether(dst=self.pg7.local_mac,
400 src=self.pg7.remote_mac) /
401 IP(src=self.pg7.remote_ip4, dst="9.0.0.100") /
402 TCP(sport=1234, dport=4321, flags=80) /
405 nowUTC = int(time.time())
406 nowUNIX = nowUTC+2208988800
407 self.send_packets(src_if=self.pg7, dst_if=self.pg8)
409 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 10)
410 self.collector.get_capture(2)
412 if cflow[0].haslayer(IPFIX):
413 self.assertEqual(cflow[IPFIX].version, 10)
414 self.assertEqual(cflow[IPFIX].observationDomainID, 1)
415 self.assertEqual(cflow[IPFIX].sequenceNumber, 0)
416 self.assertAlmostEqual(cflow[IPFIX].exportTime, nowUTC, delta=5)
417 if cflow.haslayer(Data):
418 record = ipfix_decoder.decode_data_set(cflow[0].getlayer(Set))[0]
420 self.assertEqual(int(binascii.hexlify(record[10]), 16), 8)
422 self.assertEqual(int(binascii.hexlify(record[14]), 16), 9)
424 self.assertEqual(int(binascii.hexlify(record[2]), 16), 1)
426 self.assertEqual(mac_ntop(record[56]), self.pg8.local_mac)
428 self.assertEqual(mac_ntop(record[80]), self.pg8.remote_mac)
429 flowTimestamp = int(binascii.hexlify(record[156]), 16) >> 32
430 # flow start timestamp
431 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
432 flowTimestamp = int(binascii.hexlify(record[157]), 16) >> 32
434 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
436 self.assertEqual(int(binascii.hexlify(record[256]), 16), 8)
438 self.assertEqual(inet_ntop(socket.AF_INET, record[8]),
441 self.assertEqual(inet_ntop(socket.AF_INET, record[12]),
444 self.assertEqual(int(binascii.hexlify(record[4]), 16), 6)
446 self.assertEqual(int(binascii.hexlify(record[7]), 16), 1234)
448 self.assertEqual(int(binascii.hexlify(record[11]), 16), 4321)
450 self.assertEqual(int(binascii.hexlify(record[6]), 16), 80)
452 ipfix.remove_vpp_config()
453 self.logger.info("FFP_TEST_FINISH_0000")
456 @tag_fixme_vpp_workers
457 class Datapath(MethodHolder):
458 """collect information on Ethernet, IP4 and IP6 datapath (no timers)"""
462 super(Datapath, cls).setUpClass()
465 def tearDownClass(cls):
466 super(Datapath, cls).tearDownClass()
468 def test_templatesL2(self):
469 """ verify template on L2 datapath"""
470 self.logger.info("FFP_TEST_START_0000")
471 self.pg_enable_capture(self.pg_interfaces)
473 ipfix = VppCFLOW(test=self, layer='l2')
474 ipfix.add_vpp_config()
476 # template packet should arrive immediately
477 self.vapi.ipfix_flush()
478 ipfix.verify_templates(timeout=3, count=1)
479 self.collector.get_capture(1)
481 ipfix.remove_vpp_config()
482 self.logger.info("FFP_TEST_FINISH_0000")
484 def test_L2onL2(self):
485 """ L2 data on L2 datapath"""
486 self.logger.info("FFP_TEST_START_0001")
487 self.pg_enable_capture(self.pg_interfaces)
490 ipfix = VppCFLOW(test=self, layer='l2')
491 ipfix.add_vpp_config()
493 ipfix_decoder = IPFIXDecoder()
494 # template packet should arrive immediately
495 templates = ipfix.verify_templates(ipfix_decoder, count=1)
497 self.create_stream(packets=1)
498 capture = self.send_packets()
500 # make sure the one packet we expect actually showed up
501 self.vapi.ipfix_flush()
502 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
503 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
504 {2: 'packets', 256: 8})
505 self.collector.get_capture(2)
507 ipfix.remove_vpp_config()
508 self.logger.info("FFP_TEST_FINISH_0001")
510 def test_L3onL2(self):
511 """ L3 data on L2 datapath"""
512 self.logger.info("FFP_TEST_START_0002")
513 self.pg_enable_capture(self.pg_interfaces)
516 ipfix = VppCFLOW(test=self, layer='l3')
517 ipfix.add_vpp_config()
519 ipfix_decoder = IPFIXDecoder()
520 # template packet should arrive immediately
521 templates = ipfix.verify_templates(ipfix_decoder, count=2)
523 self.create_stream(packets=1)
524 capture = self.send_packets()
526 # make sure the one packet we expect actually showed up
527 self.vapi.ipfix_flush()
528 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
529 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
530 {2: 'packets', 4: 17,
531 8: 'src_ip', 12: 'dst_ip'})
533 self.collector.get_capture(3)
535 ipfix.remove_vpp_config()
536 self.logger.info("FFP_TEST_FINISH_0002")
538 def test_L4onL2(self):
539 """ L4 data on L2 datapath"""
540 self.logger.info("FFP_TEST_START_0003")
541 self.pg_enable_capture(self.pg_interfaces)
544 ipfix = VppCFLOW(test=self, layer='l4')
545 ipfix.add_vpp_config()
547 ipfix_decoder = IPFIXDecoder()
548 # template packet should arrive immediately
549 templates = ipfix.verify_templates(ipfix_decoder, count=2)
551 self.create_stream(packets=1)
552 capture = self.send_packets()
554 # make sure the one packet we expect actually showed up
555 self.vapi.ipfix_flush()
556 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
557 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
558 {2: 'packets', 7: 'sport', 11: 'dport'})
560 self.collector.get_capture(3)
562 ipfix.remove_vpp_config()
563 self.logger.info("FFP_TEST_FINISH_0003")
565 def test_templatesIp4(self):
566 """ verify templates on IP4 datapath"""
567 self.logger.info("FFP_TEST_START_0000")
569 self.pg_enable_capture(self.pg_interfaces)
571 ipfix = VppCFLOW(test=self, datapath='ip4')
572 ipfix.add_vpp_config()
574 # template packet should arrive immediately
575 self.vapi.ipfix_flush()
576 ipfix.verify_templates(timeout=3, count=1)
577 self.collector.get_capture(1)
579 ipfix.remove_vpp_config()
581 self.logger.info("FFP_TEST_FINISH_0000")
583 def test_L2onIP4(self):
584 """ L2 data on IP4 datapath"""
585 self.logger.info("FFP_TEST_START_0001")
586 self.pg_enable_capture(self.pg_interfaces)
589 ipfix = VppCFLOW(test=self, intf='pg4', layer='l2', datapath='ip4')
590 ipfix.add_vpp_config()
592 ipfix_decoder = IPFIXDecoder()
593 # template packet should arrive immediately
594 templates = ipfix.verify_templates(ipfix_decoder, count=1)
596 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
597 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
599 # make sure the one packet we expect actually showed up
600 self.vapi.ipfix_flush()
601 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
602 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
603 {2: 'packets', 256: 8})
605 # expected two templates and one cflow packet
606 self.collector.get_capture(2)
608 ipfix.remove_vpp_config()
609 self.logger.info("FFP_TEST_FINISH_0001")
611 def test_L3onIP4(self):
612 """ L3 data on IP4 datapath"""
613 self.logger.info("FFP_TEST_START_0002")
614 self.pg_enable_capture(self.pg_interfaces)
617 ipfix = VppCFLOW(test=self, intf='pg4', layer='l3', datapath='ip4')
618 ipfix.add_vpp_config()
620 ipfix_decoder = IPFIXDecoder()
621 # template packet should arrive immediately
622 templates = ipfix.verify_templates(ipfix_decoder, count=1)
624 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
625 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
627 # make sure the one packet we expect actually showed up
628 self.vapi.ipfix_flush()
629 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
630 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
631 {1: 'octets', 2: 'packets',
632 8: 'src_ip', 12: 'dst_ip'})
634 # expected two templates and one cflow packet
635 self.collector.get_capture(2)
637 ipfix.remove_vpp_config()
638 self.logger.info("FFP_TEST_FINISH_0002")
640 def test_L4onIP4(self):
641 """ L4 data on IP4 datapath"""
642 self.logger.info("FFP_TEST_START_0003")
643 self.pg_enable_capture(self.pg_interfaces)
646 ipfix = VppCFLOW(test=self, intf='pg4', layer='l4', datapath='ip4')
647 ipfix.add_vpp_config()
649 ipfix_decoder = IPFIXDecoder()
650 # template packet should arrive immediately
651 templates = ipfix.verify_templates(ipfix_decoder, count=1)
653 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
654 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
656 # make sure the one packet we expect actually showed up
657 self.vapi.ipfix_flush()
658 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
659 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
660 {2: 'packets', 7: 'sport', 11: 'dport'})
662 # expected two templates and one cflow packet
663 self.collector.get_capture(2)
665 ipfix.remove_vpp_config()
666 self.logger.info("FFP_TEST_FINISH_0003")
668 def test_templatesIP6(self):
669 """ verify templates on IP6 datapath"""
670 self.logger.info("FFP_TEST_START_0000")
671 self.pg_enable_capture(self.pg_interfaces)
673 ipfix = VppCFLOW(test=self, datapath='ip6')
674 ipfix.add_vpp_config()
676 # template packet should arrive immediately
677 ipfix.verify_templates(count=1)
678 self.collector.get_capture(1)
680 ipfix.remove_vpp_config()
682 self.logger.info("FFP_TEST_FINISH_0000")
684 def test_L2onIP6(self):
685 """ L2 data on IP6 datapath"""
686 self.logger.info("FFP_TEST_START_0001")
687 self.pg_enable_capture(self.pg_interfaces)
690 ipfix = VppCFLOW(test=self, intf='pg6', layer='l2', datapath='ip6')
691 ipfix.add_vpp_config()
693 ipfix_decoder = IPFIXDecoder()
694 # template packet should arrive immediately
695 templates = ipfix.verify_templates(ipfix_decoder, count=1)
697 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
699 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
701 # make sure the one packet we expect actually showed up
702 self.vapi.ipfix_flush()
703 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
704 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
705 {2: 'packets', 256: 56710},
708 # expected two templates and one cflow packet
709 self.collector.get_capture(2)
711 ipfix.remove_vpp_config()
712 self.logger.info("FFP_TEST_FINISH_0001")
714 def test_L3onIP6(self):
715 """ L3 data on IP6 datapath"""
716 self.logger.info("FFP_TEST_START_0002")
717 self.pg_enable_capture(self.pg_interfaces)
720 ipfix = VppCFLOW(test=self, intf='pg6', layer='l3', datapath='ip6')
721 ipfix.add_vpp_config()
723 ipfix_decoder = IPFIXDecoder()
724 # template packet should arrive immediately
725 templates = ipfix.verify_templates(ipfix_decoder, count=1)
727 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
729 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
731 # make sure the one packet we expect actually showed up
732 self.vapi.ipfix_flush()
733 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
734 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
736 27: 'src_ip', 28: 'dst_ip'},
739 # expected two templates and one cflow packet
740 self.collector.get_capture(2)
742 ipfix.remove_vpp_config()
743 self.logger.info("FFP_TEST_FINISH_0002")
745 def test_L4onIP6(self):
746 """ L4 data on IP6 datapath"""
747 self.logger.info("FFP_TEST_START_0003")
748 self.pg_enable_capture(self.pg_interfaces)
751 ipfix = VppCFLOW(test=self, intf='pg6', layer='l4', datapath='ip6')
752 ipfix.add_vpp_config()
754 ipfix_decoder = IPFIXDecoder()
755 # template packet should arrive immediately
756 templates = ipfix.verify_templates(ipfix_decoder, count=1)
758 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
760 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
762 # make sure the one packet we expect actually showed up
763 self.vapi.ipfix_flush()
764 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
765 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
766 {2: 'packets', 7: 'sport', 11: 'dport'},
769 # expected two templates and one cflow packet
770 self.collector.get_capture(2)
772 ipfix.remove_vpp_config()
773 self.logger.info("FFP_TEST_FINISH_0003")
776 """ no timers, one CFLOW packet, 9 Flows inside"""
777 self.logger.info("FFP_TEST_START_0001")
778 self.pg_enable_capture(self.pg_interfaces)
781 ipfix = VppCFLOW(test=self)
782 ipfix.add_vpp_config()
784 ipfix_decoder = IPFIXDecoder()
785 # template packet should arrive immediately
786 templates = ipfix.verify_templates(ipfix_decoder)
788 self.create_stream(packets=9)
789 capture = self.send_packets()
791 # make sure the one packet we expect actually showed up
792 self.vapi.ipfix_flush()
793 cflow = self.wait_for_cflow_packet(self.collector, templates[1])
794 self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow])
795 self.collector.get_capture(4)
797 ipfix.remove_vpp_config()
798 self.logger.info("FFP_TEST_FINISH_0001")
801 """ no timers, two CFLOW packets (mtu=256), 3 Flows in each"""
802 self.logger.info("FFP_TEST_START_0002")
803 self.pg_enable_capture(self.pg_interfaces)
806 ipfix = VppCFLOW(test=self, mtu=256)
807 ipfix.add_vpp_config()
809 ipfix_decoder = IPFIXDecoder()
810 # template packet should arrive immediately
811 self.vapi.ipfix_flush()
812 templates = ipfix.verify_templates(ipfix_decoder)
814 self.create_stream(packets=6)
815 capture = self.send_packets()
817 # make sure the one packet we expect actually showed up
819 self.vapi.ipfix_flush()
820 cflows.append(self.wait_for_cflow_packet(self.collector,
822 cflows.append(self.wait_for_cflow_packet(self.collector,
824 self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows)
825 self.collector.get_capture(5)
827 ipfix.remove_vpp_config()
828 self.logger.info("FFP_TEST_FINISH_0002")
831 @unittest.skipUnless(config.extended, "part of extended tests")
832 class DisableIPFIX(MethodHolder):
837 super(DisableIPFIX, cls).setUpClass()
840 def tearDownClass(cls):
841 super(DisableIPFIX, cls).tearDownClass()
844 """ disable IPFIX after first packets"""
845 self.logger.info("FFP_TEST_START_0001")
846 self.pg_enable_capture(self.pg_interfaces)
849 ipfix = VppCFLOW(test=self)
850 ipfix.add_vpp_config()
852 ipfix_decoder = IPFIXDecoder()
853 # template packet should arrive immediately
854 templates = ipfix.verify_templates(ipfix_decoder)
859 # make sure the one packet we expect actually showed up
860 self.vapi.ipfix_flush()
861 self.wait_for_cflow_packet(self.collector, templates[1])
862 self.collector.get_capture(4)
865 ipfix.disable_exporter()
866 self.pg_enable_capture([self.collector])
870 # make sure no one packet arrived in 1 minute
871 self.vapi.ipfix_flush()
872 self.sleep(1, "wait before verifying no packets sent")
873 self.collector.assert_nothing_captured()
875 ipfix.remove_vpp_config()
876 self.logger.info("FFP_TEST_FINISH_0001")
879 @unittest.skipUnless(config.extended, "part of extended tests")
880 class ReenableIPFIX(MethodHolder):
881 """Re-enable IPFIX"""
885 super(ReenableIPFIX, cls).setUpClass()
888 def tearDownClass(cls):
889 super(ReenableIPFIX, cls).tearDownClass()
892 """ disable IPFIX after first packets and re-enable after few packets
894 self.logger.info("FFP_TEST_START_0001")
895 self.pg_enable_capture(self.pg_interfaces)
898 ipfix = VppCFLOW(test=self)
899 ipfix.add_vpp_config()
901 ipfix_decoder = IPFIXDecoder()
902 # template packet should arrive immediately
903 templates = ipfix.verify_templates(ipfix_decoder)
905 self.create_stream(packets=5)
908 # make sure the one packet we expect actually showed up
909 self.vapi.ipfix_flush()
910 self.wait_for_cflow_packet(self.collector, templates[1])
911 self.collector.get_capture(4)
914 ipfix.disable_exporter()
915 self.vapi.ipfix_flush()
916 self.pg_enable_capture([self.collector])
920 # make sure no one packet arrived in active timer span
921 self.vapi.ipfix_flush()
922 self.sleep(1, "wait before verifying no packets sent")
923 self.collector.assert_nothing_captured()
924 self.pg2.get_capture(5)
927 ipfix.enable_exporter()
929 capture = self.collector.get_capture(4)
933 self.assertTrue(p.haslayer(IPFIX))
934 if p.haslayer(Template):
936 self.assertTrue(nr_templates, 3)
938 self.assertTrue(p.haslayer(IPFIX))
941 self.assertTrue(nr_templates, 1)
943 ipfix.remove_vpp_config()
944 self.logger.info("FFP_TEST_FINISH_0001")
947 @unittest.skipUnless(config.extended, "part of extended tests")
948 class DisableFP(MethodHolder):
949 """Disable Flowprobe feature"""
953 super(DisableFP, cls).setUpClass()
956 def tearDownClass(cls):
957 super(DisableFP, cls).tearDownClass()
960 """ disable flowprobe feature after first packets"""
961 self.logger.info("FFP_TEST_START_0001")
962 self.pg_enable_capture(self.pg_interfaces)
964 ipfix = VppCFLOW(test=self)
965 ipfix.add_vpp_config()
967 ipfix_decoder = IPFIXDecoder()
968 # template packet should arrive immediately
969 templates = ipfix.verify_templates(ipfix_decoder)
974 # make sure the one packet we expect actually showed up
975 self.vapi.ipfix_flush()
976 self.wait_for_cflow_packet(self.collector, templates[1])
977 self.collector.get_capture(4)
980 ipfix.disable_flowprobe_feature()
981 self.pg_enable_capture([self.collector])
985 # make sure no one packet arrived in active timer span
986 self.vapi.ipfix_flush()
987 self.sleep(1, "wait before verifying no packets sent")
988 self.collector.assert_nothing_captured()
990 ipfix.remove_vpp_config()
991 self.logger.info("FFP_TEST_FINISH_0001")
994 @unittest.skipUnless(config.extended, "part of extended tests")
995 class ReenableFP(MethodHolder):
996 """Re-enable Flowprobe feature"""
1000 super(ReenableFP, cls).setUpClass()
1003 def tearDownClass(cls):
1004 super(ReenableFP, cls).tearDownClass()
1006 def test_0001(self):
1007 """ disable flowprobe feature after first packets and re-enable
1008 after few packets """
1009 self.logger.info("FFP_TEST_START_0001")
1010 self.pg_enable_capture(self.pg_interfaces)
1013 ipfix = VppCFLOW(test=self)
1014 ipfix.add_vpp_config()
1016 ipfix_decoder = IPFIXDecoder()
1017 # template packet should arrive immediately
1018 self.vapi.ipfix_flush()
1019 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1021 self.create_stream()
1024 # make sure the one packet we expect actually showed up
1025 self.vapi.ipfix_flush()
1026 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1027 self.collector.get_capture(4)
1029 # disable FPP feature
1030 ipfix.disable_flowprobe_feature()
1031 self.pg_enable_capture([self.collector])
1035 # make sure no one packet arrived in active timer span
1036 self.vapi.ipfix_flush()
1037 self.sleep(5, "wait before verifying no packets sent")
1038 self.collector.assert_nothing_captured()
1040 # enable FPP feature
1041 ipfix.enable_flowprobe_feature()
1042 self.vapi.ipfix_flush()
1043 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1047 # make sure the next packets (templates and data) we expect actually
1049 self.vapi.ipfix_flush()
1050 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1051 self.collector.get_capture(4)
1053 ipfix.remove_vpp_config()
1054 self.logger.info("FFP_TEST_FINISH_0001")
1057 if __name__ == '__main__':
1058 unittest.main(testRunner=VppTestRunner)