7 from scapy.packet import Raw
8 from scapy.layers.l2 import Ether
9 from scapy.layers.inet import IP, UDP
10 from scapy.layers.inet6 import IPv6
12 from framework import VppTestCase, VppTestRunner, running_extended_tests
13 from vpp_object import VppObject
14 from vpp_pg_interface import CaptureTimeoutError
16 from ipfix import IPFIX, Set, Template, Data, IPFIXDecoder
19 class VppCFLOW(VppObject):
20 """CFLOW object for IPFIX exporter and Flowprobe feature"""
22 def __init__(self, test, intf='pg2', active=0, passive=0, timeout=100,
23 mtu=1024, datapath='l2', layer='l2 l3 l4'):
27 if passive == 0 or passive < active:
28 self._passive = active+1
30 self._passive = passive
31 self._datapath = datapath # l2 ip4 ip6
32 self._collect = layer # l2 l3 l4
33 self._timeout = timeout
35 self._configured = False
37 def add_vpp_config(self):
38 self.enable_exporter()
39 self._test.vapi.ppcli("flowprobe params record %s active %s "
40 "passive %s" % (self._collect, self._active,
42 self.enable_flowprobe_feature()
43 self._test.vapi.cli("ipfix flush")
44 self._configured = True
46 def remove_vpp_config(self):
47 self.disable_exporter()
48 self.disable_flowprobe_feature()
49 self._test.vapi.cli("ipfix flush")
50 self._configured = False
52 def enable_exporter(self):
53 self._test.vapi.set_ipfix_exporter(
54 collector_address=self._test.pg0.remote_ip4n,
55 src_address=self._test.pg0.local_ip4n,
57 template_interval=self._timeout)
59 def enable_flowprobe_feature(self):
60 self._test.vapi.ppcli("flowprobe feature add-del %s %s" %
61 (self._intf, self._datapath))
63 def disable_exporter(self):
64 self._test.vapi.cli("set ipfix exporter collector 0.0.0.0")
66 def disable_flowprobe_feature(self):
67 self._test.vapi.cli("flowprobe feature add-del %s %s disable" %
68 (self._intf, self._datapath))
71 return "ipfix-collector-%s" % (self._src, self.dst)
73 def query_vpp_config(self):
74 return self._configured
76 def verify_templates(self, decoder=None, timeout=1, count=3):
78 p = self._test.wait_for_cflow_packet(self._test.collector, 2, timeout)
79 self._test.assertTrue(p.haslayer(IPFIX))
80 if decoder is not None and p.haslayer(Template):
81 templates.append(p[Template].templateID)
82 decoder.add_template(p.getlayer(Template))
84 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
85 self._test.assertTrue(p.haslayer(IPFIX))
86 if decoder is not None and p.haslayer(Template):
87 templates.append(p[Template].templateID)
88 decoder.add_template(p.getlayer(Template))
90 p = self._test.wait_for_cflow_packet(self._test.collector, 2)
91 self._test.assertTrue(p.haslayer(IPFIX))
92 if decoder is not None and p.haslayer(Template):
93 templates.append(p[Template].templateID)
94 decoder.add_template(p.getlayer(Template))
98 class MethodHolder(VppTestCase):
99 """ Flow-per-packet plugin: test L2, IP4, IP6 reporting """
103 max_number_of_packets = 10
109 Perform standard class setup (defined by class method setUpClass in
110 class VppTestCase) before running the test case, set test case related
111 variables and configure VPP.
113 super(MethodHolder, cls).setUpClass()
115 # Create pg interfaces
116 cls.create_pg_interfaces(range(7))
119 cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
121 # Create BD with MAC learning and unknown unicast flooding disabled
122 # and put interfaces to this BD
123 cls.vapi.bridge_domain_add_del(bd_id=1, uu_flood=1, learn=1)
124 cls.vapi.sw_interface_set_l2_bridge(cls.pg1._sw_if_index, bd_id=1)
125 cls.vapi.sw_interface_set_l2_bridge(cls.pg2._sw_if_index, bd_id=1)
127 # Set up all interfaces
128 for i in cls.pg_interfaces:
132 cls.pg0.configure_ipv4_neighbors()
133 cls.collector = cls.pg0
136 cls.pg1.resolve_arp()
138 cls.pg2.resolve_arp()
140 cls.pg3.resolve_arp()
142 cls.pg4.resolve_arp()
145 cls.pg5.resolve_ndp()
146 cls.pg5.disable_ipv6_ra()
148 cls.pg6.resolve_ndp()
149 cls.pg6.disable_ipv6_ra()
151 super(MethodHolder, cls).tearDownClass()
154 def create_stream(self, src_if=None, dst_if=None, packets=None,
155 size=None, ip_ver='v4'):
156 """Create a packet stream to tickle the plugin
158 :param VppInterface src_if: Source interface for packet stream
159 :param VppInterface src_if: Dst interface for packet stream
167 packets = random.randint(1, self.max_number_of_packets)
169 for p in range(0, packets):
171 pkt_size = random.choice(self.pg_if_packet_sizes)
172 info = self.create_packet_info(src_if, dst_if)
173 payload = self.info_to_payload(info)
174 p = Ether(src=src_if.remote_mac, dst=src_if.local_mac)
176 p /= IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4)
178 p /= IPv6(src=src_if.remote_ip6, dst=dst_if.remote_ip6)
179 p /= (UDP(sport=1234, dport=4321) / Raw(payload))
181 self.extend_packet(p, pkt_size)
184 def verify_cflow_data(self, decoder, capture, cflow):
190 if cflow.haslayer(Data):
191 data = decoder.decode_data_set(cflow.getlayer(Set))
193 self.assertEqual(int(record[1].encode('hex'), 16), octets)
194 self.assertEqual(int(record[2].encode('hex'), 16), packets)
196 def send_packets(self, src_if=None, dst_if=None):
201 self.pg_enable_capture([dst_if])
202 src_if.add_stream(self.pkts)
204 return dst_if.get_capture(len(self.pkts))
206 def verify_cflow_data_detail(self, decoder, capture, cflow,
207 data_set={1: 'octets', 2: 'packets'},
210 print capture[0].show()
211 if cflow.haslayer(Data):
212 data = decoder.decode_data_set(cflow.getlayer(Set))
216 ip_layer = capture[0][IP]
218 ip_layer = capture[0][IPv6]
219 if data_set is not None:
221 # skip flow if in/out gress interface is 0
222 if int(record[10].encode('hex'), 16) == 0:
224 if int(record[14].encode('hex'), 16) == 0:
227 for field in data_set:
228 if field not in record.keys():
230 value = data_set[field]
231 if value == 'octets':
234 value += 40 # ??? is this correct
235 elif value == 'packets':
237 elif value == 'src_ip':
239 ip = socket.inet_pton(socket.AF_INET,
242 ip = socket.inet_pton(socket.AF_INET6,
244 value = int(ip.encode('hex'), 16)
245 elif value == 'dst_ip':
247 ip = socket.inet_pton(socket.AF_INET,
250 ip = socket.inet_pton(socket.AF_INET6,
252 value = int(ip.encode('hex'), 16)
253 elif value == 'sport':
254 value = int(capture[0][UDP].sport)
255 elif value == 'dport':
256 value = int(capture[0][UDP].dport)
257 self.assertEqual(int(record[field].encode('hex'), 16),
260 def verify_cflow_data_notimer(self, decoder, capture, cflows):
263 if cflow.haslayer(Data):
264 data = decoder.decode_data_set(cflow.getlayer(Set))
266 raise Exception("No CFLOW data")
271 self.assertEqual(p[IP].len, int(rec[1].encode('hex'), 16))
272 self.assertEqual(1, int(rec[2].encode('hex'), 16))
273 self.assertEqual(len(capture), idx)
275 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1,
277 """ wait for CFLOW packet and verify its correctness
279 :param timeout: how long to wait
281 :returns: tuple (packet, time spent waiting for packet)
283 self.logger.info("IPFIX: Waiting for CFLOW packet")
284 deadline = time.time() + timeout
286 # self.logger.debug(self.vapi.ppcli("show flow table"))
290 self.assert_in_range(counter, 0, 100, "number of packets ignored")
291 time_left = deadline - time.time()
293 if time_left < 0 and expected:
294 # self.logger.debug(self.vapi.ppcli("show flow table"))
295 raise CaptureTimeoutError(
296 "Packet did not arrive within timeout")
297 p = collector_intf.wait_for_packet(timeout=time_left)
298 except CaptureTimeoutError:
300 # self.logger.debug(self.vapi.ppcli("show flow table"))
301 raise CaptureTimeoutError(
302 "Packet did not arrive within timeout")
306 raise CaptureTimeoutError("Packet arrived even not expected")
307 self.assertEqual(p[Set].setID, set_id)
308 # self.logger.debug(self.vapi.ppcli("show flow table"))
309 self.logger.debug(ppp("IPFIX: Got packet:", p))
314 class Timers(MethodHolder):
315 """Template verification, timer tests"""
318 """ timer less than template timeout"""
319 self.logger.info("FFP_TEST_START_0002")
320 self.pg_enable_capture(self.pg_interfaces)
323 ipfix = VppCFLOW(test=self, active=2)
324 ipfix.add_vpp_config()
326 ipfix_decoder = IPFIXDecoder()
327 # template packet should arrive immediately
328 templates = ipfix.verify_templates(ipfix_decoder)
330 self.create_stream(packets=2)
332 capture = self.pg2.get_capture(2)
334 # make sure the one packet we expect actually showed up
335 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
336 self.verify_cflow_data(ipfix_decoder, capture, cflow)
338 ipfix.remove_vpp_config()
339 self.logger.info("FFP_TEST_FINISH_0002")
342 """ timer greater than template timeout"""
343 self.logger.info("FFP_TEST_START_0003")
344 self.pg_enable_capture(self.pg_interfaces)
347 ipfix = VppCFLOW(test=self, timeout=3, active=4)
348 ipfix.add_vpp_config()
350 ipfix_decoder = IPFIXDecoder()
351 # template packet should arrive immediately
352 ipfix.verify_templates()
354 self.create_stream(packets=2)
356 capture = self.pg2.get_capture(2)
358 # next set of template packet should arrive after 20 seconds
359 # template packet should arrive within 20 s
360 templates = ipfix.verify_templates(ipfix_decoder, timeout=5)
362 # make sure the one packet we expect actually showed up
363 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 15)
364 self.verify_cflow_data(ipfix_decoder, capture, cflow)
366 ipfix.remove_vpp_config()
367 self.logger.info("FFP_TEST_FINISH_0003")
370 class Datapath(MethodHolder):
371 """collect information on Ethernet, IP4 and IP6 datapath (no timers)"""
373 def test_templatesL2(self):
374 """ verify template on L2 datapath"""
375 self.logger.info("FFP_TEST_START_0000")
376 self.pg_enable_capture(self.pg_interfaces)
378 ipfix = VppCFLOW(test=self, layer='l2')
379 ipfix.add_vpp_config()
381 # template packet should arrive immediately
382 self.vapi.cli("ipfix flush")
383 ipfix.verify_templates(timeout=3, count=1)
384 self.collector.get_capture(1)
386 ipfix.remove_vpp_config()
387 self.logger.info("FFP_TEST_FINISH_0000")
389 def test_L2onL2(self):
390 """ L2 data on L2 datapath"""
391 self.logger.info("FFP_TEST_START_0001")
392 self.pg_enable_capture(self.pg_interfaces)
395 ipfix = VppCFLOW(test=self, layer='l2')
396 ipfix.add_vpp_config()
398 ipfix_decoder = IPFIXDecoder()
399 # template packet should arrive immediately
400 templates = ipfix.verify_templates(ipfix_decoder, count=1)
402 self.create_stream(packets=1)
403 capture = self.send_packets()
405 # make sure the one packet we expect actually showed up
406 self.vapi.cli("ipfix flush")
407 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
408 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
409 {2: 'packets', 256: 8})
410 self.collector.get_capture(2)
412 ipfix.remove_vpp_config()
413 self.logger.info("FFP_TEST_FINISH_0001")
415 def test_L3onL2(self):
416 """ L3 data on L2 datapath"""
417 self.logger.info("FFP_TEST_START_0002")
418 self.pg_enable_capture(self.pg_interfaces)
421 ipfix = VppCFLOW(test=self, layer='l3')
422 ipfix.add_vpp_config()
424 ipfix_decoder = IPFIXDecoder()
425 # template packet should arrive immediately
426 templates = ipfix.verify_templates(ipfix_decoder, count=2)
428 self.create_stream(packets=1)
429 capture = self.send_packets()
431 # make sure the one packet we expect actually showed up
432 self.vapi.cli("ipfix flush")
433 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
434 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
435 {2: 'packets', 4: 17,
436 8: 'src_ip', 12: 'dst_ip'})
438 self.collector.get_capture(3)
440 ipfix.remove_vpp_config()
441 self.logger.info("FFP_TEST_FINISH_0002")
443 def test_L4onL2(self):
444 """ L4 data on L2 datapath"""
445 self.logger.info("FFP_TEST_START_0003")
446 self.pg_enable_capture(self.pg_interfaces)
449 ipfix = VppCFLOW(test=self, layer='l4')
450 ipfix.add_vpp_config()
452 ipfix_decoder = IPFIXDecoder()
453 # template packet should arrive immediately
454 templates = ipfix.verify_templates(ipfix_decoder, count=2)
456 self.create_stream(packets=1)
457 capture = self.send_packets()
459 # make sure the one packet we expect actually showed up
460 self.vapi.cli("ipfix flush")
461 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
462 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
463 {2: 'packets', 7: 'sport', 11: 'dport'})
465 self.collector.get_capture(3)
467 ipfix.remove_vpp_config()
468 self.logger.info("FFP_TEST_FINISH_0003")
470 def test_templatesIp4(self):
471 """ verify templates on IP4 datapath"""
472 self.logger.info("FFP_TEST_START_0000")
474 self.pg_enable_capture(self.pg_interfaces)
476 ipfix = VppCFLOW(test=self, datapath='ip4')
477 ipfix.add_vpp_config()
479 # template packet should arrive immediately
480 self.vapi.cli("ipfix flush")
481 ipfix.verify_templates(timeout=3, count=1)
482 self.collector.get_capture(1)
484 ipfix.remove_vpp_config()
486 self.logger.info("FFP_TEST_FINISH_0000")
488 def test_L2onIP4(self):
489 """ L2 data on IP4 datapath"""
490 self.logger.info("FFP_TEST_START_0001")
491 self.pg_enable_capture(self.pg_interfaces)
494 ipfix = VppCFLOW(test=self, intf='pg4', layer='l2', datapath='ip4')
495 ipfix.add_vpp_config()
497 ipfix_decoder = IPFIXDecoder()
498 # template packet should arrive immediately
499 templates = ipfix.verify_templates(ipfix_decoder, count=1)
501 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
502 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
504 # make sure the one packet we expect actually showed up
505 self.vapi.cli("ipfix flush")
506 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
507 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
508 {2: 'packets', 256: 8})
510 # expected two templates and one cflow packet
511 self.collector.get_capture(2)
513 ipfix.remove_vpp_config()
514 self.logger.info("FFP_TEST_FINISH_0001")
516 def test_L3onIP4(self):
517 """ L3 data on IP4 datapath"""
518 self.logger.info("FFP_TEST_START_0002")
519 self.pg_enable_capture(self.pg_interfaces)
522 ipfix = VppCFLOW(test=self, intf='pg4', layer='l3', datapath='ip4')
523 ipfix.add_vpp_config()
525 ipfix_decoder = IPFIXDecoder()
526 # template packet should arrive immediately
527 templates = ipfix.verify_templates(ipfix_decoder, count=1)
529 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
530 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
532 # make sure the one packet we expect actually showed up
533 self.vapi.cli("ipfix flush")
534 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
535 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
536 {1: 'octets', 2: 'packets',
537 8: 'src_ip', 12: 'dst_ip'})
539 # expected two templates and one cflow packet
540 self.collector.get_capture(2)
542 ipfix.remove_vpp_config()
543 self.logger.info("FFP_TEST_FINISH_0002")
545 def test_L4onIP4(self):
546 """ L4 data on IP4 datapath"""
547 self.logger.info("FFP_TEST_START_0003")
548 self.pg_enable_capture(self.pg_interfaces)
551 ipfix = VppCFLOW(test=self, intf='pg4', layer='l4', datapath='ip4')
552 ipfix.add_vpp_config()
554 ipfix_decoder = IPFIXDecoder()
555 # template packet should arrive immediately
556 templates = ipfix.verify_templates(ipfix_decoder, count=1)
558 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
559 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
561 # make sure the one packet we expect actually showed up
562 self.vapi.cli("ipfix flush")
563 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
564 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
565 {2: 'packets', 7: 'sport', 11: 'dport'})
567 # expected two templates and one cflow packet
568 self.collector.get_capture(2)
570 ipfix.remove_vpp_config()
571 self.logger.info("FFP_TEST_FINISH_0003")
573 def test_templatesIP6(self):
574 """ verify templates on IP6 datapath"""
575 self.logger.info("FFP_TEST_START_0000")
576 self.pg_enable_capture(self.pg_interfaces)
578 ipfix = VppCFLOW(test=self, datapath='ip6')
579 ipfix.add_vpp_config()
581 # template packet should arrive immediately
582 ipfix.verify_templates(count=1)
583 self.collector.get_capture(1)
585 ipfix.remove_vpp_config()
587 self.logger.info("FFP_TEST_FINISH_0000")
589 def test_L2onIP6(self):
590 """ L2 data on IP6 datapath"""
591 self.logger.info("FFP_TEST_START_0001")
592 self.pg_enable_capture(self.pg_interfaces)
595 ipfix = VppCFLOW(test=self, intf='pg6', layer='l2', datapath='ip6')
596 ipfix.add_vpp_config()
598 ipfix_decoder = IPFIXDecoder()
599 # template packet should arrive immediately
600 templates = ipfix.verify_templates(ipfix_decoder, count=1)
602 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
604 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
606 # make sure the one packet we expect actually showed up
607 self.vapi.cli("ipfix flush")
608 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
609 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
610 {2: 'packets', 256: 56710},
613 # expected two templates and one cflow packet
614 self.collector.get_capture(2)
616 ipfix.remove_vpp_config()
617 self.logger.info("FFP_TEST_FINISH_0001")
619 def test_L3onIP6(self):
620 """ L3 data on IP6 datapath"""
621 self.logger.info("FFP_TEST_START_0002")
622 self.pg_enable_capture(self.pg_interfaces)
625 ipfix = VppCFLOW(test=self, intf='pg6', layer='l3', datapath='ip6')
626 ipfix.add_vpp_config()
628 ipfix_decoder = IPFIXDecoder()
629 # template packet should arrive immediately
630 templates = ipfix.verify_templates(ipfix_decoder, count=1)
632 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
634 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
636 # make sure the one packet we expect actually showed up
637 self.vapi.cli("ipfix flush")
638 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
639 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
641 27: 'src_ip', 28: 'dst_ip'},
644 # expected two templates and one cflow packet
645 self.collector.get_capture(2)
647 ipfix.remove_vpp_config()
648 self.logger.info("FFP_TEST_FINISH_0002")
650 def test_L4onIP6(self):
651 """ L4 data on IP6 datapath"""
652 self.logger.info("FFP_TEST_START_0003")
653 self.pg_enable_capture(self.pg_interfaces)
656 ipfix = VppCFLOW(test=self, intf='pg6', layer='l4', datapath='ip6')
657 ipfix.add_vpp_config()
659 ipfix_decoder = IPFIXDecoder()
660 # template packet should arrive immediately
661 templates = ipfix.verify_templates(ipfix_decoder, count=1)
663 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
665 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
667 # make sure the one packet we expect actually showed up
668 self.vapi.cli("ipfix flush")
669 cflow = self.wait_for_cflow_packet(self.collector, templates[0])
670 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
671 {2: 'packets', 7: 'sport', 11: 'dport'},
674 # expected two templates and one cflow packet
675 self.collector.get_capture(2)
677 ipfix.remove_vpp_config()
678 self.logger.info("FFP_TEST_FINISH_0003")
681 """ no timers, one CFLOW packet, 9 Flows inside"""
682 self.logger.info("FFP_TEST_START_0001")
683 self.pg_enable_capture(self.pg_interfaces)
686 ipfix = VppCFLOW(test=self)
687 ipfix.add_vpp_config()
689 ipfix_decoder = IPFIXDecoder()
690 # template packet should arrive immediately
691 templates = ipfix.verify_templates(ipfix_decoder)
693 self.create_stream(packets=9)
694 capture = self.send_packets()
696 # make sure the one packet we expect actually showed up
697 self.vapi.cli("ipfix flush")
698 cflow = self.wait_for_cflow_packet(self.collector, templates[1])
699 self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow])
700 self.collector.get_capture(4)
702 ipfix.remove_vpp_config()
703 self.logger.info("FFP_TEST_FINISH_0001")
706 """ no timers, two CFLOW packets (mtu=256), 3 Flows in each"""
707 self.logger.info("FFP_TEST_START_0002")
708 self.pg_enable_capture(self.pg_interfaces)
711 ipfix = VppCFLOW(test=self, mtu=256)
712 ipfix.add_vpp_config()
714 ipfix_decoder = IPFIXDecoder()
715 # template packet should arrive immediately
716 self.vapi.cli("ipfix flush")
717 templates = ipfix.verify_templates(ipfix_decoder)
719 self.create_stream(packets=6)
720 capture = self.send_packets()
722 # make sure the one packet we expect actually showed up
724 self.vapi.cli("ipfix flush")
725 cflows.append(self.wait_for_cflow_packet(self.collector,
727 cflows.append(self.wait_for_cflow_packet(self.collector,
729 self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows)
730 self.collector.get_capture(5)
732 ipfix.remove_vpp_config()
733 self.logger.info("FFP_TEST_FINISH_0002")
736 @unittest.skipUnless(running_extended_tests(), "part of extended tests")
737 class DisableIPFIX(MethodHolder):
741 """ disable IPFIX after first packets"""
742 self.logger.info("FFP_TEST_START_0001")
743 self.pg_enable_capture(self.pg_interfaces)
746 ipfix = VppCFLOW(test=self)
747 ipfix.add_vpp_config()
749 ipfix_decoder = IPFIXDecoder()
750 # template packet should arrive immediately
751 templates = ipfix.verify_templates(ipfix_decoder)
756 # make sure the one packet we expect actually showed up
757 self.vapi.cli("ipfix flush")
758 self.wait_for_cflow_packet(self.collector, templates[1])
759 self.collector.get_capture(4)
762 ipfix.disable_exporter()
763 self.pg_enable_capture([self.collector])
767 # make sure no one packet arrived in 1 minute
768 self.vapi.cli("ipfix flush")
769 self.wait_for_cflow_packet(self.collector, templates[1],
771 self.collector.get_capture(0)
773 ipfix.remove_vpp_config()
774 self.logger.info("FFP_TEST_FINISH_0001")
777 @unittest.skipUnless(running_extended_tests(), "part of extended tests")
778 class ReenableIPFIX(MethodHolder):
779 """Re-enable IPFIX"""
782 """ disable IPFIX after first packets and re-enable after few packets
784 self.logger.info("FFP_TEST_START_0001")
785 self.pg_enable_capture(self.pg_interfaces)
788 ipfix = VppCFLOW(test=self)
789 ipfix.add_vpp_config()
791 ipfix_decoder = IPFIXDecoder()
792 # template packet should arrive immediately
793 templates = ipfix.verify_templates(ipfix_decoder)
795 self.create_stream(packets=5)
798 # make sure the one packet we expect actually showed up
799 self.vapi.cli("ipfix flush")
800 self.wait_for_cflow_packet(self.collector, templates[1])
801 self.collector.get_capture(4)
804 ipfix.disable_exporter()
805 self.vapi.cli("ipfix flush")
806 self.pg_enable_capture([self.collector])
810 # make sure no one packet arrived in active timer span
811 self.vapi.cli("ipfix flush")
812 self.wait_for_cflow_packet(self.collector, templates[1],
814 self.collector.get_capture(0)
815 self.pg2.get_capture(5)
818 ipfix.enable_exporter()
820 capture = self.collector.get_capture(4)
824 self.assertTrue(p.haslayer(IPFIX))
825 if p.haslayer(Template):
827 self.assertTrue(nr_templates, 3)
829 self.assertTrue(p.haslayer(IPFIX))
832 self.assertTrue(nr_templates, 1)
834 ipfix.remove_vpp_config()
835 self.logger.info("FFP_TEST_FINISH_0001")
838 @unittest.skipUnless(running_extended_tests(), "part of extended tests")
839 class DisableFP(MethodHolder):
840 """Disable Flowprobe feature"""
843 """ disable flowprobe feature after first packets"""
844 self.logger.info("FFP_TEST_START_0001")
845 self.pg_enable_capture(self.pg_interfaces)
847 ipfix = VppCFLOW(test=self)
848 ipfix.add_vpp_config()
850 ipfix_decoder = IPFIXDecoder()
851 # template packet should arrive immediately
852 templates = ipfix.verify_templates(ipfix_decoder)
857 # make sure the one packet we expect actually showed up
858 self.vapi.cli("ipfix flush")
859 self.wait_for_cflow_packet(self.collector, templates[1])
860 self.collector.get_capture(4)
863 ipfix.disable_flowprobe_feature()
864 self.pg_enable_capture([self.collector])
868 # make sure no one packet arrived in active timer span
869 self.vapi.cli("ipfix flush")
870 self.wait_for_cflow_packet(self.collector, templates[1],
872 self.collector.get_capture(0)
874 ipfix.remove_vpp_config()
875 self.logger.info("FFP_TEST_FINISH_0001")
878 @unittest.skipUnless(running_extended_tests(), "part of extended tests")
879 class ReenableFP(MethodHolder):
880 """Re-enable Flowprobe feature"""
883 """ disable flowprobe feature after first packets and re-enable
884 after few packets """
885 self.logger.info("FFP_TEST_START_0001")
886 self.pg_enable_capture(self.pg_interfaces)
889 ipfix = VppCFLOW(test=self)
890 ipfix.add_vpp_config()
892 ipfix_decoder = IPFIXDecoder()
893 # template packet should arrive immediately
894 self.vapi.cli("ipfix flush")
895 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
900 # make sure the one packet we expect actually showed up
901 self.vapi.cli("ipfix flush")
902 self.wait_for_cflow_packet(self.collector, templates[1], 5)
903 self.collector.get_capture(4)
906 ipfix.disable_flowprobe_feature()
907 self.pg_enable_capture([self.collector])
911 # make sure no one packet arrived in active timer span
912 self.vapi.cli("ipfix flush")
913 self.wait_for_cflow_packet(self.collector, templates[1], 5,
915 self.collector.get_capture(0)
918 ipfix.enable_flowprobe_feature()
919 self.vapi.cli("ipfix flush")
920 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
924 # make sure the next packets (templates and data) we expect actually
926 self.vapi.cli("ipfix flush")
927 self.wait_for_cflow_packet(self.collector, templates[1], 5)
928 self.collector.get_capture(4)
930 ipfix.remove_vpp_config()
931 self.logger.info("FFP_TEST_FINISH_0001")
934 if __name__ == '__main__':
935 unittest.main(testRunner=VppTestRunner)