8 from scapy.packet import Raw
9 from scapy.layers.l2 import Ether
10 from scapy.layers.inet import IP, TCP, UDP
11 from scapy.layers.inet6 import IPv6
13 from framework import VppTestCase, VppTestRunner, running_extended_tests
14 from vpp_object import VppObject
15 from vpp_pg_interface import CaptureTimeoutError
17 from ipfix import IPFIX, Set, Template, Data, IPFIXDecoder
18 from vpp_ip_route import VppIpRoute, VppRoutePath
21 class VppCFLOW(VppObject):
22 """CFLOW object for IPFIX exporter and Flowprobe feature"""
24 def __init__(self, test, intf='pg2', active=0, passive=0, timeout=100,
25 mtu=1024, datapath='l2', layer='l2 l3 l4'):
29 if passive == 0 or passive < active:
30 self._passive = active+1
32 self._passive = passive
33 self._datapath = datapath # l2 ip4 ip6
34 self._collect = layer # l2 l3 l4
35 self._timeout = timeout
37 self._configured = False
39 def add_vpp_config(self):
40 self.enable_exporter()
41 self._test.vapi.ppcli("flowprobe params record %s active %s "
42 "passive %s" % (self._collect, self._active,
44 self.enable_flowprobe_feature()
45 self._test.vapi.cli("ipfix flush")
46 self._configured = True
48 def remove_vpp_config(self):
49 self.disable_exporter()
50 self.disable_flowprobe_feature()
51 self._test.vapi.cli("ipfix flush")
52 self._configured = False
54 def enable_exporter(self):
55 self._test.vapi.set_ipfix_exporter(
56 collector_address=self._test.pg0.remote_ip4n,
57 src_address=self._test.pg0.local_ip4n,
59 template_interval=self._timeout)
61 def enable_flowprobe_feature(self):
62 self._test.vapi.ppcli("flowprobe feature add-del %s %s" %
63 (self._intf, self._datapath))
65 def disable_exporter(self):
66 self._test.vapi.cli("set ipfix exporter collector 0.0.0.0")
68 def disable_flowprobe_feature(self):
69 self._test.vapi.cli("flowprobe feature add-del %s %s disable" %
70 (self._intf, self._datapath))
73 return "ipfix-collector-%s" % (self._src, self.dst)
75 def query_vpp_config(self):
76 return self._configured
78 def verify_templates(self, decoder=None, timeout=1, count=3):
80 p = self._test.wait_for_cflow_packet(self._test.collector, 2, timeout)
81 self._test.assertTrue(p.haslayer(IPFIX))
82 if decoder is not None and p.haslayer(Template):
83 templates.append(p[Template].templateID)
84 decoder.add_template(p.getlayer(Template))
86 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
87 self._test.assertTrue(p.haslayer(IPFIX))
88 if decoder is not None and p.haslayer(Template):
89 templates.append(p[Template].templateID)
90 decoder.add_template(p.getlayer(Template))
92 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
93 self._test.assertTrue(p.haslayer(IPFIX))
94 if decoder is not None and p.haslayer(Template):
95 templates.append(p[Template].templateID)
96 decoder.add_template(p.getlayer(Template))
100 class MethodHolder(VppTestCase):
101 """ Flow-per-packet plugin: test L2, IP4, IP6 reporting """
105 max_number_of_packets = 10
111 Perform standard class setup (defined by class method setUpClass in
112 class VppTestCase) before running the test case, set test case related
113 variables and configure VPP.
115 super(MethodHolder, cls).setUpClass()
117 # Create pg interfaces
118 cls.create_pg_interfaces(range(9))
121 cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
123 # Create BD with MAC learning and unknown unicast flooding disabled
124 # and put interfaces to this BD
125 cls.vapi.bridge_domain_add_del(bd_id=1, uu_flood=1, learn=1)
126 cls.vapi.sw_interface_set_l2_bridge(cls.pg1._sw_if_index, bd_id=1)
127 cls.vapi.sw_interface_set_l2_bridge(cls.pg2._sw_if_index, bd_id=1)
129 # Set up all interfaces
130 for i in cls.pg_interfaces:
134 cls.pg0.configure_ipv4_neighbors()
135 cls.collector = cls.pg0
138 cls.pg1.resolve_arp()
140 cls.pg2.resolve_arp()
142 cls.pg3.resolve_arp()
144 cls.pg4.resolve_arp()
147 cls.pg8.configure_ipv4_neighbors()
150 cls.pg5.resolve_ndp()
151 cls.pg5.disable_ipv6_ra()
153 cls.pg6.resolve_ndp()
154 cls.pg6.disable_ipv6_ra()
156 super(MethodHolder, cls).tearDownClass()
159 def create_stream(self, src_if=None, dst_if=None, packets=None,
160 size=None, ip_ver='v4'):
161 """Create a packet stream to tickle the plugin
163 :param VppInterface src_if: Source interface for packet stream
164 :param VppInterface src_if: Dst interface for packet stream
172 packets = random.randint(1, self.max_number_of_packets)
174 for p in range(0, packets):
176 pkt_size = random.choice(self.pg_if_packet_sizes)
177 info = self.create_packet_info(src_if, dst_if)
178 payload = self.info_to_payload(info)
179 p = Ether(src=src_if.remote_mac, dst=src_if.local_mac)
181 p /= IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4)
183 p /= IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6)
184 p /= UDP(sport=1234, dport=4321)
187 self.extend_packet(p, pkt_size)
190 def verify_cflow_data(self, decoder, capture, cflow):
196 if cflow.haslayer(Data):
197 data = decoder.decode_data_set(cflow.getlayer(Set))
199 self.assertEqual(int(record[1].encode('hex'), 16), octets)
200 self.assertEqual(int(record[2].encode('hex'), 16), packets)
202 def send_packets(self, src_if=None, dst_if=None):
207 self.pg_enable_capture([dst_if])
208 src_if.add_stream(self.pkts)
210 return dst_if.get_capture(len(self.pkts))
212 def verify_cflow_data_detail(self, decoder, capture, cflow,
213 data_set={1: 'octets', 2: 'packets'},
216 print capture[0].show()
217 if cflow.haslayer(Data):
218 data = decoder.decode_data_set(cflow.getlayer(Set))
222 ip_layer = capture[0][IP]
224 ip_layer = capture[0][IPv6]
225 if data_set is not None:
227 # skip flow if in/out gress interface is 0
228 if int(record[10].encode('hex'), 16) == 0:
230 if int(record[14].encode('hex'), 16) == 0:
233 for field in data_set:
234 if field not in record.keys():
236 value = data_set[field]
237 if value == 'octets':
240 value += 40 # ??? is this correct
241 elif value == 'packets':
243 elif value == 'src_ip':
245 ip = socket.inet_pton(socket.AF_INET,
248 ip = socket.inet_pton(socket.AF_INET6,
250 value = int(ip.encode('hex'), 16)
251 elif value == 'dst_ip':
253 ip = socket.inet_pton(socket.AF_INET,
256 ip = socket.inet_pton(socket.AF_INET6,
258 value = int(ip.encode('hex'), 16)
259 elif value == 'sport':
260 value = int(capture[0][UDP].sport)
261 elif value == 'dport':
262 value = int(capture[0][UDP].dport)
263 self.assertEqual(int(record[field].encode('hex'), 16),
266 def verify_cflow_data_notimer(self, decoder, capture, cflows):
269 if cflow.haslayer(Data):
270 data = decoder.decode_data_set(cflow.getlayer(Set))
272 raise Exception("No CFLOW data")
277 self.assertEqual(p[IP].len, int(rec[1].encode('hex'), 16))
278 self.assertEqual(1, int(rec[2].encode('hex'), 16))
279 self.assertEqual(len(capture), idx)
281 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1,
283 """ wait for CFLOW packet and verify its correctness
285 :param timeout: how long to wait
287 :returns: tuple (packet, time spent waiting for packet)
289 self.logger.info("IPFIX: Waiting for CFLOW packet")
290 deadline = time.time() + timeout
292 # self.logger.debug(self.vapi.ppcli("show flow table"))
296 self.assert_in_range(counter, 0, 100, "number of packets ignored")
297 time_left = deadline - time.time()
299 if time_left < 0 and expected:
300 # self.logger.debug(self.vapi.ppcli("show flow table"))
301 raise CaptureTimeoutError(
302 "Packet did not arrive within timeout")
303 p = collector_intf.wait_for_packet(timeout=time_left)
304 except CaptureTimeoutError:
306 # self.logger.debug(self.vapi.ppcli("show flow table"))
307 raise CaptureTimeoutError(
308 "Packet did not arrive within timeout")
312 raise CaptureTimeoutError("Packet arrived even not expected")
313 self.assertEqual(p[Set].setID, set_id)
314 # self.logger.debug(self.vapi.ppcli("show flow table"))
315 self.logger.debug(ppp("IPFIX: Got packet:", p))
320 class Flowprobe(MethodHolder):
321 """Template verification, timer tests"""
324 """ timer less than template timeout"""
325 self.logger.info("FFP_TEST_START_0001")
326 self.pg_enable_capture(self.pg_interfaces)
329 ipfix = VppCFLOW(test=self, active=2)
330 ipfix.add_vpp_config()
332 ipfix_decoder = IPFIXDecoder()
333 # template packet should arrive immediately
334 templates = ipfix.verify_templates(ipfix_decoder)
336 self.create_stream(packets=1)
338 capture = self.pg2.get_capture(1)
340 # make sure the one packet we expect actually showed up
341 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
342 self.verify_cflow_data(ipfix_decoder, capture, cflow)
344 ipfix.remove_vpp_config()
345 self.logger.info("FFP_TEST_FINISH_0001")
348 """ timer greater than template timeout"""
349 self.logger.info("FFP_TEST_START_0002")
350 self.pg_enable_capture(self.pg_interfaces)
353 ipfix = VppCFLOW(test=self, timeout=3, active=4)
354 ipfix.add_vpp_config()
356 ipfix_decoder = IPFIXDecoder()
357 # template packet should arrive immediately
358 ipfix.verify_templates()
360 self.create_stream(packets=2)
362 capture = self.pg2.get_capture(2)
364 # next set of template packet should arrive after 20 seconds
365 # template packet should arrive within 20 s
366 templates = ipfix.verify_templates(ipfix_decoder, timeout=5)
368 # make sure the one packet we expect actually showed up
369 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
370 self.verify_cflow_data(ipfix_decoder, capture, cflow)
372 ipfix.remove_vpp_config()
373 self.logger.info("FFP_TEST_FINISH_0002")
375 def test_cflow_packet(self):
376 """verify cflow packet fields"""
377 self.logger.info("FFP_TEST_START_0000")
378 self.pg_enable_capture(self.pg_interfaces)
381 ipfix = VppCFLOW(test=self, intf='pg8', datapath="ip4",
382 layer='l2 l3 l4', active=2)
383 ipfix.add_vpp_config()
385 route_9001 = VppIpRoute(self, "9.0.0.0", 24,
386 [VppRoutePath(self.pg8._remote_hosts[0].ip4,
387 self.pg8.sw_if_index)])
388 route_9001.add_vpp_config()
390 ipfix_decoder = IPFIXDecoder()
391 templates = ipfix.verify_templates(ipfix_decoder, count=1)
393 self.pkts = [(Ether(dst=self.pg7.local_mac,
394 src=self.pg7.remote_mac) /
395 IP(src=self.pg7.remote_ip4, dst="9.0.0.100") /
396 TCP(sport=1234, dport=4321, flags=80) /
399 nowUTC = int(time.time())
400 nowUNIX = nowUTC+2208988800
401 self.send_packets(src_if=self.pg7, dst_if=self.pg8)
403 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 10)
404 self.collector.get_capture(2)
406 if cflow[0].haslayer(IPFIX):
407 self.assertEqual(cflow[IPFIX].version, 10)
408 self.assertEqual(cflow[IPFIX].observationDomainID, 1)
409 self.assertEqual(cflow[IPFIX].sequenceNumber, 0)
410 self.assertAlmostEqual(cflow[IPFIX].exportTime, nowUTC, delta=5)
411 if cflow.haslayer(Data):
412 record = ipfix_decoder.decode_data_set(cflow[0].getlayer(Set))[0]
414 self.assertEqual(int(record[10].encode('hex'), 16), 8)
416 self.assertEqual(int(record[14].encode('hex'), 16), 9)
418 self.assertEqual(int(record[2].encode('hex'), 16), 1)
420 self.assertEqual(':'.join(re.findall('..', record[56].encode(
421 'hex'))), self.pg8.local_mac)
423 self.assertEqual(':'.join(re.findall('..', record[80].encode(
424 'hex'))), self.pg8.remote_mac)
425 flowTimestamp = int(record[156].encode('hex'), 16) >> 32
426 # flow start timestamp
427 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
428 flowTimestamp = int(record[157].encode('hex'), 16) >> 32
430 self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1)
432 self.assertEqual(int(record[256].encode('hex'), 16), 8)
434 self.assertEqual('.'.join(re.findall('..', record[8].encode(
436 '.'.join('{:02x}'.format(int(n)) for n in
437 self.pg7.remote_ip4.split('.')))
439 self.assertEqual('.'.join(re.findall('..', record[12].encode(
441 '.'.join('{:02x}'.format(int(n)) for n in
442 "9.0.0.100".split('.')))
444 self.assertEqual(int(record[4].encode('hex'), 16), 6)
446 self.assertEqual(int(record[7].encode('hex'), 16), 1234)
448 self.assertEqual(int(record[11].encode('hex'), 16), 4321)
450 self.assertEqual(int(record[6].encode('hex'), 16), 80)
452 ipfix.remove_vpp_config()
453 self.logger.info("FFP_TEST_FINISH_0000")
456 class Datapath(MethodHolder):
457 """collect information on Ethernet, IP4 and IP6 datapath (no timers)"""
459 def test_templatesL2(self):
460 """ verify template on L2 datapath"""
461 self.logger.info("FFP_TEST_START_0000")
462 self.pg_enable_capture(self.pg_interfaces)
464 ipfix = VppCFLOW(test=self, layer='l2')
465 ipfix.add_vpp_config()
467 # template packet should arrive immediately
468 self.vapi.cli("ipfix flush")
469 ipfix.verify_templates(timeout=3, count=1)
470 self.collector.get_capture(1)
472 ipfix.remove_vpp_config()
473 self.logger.info("FFP_TEST_FINISH_0000")
475 def test_L2onL2(self):
476 """ L2 data on L2 datapath"""
477 self.logger.info("FFP_TEST_START_0001")
478 self.pg_enable_capture(self.pg_interfaces)
481 ipfix = VppCFLOW(test=self, layer='l2')
482 ipfix.add_vpp_config()
484 ipfix_decoder = IPFIXDecoder()
485 # template packet should arrive immediately
486 templates = ipfix.verify_templates(ipfix_decoder, count=1)
488 self.create_stream(packets=1)
489 capture = self.send_packets()
491 # make sure the one packet we expect actually showed up
492 self.vapi.cli("ipfix flush")
493 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
494 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
495 {2: 'packets', 256: 8})
496 self.collector.get_capture(2)
498 ipfix.remove_vpp_config()
499 self.logger.info("FFP_TEST_FINISH_0001")
501 def test_L3onL2(self):
502 """ L3 data on L2 datapath"""
503 self.logger.info("FFP_TEST_START_0002")
504 self.pg_enable_capture(self.pg_interfaces)
507 ipfix = VppCFLOW(test=self, layer='l3')
508 ipfix.add_vpp_config()
510 ipfix_decoder = IPFIXDecoder()
511 # template packet should arrive immediately
512 templates = ipfix.verify_templates(ipfix_decoder, count=2)
514 self.create_stream(packets=1)
515 capture = self.send_packets()
517 # make sure the one packet we expect actually showed up
518 self.vapi.cli("ipfix flush")
519 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
520 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
521 {2: 'packets', 4: 17,
522 8: 'src_ip', 12: 'dst_ip'})
524 self.collector.get_capture(3)
526 ipfix.remove_vpp_config()
527 self.logger.info("FFP_TEST_FINISH_0002")
529 def test_L4onL2(self):
530 """ L4 data on L2 datapath"""
531 self.logger.info("FFP_TEST_START_0003")
532 self.pg_enable_capture(self.pg_interfaces)
535 ipfix = VppCFLOW(test=self, layer='l4')
536 ipfix.add_vpp_config()
538 ipfix_decoder = IPFIXDecoder()
539 # template packet should arrive immediately
540 templates = ipfix.verify_templates(ipfix_decoder, count=2)
542 self.create_stream(packets=1)
543 capture = self.send_packets()
545 # make sure the one packet we expect actually showed up
546 self.vapi.cli("ipfix flush")
547 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
548 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
549 {2: 'packets', 7: 'sport', 11: 'dport'})
551 self.collector.get_capture(3)
553 ipfix.remove_vpp_config()
554 self.logger.info("FFP_TEST_FINISH_0003")
556 def test_templatesIp4(self):
557 """ verify templates on IP4 datapath"""
558 self.logger.info("FFP_TEST_START_0000")
560 self.pg_enable_capture(self.pg_interfaces)
562 ipfix = VppCFLOW(test=self, datapath='ip4')
563 ipfix.add_vpp_config()
565 # template packet should arrive immediately
566 self.vapi.cli("ipfix flush")
567 ipfix.verify_templates(timeout=3, count=1)
568 self.collector.get_capture(1)
570 ipfix.remove_vpp_config()
572 self.logger.info("FFP_TEST_FINISH_0000")
574 def test_L2onIP4(self):
575 """ L2 data on IP4 datapath"""
576 self.logger.info("FFP_TEST_START_0001")
577 self.pg_enable_capture(self.pg_interfaces)
580 ipfix = VppCFLOW(test=self, intf='pg4', layer='l2', datapath='ip4')
581 ipfix.add_vpp_config()
583 ipfix_decoder = IPFIXDecoder()
584 # template packet should arrive immediately
585 templates = ipfix.verify_templates(ipfix_decoder, count=1)
587 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
588 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
590 # make sure the one packet we expect actually showed up
591 self.vapi.cli("ipfix flush")
592 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
593 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
594 {2: 'packets', 256: 8})
596 # expected two templates and one cflow packet
597 self.collector.get_capture(2)
599 ipfix.remove_vpp_config()
600 self.logger.info("FFP_TEST_FINISH_0001")
602 def test_L3onIP4(self):
603 """ L3 data on IP4 datapath"""
604 self.logger.info("FFP_TEST_START_0002")
605 self.pg_enable_capture(self.pg_interfaces)
608 ipfix = VppCFLOW(test=self, intf='pg4', layer='l3', datapath='ip4')
609 ipfix.add_vpp_config()
611 ipfix_decoder = IPFIXDecoder()
612 # template packet should arrive immediately
613 templates = ipfix.verify_templates(ipfix_decoder, count=1)
615 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
616 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
618 # make sure the one packet we expect actually showed up
619 self.vapi.cli("ipfix flush")
620 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
621 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
622 {1: 'octets', 2: 'packets',
623 8: 'src_ip', 12: 'dst_ip'})
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_0002")
631 def test_L4onIP4(self):
632 """ L4 data on IP4 datapath"""
633 self.logger.info("FFP_TEST_START_0003")
634 self.pg_enable_capture(self.pg_interfaces)
637 ipfix = VppCFLOW(test=self, intf='pg4', layer='l4', 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 {2: 'packets', 7: 'sport', 11: 'dport'})
653 # expected two templates and one cflow packet
654 self.collector.get_capture(2)
656 ipfix.remove_vpp_config()
657 self.logger.info("FFP_TEST_FINISH_0003")
659 def test_templatesIP6(self):
660 """ verify templates on IP6 datapath"""
661 self.logger.info("FFP_TEST_START_0000")
662 self.pg_enable_capture(self.pg_interfaces)
664 ipfix = VppCFLOW(test=self, datapath='ip6')
665 ipfix.add_vpp_config()
667 # template packet should arrive immediately
668 ipfix.verify_templates(count=1)
669 self.collector.get_capture(1)
671 ipfix.remove_vpp_config()
673 self.logger.info("FFP_TEST_FINISH_0000")
675 def test_L2onIP6(self):
676 """ L2 data on IP6 datapath"""
677 self.logger.info("FFP_TEST_START_0001")
678 self.pg_enable_capture(self.pg_interfaces)
681 ipfix = VppCFLOW(test=self, intf='pg6', layer='l2', datapath='ip6')
682 ipfix.add_vpp_config()
684 ipfix_decoder = IPFIXDecoder()
685 # template packet should arrive immediately
686 templates = ipfix.verify_templates(ipfix_decoder, count=1)
688 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
690 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
692 # make sure the one packet we expect actually showed up
693 self.vapi.cli("ipfix flush")
694 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
695 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
696 {2: 'packets', 256: 56710},
699 # expected two templates and one cflow packet
700 self.collector.get_capture(2)
702 ipfix.remove_vpp_config()
703 self.logger.info("FFP_TEST_FINISH_0001")
705 def test_L3onIP6(self):
706 """ L3 data on IP6 datapath"""
707 self.logger.info("FFP_TEST_START_0002")
708 self.pg_enable_capture(self.pg_interfaces)
711 ipfix = VppCFLOW(test=self, intf='pg6', layer='l3', datapath='ip6')
712 ipfix.add_vpp_config()
714 ipfix_decoder = IPFIXDecoder()
715 # template packet should arrive immediately
716 templates = ipfix.verify_templates(ipfix_decoder, count=1)
718 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
720 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
722 # make sure the one packet we expect actually showed up
723 self.vapi.cli("ipfix flush")
724 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
725 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
727 27: 'src_ip', 28: 'dst_ip'},
730 # expected two templates and one cflow packet
731 self.collector.get_capture(2)
733 ipfix.remove_vpp_config()
734 self.logger.info("FFP_TEST_FINISH_0002")
736 def test_L4onIP6(self):
737 """ L4 data on IP6 datapath"""
738 self.logger.info("FFP_TEST_START_0003")
739 self.pg_enable_capture(self.pg_interfaces)
742 ipfix = VppCFLOW(test=self, intf='pg6', layer='l4', datapath='ip6')
743 ipfix.add_vpp_config()
745 ipfix_decoder = IPFIXDecoder()
746 # template packet should arrive immediately
747 templates = ipfix.verify_templates(ipfix_decoder, count=1)
749 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
751 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
753 # make sure the one packet we expect actually showed up
754 self.vapi.cli("ipfix flush")
755 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
756 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
757 {2: 'packets', 7: 'sport', 11: 'dport'},
760 # expected two templates and one cflow packet
761 self.collector.get_capture(2)
763 ipfix.remove_vpp_config()
764 self.logger.info("FFP_TEST_FINISH_0003")
767 """ no timers, one CFLOW packet, 9 Flows inside"""
768 self.logger.info("FFP_TEST_START_0001")
769 self.pg_enable_capture(self.pg_interfaces)
772 ipfix = VppCFLOW(test=self)
773 ipfix.add_vpp_config()
775 ipfix_decoder = IPFIXDecoder()
776 # template packet should arrive immediately
777 templates = ipfix.verify_templates(ipfix_decoder)
779 self.create_stream(packets=9)
780 capture = self.send_packets()
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[1])
785 self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow])
786 self.collector.get_capture(4)
788 ipfix.remove_vpp_config()
789 self.logger.info("FFP_TEST_FINISH_0001")
792 """ no timers, two CFLOW packets (mtu=256), 3 Flows in each"""
793 self.logger.info("FFP_TEST_START_0002")
794 self.pg_enable_capture(self.pg_interfaces)
797 ipfix = VppCFLOW(test=self, mtu=256)
798 ipfix.add_vpp_config()
800 ipfix_decoder = IPFIXDecoder()
801 # template packet should arrive immediately
802 self.vapi.cli("ipfix flush")
803 templates = ipfix.verify_templates(ipfix_decoder)
805 self.create_stream(packets=6)
806 capture = self.send_packets()
808 # make sure the one packet we expect actually showed up
810 self.vapi.cli("ipfix flush")
811 cflows.append(self.wait_for_cflow_packet(self.collector,
813 cflows.append(self.wait_for_cflow_packet(self.collector,
815 self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows)
816 self.collector.get_capture(5)
818 ipfix.remove_vpp_config()
819 self.logger.info("FFP_TEST_FINISH_0002")
822 @unittest.skipUnless(running_extended_tests(), "part of extended tests")
823 class DisableIPFIX(MethodHolder):
827 """ disable IPFIX after first packets"""
828 self.logger.info("FFP_TEST_START_0001")
829 self.pg_enable_capture(self.pg_interfaces)
832 ipfix = VppCFLOW(test=self)
833 ipfix.add_vpp_config()
835 ipfix_decoder = IPFIXDecoder()
836 # template packet should arrive immediately
837 templates = ipfix.verify_templates(ipfix_decoder)
842 # make sure the one packet we expect actually showed up
843 self.vapi.cli("ipfix flush")
844 self.wait_for_cflow_packet(self.collector, templates[1])
845 self.collector.get_capture(4)
848 ipfix.disable_exporter()
849 self.pg_enable_capture([self.collector])
853 # make sure no one packet arrived in 1 minute
854 self.vapi.cli("ipfix flush")
855 self.wait_for_cflow_packet(self.collector, templates[1],
857 self.collector.get_capture(0)
859 ipfix.remove_vpp_config()
860 self.logger.info("FFP_TEST_FINISH_0001")
863 @unittest.skipUnless(running_extended_tests(), "part of extended tests")
864 class ReenableIPFIX(MethodHolder):
865 """Re-enable IPFIX"""
868 """ disable IPFIX after first packets and re-enable after few packets
870 self.logger.info("FFP_TEST_START_0001")
871 self.pg_enable_capture(self.pg_interfaces)
874 ipfix = VppCFLOW(test=self)
875 ipfix.add_vpp_config()
877 ipfix_decoder = IPFIXDecoder()
878 # template packet should arrive immediately
879 templates = ipfix.verify_templates(ipfix_decoder)
881 self.create_stream(packets=5)
884 # make sure the one packet we expect actually showed up
885 self.vapi.cli("ipfix flush")
886 self.wait_for_cflow_packet(self.collector, templates[1])
887 self.collector.get_capture(4)
890 ipfix.disable_exporter()
891 self.vapi.cli("ipfix flush")
892 self.pg_enable_capture([self.collector])
896 # make sure no one packet arrived in active timer span
897 self.vapi.cli("ipfix flush")
898 self.wait_for_cflow_packet(self.collector, templates[1],
900 self.collector.get_capture(0)
901 self.pg2.get_capture(5)
904 ipfix.enable_exporter()
906 capture = self.collector.get_capture(4)
910 self.assertTrue(p.haslayer(IPFIX))
911 if p.haslayer(Template):
913 self.assertTrue(nr_templates, 3)
915 self.assertTrue(p.haslayer(IPFIX))
918 self.assertTrue(nr_templates, 1)
920 ipfix.remove_vpp_config()
921 self.logger.info("FFP_TEST_FINISH_0001")
924 @unittest.skipUnless(running_extended_tests(), "part of extended tests")
925 class DisableFP(MethodHolder):
926 """Disable Flowprobe feature"""
929 """ disable flowprobe feature after first packets"""
930 self.logger.info("FFP_TEST_START_0001")
931 self.pg_enable_capture(self.pg_interfaces)
933 ipfix = VppCFLOW(test=self)
934 ipfix.add_vpp_config()
936 ipfix_decoder = IPFIXDecoder()
937 # template packet should arrive immediately
938 templates = ipfix.verify_templates(ipfix_decoder)
943 # make sure the one packet we expect actually showed up
944 self.vapi.cli("ipfix flush")
945 self.wait_for_cflow_packet(self.collector, templates[1])
946 self.collector.get_capture(4)
949 ipfix.disable_flowprobe_feature()
950 self.pg_enable_capture([self.collector])
954 # make sure no one packet arrived in active timer span
955 self.vapi.cli("ipfix flush")
956 self.wait_for_cflow_packet(self.collector, templates[1],
958 self.collector.get_capture(0)
960 ipfix.remove_vpp_config()
961 self.logger.info("FFP_TEST_FINISH_0001")
964 @unittest.skipUnless(running_extended_tests(), "part of extended tests")
965 class ReenableFP(MethodHolder):
966 """Re-enable Flowprobe feature"""
969 """ disable flowprobe feature after first packets and re-enable
970 after few packets """
971 self.logger.info("FFP_TEST_START_0001")
972 self.pg_enable_capture(self.pg_interfaces)
975 ipfix = VppCFLOW(test=self)
976 ipfix.add_vpp_config()
978 ipfix_decoder = IPFIXDecoder()
979 # template packet should arrive immediately
980 self.vapi.cli("ipfix flush")
981 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
986 # make sure the one packet we expect actually showed up
987 self.vapi.cli("ipfix flush")
988 self.wait_for_cflow_packet(self.collector, templates[1], 5)
989 self.collector.get_capture(4)
992 ipfix.disable_flowprobe_feature()
993 self.pg_enable_capture([self.collector])
997 # make sure no one packet arrived in active timer span
998 self.vapi.cli("ipfix flush")
999 self.wait_for_cflow_packet(self.collector, templates[1], 5,
1001 self.collector.get_capture(0)
1003 # enable FPP feature
1004 ipfix.enable_flowprobe_feature()
1005 self.vapi.cli("ipfix flush")
1006 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
1010 # make sure the next packets (templates and data) we expect actually
1012 self.vapi.cli("ipfix flush")
1013 self.wait_for_cflow_packet(self.collector, templates[1], 5)
1014 self.collector.get_capture(4)
1016 ipfix.remove_vpp_config()
1017 self.logger.info("FFP_TEST_FINISH_0001")
1020 if __name__ == '__main__':
1021 unittest.main(testRunner=VppTestRunner)