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()
161 def create_stream(self, src_if=None, dst_if=None, packets=None,
162 size=None, ip_ver='v4'):
163 """Create a packet stream to tickle the plugin
165 :param VppInterface src_if: Source interface for packet stream
166 :param VppInterface src_if: Dst interface for packet stream
174 packets = random.randint(1, self.max_number_of_packets)
176 for p in range(0, packets):
178 pkt_size = random.choice(self.pg_if_packet_sizes)
179 info = self.create_packet_info(src_if, dst_if)
180 payload = self.info_to_payload(info)
181 p = Ether(src=src_if.remote_mac, dst=src_if.local_mac)
183 p /= IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4)
185 p /= IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6)
186 p /= UDP(sport=1234, dport=4321)
189 self.extend_packet(p, pkt_size)
192 def verify_cflow_data(self, decoder, capture, cflow):
198 if cflow.haslayer(Data):
199 data = decoder.decode_data_set(cflow.getlayer(Set))
201 self.assertEqual(int(binascii.hexlify(record[1]), 16), octets)
202 self.assertEqual(int(binascii.hexlify(record[2]), 16), packets)
204 def send_packets(self, src_if=None, dst_if=None):
209 self.pg_enable_capture([dst_if])
210 src_if.add_stream(self.pkts)
212 return dst_if.get_capture(len(self.pkts))
214 def verify_cflow_data_detail(self, decoder, capture, cflow,
215 data_set={1: 'octets', 2: 'packets'},
218 print(capture[0].show())
219 if cflow.haslayer(Data):
220 data = decoder.decode_data_set(cflow.getlayer(Set))
224 ip_layer = capture[0][IP]
226 ip_layer = capture[0][IPv6]
227 if data_set is not None:
229 # skip flow if in/out gress interface is 0
230 if int(binascii.hexlify(record[10]), 16) == 0:
232 if int(binascii.hexlify(record[14]), 16) == 0:
235 for field in data_set:
236 if field not in record.keys():
238 value = data_set[field]
239 if value == 'octets':
242 value += 40 # ??? is this correct
243 elif value == 'packets':
245 elif value == 'src_ip':
247 ip = socket.inet_pton(socket.AF_INET,
250 ip = socket.inet_pton(socket.AF_INET6,
252 value = int(binascii.hexlify(ip), 16)
253 elif value == 'dst_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 == 'sport':
262 value = int(capture[0][UDP].sport)
263 elif value == 'dport':
264 value = int(capture[0][UDP].dport)
265 self.assertEqual(int(binascii.hexlify(
269 def verify_cflow_data_notimer(self, decoder, capture, cflows):
272 if cflow.haslayer(Data):
273 data = decoder.decode_data_set(cflow.getlayer(Set))
275 raise Exception("No CFLOW data")
280 self.assertEqual(p[IP].len, int(
281 binascii.hexlify(rec[1]), 16))
282 self.assertEqual(1, int(
283 binascii.hexlify(rec[2]), 16))
284 self.assertEqual(len(capture), idx)
286 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1,
288 """ wait for CFLOW packet and verify its correctness
290 :param timeout: how long to wait
292 :returns: tuple (packet, time spent waiting for packet)
294 self.logger.info("IPFIX: Waiting for CFLOW packet")
295 deadline = time.time() + timeout
297 # self.logger.debug(self.vapi.ppcli("show flow table"))
301 self.assert_in_range(counter, 0, 100, "number of packets ignored")
302 time_left = deadline - time.time()
304 if time_left < 0 and expected:
305 # self.logger.debug(self.vapi.ppcli("show flow table"))
306 raise CaptureTimeoutError(
307 "Packet did not arrive within timeout")
308 p = collector_intf.wait_for_packet(timeout=time_left)
309 except CaptureTimeoutError:
311 # self.logger.debug(self.vapi.ppcli("show flow table"))
312 raise CaptureTimeoutError(
313 "Packet did not arrive within timeout")
317 raise CaptureTimeoutError("Packet arrived even not expected")
318 self.assertEqual(p[Set].setID, set_id)
319 # self.logger.debug(self.vapi.ppcli("show flow table"))
320 self.logger.debug(ppp("IPFIX: Got packet:", p))
325 class Flowprobe(MethodHolder):
326 """Template verification, timer tests"""
329 """ timer less than template timeout"""
330 self.logger.info("FFP_TEST_START_0001")
331 self.pg_enable_capture(self.pg_interfaces)
334 ipfix = VppCFLOW(test=self, active=2)
335 ipfix.add_vpp_config()
337 ipfix_decoder = IPFIXDecoder()
338 # template packet should arrive immediately
339 templates = ipfix.verify_templates(ipfix_decoder)
341 self.create_stream(packets=1)
343 capture = self.pg2.get_capture(1)
345 # make sure the one packet we expect actually showed up
346 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
347 self.verify_cflow_data(ipfix_decoder, capture, cflow)
349 ipfix.remove_vpp_config()
350 self.logger.info("FFP_TEST_FINISH_0001")
353 """ timer greater than template timeout"""
354 self.logger.info("FFP_TEST_START_0002")
355 self.pg_enable_capture(self.pg_interfaces)
358 ipfix = VppCFLOW(test=self, timeout=3, active=4)
359 ipfix.add_vpp_config()
361 ipfix_decoder = IPFIXDecoder()
362 # template packet should arrive immediately
363 ipfix.verify_templates()
365 self.create_stream(packets=2)
367 capture = self.pg2.get_capture(2)
369 # next set of template packet should arrive after 20 seconds
370 # template packet should arrive within 20 s
371 templates = ipfix.verify_templates(ipfix_decoder, timeout=5)
373 # make sure the one packet we expect actually showed up
374 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
375 self.verify_cflow_data(ipfix_decoder, capture, cflow)
377 ipfix.remove_vpp_config()
378 self.logger.info("FFP_TEST_FINISH_0002")
380 def test_cflow_packet(self):
381 """verify cflow packet fields"""
382 self.logger.info("FFP_TEST_START_0000")
383 self.pg_enable_capture(self.pg_interfaces)
386 ipfix = VppCFLOW(test=self, intf='pg8', datapath="ip4",
387 layer='l2 l3 l4', active=2)
388 ipfix.add_vpp_config()
390 route_9001 = VppIpRoute(self, "9.0.0.0", 24,
391 [VppRoutePath(self.pg8._remote_hosts[0].ip4,
392 self.pg8.sw_if_index)])
393 route_9001.add_vpp_config()
395 ipfix_decoder = IPFIXDecoder()
396 templates = ipfix.verify_templates(ipfix_decoder, count=1)
398 self.pkts = [(Ether(dst=self.pg7.local_mac,
399 src=self.pg7.remote_mac) /
400 IP(src=self.pg7.remote_ip4, dst="9.0.0.100") /
401 TCP(sport=1234, dport=4321, flags=80) /
404 nowUTC = int(time.time())
405 nowUNIX = nowUTC+2208988800
406 self.send_packets(src_if=self.pg7, dst_if=self.pg8)
408 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 10)
409 self.collector.get_capture(2)
411 if cflow[0].haslayer(IPFIX):
412 self.assertEqual(cflow[IPFIX].version, 10)
413 self.assertEqual(cflow[IPFIX].observationDomainID, 1)
414 self.assertEqual(cflow[IPFIX].sequenceNumber, 0)
415 self.assertAlmostEqual(cflow[IPFIX].exportTime, nowUTC, delta=5)
416 if cflow.haslayer(Data):
417 record = ipfix_decoder.decode_data_set(cflow[0].getlayer(Set))[0]
419 self.assertEqual(int(binascii.hexlify(record[10]), 16), 8)
421 self.assertEqual(int(binascii.hexlify(record[14]), 16), 9)
423 self.assertEqual(int(binascii.hexlify(record[2]), 16), 1)
425 self.assertEqual(':'.join(re.findall('..', record[56].encode(
426 'hex'))), self.pg8.local_mac)
428 self.assertEqual(':'.join(re.findall('..', record[80].encode(
429 'hex'))), self.pg8.remote_mac)
430 flowTimestamp = int(binascii.hexlify(record[156]), 16) >> 32
431 # flow start timestamp
432 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
433 flowTimestamp = int(binascii.hexlify(record[157]), 16) >> 32
435 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
437 self.assertEqual(int(binascii.hexlify(record[256]), 16), 8)
439 self.assertEqual('.'.join(re.findall('..', record[8].encode(
441 '.'.join('{:02x}'.format(int(n)) for n in
442 self.pg7.remote_ip4.split('.')))
444 self.assertEqual('.'.join(re.findall('..', record[12].encode(
446 '.'.join('{:02x}'.format(int(n)) for n in
447 "9.0.0.100".split('.')))
449 self.assertEqual(int(binascii.hexlify(record[4]), 16), 6)
451 self.assertEqual(int(binascii.hexlify(record[7]), 16), 1234)
453 self.assertEqual(int(binascii.hexlify(record[11]), 16), 4321)
455 self.assertEqual(int(binascii.hexlify(record[6]), 16), 80)
457 ipfix.remove_vpp_config()
458 self.logger.info("FFP_TEST_FINISH_0000")
461 class Datapath(MethodHolder):
462 """collect information on Ethernet, IP4 and IP6 datapath (no timers)"""
464 def test_templatesL2(self):
465 """ verify template on L2 datapath"""
466 self.logger.info("FFP_TEST_START_0000")
467 self.pg_enable_capture(self.pg_interfaces)
469 ipfix = VppCFLOW(test=self, layer='l2')
470 ipfix.add_vpp_config()
472 # template packet should arrive immediately
473 self.vapi.cli("ipfix flush")
474 ipfix.verify_templates(timeout=3, count=1)
475 self.collector.get_capture(1)
477 ipfix.remove_vpp_config()
478 self.logger.info("FFP_TEST_FINISH_0000")
480 def test_L2onL2(self):
481 """ L2 data on L2 datapath"""
482 self.logger.info("FFP_TEST_START_0001")
483 self.pg_enable_capture(self.pg_interfaces)
486 ipfix = VppCFLOW(test=self, layer='l2')
487 ipfix.add_vpp_config()
489 ipfix_decoder = IPFIXDecoder()
490 # template packet should arrive immediately
491 templates = ipfix.verify_templates(ipfix_decoder, count=1)
493 self.create_stream(packets=1)
494 capture = self.send_packets()
496 # make sure the one packet we expect actually showed up
497 self.vapi.cli("ipfix flush")
498 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
499 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
500 {2: 'packets', 256: 8})
501 self.collector.get_capture(2)
503 ipfix.remove_vpp_config()
504 self.logger.info("FFP_TEST_FINISH_0001")
506 def test_L3onL2(self):
507 """ L3 data on L2 datapath"""
508 self.logger.info("FFP_TEST_START_0002")
509 self.pg_enable_capture(self.pg_interfaces)
512 ipfix = VppCFLOW(test=self, layer='l3')
513 ipfix.add_vpp_config()
515 ipfix_decoder = IPFIXDecoder()
516 # template packet should arrive immediately
517 templates = ipfix.verify_templates(ipfix_decoder, count=2)
519 self.create_stream(packets=1)
520 capture = self.send_packets()
522 # make sure the one packet we expect actually showed up
523 self.vapi.cli("ipfix flush")
524 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
525 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
526 {2: 'packets', 4: 17,
527 8: 'src_ip', 12: 'dst_ip'})
529 self.collector.get_capture(3)
531 ipfix.remove_vpp_config()
532 self.logger.info("FFP_TEST_FINISH_0002")
534 def test_L4onL2(self):
535 """ L4 data on L2 datapath"""
536 self.logger.info("FFP_TEST_START_0003")
537 self.pg_enable_capture(self.pg_interfaces)
540 ipfix = VppCFLOW(test=self, layer='l4')
541 ipfix.add_vpp_config()
543 ipfix_decoder = IPFIXDecoder()
544 # template packet should arrive immediately
545 templates = ipfix.verify_templates(ipfix_decoder, count=2)
547 self.create_stream(packets=1)
548 capture = self.send_packets()
550 # make sure the one packet we expect actually showed up
551 self.vapi.cli("ipfix flush")
552 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
553 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
554 {2: 'packets', 7: 'sport', 11: 'dport'})
556 self.collector.get_capture(3)
558 ipfix.remove_vpp_config()
559 self.logger.info("FFP_TEST_FINISH_0003")
561 def test_templatesIp4(self):
562 """ verify templates on IP4 datapath"""
563 self.logger.info("FFP_TEST_START_0000")
565 self.pg_enable_capture(self.pg_interfaces)
567 ipfix = VppCFLOW(test=self, datapath='ip4')
568 ipfix.add_vpp_config()
570 # template packet should arrive immediately
571 self.vapi.cli("ipfix flush")
572 ipfix.verify_templates(timeout=3, count=1)
573 self.collector.get_capture(1)
575 ipfix.remove_vpp_config()
577 self.logger.info("FFP_TEST_FINISH_0000")
579 def test_L2onIP4(self):
580 """ L2 data on IP4 datapath"""
581 self.logger.info("FFP_TEST_START_0001")
582 self.pg_enable_capture(self.pg_interfaces)
585 ipfix = VppCFLOW(test=self, intf='pg4', layer='l2', datapath='ip4')
586 ipfix.add_vpp_config()
588 ipfix_decoder = IPFIXDecoder()
589 # template packet should arrive immediately
590 templates = ipfix.verify_templates(ipfix_decoder, count=1)
592 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
593 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
595 # make sure the one packet we expect actually showed up
596 self.vapi.cli("ipfix flush")
597 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
598 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
599 {2: 'packets', 256: 8})
601 # expected two templates and one cflow packet
602 self.collector.get_capture(2)
604 ipfix.remove_vpp_config()
605 self.logger.info("FFP_TEST_FINISH_0001")
607 def test_L3onIP4(self):
608 """ L3 data on IP4 datapath"""
609 self.logger.info("FFP_TEST_START_0002")
610 self.pg_enable_capture(self.pg_interfaces)
613 ipfix = VppCFLOW(test=self, intf='pg4', layer='l3', datapath='ip4')
614 ipfix.add_vpp_config()
616 ipfix_decoder = IPFIXDecoder()
617 # template packet should arrive immediately
618 templates = ipfix.verify_templates(ipfix_decoder, count=1)
620 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
621 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
623 # make sure the one packet we expect actually showed up
624 self.vapi.cli("ipfix flush")
625 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
626 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
627 {1: 'octets', 2: 'packets',
628 8: 'src_ip', 12: 'dst_ip'})
630 # expected two templates and one cflow packet
631 self.collector.get_capture(2)
633 ipfix.remove_vpp_config()
634 self.logger.info("FFP_TEST_FINISH_0002")
636 def test_L4onIP4(self):
637 """ L4 data on IP4 datapath"""
638 self.logger.info("FFP_TEST_START_0003")
639 self.pg_enable_capture(self.pg_interfaces)
642 ipfix = VppCFLOW(test=self, intf='pg4', layer='l4', datapath='ip4')
643 ipfix.add_vpp_config()
645 ipfix_decoder = IPFIXDecoder()
646 # template packet should arrive immediately
647 templates = ipfix.verify_templates(ipfix_decoder, count=1)
649 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
650 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
652 # make sure the one packet we expect actually showed up
653 self.vapi.cli("ipfix flush")
654 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
655 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
656 {2: 'packets', 7: 'sport', 11: 'dport'})
658 # expected two templates and one cflow packet
659 self.collector.get_capture(2)
661 ipfix.remove_vpp_config()
662 self.logger.info("FFP_TEST_FINISH_0003")
664 def test_templatesIP6(self):
665 """ verify templates on IP6 datapath"""
666 self.logger.info("FFP_TEST_START_0000")
667 self.pg_enable_capture(self.pg_interfaces)
669 ipfix = VppCFLOW(test=self, datapath='ip6')
670 ipfix.add_vpp_config()
672 # template packet should arrive immediately
673 ipfix.verify_templates(count=1)
674 self.collector.get_capture(1)
676 ipfix.remove_vpp_config()
678 self.logger.info("FFP_TEST_FINISH_0000")
680 def test_L2onIP6(self):
681 """ L2 data on IP6 datapath"""
682 self.logger.info("FFP_TEST_START_0001")
683 self.pg_enable_capture(self.pg_interfaces)
686 ipfix = VppCFLOW(test=self, intf='pg6', layer='l2', datapath='ip6')
687 ipfix.add_vpp_config()
689 ipfix_decoder = IPFIXDecoder()
690 # template packet should arrive immediately
691 templates = ipfix.verify_templates(ipfix_decoder, count=1)
693 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
695 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
697 # make sure the one packet we expect actually showed up
698 self.vapi.cli("ipfix flush")
699 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
700 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
701 {2: 'packets', 256: 56710},
704 # expected two templates and one cflow packet
705 self.collector.get_capture(2)
707 ipfix.remove_vpp_config()
708 self.logger.info("FFP_TEST_FINISH_0001")
710 def test_L3onIP6(self):
711 """ L3 data on IP6 datapath"""
712 self.logger.info("FFP_TEST_START_0002")
713 self.pg_enable_capture(self.pg_interfaces)
716 ipfix = VppCFLOW(test=self, intf='pg6', layer='l3', datapath='ip6')
717 ipfix.add_vpp_config()
719 ipfix_decoder = IPFIXDecoder()
720 # template packet should arrive immediately
721 templates = ipfix.verify_templates(ipfix_decoder, count=1)
723 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
725 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
727 # make sure the one packet we expect actually showed up
728 self.vapi.cli("ipfix flush")
729 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
730 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
732 27: 'src_ip', 28: 'dst_ip'},
735 # expected two templates and one cflow packet
736 self.collector.get_capture(2)
738 ipfix.remove_vpp_config()
739 self.logger.info("FFP_TEST_FINISH_0002")
741 def test_L4onIP6(self):
742 """ L4 data on IP6 datapath"""
743 self.logger.info("FFP_TEST_START_0003")
744 self.pg_enable_capture(self.pg_interfaces)
747 ipfix = VppCFLOW(test=self, intf='pg6', layer='l4', datapath='ip6')
748 ipfix.add_vpp_config()
750 ipfix_decoder = IPFIXDecoder()
751 # template packet should arrive immediately
752 templates = ipfix.verify_templates(ipfix_decoder, count=1)
754 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
756 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
758 # make sure the one packet we expect actually showed up
759 self.vapi.cli("ipfix flush")
760 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
761 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
762 {2: 'packets', 7: 'sport', 11: 'dport'},
765 # expected two templates and one cflow packet
766 self.collector.get_capture(2)
768 ipfix.remove_vpp_config()
769 self.logger.info("FFP_TEST_FINISH_0003")
772 """ no timers, one CFLOW packet, 9 Flows inside"""
773 self.logger.info("FFP_TEST_START_0001")
774 self.pg_enable_capture(self.pg_interfaces)
777 ipfix = VppCFLOW(test=self)
778 ipfix.add_vpp_config()
780 ipfix_decoder = IPFIXDecoder()
781 # template packet should arrive immediately
782 templates = ipfix.verify_templates(ipfix_decoder)
784 self.create_stream(packets=9)
785 capture = self.send_packets()
787 # make sure the one packet we expect actually showed up
788 self.vapi.cli("ipfix flush")
789 cflow = self.wait_for_cflow_packet(self.collector, templates[1])
790 self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow])
791 self.collector.get_capture(4)
793 ipfix.remove_vpp_config()
794 self.logger.info("FFP_TEST_FINISH_0001")
797 """ no timers, two CFLOW packets (mtu=256), 3 Flows in each"""
798 self.logger.info("FFP_TEST_START_0002")
799 self.pg_enable_capture(self.pg_interfaces)
802 ipfix = VppCFLOW(test=self, mtu=256)
803 ipfix.add_vpp_config()
805 ipfix_decoder = IPFIXDecoder()
806 # template packet should arrive immediately
807 self.vapi.cli("ipfix flush")
808 templates = ipfix.verify_templates(ipfix_decoder)
810 self.create_stream(packets=6)
811 capture = self.send_packets()
813 # make sure the one packet we expect actually showed up
815 self.vapi.cli("ipfix flush")
816 cflows.append(self.wait_for_cflow_packet(self.collector,
818 cflows.append(self.wait_for_cflow_packet(self.collector,
820 self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows)
821 self.collector.get_capture(5)
823 ipfix.remove_vpp_config()
824 self.logger.info("FFP_TEST_FINISH_0002")
827 @unittest.skipUnless(running_extended_tests, "part of extended tests")
828 class DisableIPFIX(MethodHolder):
832 """ disable IPFIX after first packets"""
833 self.logger.info("FFP_TEST_START_0001")
834 self.pg_enable_capture(self.pg_interfaces)
837 ipfix = VppCFLOW(test=self)
838 ipfix.add_vpp_config()
840 ipfix_decoder = IPFIXDecoder()
841 # template packet should arrive immediately
842 templates = ipfix.verify_templates(ipfix_decoder)
847 # make sure the one packet we expect actually showed up
848 self.vapi.cli("ipfix flush")
849 self.wait_for_cflow_packet(self.collector, templates[1])
850 self.collector.get_capture(4)
853 ipfix.disable_exporter()
854 self.pg_enable_capture([self.collector])
858 # make sure no one packet arrived in 1 minute
859 self.vapi.cli("ipfix flush")
860 self.wait_for_cflow_packet(self.collector, templates[1],
862 self.collector.get_capture(0)
864 ipfix.remove_vpp_config()
865 self.logger.info("FFP_TEST_FINISH_0001")
868 @unittest.skipUnless(running_extended_tests, "part of extended tests")
869 class ReenableIPFIX(MethodHolder):
870 """Re-enable IPFIX"""
873 """ disable IPFIX after first packets and re-enable after few packets
875 self.logger.info("FFP_TEST_START_0001")
876 self.pg_enable_capture(self.pg_interfaces)
879 ipfix = VppCFLOW(test=self)
880 ipfix.add_vpp_config()
882 ipfix_decoder = IPFIXDecoder()
883 # template packet should arrive immediately
884 templates = ipfix.verify_templates(ipfix_decoder)
886 self.create_stream(packets=5)
889 # make sure the one packet we expect actually showed up
890 self.vapi.cli("ipfix flush")
891 self.wait_for_cflow_packet(self.collector, templates[1])
892 self.collector.get_capture(4)
895 ipfix.disable_exporter()
896 self.vapi.cli("ipfix flush")
897 self.pg_enable_capture([self.collector])
901 # make sure no one packet arrived in active timer span
902 self.vapi.cli("ipfix flush")
903 self.wait_for_cflow_packet(self.collector, templates[1],
905 self.collector.get_capture(0)
906 self.pg2.get_capture(5)
909 ipfix.enable_exporter()
911 capture = self.collector.get_capture(4)
915 self.assertTrue(p.haslayer(IPFIX))
916 if p.haslayer(Template):
918 self.assertTrue(nr_templates, 3)
920 self.assertTrue(p.haslayer(IPFIX))
923 self.assertTrue(nr_templates, 1)
925 ipfix.remove_vpp_config()
926 self.logger.info("FFP_TEST_FINISH_0001")
929 @unittest.skipUnless(running_extended_tests, "part of extended tests")
930 class DisableFP(MethodHolder):
931 """Disable Flowprobe feature"""
934 """ disable flowprobe feature after first packets"""
935 self.logger.info("FFP_TEST_START_0001")
936 self.pg_enable_capture(self.pg_interfaces)
938 ipfix = VppCFLOW(test=self)
939 ipfix.add_vpp_config()
941 ipfix_decoder = IPFIXDecoder()
942 # template packet should arrive immediately
943 templates = ipfix.verify_templates(ipfix_decoder)
948 # make sure the one packet we expect actually showed up
949 self.vapi.cli("ipfix flush")
950 self.wait_for_cflow_packet(self.collector, templates[1])
951 self.collector.get_capture(4)
954 ipfix.disable_flowprobe_feature()
955 self.pg_enable_capture([self.collector])
959 # make sure no one packet arrived in active timer span
960 self.vapi.cli("ipfix flush")
961 self.wait_for_cflow_packet(self.collector, templates[1],
963 self.collector.get_capture(0)
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 ReenableFP(MethodHolder):
971 """Re-enable Flowprobe feature"""
974 """ disable flowprobe feature after first packets and re-enable
975 after few packets """
976 self.logger.info("FFP_TEST_START_0001")
977 self.pg_enable_capture(self.pg_interfaces)
980 ipfix = VppCFLOW(test=self)
981 ipfix.add_vpp_config()
983 ipfix_decoder = IPFIXDecoder()
984 # template packet should arrive immediately
985 self.vapi.cli("ipfix flush")
986 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
991 # make sure the one packet we expect actually showed up
992 self.vapi.cli("ipfix flush")
993 self.wait_for_cflow_packet(self.collector, templates[1], 5)
994 self.collector.get_capture(4)
997 ipfix.disable_flowprobe_feature()
998 self.pg_enable_capture([self.collector])
1002 # make sure no one packet arrived in active timer span
1003 self.vapi.cli("ipfix flush")
1004 self.wait_for_cflow_packet(self.collector, templates[1], 5,
1006 self.collector.get_capture(0)
1008 # enable FPP feature
1009 ipfix.enable_flowprobe_feature()
1010 self.vapi.cli("ipfix flush")
1011 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1015 # make sure the next packets (templates and data) we expect actually
1017 self.vapi.cli("ipfix flush")
1018 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1019 self.collector.get_capture(4)
1021 ipfix.remove_vpp_config()
1022 self.logger.info("FFP_TEST_FINISH_0001")
1025 if __name__ == '__main__':
1026 unittest.main(testRunner=VppTestRunner)