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
23 class VppCFLOW(VppObject):
24 """CFLOW object for IPFIX exporter and Flowprobe feature"""
26 def __init__(self, test, intf='pg2', active=0, passive=0, timeout=100,
27 mtu=1024, datapath='l2', layer='l2 l3 l4'):
31 if passive == 0 or passive < active:
32 self._passive = active+1
34 self._passive = passive
35 self._datapath = datapath # l2 ip4 ip6
36 self._collect = layer # l2 l3 l4
37 self._timeout = timeout
39 self._configured = False
41 def add_vpp_config(self):
42 self.enable_exporter()
43 self._test.vapi.flowprobe_params(
44 record_l2=1 if 'l2' in self._collect.lower() else 0,
45 record_l3=1 if 'l3' in self._collect.lower() else 0,
46 record_l4=1 if 'l4' in self._collect.lower() else 0,
47 active_timer=self._active, passive_timer=self._passive)
48 self.enable_flowprobe_feature()
49 self._test.vapi.cli("ipfix flush")
50 self._configured = True
52 def remove_vpp_config(self):
53 self.disable_exporter()
54 self.disable_flowprobe_feature()
55 self._test.vapi.cli("ipfix flush")
56 self._configured = False
58 def enable_exporter(self):
59 self._test.vapi.set_ipfix_exporter(
60 collector_address=self._test.pg0.remote_ip4n,
61 src_address=self._test.pg0.local_ip4n,
63 template_interval=self._timeout)
65 def enable_flowprobe_feature(self):
66 self._test.vapi.ppcli("flowprobe feature add-del %s %s" %
67 (self._intf, self._datapath))
69 def disable_exporter(self):
70 self._test.vapi.cli("set ipfix exporter collector 0.0.0.0")
72 def disable_flowprobe_feature(self):
73 self._test.vapi.cli("flowprobe feature add-del %s %s disable" %
74 (self._intf, self._datapath))
77 return "ipfix-collector-%s-%s" % (self._src, self.dst)
79 def query_vpp_config(self):
80 return self._configured
82 def verify_templates(self, decoder=None, timeout=1, count=3):
84 p = self._test.wait_for_cflow_packet(self._test.collector, 2, timeout)
85 self._test.assertTrue(p.haslayer(IPFIX))
86 if decoder is not None and p.haslayer(Template):
87 templates.append(p[Template].templateID)
88 decoder.add_template(p.getlayer(Template))
90 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
91 self._test.assertTrue(p.haslayer(IPFIX))
92 if decoder is not None and p.haslayer(Template):
93 templates.append(p[Template].templateID)
94 decoder.add_template(p.getlayer(Template))
96 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
97 self._test.assertTrue(p.haslayer(IPFIX))
98 if decoder is not None and p.haslayer(Template):
99 templates.append(p[Template].templateID)
100 decoder.add_template(p.getlayer(Template))
104 class MethodHolder(VppTestCase):
105 """ Flow-per-packet plugin: test L2, IP4, IP6 reporting """
109 max_number_of_packets = 10
115 Perform standard class setup (defined by class method setUpClass in
116 class VppTestCase) before running the test case, set test case related
117 variables and configure VPP.
119 super(MethodHolder, cls).setUpClass()
121 # Create pg interfaces
122 cls.create_pg_interfaces(range(9))
125 cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
127 # Create BD with MAC learning and unknown unicast flooding disabled
128 # and put interfaces to this BD
129 cls.vapi.bridge_domain_add_del(bd_id=1, uu_flood=1, learn=1)
130 cls.vapi.sw_interface_set_l2_bridge(
131 rx_sw_if_index=cls.pg1._sw_if_index, bd_id=1)
132 cls.vapi.sw_interface_set_l2_bridge(
133 rx_sw_if_index=cls.pg2._sw_if_index, bd_id=1)
135 # Set up all interfaces
136 for i in cls.pg_interfaces:
140 cls.pg0.configure_ipv4_neighbors()
141 cls.collector = cls.pg0
144 cls.pg1.resolve_arp()
146 cls.pg2.resolve_arp()
148 cls.pg3.resolve_arp()
150 cls.pg4.resolve_arp()
153 cls.pg8.configure_ipv4_neighbors()
156 cls.pg5.resolve_ndp()
157 cls.pg5.disable_ipv6_ra()
159 cls.pg6.resolve_ndp()
160 cls.pg6.disable_ipv6_ra()
162 super(MethodHolder, cls).tearDownClass()
166 def tearDownClass(cls):
167 super(MethodHolder, cls).tearDownClass()
169 def create_stream(self, src_if=None, dst_if=None, packets=None,
170 size=None, ip_ver='v4'):
171 """Create a packet stream to tickle the plugin
173 :param VppInterface src_if: Source interface for packet stream
174 :param VppInterface src_if: Dst interface for packet stream
182 packets = random.randint(1, self.max_number_of_packets)
184 for p in range(0, packets):
186 pkt_size = random.choice(self.pg_if_packet_sizes)
187 info = self.create_packet_info(src_if, dst_if)
188 payload = self.info_to_payload(info)
189 p = Ether(src=src_if.remote_mac, dst=src_if.local_mac)
191 p /= IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4)
193 p /= IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6)
194 p /= UDP(sport=1234, dport=4321)
197 self.extend_packet(p, pkt_size)
200 def verify_cflow_data(self, decoder, capture, cflow):
206 if cflow.haslayer(Data):
207 data = decoder.decode_data_set(cflow.getlayer(Set))
209 self.assertEqual(int(binascii.hexlify(record[1]), 16), octets)
210 self.assertEqual(int(binascii.hexlify(record[2]), 16), packets)
212 def send_packets(self, src_if=None, dst_if=None):
217 self.pg_enable_capture([dst_if])
218 src_if.add_stream(self.pkts)
220 return dst_if.get_capture(len(self.pkts))
222 def verify_cflow_data_detail(self, decoder, capture, cflow,
223 data_set={1: 'octets', 2: 'packets'},
226 print(capture[0].show())
227 if cflow.haslayer(Data):
228 data = decoder.decode_data_set(cflow.getlayer(Set))
232 ip_layer = capture[0][IP]
234 ip_layer = capture[0][IPv6]
235 if data_set is not None:
237 # skip flow if ingress/egress interface is 0
238 if int(binascii.hexlify(record[10]), 16) == 0:
240 if int(binascii.hexlify(record[14]), 16) == 0:
243 for field in data_set:
244 if field not in record.keys():
246 value = data_set[field]
247 if value == 'octets':
250 value += 40 # ??? is this correct
251 elif value == 'packets':
253 elif value == 'src_ip':
255 ip = socket.inet_pton(socket.AF_INET,
258 ip = socket.inet_pton(socket.AF_INET6,
260 value = int(binascii.hexlify(ip), 16)
261 elif value == 'dst_ip':
263 ip = socket.inet_pton(socket.AF_INET,
266 ip = socket.inet_pton(socket.AF_INET6,
268 value = int(binascii.hexlify(ip), 16)
269 elif value == 'sport':
270 value = int(capture[0][UDP].sport)
271 elif value == 'dport':
272 value = int(capture[0][UDP].dport)
273 self.assertEqual(int(binascii.hexlify(
277 def verify_cflow_data_notimer(self, decoder, capture, cflows):
280 if cflow.haslayer(Data):
281 data = decoder.decode_data_set(cflow.getlayer(Set))
283 raise Exception("No CFLOW data")
288 self.assertEqual(p[IP].len, int(
289 binascii.hexlify(rec[1]), 16))
290 self.assertEqual(1, int(
291 binascii.hexlify(rec[2]), 16))
292 self.assertEqual(len(capture), idx)
294 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1,
296 """ wait for CFLOW packet and verify its correctness
298 :param timeout: how long to wait
300 :returns: tuple (packet, time spent waiting for packet)
302 self.logger.info("IPFIX: Waiting for CFLOW packet")
303 deadline = time.time() + timeout
305 # self.logger.debug(self.vapi.ppcli("show flow table"))
309 self.assert_in_range(counter, 0, 100, "number of packets ignored")
310 time_left = deadline - time.time()
312 if time_left < 0 and expected:
313 # self.logger.debug(self.vapi.ppcli("show flow table"))
314 raise CaptureTimeoutError(
315 "Packet did not arrive within timeout")
316 p = collector_intf.wait_for_packet(timeout=time_left)
317 except CaptureTimeoutError:
319 # self.logger.debug(self.vapi.ppcli("show flow table"))
320 raise CaptureTimeoutError(
321 "Packet did not arrive within timeout")
325 raise CaptureTimeoutError("Packet arrived even not expected")
326 self.assertEqual(p[Set].setID, set_id)
327 # self.logger.debug(self.vapi.ppcli("show flow table"))
328 self.logger.debug(ppp("IPFIX: Got packet:", p))
333 class Flowprobe(MethodHolder):
334 """Template verification, timer tests"""
338 super(Flowprobe, cls).setUpClass()
341 def tearDownClass(cls):
342 super(Flowprobe, cls).tearDownClass()
345 """ timer less than template timeout"""
346 self.logger.info("FFP_TEST_START_0001")
347 self.pg_enable_capture(self.pg_interfaces)
350 ipfix = VppCFLOW(test=self, active=2)
351 ipfix.add_vpp_config()
353 ipfix_decoder = IPFIXDecoder()
354 # template packet should arrive immediately
355 templates = ipfix.verify_templates(ipfix_decoder)
357 self.create_stream(packets=1)
359 capture = self.pg2.get_capture(1)
361 # make sure the one packet we expect actually showed up
362 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
363 self.verify_cflow_data(ipfix_decoder, capture, cflow)
365 ipfix.remove_vpp_config()
366 self.logger.info("FFP_TEST_FINISH_0001")
369 """ timer greater than template timeout"""
370 self.logger.info("FFP_TEST_START_0002")
371 self.pg_enable_capture(self.pg_interfaces)
374 ipfix = VppCFLOW(test=self, timeout=3, active=4)
375 ipfix.add_vpp_config()
377 ipfix_decoder = IPFIXDecoder()
378 # template packet should arrive immediately
379 ipfix.verify_templates()
381 self.create_stream(packets=2)
383 capture = self.pg2.get_capture(2)
385 # next set of template packet should arrive after 20 seconds
386 # template packet should arrive within 20 s
387 templates = ipfix.verify_templates(ipfix_decoder, timeout=5)
389 # make sure the one packet we expect actually showed up
390 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
391 self.verify_cflow_data(ipfix_decoder, capture, cflow)
393 ipfix.remove_vpp_config()
394 self.logger.info("FFP_TEST_FINISH_0002")
396 def test_cflow_packet(self):
397 """verify cflow packet fields"""
398 self.logger.info("FFP_TEST_START_0000")
399 self.pg_enable_capture(self.pg_interfaces)
402 ipfix = VppCFLOW(test=self, intf='pg8', datapath="ip4",
403 layer='l2 l3 l4', active=2)
404 ipfix.add_vpp_config()
406 route_9001 = VppIpRoute(self, "9.0.0.0", 24,
407 [VppRoutePath(self.pg8._remote_hosts[0].ip4,
408 self.pg8.sw_if_index)])
409 route_9001.add_vpp_config()
411 ipfix_decoder = IPFIXDecoder()
412 templates = ipfix.verify_templates(ipfix_decoder, count=1)
414 self.pkts = [(Ether(dst=self.pg7.local_mac,
415 src=self.pg7.remote_mac) /
416 IP(src=self.pg7.remote_ip4, dst="9.0.0.100") /
417 TCP(sport=1234, dport=4321, flags=80) /
420 nowUTC = int(time.time())
421 nowUNIX = nowUTC+2208988800
422 self.send_packets(src_if=self.pg7, dst_if=self.pg8)
424 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 10)
425 self.collector.get_capture(2)
427 if cflow[0].haslayer(IPFIX):
428 self.assertEqual(cflow[IPFIX].version, 10)
429 self.assertEqual(cflow[IPFIX].observationDomainID, 1)
430 self.assertEqual(cflow[IPFIX].sequenceNumber, 0)
431 self.assertAlmostEqual(cflow[IPFIX].exportTime, nowUTC, delta=5)
432 if cflow.haslayer(Data):
433 record = ipfix_decoder.decode_data_set(cflow[0].getlayer(Set))[0]
435 self.assertEqual(int(binascii.hexlify(record[10]), 16), 8)
437 self.assertEqual(int(binascii.hexlify(record[14]), 16), 9)
439 self.assertEqual(int(binascii.hexlify(record[2]), 16), 1)
441 self.assertEqual(':'.join(re.findall('..', record[56].encode(
442 'hex'))), self.pg8.local_mac)
444 self.assertEqual(':'.join(re.findall('..', record[80].encode(
445 'hex'))), 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('.'.join(re.findall('..', record[8].encode(
457 '.'.join('{:02x}'.format(int(n)) for n in
458 self.pg7.remote_ip4.split('.')))
460 self.assertEqual('.'.join(re.findall('..', record[12].encode(
462 '.'.join('{:02x}'.format(int(n)) for n in
463 "9.0.0.100".split('.')))
465 self.assertEqual(int(binascii.hexlify(record[4]), 16), 6)
467 self.assertEqual(int(binascii.hexlify(record[7]), 16), 1234)
469 self.assertEqual(int(binascii.hexlify(record[11]), 16), 4321)
471 self.assertEqual(int(binascii.hexlify(record[6]), 16), 80)
473 ipfix.remove_vpp_config()
474 self.logger.info("FFP_TEST_FINISH_0000")
477 class Datapath(MethodHolder):
478 """collect information on Ethernet, IP4 and IP6 datapath (no timers)"""
482 super(Datapath, cls).setUpClass()
485 def tearDownClass(cls):
486 super(Datapath, cls).tearDownClass()
488 def test_templatesL2(self):
489 """ verify template on L2 datapath"""
490 self.logger.info("FFP_TEST_START_0000")
491 self.pg_enable_capture(self.pg_interfaces)
493 ipfix = VppCFLOW(test=self, layer='l2')
494 ipfix.add_vpp_config()
496 # template packet should arrive immediately
497 self.vapi.cli("ipfix flush")
498 ipfix.verify_templates(timeout=3, count=1)
499 self.collector.get_capture(1)
501 ipfix.remove_vpp_config()
502 self.logger.info("FFP_TEST_FINISH_0000")
504 def test_L2onL2(self):
505 """ L2 data on L2 datapath"""
506 self.logger.info("FFP_TEST_START_0001")
507 self.pg_enable_capture(self.pg_interfaces)
510 ipfix = VppCFLOW(test=self, layer='l2')
511 ipfix.add_vpp_config()
513 ipfix_decoder = IPFIXDecoder()
514 # template packet should arrive immediately
515 templates = ipfix.verify_templates(ipfix_decoder, count=1)
517 self.create_stream(packets=1)
518 capture = self.send_packets()
520 # make sure the one packet we expect actually showed up
521 self.vapi.cli("ipfix flush")
522 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
523 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
524 {2: 'packets', 256: 8})
525 self.collector.get_capture(2)
527 ipfix.remove_vpp_config()
528 self.logger.info("FFP_TEST_FINISH_0001")
530 def test_L3onL2(self):
531 """ L3 data on L2 datapath"""
532 self.logger.info("FFP_TEST_START_0002")
533 self.pg_enable_capture(self.pg_interfaces)
536 ipfix = VppCFLOW(test=self, layer='l3')
537 ipfix.add_vpp_config()
539 ipfix_decoder = IPFIXDecoder()
540 # template packet should arrive immediately
541 templates = ipfix.verify_templates(ipfix_decoder, count=2)
543 self.create_stream(packets=1)
544 capture = self.send_packets()
546 # make sure the one packet we expect actually showed up
547 self.vapi.cli("ipfix flush")
548 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
549 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
550 {2: 'packets', 4: 17,
551 8: 'src_ip', 12: 'dst_ip'})
553 self.collector.get_capture(3)
555 ipfix.remove_vpp_config()
556 self.logger.info("FFP_TEST_FINISH_0002")
558 def test_L4onL2(self):
559 """ L4 data on L2 datapath"""
560 self.logger.info("FFP_TEST_START_0003")
561 self.pg_enable_capture(self.pg_interfaces)
564 ipfix = VppCFLOW(test=self, layer='l4')
565 ipfix.add_vpp_config()
567 ipfix_decoder = IPFIXDecoder()
568 # template packet should arrive immediately
569 templates = ipfix.verify_templates(ipfix_decoder, count=2)
571 self.create_stream(packets=1)
572 capture = self.send_packets()
574 # make sure the one packet we expect actually showed up
575 self.vapi.cli("ipfix flush")
576 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
577 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
578 {2: 'packets', 7: 'sport', 11: 'dport'})
580 self.collector.get_capture(3)
582 ipfix.remove_vpp_config()
583 self.logger.info("FFP_TEST_FINISH_0003")
585 def test_templatesIp4(self):
586 """ verify templates on IP4 datapath"""
587 self.logger.info("FFP_TEST_START_0000")
589 self.pg_enable_capture(self.pg_interfaces)
591 ipfix = VppCFLOW(test=self, datapath='ip4')
592 ipfix.add_vpp_config()
594 # template packet should arrive immediately
595 self.vapi.cli("ipfix flush")
596 ipfix.verify_templates(timeout=3, count=1)
597 self.collector.get_capture(1)
599 ipfix.remove_vpp_config()
601 self.logger.info("FFP_TEST_FINISH_0000")
603 def test_L2onIP4(self):
604 """ L2 data on IP4 datapath"""
605 self.logger.info("FFP_TEST_START_0001")
606 self.pg_enable_capture(self.pg_interfaces)
609 ipfix = VppCFLOW(test=self, intf='pg4', layer='l2', datapath='ip4')
610 ipfix.add_vpp_config()
612 ipfix_decoder = IPFIXDecoder()
613 # template packet should arrive immediately
614 templates = ipfix.verify_templates(ipfix_decoder, count=1)
616 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
617 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
619 # make sure the one packet we expect actually showed up
620 self.vapi.cli("ipfix flush")
621 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
622 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
623 {2: 'packets', 256: 8})
625 # expected two templates and one cflow packet
626 self.collector.get_capture(2)
628 ipfix.remove_vpp_config()
629 self.logger.info("FFP_TEST_FINISH_0001")
631 def test_L3onIP4(self):
632 """ L3 data on IP4 datapath"""
633 self.logger.info("FFP_TEST_START_0002")
634 self.pg_enable_capture(self.pg_interfaces)
637 ipfix = VppCFLOW(test=self, intf='pg4', layer='l3', datapath='ip4')
638 ipfix.add_vpp_config()
640 ipfix_decoder = IPFIXDecoder()
641 # template packet should arrive immediately
642 templates = ipfix.verify_templates(ipfix_decoder, count=1)
644 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
645 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
647 # make sure the one packet we expect actually showed up
648 self.vapi.cli("ipfix flush")
649 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
650 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
651 {1: 'octets', 2: 'packets',
652 8: 'src_ip', 12: 'dst_ip'})
654 # expected two templates and one cflow packet
655 self.collector.get_capture(2)
657 ipfix.remove_vpp_config()
658 self.logger.info("FFP_TEST_FINISH_0002")
660 def test_L4onIP4(self):
661 """ L4 data on IP4 datapath"""
662 self.logger.info("FFP_TEST_START_0003")
663 self.pg_enable_capture(self.pg_interfaces)
666 ipfix = VppCFLOW(test=self, intf='pg4', layer='l4', datapath='ip4')
667 ipfix.add_vpp_config()
669 ipfix_decoder = IPFIXDecoder()
670 # template packet should arrive immediately
671 templates = ipfix.verify_templates(ipfix_decoder, count=1)
673 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
674 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
676 # make sure the one packet we expect actually showed up
677 self.vapi.cli("ipfix flush")
678 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
679 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
680 {2: 'packets', 7: 'sport', 11: 'dport'})
682 # expected two templates and one cflow packet
683 self.collector.get_capture(2)
685 ipfix.remove_vpp_config()
686 self.logger.info("FFP_TEST_FINISH_0003")
688 def test_templatesIP6(self):
689 """ verify templates on IP6 datapath"""
690 self.logger.info("FFP_TEST_START_0000")
691 self.pg_enable_capture(self.pg_interfaces)
693 ipfix = VppCFLOW(test=self, datapath='ip6')
694 ipfix.add_vpp_config()
696 # template packet should arrive immediately
697 ipfix.verify_templates(count=1)
698 self.collector.get_capture(1)
700 ipfix.remove_vpp_config()
702 self.logger.info("FFP_TEST_FINISH_0000")
704 def test_L2onIP6(self):
705 """ L2 data on IP6 datapath"""
706 self.logger.info("FFP_TEST_START_0001")
707 self.pg_enable_capture(self.pg_interfaces)
710 ipfix = VppCFLOW(test=self, intf='pg6', layer='l2', datapath='ip6')
711 ipfix.add_vpp_config()
713 ipfix_decoder = IPFIXDecoder()
714 # template packet should arrive immediately
715 templates = ipfix.verify_templates(ipfix_decoder, count=1)
717 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
719 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
721 # make sure the one packet we expect actually showed up
722 self.vapi.cli("ipfix flush")
723 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
724 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
725 {2: 'packets', 256: 56710},
728 # expected two templates and one cflow packet
729 self.collector.get_capture(2)
731 ipfix.remove_vpp_config()
732 self.logger.info("FFP_TEST_FINISH_0001")
734 def test_L3onIP6(self):
735 """ L3 data on IP6 datapath"""
736 self.logger.info("FFP_TEST_START_0002")
737 self.pg_enable_capture(self.pg_interfaces)
740 ipfix = VppCFLOW(test=self, intf='pg6', layer='l3', datapath='ip6')
741 ipfix.add_vpp_config()
743 ipfix_decoder = IPFIXDecoder()
744 # template packet should arrive immediately
745 templates = ipfix.verify_templates(ipfix_decoder, count=1)
747 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
749 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
751 # make sure the one packet we expect actually showed up
752 self.vapi.cli("ipfix flush")
753 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
754 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
756 27: 'src_ip', 28: 'dst_ip'},
759 # expected two templates and one cflow packet
760 self.collector.get_capture(2)
762 ipfix.remove_vpp_config()
763 self.logger.info("FFP_TEST_FINISH_0002")
765 def test_L4onIP6(self):
766 """ L4 data on IP6 datapath"""
767 self.logger.info("FFP_TEST_START_0003")
768 self.pg_enable_capture(self.pg_interfaces)
771 ipfix = VppCFLOW(test=self, intf='pg6', layer='l4', datapath='ip6')
772 ipfix.add_vpp_config()
774 ipfix_decoder = IPFIXDecoder()
775 # template packet should arrive immediately
776 templates = ipfix.verify_templates(ipfix_decoder, count=1)
778 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
780 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
782 # make sure the one packet we expect actually showed up
783 self.vapi.cli("ipfix flush")
784 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
785 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
786 {2: 'packets', 7: 'sport', 11: 'dport'},
789 # expected two templates and one cflow packet
790 self.collector.get_capture(2)
792 ipfix.remove_vpp_config()
793 self.logger.info("FFP_TEST_FINISH_0003")
796 """ no timers, one CFLOW packet, 9 Flows inside"""
797 self.logger.info("FFP_TEST_START_0001")
798 self.pg_enable_capture(self.pg_interfaces)
801 ipfix = VppCFLOW(test=self)
802 ipfix.add_vpp_config()
804 ipfix_decoder = IPFIXDecoder()
805 # template packet should arrive immediately
806 templates = ipfix.verify_templates(ipfix_decoder)
808 self.create_stream(packets=9)
809 capture = self.send_packets()
811 # make sure the one packet we expect actually showed up
812 self.vapi.cli("ipfix flush")
813 cflow = self.wait_for_cflow_packet(self.collector, templates[1])
814 self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow])
815 self.collector.get_capture(4)
817 ipfix.remove_vpp_config()
818 self.logger.info("FFP_TEST_FINISH_0001")
821 """ no timers, two CFLOW packets (mtu=256), 3 Flows in each"""
822 self.logger.info("FFP_TEST_START_0002")
823 self.pg_enable_capture(self.pg_interfaces)
826 ipfix = VppCFLOW(test=self, mtu=256)
827 ipfix.add_vpp_config()
829 ipfix_decoder = IPFIXDecoder()
830 # template packet should arrive immediately
831 self.vapi.cli("ipfix flush")
832 templates = ipfix.verify_templates(ipfix_decoder)
834 self.create_stream(packets=6)
835 capture = self.send_packets()
837 # make sure the one packet we expect actually showed up
839 self.vapi.cli("ipfix flush")
840 cflows.append(self.wait_for_cflow_packet(self.collector,
842 cflows.append(self.wait_for_cflow_packet(self.collector,
844 self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows)
845 self.collector.get_capture(5)
847 ipfix.remove_vpp_config()
848 self.logger.info("FFP_TEST_FINISH_0002")
851 @unittest.skipUnless(running_extended_tests, "part of extended tests")
852 class DisableIPFIX(MethodHolder):
857 super(DisableIPFIX, cls).setUpClass()
860 def tearDownClass(cls):
861 super(DisableIPFIX, cls).tearDownClass()
864 """ disable IPFIX after first packets"""
865 self.logger.info("FFP_TEST_START_0001")
866 self.pg_enable_capture(self.pg_interfaces)
869 ipfix = VppCFLOW(test=self)
870 ipfix.add_vpp_config()
872 ipfix_decoder = IPFIXDecoder()
873 # template packet should arrive immediately
874 templates = ipfix.verify_templates(ipfix_decoder)
879 # make sure the one packet we expect actually showed up
880 self.vapi.cli("ipfix flush")
881 self.wait_for_cflow_packet(self.collector, templates[1])
882 self.collector.get_capture(4)
885 ipfix.disable_exporter()
886 self.pg_enable_capture([self.collector])
890 # make sure no one packet arrived in 1 minute
891 self.vapi.cli("ipfix flush")
892 self.wait_for_cflow_packet(self.collector, templates[1],
894 self.collector.get_capture(0)
896 ipfix.remove_vpp_config()
897 self.logger.info("FFP_TEST_FINISH_0001")
900 @unittest.skipUnless(running_extended_tests, "part of extended tests")
901 class ReenableIPFIX(MethodHolder):
902 """Re-enable IPFIX"""
906 super(ReenableIPFIX, cls).setUpClass()
909 def tearDownClass(cls):
910 super(ReenableIPFIX, cls).tearDownClass()
913 """ disable IPFIX after first packets and re-enable after few packets
915 self.logger.info("FFP_TEST_START_0001")
916 self.pg_enable_capture(self.pg_interfaces)
919 ipfix = VppCFLOW(test=self)
920 ipfix.add_vpp_config()
922 ipfix_decoder = IPFIXDecoder()
923 # template packet should arrive immediately
924 templates = ipfix.verify_templates(ipfix_decoder)
926 self.create_stream(packets=5)
929 # make sure the one packet we expect actually showed up
930 self.vapi.cli("ipfix flush")
931 self.wait_for_cflow_packet(self.collector, templates[1])
932 self.collector.get_capture(4)
935 ipfix.disable_exporter()
936 self.vapi.cli("ipfix flush")
937 self.pg_enable_capture([self.collector])
941 # make sure no one packet arrived in active timer span
942 self.vapi.cli("ipfix flush")
943 self.wait_for_cflow_packet(self.collector, templates[1],
945 self.collector.get_capture(0)
946 self.pg2.get_capture(5)
949 ipfix.enable_exporter()
951 capture = self.collector.get_capture(4)
955 self.assertTrue(p.haslayer(IPFIX))
956 if p.haslayer(Template):
958 self.assertTrue(nr_templates, 3)
960 self.assertTrue(p.haslayer(IPFIX))
963 self.assertTrue(nr_templates, 1)
965 ipfix.remove_vpp_config()
966 self.logger.info("FFP_TEST_FINISH_0001")
969 @unittest.skipUnless(running_extended_tests, "part of extended tests")
970 class DisableFP(MethodHolder):
971 """Disable Flowprobe feature"""
975 super(DisableFP, cls).setUpClass()
978 def tearDownClass(cls):
979 super(DisableFP, cls).tearDownClass()
982 """ disable flowprobe feature after first packets"""
983 self.logger.info("FFP_TEST_START_0001")
984 self.pg_enable_capture(self.pg_interfaces)
986 ipfix = VppCFLOW(test=self)
987 ipfix.add_vpp_config()
989 ipfix_decoder = IPFIXDecoder()
990 # template packet should arrive immediately
991 templates = ipfix.verify_templates(ipfix_decoder)
996 # make sure the one packet we expect actually showed up
997 self.vapi.cli("ipfix flush")
998 self.wait_for_cflow_packet(self.collector, templates[1])
999 self.collector.get_capture(4)
1002 ipfix.disable_flowprobe_feature()
1003 self.pg_enable_capture([self.collector])
1007 # make sure no one packet arrived in active timer span
1008 self.vapi.cli("ipfix flush")
1009 self.wait_for_cflow_packet(self.collector, templates[1],
1011 self.collector.get_capture(0)
1013 ipfix.remove_vpp_config()
1014 self.logger.info("FFP_TEST_FINISH_0001")
1017 @unittest.skipUnless(running_extended_tests, "part of extended tests")
1018 class ReenableFP(MethodHolder):
1019 """Re-enable Flowprobe feature"""
1022 def setUpClass(cls):
1023 super(ReenableFP, cls).setUpClass()
1026 def tearDownClass(cls):
1027 super(ReenableFP, cls).tearDownClass()
1029 def test_0001(self):
1030 """ disable flowprobe feature after first packets and re-enable
1031 after few packets """
1032 self.logger.info("FFP_TEST_START_0001")
1033 self.pg_enable_capture(self.pg_interfaces)
1036 ipfix = VppCFLOW(test=self)
1037 ipfix.add_vpp_config()
1039 ipfix_decoder = IPFIXDecoder()
1040 # template packet should arrive immediately
1041 self.vapi.cli("ipfix flush")
1042 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1044 self.create_stream()
1047 # make sure the one packet we expect actually showed up
1048 self.vapi.cli("ipfix flush")
1049 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1050 self.collector.get_capture(4)
1052 # disable FPP feature
1053 ipfix.disable_flowprobe_feature()
1054 self.pg_enable_capture([self.collector])
1058 # make sure no one packet arrived in active timer span
1059 self.vapi.cli("ipfix flush")
1060 self.wait_for_cflow_packet(self.collector, templates[1], 5,
1062 self.collector.get_capture(0)
1064 # enable FPP feature
1065 ipfix.enable_flowprobe_feature()
1066 self.vapi.cli("ipfix flush")
1067 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1071 # make sure the next packets (templates and data) we expect actually
1073 self.vapi.cli("ipfix flush")
1074 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1075 self.collector.get_capture(4)
1077 ipfix.remove_vpp_config()
1078 self.logger.info("FFP_TEST_FINISH_0001")
1081 if __name__ == '__main__':
1082 unittest.main(testRunner=VppTestRunner)