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.ppcli("flowprobe params record %s active %s "
44 "passive %s" % (self._collect, self._active,
46 self.enable_flowprobe_feature()
47 self._test.vapi.cli("ipfix flush")
48 self._configured = True
50 def remove_vpp_config(self):
51 self.disable_exporter()
52 self.disable_flowprobe_feature()
53 self._test.vapi.cli("ipfix flush")
54 self._configured = False
56 def enable_exporter(self):
57 self._test.vapi.set_ipfix_exporter(
58 collector_address=self._test.pg0.remote_ip4n,
59 src_address=self._test.pg0.local_ip4n,
61 template_interval=self._timeout)
63 def enable_flowprobe_feature(self):
64 self._test.vapi.ppcli("flowprobe feature add-del %s %s" %
65 (self._intf, self._datapath))
67 def disable_exporter(self):
68 self._test.vapi.cli("set ipfix exporter collector 0.0.0.0")
70 def disable_flowprobe_feature(self):
71 self._test.vapi.cli("flowprobe feature add-del %s %s disable" %
72 (self._intf, self._datapath))
75 return "ipfix-collector-%s" % (self._src, self.dst)
77 def query_vpp_config(self):
78 return self._configured
80 def verify_templates(self, decoder=None, timeout=1, count=3):
82 p = self._test.wait_for_cflow_packet(self._test.collector, 2, timeout)
83 self._test.assertTrue(p.haslayer(IPFIX))
84 if decoder is not None and p.haslayer(Template):
85 templates.append(p[Template].templateID)
86 decoder.add_template(p.getlayer(Template))
88 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
89 self._test.assertTrue(p.haslayer(IPFIX))
90 if decoder is not None and p.haslayer(Template):
91 templates.append(p[Template].templateID)
92 decoder.add_template(p.getlayer(Template))
94 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
95 self._test.assertTrue(p.haslayer(IPFIX))
96 if decoder is not None and p.haslayer(Template):
97 templates.append(p[Template].templateID)
98 decoder.add_template(p.getlayer(Template))
102 class MethodHolder(VppTestCase):
103 """ Flow-per-packet plugin: test L2, IP4, IP6 reporting """
107 max_number_of_packets = 10
113 Perform standard class setup (defined by class method setUpClass in
114 class VppTestCase) before running the test case, set test case related
115 variables and configure VPP.
117 super(MethodHolder, cls).setUpClass()
119 # Create pg interfaces
120 cls.create_pg_interfaces(range(9))
123 cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
125 # Create BD with MAC learning and unknown unicast flooding disabled
126 # and put interfaces to this BD
127 cls.vapi.bridge_domain_add_del(bd_id=1, uu_flood=1, learn=1)
128 cls.vapi.sw_interface_set_l2_bridge(cls.pg1._sw_if_index, bd_id=1)
129 cls.vapi.sw_interface_set_l2_bridge(cls.pg2._sw_if_index, bd_id=1)
131 # Set up all interfaces
132 for i in cls.pg_interfaces:
136 cls.pg0.configure_ipv4_neighbors()
137 cls.collector = cls.pg0
140 cls.pg1.resolve_arp()
142 cls.pg2.resolve_arp()
144 cls.pg3.resolve_arp()
146 cls.pg4.resolve_arp()
149 cls.pg8.configure_ipv4_neighbors()
152 cls.pg5.resolve_ndp()
153 cls.pg5.disable_ipv6_ra()
155 cls.pg6.resolve_ndp()
156 cls.pg6.disable_ipv6_ra()
158 super(MethodHolder, cls).tearDownClass()
162 def tearDownClass(cls):
163 super(MethodHolder, cls).tearDownClass()
165 def create_stream(self, src_if=None, dst_if=None, packets=None,
166 size=None, ip_ver='v4'):
167 """Create a packet stream to tickle the plugin
169 :param VppInterface src_if: Source interface for packet stream
170 :param VppInterface src_if: Dst interface for packet stream
178 packets = random.randint(1, self.max_number_of_packets)
180 for p in range(0, packets):
182 pkt_size = random.choice(self.pg_if_packet_sizes)
183 info = self.create_packet_info(src_if, dst_if)
184 payload = self.info_to_payload(info)
185 p = Ether(src=src_if.remote_mac, dst=src_if.local_mac)
187 p /= IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4)
189 p /= IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6)
190 p /= UDP(sport=1234, dport=4321)
193 self.extend_packet(p, pkt_size)
196 def verify_cflow_data(self, decoder, capture, cflow):
202 if cflow.haslayer(Data):
203 data = decoder.decode_data_set(cflow.getlayer(Set))
205 self.assertEqual(int(binascii.hexlify(record[1]), 16), octets)
206 self.assertEqual(int(binascii.hexlify(record[2]), 16), packets)
208 def send_packets(self, src_if=None, dst_if=None):
213 self.pg_enable_capture([dst_if])
214 src_if.add_stream(self.pkts)
216 return dst_if.get_capture(len(self.pkts))
218 def verify_cflow_data_detail(self, decoder, capture, cflow,
219 data_set={1: 'octets', 2: 'packets'},
222 print(capture[0].show())
223 if cflow.haslayer(Data):
224 data = decoder.decode_data_set(cflow.getlayer(Set))
228 ip_layer = capture[0][IP]
230 ip_layer = capture[0][IPv6]
231 if data_set is not None:
233 # skip flow if in/out gress interface is 0
234 if int(binascii.hexlify(record[10]), 16) == 0:
236 if int(binascii.hexlify(record[14]), 16) == 0:
239 for field in data_set:
240 if field not in record.keys():
242 value = data_set[field]
243 if value == 'octets':
246 value += 40 # ??? is this correct
247 elif value == 'packets':
249 elif value == 'src_ip':
251 ip = socket.inet_pton(socket.AF_INET,
254 ip = socket.inet_pton(socket.AF_INET6,
256 value = int(binascii.hexlify(ip), 16)
257 elif value == 'dst_ip':
259 ip = socket.inet_pton(socket.AF_INET,
262 ip = socket.inet_pton(socket.AF_INET6,
264 value = int(binascii.hexlify(ip), 16)
265 elif value == 'sport':
266 value = int(capture[0][UDP].sport)
267 elif value == 'dport':
268 value = int(capture[0][UDP].dport)
269 self.assertEqual(int(binascii.hexlify(
273 def verify_cflow_data_notimer(self, decoder, capture, cflows):
276 if cflow.haslayer(Data):
277 data = decoder.decode_data_set(cflow.getlayer(Set))
279 raise Exception("No CFLOW data")
284 self.assertEqual(p[IP].len, int(
285 binascii.hexlify(rec[1]), 16))
286 self.assertEqual(1, int(
287 binascii.hexlify(rec[2]), 16))
288 self.assertEqual(len(capture), idx)
290 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1,
292 """ wait for CFLOW packet and verify its correctness
294 :param timeout: how long to wait
296 :returns: tuple (packet, time spent waiting for packet)
298 self.logger.info("IPFIX: Waiting for CFLOW packet")
299 deadline = time.time() + timeout
301 # self.logger.debug(self.vapi.ppcli("show flow table"))
305 self.assert_in_range(counter, 0, 100, "number of packets ignored")
306 time_left = deadline - time.time()
308 if time_left < 0 and expected:
309 # self.logger.debug(self.vapi.ppcli("show flow table"))
310 raise CaptureTimeoutError(
311 "Packet did not arrive within timeout")
312 p = collector_intf.wait_for_packet(timeout=time_left)
313 except CaptureTimeoutError:
315 # self.logger.debug(self.vapi.ppcli("show flow table"))
316 raise CaptureTimeoutError(
317 "Packet did not arrive within timeout")
321 raise CaptureTimeoutError("Packet arrived even not expected")
322 self.assertEqual(p[Set].setID, set_id)
323 # self.logger.debug(self.vapi.ppcli("show flow table"))
324 self.logger.debug(ppp("IPFIX: Got packet:", p))
329 class Flowprobe(MethodHolder):
330 """Template verification, timer tests"""
334 super(Flowprobe, cls).setUpClass()
337 def tearDownClass(cls):
338 super(Flowprobe, cls).tearDownClass()
341 """ timer less than template timeout"""
342 self.logger.info("FFP_TEST_START_0001")
343 self.pg_enable_capture(self.pg_interfaces)
346 ipfix = VppCFLOW(test=self, active=2)
347 ipfix.add_vpp_config()
349 ipfix_decoder = IPFIXDecoder()
350 # template packet should arrive immediately
351 templates = ipfix.verify_templates(ipfix_decoder)
353 self.create_stream(packets=1)
355 capture = self.pg2.get_capture(1)
357 # make sure the one packet we expect actually showed up
358 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
359 self.verify_cflow_data(ipfix_decoder, capture, cflow)
361 ipfix.remove_vpp_config()
362 self.logger.info("FFP_TEST_FINISH_0001")
365 """ timer greater than template timeout"""
366 self.logger.info("FFP_TEST_START_0002")
367 self.pg_enable_capture(self.pg_interfaces)
370 ipfix = VppCFLOW(test=self, timeout=3, active=4)
371 ipfix.add_vpp_config()
373 ipfix_decoder = IPFIXDecoder()
374 # template packet should arrive immediately
375 ipfix.verify_templates()
377 self.create_stream(packets=2)
379 capture = self.pg2.get_capture(2)
381 # next set of template packet should arrive after 20 seconds
382 # template packet should arrive within 20 s
383 templates = ipfix.verify_templates(ipfix_decoder, timeout=5)
385 # make sure the one packet we expect actually showed up
386 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
387 self.verify_cflow_data(ipfix_decoder, capture, cflow)
389 ipfix.remove_vpp_config()
390 self.logger.info("FFP_TEST_FINISH_0002")
392 def test_cflow_packet(self):
393 """verify cflow packet fields"""
394 self.logger.info("FFP_TEST_START_0000")
395 self.pg_enable_capture(self.pg_interfaces)
398 ipfix = VppCFLOW(test=self, intf='pg8', datapath="ip4",
399 layer='l2 l3 l4', active=2)
400 ipfix.add_vpp_config()
402 route_9001 = VppIpRoute(self, "9.0.0.0", 24,
403 [VppRoutePath(self.pg8._remote_hosts[0].ip4,
404 self.pg8.sw_if_index)])
405 route_9001.add_vpp_config()
407 ipfix_decoder = IPFIXDecoder()
408 templates = ipfix.verify_templates(ipfix_decoder, count=1)
410 self.pkts = [(Ether(dst=self.pg7.local_mac,
411 src=self.pg7.remote_mac) /
412 IP(src=self.pg7.remote_ip4, dst="9.0.0.100") /
413 TCP(sport=1234, dport=4321, flags=80) /
416 nowUTC = int(time.time())
417 nowUNIX = nowUTC+2208988800
418 self.send_packets(src_if=self.pg7, dst_if=self.pg8)
420 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 10)
421 self.collector.get_capture(2)
423 if cflow[0].haslayer(IPFIX):
424 self.assertEqual(cflow[IPFIX].version, 10)
425 self.assertEqual(cflow[IPFIX].observationDomainID, 1)
426 self.assertEqual(cflow[IPFIX].sequenceNumber, 0)
427 self.assertAlmostEqual(cflow[IPFIX].exportTime, nowUTC, delta=5)
428 if cflow.haslayer(Data):
429 record = ipfix_decoder.decode_data_set(cflow[0].getlayer(Set))[0]
431 self.assertEqual(int(binascii.hexlify(record[10]), 16), 8)
433 self.assertEqual(int(binascii.hexlify(record[14]), 16), 9)
435 self.assertEqual(int(binascii.hexlify(record[2]), 16), 1)
437 self.assertEqual(':'.join(re.findall('..', record[56].encode(
438 'hex'))), self.pg8.local_mac)
440 self.assertEqual(':'.join(re.findall('..', record[80].encode(
441 'hex'))), self.pg8.remote_mac)
442 flowTimestamp = int(binascii.hexlify(record[156]), 16) >> 32
443 # flow start timestamp
444 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
445 flowTimestamp = int(binascii.hexlify(record[157]), 16) >> 32
447 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
449 self.assertEqual(int(binascii.hexlify(record[256]), 16), 8)
451 self.assertEqual('.'.join(re.findall('..', record[8].encode(
453 '.'.join('{:02x}'.format(int(n)) for n in
454 self.pg7.remote_ip4.split('.')))
456 self.assertEqual('.'.join(re.findall('..', record[12].encode(
458 '.'.join('{:02x}'.format(int(n)) for n in
459 "9.0.0.100".split('.')))
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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("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.cli("ipfix flush")
933 self.pg_enable_capture([self.collector])
937 # make sure no one packet arrived in active timer span
938 self.vapi.cli("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.cli("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.cli("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.cli("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.cli("ipfix flush")
1045 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1046 self.collector.get_capture(4)
1048 # disble 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.cli("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.cli("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.cli("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)