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-%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(
129 rx_sw_if_index=cls.pg1._sw_if_index, bd_id=1)
130 cls.vapi.sw_interface_set_l2_bridge(
131 rx_sw_if_index=cls.pg2._sw_if_index, bd_id=1)
133 # Set up all interfaces
134 for i in cls.pg_interfaces:
138 cls.pg0.configure_ipv4_neighbors()
139 cls.collector = cls.pg0
142 cls.pg1.resolve_arp()
144 cls.pg2.resolve_arp()
146 cls.pg3.resolve_arp()
148 cls.pg4.resolve_arp()
151 cls.pg8.configure_ipv4_neighbors()
154 cls.pg5.resolve_ndp()
155 cls.pg5.disable_ipv6_ra()
157 cls.pg6.resolve_ndp()
158 cls.pg6.disable_ipv6_ra()
160 super(MethodHolder, cls).tearDownClass()
164 def tearDownClass(cls):
165 super(MethodHolder, cls).tearDownClass()
167 def create_stream(self, src_if=None, dst_if=None, packets=None,
168 size=None, ip_ver='v4'):
169 """Create a packet stream to tickle the plugin
171 :param VppInterface src_if: Source interface for packet stream
172 :param VppInterface src_if: Dst interface for packet stream
180 packets = random.randint(1, self.max_number_of_packets)
182 for p in range(0, packets):
184 pkt_size = random.choice(self.pg_if_packet_sizes)
185 info = self.create_packet_info(src_if, dst_if)
186 payload = self.info_to_payload(info)
187 p = Ether(src=src_if.remote_mac, dst=src_if.local_mac)
189 p /= IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4)
191 p /= IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6)
192 p /= UDP(sport=1234, dport=4321)
195 self.extend_packet(p, pkt_size)
198 def verify_cflow_data(self, decoder, capture, cflow):
204 if cflow.haslayer(Data):
205 data = decoder.decode_data_set(cflow.getlayer(Set))
207 self.assertEqual(int(binascii.hexlify(record[1]), 16), octets)
208 self.assertEqual(int(binascii.hexlify(record[2]), 16), packets)
210 def send_packets(self, src_if=None, dst_if=None):
215 self.pg_enable_capture([dst_if])
216 src_if.add_stream(self.pkts)
218 return dst_if.get_capture(len(self.pkts))
220 def verify_cflow_data_detail(self, decoder, capture, cflow,
221 data_set={1: 'octets', 2: 'packets'},
224 print(capture[0].show())
225 if cflow.haslayer(Data):
226 data = decoder.decode_data_set(cflow.getlayer(Set))
230 ip_layer = capture[0][IP]
232 ip_layer = capture[0][IPv6]
233 if data_set is not None:
235 # skip flow if in/out gress interface is 0
236 if int(binascii.hexlify(record[10]), 16) == 0:
238 if int(binascii.hexlify(record[14]), 16) == 0:
241 for field in data_set:
242 if field not in record.keys():
244 value = data_set[field]
245 if value == 'octets':
248 value += 40 # ??? is this correct
249 elif value == 'packets':
251 elif value == 'src_ip':
253 ip = socket.inet_pton(socket.AF_INET,
256 ip = socket.inet_pton(socket.AF_INET6,
258 value = int(binascii.hexlify(ip), 16)
259 elif value == 'dst_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 == 'sport':
268 value = int(capture[0][UDP].sport)
269 elif value == 'dport':
270 value = int(capture[0][UDP].dport)
271 self.assertEqual(int(binascii.hexlify(
275 def verify_cflow_data_notimer(self, decoder, capture, cflows):
278 if cflow.haslayer(Data):
279 data = decoder.decode_data_set(cflow.getlayer(Set))
281 raise Exception("No CFLOW data")
286 self.assertEqual(p[IP].len, int(
287 binascii.hexlify(rec[1]), 16))
288 self.assertEqual(1, int(
289 binascii.hexlify(rec[2]), 16))
290 self.assertEqual(len(capture), idx)
292 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1,
294 """ wait for CFLOW packet and verify its correctness
296 :param timeout: how long to wait
298 :returns: tuple (packet, time spent waiting for packet)
300 self.logger.info("IPFIX: Waiting for CFLOW packet")
301 deadline = time.time() + timeout
303 # self.logger.debug(self.vapi.ppcli("show flow table"))
307 self.assert_in_range(counter, 0, 100, "number of packets ignored")
308 time_left = deadline - time.time()
310 if time_left < 0 and expected:
311 # self.logger.debug(self.vapi.ppcli("show flow table"))
312 raise CaptureTimeoutError(
313 "Packet did not arrive within timeout")
314 p = collector_intf.wait_for_packet(timeout=time_left)
315 except CaptureTimeoutError:
317 # self.logger.debug(self.vapi.ppcli("show flow table"))
318 raise CaptureTimeoutError(
319 "Packet did not arrive within timeout")
323 raise CaptureTimeoutError("Packet arrived even not expected")
324 self.assertEqual(p[Set].setID, set_id)
325 # self.logger.debug(self.vapi.ppcli("show flow table"))
326 self.logger.debug(ppp("IPFIX: Got packet:", p))
331 class Flowprobe(MethodHolder):
332 """Template verification, timer tests"""
336 super(Flowprobe, cls).setUpClass()
339 def tearDownClass(cls):
340 super(Flowprobe, cls).tearDownClass()
343 """ timer less than template timeout"""
344 self.logger.info("FFP_TEST_START_0001")
345 self.pg_enable_capture(self.pg_interfaces)
348 ipfix = VppCFLOW(test=self, active=2)
349 ipfix.add_vpp_config()
351 ipfix_decoder = IPFIXDecoder()
352 # template packet should arrive immediately
353 templates = ipfix.verify_templates(ipfix_decoder)
355 self.create_stream(packets=1)
357 capture = self.pg2.get_capture(1)
359 # make sure the one packet we expect actually showed up
360 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
361 self.verify_cflow_data(ipfix_decoder, capture, cflow)
363 ipfix.remove_vpp_config()
364 self.logger.info("FFP_TEST_FINISH_0001")
367 """ timer greater than template timeout"""
368 self.logger.info("FFP_TEST_START_0002")
369 self.pg_enable_capture(self.pg_interfaces)
372 ipfix = VppCFLOW(test=self, timeout=3, active=4)
373 ipfix.add_vpp_config()
375 ipfix_decoder = IPFIXDecoder()
376 # template packet should arrive immediately
377 ipfix.verify_templates()
379 self.create_stream(packets=2)
381 capture = self.pg2.get_capture(2)
383 # next set of template packet should arrive after 20 seconds
384 # template packet should arrive within 20 s
385 templates = ipfix.verify_templates(ipfix_decoder, timeout=5)
387 # make sure the one packet we expect actually showed up
388 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
389 self.verify_cflow_data(ipfix_decoder, capture, cflow)
391 ipfix.remove_vpp_config()
392 self.logger.info("FFP_TEST_FINISH_0002")
394 def test_cflow_packet(self):
395 """verify cflow packet fields"""
396 self.logger.info("FFP_TEST_START_0000")
397 self.pg_enable_capture(self.pg_interfaces)
400 ipfix = VppCFLOW(test=self, intf='pg8', datapath="ip4",
401 layer='l2 l3 l4', active=2)
402 ipfix.add_vpp_config()
404 route_9001 = VppIpRoute(self, "9.0.0.0", 24,
405 [VppRoutePath(self.pg8._remote_hosts[0].ip4,
406 self.pg8.sw_if_index)])
407 route_9001.add_vpp_config()
409 ipfix_decoder = IPFIXDecoder()
410 templates = ipfix.verify_templates(ipfix_decoder, count=1)
412 self.pkts = [(Ether(dst=self.pg7.local_mac,
413 src=self.pg7.remote_mac) /
414 IP(src=self.pg7.remote_ip4, dst="9.0.0.100") /
415 TCP(sport=1234, dport=4321, flags=80) /
418 nowUTC = int(time.time())
419 nowUNIX = nowUTC+2208988800
420 self.send_packets(src_if=self.pg7, dst_if=self.pg8)
422 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 10)
423 self.collector.get_capture(2)
425 if cflow[0].haslayer(IPFIX):
426 self.assertEqual(cflow[IPFIX].version, 10)
427 self.assertEqual(cflow[IPFIX].observationDomainID, 1)
428 self.assertEqual(cflow[IPFIX].sequenceNumber, 0)
429 self.assertAlmostEqual(cflow[IPFIX].exportTime, nowUTC, delta=5)
430 if cflow.haslayer(Data):
431 record = ipfix_decoder.decode_data_set(cflow[0].getlayer(Set))[0]
433 self.assertEqual(int(binascii.hexlify(record[10]), 16), 8)
435 self.assertEqual(int(binascii.hexlify(record[14]), 16), 9)
437 self.assertEqual(int(binascii.hexlify(record[2]), 16), 1)
439 self.assertEqual(':'.join(re.findall('..', record[56].encode(
440 'hex'))), self.pg8.local_mac)
442 self.assertEqual(':'.join(re.findall('..', record[80].encode(
443 'hex'))), self.pg8.remote_mac)
444 flowTimestamp = int(binascii.hexlify(record[156]), 16) >> 32
445 # flow start timestamp
446 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
447 flowTimestamp = int(binascii.hexlify(record[157]), 16) >> 32
449 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
451 self.assertEqual(int(binascii.hexlify(record[256]), 16), 8)
453 self.assertEqual('.'.join(re.findall('..', record[8].encode(
455 '.'.join('{:02x}'.format(int(n)) for n in
456 self.pg7.remote_ip4.split('.')))
458 self.assertEqual('.'.join(re.findall('..', record[12].encode(
460 '.'.join('{:02x}'.format(int(n)) for n in
461 "9.0.0.100".split('.')))
463 self.assertEqual(int(binascii.hexlify(record[4]), 16), 6)
465 self.assertEqual(int(binascii.hexlify(record[7]), 16), 1234)
467 self.assertEqual(int(binascii.hexlify(record[11]), 16), 4321)
469 self.assertEqual(int(binascii.hexlify(record[6]), 16), 80)
471 ipfix.remove_vpp_config()
472 self.logger.info("FFP_TEST_FINISH_0000")
475 class Datapath(MethodHolder):
476 """collect information on Ethernet, IP4 and IP6 datapath (no timers)"""
480 super(Datapath, cls).setUpClass()
483 def tearDownClass(cls):
484 super(Datapath, cls).tearDownClass()
486 def test_templatesL2(self):
487 """ verify template on L2 datapath"""
488 self.logger.info("FFP_TEST_START_0000")
489 self.pg_enable_capture(self.pg_interfaces)
491 ipfix = VppCFLOW(test=self, layer='l2')
492 ipfix.add_vpp_config()
494 # template packet should arrive immediately
495 self.vapi.cli("ipfix flush")
496 ipfix.verify_templates(timeout=3, count=1)
497 self.collector.get_capture(1)
499 ipfix.remove_vpp_config()
500 self.logger.info("FFP_TEST_FINISH_0000")
502 def test_L2onL2(self):
503 """ L2 data on L2 datapath"""
504 self.logger.info("FFP_TEST_START_0001")
505 self.pg_enable_capture(self.pg_interfaces)
508 ipfix = VppCFLOW(test=self, layer='l2')
509 ipfix.add_vpp_config()
511 ipfix_decoder = IPFIXDecoder()
512 # template packet should arrive immediately
513 templates = ipfix.verify_templates(ipfix_decoder, count=1)
515 self.create_stream(packets=1)
516 capture = self.send_packets()
518 # make sure the one packet we expect actually showed up
519 self.vapi.cli("ipfix flush")
520 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
521 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
522 {2: 'packets', 256: 8})
523 self.collector.get_capture(2)
525 ipfix.remove_vpp_config()
526 self.logger.info("FFP_TEST_FINISH_0001")
528 def test_L3onL2(self):
529 """ L3 data on L2 datapath"""
530 self.logger.info("FFP_TEST_START_0002")
531 self.pg_enable_capture(self.pg_interfaces)
534 ipfix = VppCFLOW(test=self, layer='l3')
535 ipfix.add_vpp_config()
537 ipfix_decoder = IPFIXDecoder()
538 # template packet should arrive immediately
539 templates = ipfix.verify_templates(ipfix_decoder, count=2)
541 self.create_stream(packets=1)
542 capture = self.send_packets()
544 # make sure the one packet we expect actually showed up
545 self.vapi.cli("ipfix flush")
546 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
547 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
548 {2: 'packets', 4: 17,
549 8: 'src_ip', 12: 'dst_ip'})
551 self.collector.get_capture(3)
553 ipfix.remove_vpp_config()
554 self.logger.info("FFP_TEST_FINISH_0002")
556 def test_L4onL2(self):
557 """ L4 data on L2 datapath"""
558 self.logger.info("FFP_TEST_START_0003")
559 self.pg_enable_capture(self.pg_interfaces)
562 ipfix = VppCFLOW(test=self, layer='l4')
563 ipfix.add_vpp_config()
565 ipfix_decoder = IPFIXDecoder()
566 # template packet should arrive immediately
567 templates = ipfix.verify_templates(ipfix_decoder, count=2)
569 self.create_stream(packets=1)
570 capture = self.send_packets()
572 # make sure the one packet we expect actually showed up
573 self.vapi.cli("ipfix flush")
574 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
575 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
576 {2: 'packets', 7: 'sport', 11: 'dport'})
578 self.collector.get_capture(3)
580 ipfix.remove_vpp_config()
581 self.logger.info("FFP_TEST_FINISH_0003")
583 def test_templatesIp4(self):
584 """ verify templates on IP4 datapath"""
585 self.logger.info("FFP_TEST_START_0000")
587 self.pg_enable_capture(self.pg_interfaces)
589 ipfix = VppCFLOW(test=self, datapath='ip4')
590 ipfix.add_vpp_config()
592 # template packet should arrive immediately
593 self.vapi.cli("ipfix flush")
594 ipfix.verify_templates(timeout=3, count=1)
595 self.collector.get_capture(1)
597 ipfix.remove_vpp_config()
599 self.logger.info("FFP_TEST_FINISH_0000")
601 def test_L2onIP4(self):
602 """ L2 data on IP4 datapath"""
603 self.logger.info("FFP_TEST_START_0001")
604 self.pg_enable_capture(self.pg_interfaces)
607 ipfix = VppCFLOW(test=self, intf='pg4', layer='l2', datapath='ip4')
608 ipfix.add_vpp_config()
610 ipfix_decoder = IPFIXDecoder()
611 # template packet should arrive immediately
612 templates = ipfix.verify_templates(ipfix_decoder, count=1)
614 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
615 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
617 # make sure the one packet we expect actually showed up
618 self.vapi.cli("ipfix flush")
619 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
620 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
621 {2: 'packets', 256: 8})
623 # expected two templates and one cflow packet
624 self.collector.get_capture(2)
626 ipfix.remove_vpp_config()
627 self.logger.info("FFP_TEST_FINISH_0001")
629 def test_L3onIP4(self):
630 """ L3 data on IP4 datapath"""
631 self.logger.info("FFP_TEST_START_0002")
632 self.pg_enable_capture(self.pg_interfaces)
635 ipfix = VppCFLOW(test=self, intf='pg4', layer='l3', datapath='ip4')
636 ipfix.add_vpp_config()
638 ipfix_decoder = IPFIXDecoder()
639 # template packet should arrive immediately
640 templates = ipfix.verify_templates(ipfix_decoder, count=1)
642 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
643 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
645 # make sure the one packet we expect actually showed up
646 self.vapi.cli("ipfix flush")
647 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
648 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
649 {1: 'octets', 2: 'packets',
650 8: 'src_ip', 12: 'dst_ip'})
652 # expected two templates and one cflow packet
653 self.collector.get_capture(2)
655 ipfix.remove_vpp_config()
656 self.logger.info("FFP_TEST_FINISH_0002")
658 def test_L4onIP4(self):
659 """ L4 data on IP4 datapath"""
660 self.logger.info("FFP_TEST_START_0003")
661 self.pg_enable_capture(self.pg_interfaces)
664 ipfix = VppCFLOW(test=self, intf='pg4', layer='l4', datapath='ip4')
665 ipfix.add_vpp_config()
667 ipfix_decoder = IPFIXDecoder()
668 # template packet should arrive immediately
669 templates = ipfix.verify_templates(ipfix_decoder, count=1)
671 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
672 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
674 # make sure the one packet we expect actually showed up
675 self.vapi.cli("ipfix flush")
676 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
677 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
678 {2: 'packets', 7: 'sport', 11: 'dport'})
680 # expected two templates and one cflow packet
681 self.collector.get_capture(2)
683 ipfix.remove_vpp_config()
684 self.logger.info("FFP_TEST_FINISH_0003")
686 def test_templatesIP6(self):
687 """ verify templates on IP6 datapath"""
688 self.logger.info("FFP_TEST_START_0000")
689 self.pg_enable_capture(self.pg_interfaces)
691 ipfix = VppCFLOW(test=self, datapath='ip6')
692 ipfix.add_vpp_config()
694 # template packet should arrive immediately
695 ipfix.verify_templates(count=1)
696 self.collector.get_capture(1)
698 ipfix.remove_vpp_config()
700 self.logger.info("FFP_TEST_FINISH_0000")
702 def test_L2onIP6(self):
703 """ L2 data on IP6 datapath"""
704 self.logger.info("FFP_TEST_START_0001")
705 self.pg_enable_capture(self.pg_interfaces)
708 ipfix = VppCFLOW(test=self, intf='pg6', layer='l2', datapath='ip6')
709 ipfix.add_vpp_config()
711 ipfix_decoder = IPFIXDecoder()
712 # template packet should arrive immediately
713 templates = ipfix.verify_templates(ipfix_decoder, count=1)
715 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
717 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
719 # make sure the one packet we expect actually showed up
720 self.vapi.cli("ipfix flush")
721 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
722 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
723 {2: 'packets', 256: 56710},
726 # expected two templates and one cflow packet
727 self.collector.get_capture(2)
729 ipfix.remove_vpp_config()
730 self.logger.info("FFP_TEST_FINISH_0001")
732 def test_L3onIP6(self):
733 """ L3 data on IP6 datapath"""
734 self.logger.info("FFP_TEST_START_0002")
735 self.pg_enable_capture(self.pg_interfaces)
738 ipfix = VppCFLOW(test=self, intf='pg6', layer='l3', datapath='ip6')
739 ipfix.add_vpp_config()
741 ipfix_decoder = IPFIXDecoder()
742 # template packet should arrive immediately
743 templates = ipfix.verify_templates(ipfix_decoder, count=1)
745 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
747 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
749 # make sure the one packet we expect actually showed up
750 self.vapi.cli("ipfix flush")
751 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
752 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
754 27: 'src_ip', 28: 'dst_ip'},
757 # expected two templates and one cflow packet
758 self.collector.get_capture(2)
760 ipfix.remove_vpp_config()
761 self.logger.info("FFP_TEST_FINISH_0002")
763 def test_L4onIP6(self):
764 """ L4 data on IP6 datapath"""
765 self.logger.info("FFP_TEST_START_0003")
766 self.pg_enable_capture(self.pg_interfaces)
769 ipfix = VppCFLOW(test=self, intf='pg6', layer='l4', datapath='ip6')
770 ipfix.add_vpp_config()
772 ipfix_decoder = IPFIXDecoder()
773 # template packet should arrive immediately
774 templates = ipfix.verify_templates(ipfix_decoder, count=1)
776 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
778 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
780 # make sure the one packet we expect actually showed up
781 self.vapi.cli("ipfix flush")
782 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
783 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
784 {2: 'packets', 7: 'sport', 11: 'dport'},
787 # expected two templates and one cflow packet
788 self.collector.get_capture(2)
790 ipfix.remove_vpp_config()
791 self.logger.info("FFP_TEST_FINISH_0003")
794 """ no timers, one CFLOW packet, 9 Flows inside"""
795 self.logger.info("FFP_TEST_START_0001")
796 self.pg_enable_capture(self.pg_interfaces)
799 ipfix = VppCFLOW(test=self)
800 ipfix.add_vpp_config()
802 ipfix_decoder = IPFIXDecoder()
803 # template packet should arrive immediately
804 templates = ipfix.verify_templates(ipfix_decoder)
806 self.create_stream(packets=9)
807 capture = self.send_packets()
809 # make sure the one packet we expect actually showed up
810 self.vapi.cli("ipfix flush")
811 cflow = self.wait_for_cflow_packet(self.collector, templates[1])
812 self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow])
813 self.collector.get_capture(4)
815 ipfix.remove_vpp_config()
816 self.logger.info("FFP_TEST_FINISH_0001")
819 """ no timers, two CFLOW packets (mtu=256), 3 Flows in each"""
820 self.logger.info("FFP_TEST_START_0002")
821 self.pg_enable_capture(self.pg_interfaces)
824 ipfix = VppCFLOW(test=self, mtu=256)
825 ipfix.add_vpp_config()
827 ipfix_decoder = IPFIXDecoder()
828 # template packet should arrive immediately
829 self.vapi.cli("ipfix flush")
830 templates = ipfix.verify_templates(ipfix_decoder)
832 self.create_stream(packets=6)
833 capture = self.send_packets()
835 # make sure the one packet we expect actually showed up
837 self.vapi.cli("ipfix flush")
838 cflows.append(self.wait_for_cflow_packet(self.collector,
840 cflows.append(self.wait_for_cflow_packet(self.collector,
842 self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows)
843 self.collector.get_capture(5)
845 ipfix.remove_vpp_config()
846 self.logger.info("FFP_TEST_FINISH_0002")
849 @unittest.skipUnless(running_extended_tests, "part of extended tests")
850 class DisableIPFIX(MethodHolder):
855 super(DisableIPFIX, cls).setUpClass()
858 def tearDownClass(cls):
859 super(DisableIPFIX, cls).tearDownClass()
862 """ disable IPFIX after first packets"""
863 self.logger.info("FFP_TEST_START_0001")
864 self.pg_enable_capture(self.pg_interfaces)
867 ipfix = VppCFLOW(test=self)
868 ipfix.add_vpp_config()
870 ipfix_decoder = IPFIXDecoder()
871 # template packet should arrive immediately
872 templates = ipfix.verify_templates(ipfix_decoder)
877 # make sure the one packet we expect actually showed up
878 self.vapi.cli("ipfix flush")
879 self.wait_for_cflow_packet(self.collector, templates[1])
880 self.collector.get_capture(4)
883 ipfix.disable_exporter()
884 self.pg_enable_capture([self.collector])
888 # make sure no one packet arrived in 1 minute
889 self.vapi.cli("ipfix flush")
890 self.wait_for_cflow_packet(self.collector, templates[1],
892 self.collector.get_capture(0)
894 ipfix.remove_vpp_config()
895 self.logger.info("FFP_TEST_FINISH_0001")
898 @unittest.skipUnless(running_extended_tests, "part of extended tests")
899 class ReenableIPFIX(MethodHolder):
900 """Re-enable IPFIX"""
904 super(ReenableIPFIX, cls).setUpClass()
907 def tearDownClass(cls):
908 super(ReenableIPFIX, cls).tearDownClass()
911 """ disable IPFIX after first packets and re-enable after few packets
913 self.logger.info("FFP_TEST_START_0001")
914 self.pg_enable_capture(self.pg_interfaces)
917 ipfix = VppCFLOW(test=self)
918 ipfix.add_vpp_config()
920 ipfix_decoder = IPFIXDecoder()
921 # template packet should arrive immediately
922 templates = ipfix.verify_templates(ipfix_decoder)
924 self.create_stream(packets=5)
927 # make sure the one packet we expect actually showed up
928 self.vapi.cli("ipfix flush")
929 self.wait_for_cflow_packet(self.collector, templates[1])
930 self.collector.get_capture(4)
933 ipfix.disable_exporter()
934 self.vapi.cli("ipfix flush")
935 self.pg_enable_capture([self.collector])
939 # make sure no one packet arrived in active timer span
940 self.vapi.cli("ipfix flush")
941 self.wait_for_cflow_packet(self.collector, templates[1],
943 self.collector.get_capture(0)
944 self.pg2.get_capture(5)
947 ipfix.enable_exporter()
949 capture = self.collector.get_capture(4)
953 self.assertTrue(p.haslayer(IPFIX))
954 if p.haslayer(Template):
956 self.assertTrue(nr_templates, 3)
958 self.assertTrue(p.haslayer(IPFIX))
961 self.assertTrue(nr_templates, 1)
963 ipfix.remove_vpp_config()
964 self.logger.info("FFP_TEST_FINISH_0001")
967 @unittest.skipUnless(running_extended_tests, "part of extended tests")
968 class DisableFP(MethodHolder):
969 """Disable Flowprobe feature"""
973 super(DisableFP, cls).setUpClass()
976 def tearDownClass(cls):
977 super(DisableFP, cls).tearDownClass()
980 """ disable flowprobe feature after first packets"""
981 self.logger.info("FFP_TEST_START_0001")
982 self.pg_enable_capture(self.pg_interfaces)
984 ipfix = VppCFLOW(test=self)
985 ipfix.add_vpp_config()
987 ipfix_decoder = IPFIXDecoder()
988 # template packet should arrive immediately
989 templates = ipfix.verify_templates(ipfix_decoder)
994 # make sure the one packet we expect actually showed up
995 self.vapi.cli("ipfix flush")
996 self.wait_for_cflow_packet(self.collector, templates[1])
997 self.collector.get_capture(4)
1000 ipfix.disable_flowprobe_feature()
1001 self.pg_enable_capture([self.collector])
1005 # make sure no one packet arrived in active timer span
1006 self.vapi.cli("ipfix flush")
1007 self.wait_for_cflow_packet(self.collector, templates[1],
1009 self.collector.get_capture(0)
1011 ipfix.remove_vpp_config()
1012 self.logger.info("FFP_TEST_FINISH_0001")
1015 @unittest.skipUnless(running_extended_tests, "part of extended tests")
1016 class ReenableFP(MethodHolder):
1017 """Re-enable Flowprobe feature"""
1020 def setUpClass(cls):
1021 super(ReenableFP, cls).setUpClass()
1024 def tearDownClass(cls):
1025 super(ReenableFP, cls).tearDownClass()
1027 def test_0001(self):
1028 """ disable flowprobe feature after first packets and re-enable
1029 after few packets """
1030 self.logger.info("FFP_TEST_START_0001")
1031 self.pg_enable_capture(self.pg_interfaces)
1034 ipfix = VppCFLOW(test=self)
1035 ipfix.add_vpp_config()
1037 ipfix_decoder = IPFIXDecoder()
1038 # template packet should arrive immediately
1039 self.vapi.cli("ipfix flush")
1040 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1042 self.create_stream()
1045 # make sure the one packet we expect actually showed up
1046 self.vapi.cli("ipfix flush")
1047 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1048 self.collector.get_capture(4)
1050 # disble FPP feature
1051 ipfix.disable_flowprobe_feature()
1052 self.pg_enable_capture([self.collector])
1056 # make sure no one packet arrived in active timer span
1057 self.vapi.cli("ipfix flush")
1058 self.wait_for_cflow_packet(self.collector, templates[1], 5,
1060 self.collector.get_capture(0)
1062 # enable FPP feature
1063 ipfix.enable_flowprobe_feature()
1064 self.vapi.cli("ipfix flush")
1065 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1069 # make sure the next packets (templates and data) we expect actually
1071 self.vapi.cli("ipfix flush")
1072 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1073 self.collector.get_capture(4)
1075 ipfix.remove_vpp_config()
1076 self.logger.info("FFP_TEST_FINISH_0001")
1079 if __name__ == '__main__':
1080 unittest.main(testRunner=VppTestRunner)