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
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=300,
23 mtu=512, datapath='l2', layer='l2 l3 l4'):
27 if passive == 0 or passive < active:
28 self._passive = active+5
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 = 16
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 verify_cflow_data_detail(self, decoder, capture, cflow,
197 data_set={1: 'octets', 2: 'packets'},
200 print capture[0].show()
201 if cflow.haslayer(Data):
202 data = decoder.decode_data_set(cflow.getlayer(Set))
206 ip_layer = capture[0][IP]
208 ip_layer = capture[0][IPv6]
209 if data_set is not None:
211 # skip flow if in/out gress interface is 0
212 if int(record[10].encode('hex'), 16) == 0:
214 if int(record[14].encode('hex'), 16) == 0:
217 for field in data_set:
218 if field not in record.keys():
220 value = data_set[field]
221 if value == 'octets':
224 value += 40 # ??? is this correct
225 elif value == 'packets':
227 elif value == 'src_ip':
229 ip = socket.inet_pton(socket.AF_INET,
232 ip = socket.inet_pton(socket.AF_INET6,
234 value = int(ip.encode('hex'), 16)
235 elif value == 'dst_ip':
237 ip = socket.inet_pton(socket.AF_INET,
240 ip = socket.inet_pton(socket.AF_INET6,
242 value = int(ip.encode('hex'), 16)
243 elif value == 'sport':
244 value = int(capture[0][UDP].sport)
245 elif value == 'dport':
246 value = int(capture[0][UDP].dport)
247 self.assertEqual(int(record[field].encode('hex'), 16),
250 def verify_cflow_data_notimer(self, decoder, capture, cflows):
253 if cflow.haslayer(Data):
254 data = decoder.decode_data_set(cflow.getlayer(Set))
256 raise Exception("No CFLOW data")
261 self.assertEqual(p[IP].len, int(rec[1].encode('hex'), 16))
262 self.assertEqual(1, int(rec[2].encode('hex'), 16))
263 self.assertEqual(len(capture), idx)
265 def wait_for_cflow_packet(self, collector_intf, set_id=2, timeout=1,
267 """ wait for CFLOW packet and verify its correctness
269 :param timeout: how long to wait
271 :returns: tuple (packet, time spent waiting for packet)
273 self.logger.info("IPFIX: Waiting for CFLOW packet")
274 deadline = time.time() + timeout
276 # self.logger.debug(self.vapi.ppcli("show flow table"))
280 self.assert_in_range(counter, 0, 100, "number of packets ignored")
281 time_left = deadline - time.time()
283 if time_left < 0 and expected:
284 # self.logger.debug(self.vapi.ppcli("show flow table"))
285 raise CaptureTimeoutError(
286 "Packet did not arrive within timeout")
287 p = collector_intf.wait_for_packet(timeout=time_left)
288 except CaptureTimeoutError:
290 # self.logger.debug(self.vapi.ppcli("show flow table"))
291 raise CaptureTimeoutError(
292 "Packet did not arrive within timeout")
296 raise CaptureTimeoutError("Packet arrived even not expected")
297 self.assertEqual(p[Set].setID, set_id)
298 # self.logger.debug(self.vapi.ppcli("show flow table"))
299 self.logger.debug(ppp("IPFIX: Got packet:", p))
303 def send_packets(self, src_if=None, dst_if=None):
309 self.pg_enable_capture([dst_if])
310 src_if.add_stream(self.pkts)
312 return dst_if.get_capture(len(self.pkts))
315 class TestFFP_Timers(MethodHolder):
316 """Template verification, timer tests"""
319 """ receive template data packets"""
320 self.logger.info("FFP_TEST_START_0001")
321 self.pg_enable_capture(self.pg_interfaces)
323 ipfix = VppCFLOW(test=self, active=10)
324 ipfix.add_vpp_config()
326 # template packet should arrive immediately
327 ipfix.verify_templates(timeout=3)
329 ipfix.remove_vpp_config()
330 self.logger.info("FFP_TEST_FINISH_0001")
333 """ timer=10s, less than template timeout"""
334 self.logger.info("FFP_TEST_START_0002")
335 self.pg_enable_capture(self.pg_interfaces)
338 ipfix = VppCFLOW(test=self, active=20)
339 ipfix.add_vpp_config()
341 ipfix_decoder = IPFIXDecoder()
342 # template packet should arrive immediately
343 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
346 capture = self.send_packets()
348 # make sure the one packet we expect actually showed up
349 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 39)
350 self.verify_cflow_data(ipfix_decoder, capture, cflow)
352 ipfix.remove_vpp_config()
353 self.logger.info("FFP_TEST_FINISH_0002")
356 """ timer=30s, greater than template timeout"""
357 self.logger.info("FFP_TEST_START_0003")
358 self.pg_enable_capture(self.pg_interfaces)
361 ipfix = VppCFLOW(test=self, timeout=20, active=25)
362 ipfix.add_vpp_config()
364 ipfix_decoder = IPFIXDecoder()
365 # template packet should arrive immediately
366 ipfix.verify_templates(timeout=3)
369 capture = self.send_packets()
371 # next set of template packet should arrive after 20 seconds
372 # template packet should arrive within 20 s
373 templates = ipfix.verify_templates(ipfix_decoder, timeout=25)
375 # make sure the one packet we expect actually showed up
376 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 55)
377 self.verify_cflow_data(ipfix_decoder, capture, cflow)
379 ipfix.remove_vpp_config()
380 self.logger.info("FFP_TEST_FINISH_0003")
383 """ sent packet after first cflow packet arrived"""
384 self.logger.info("FFP_TEST_START_0004")
385 self.pg_enable_capture(self.pg_interfaces)
388 ipfix = VppCFLOW(test=self, active=20)
389 ipfix.add_vpp_config()
391 ipfix_decoder = IPFIXDecoder()
392 # template packet should arrive immediately
393 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
398 # make sure the one packet we expect actually showed up
399 self.wait_for_cflow_packet(self.collector, templates[1], 39)
401 self.pg_enable_capture([self.pg2])
403 capture = self.send_packets()
405 # make sure the one packet we expect actually showed up
406 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 30)
407 self.verify_cflow_data(ipfix_decoder, capture, cflow)
409 ipfix.remove_vpp_config()
410 self.logger.info("FFP_TEST_FINISH_0004")
413 class TestFFP_DatapathL2(MethodHolder):
414 """collect information on Ethernet datapath"""
417 """ verify template on L2 datapath"""
418 self.logger.info("FFP_TEST_START_0000")
419 self.pg_enable_capture(self.pg_interfaces)
421 ipfix = VppCFLOW(test=self, active=10)
422 ipfix.add_vpp_config()
424 # template packet should arrive immediately
425 ipfix.verify_templates(timeout=3, count=3)
426 self.collector.get_capture(3)
428 ipfix.remove_vpp_config()
429 self.logger.info("FFP_TEST_FINISH_0000")
432 """ L2 data on L2 datapath"""
433 self.logger.info("FFP_TEST_START_0001")
434 self.pg_enable_capture(self.pg_interfaces)
437 ipfix = VppCFLOW(test=self, active=10, layer='l2')
438 ipfix.add_vpp_config()
440 ipfix_decoder = IPFIXDecoder()
441 # template packet should arrive immediately
442 templates = ipfix.verify_templates(ipfix_decoder, timeout=3, count=1)
444 self.create_stream(packets=1)
445 capture = self.send_packets()
447 # make sure the one packet we expect actually showed up
448 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 39)
449 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
450 {2: 'packets', 256: 8})
452 # expected two templates and one cflow packet
453 self.collector.get_capture(2)
455 ipfix.remove_vpp_config()
456 self.logger.info("FFP_TEST_FINISH_0001")
459 """ L3 data on L2 datapath"""
460 self.logger.info("FFP_TEST_START_0002")
461 self.pg_enable_capture(self.pg_interfaces)
464 ipfix = VppCFLOW(test=self, active=10, layer='l3')
465 ipfix.add_vpp_config()
467 ipfix_decoder = IPFIXDecoder()
468 # template packet should arrive immediately
469 templates = ipfix.verify_templates(ipfix_decoder, timeout=3, count=2)
471 self.create_stream(packets=1)
472 capture = self.send_packets()
474 # make sure the one packet we expect actually showed up
475 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 39)
476 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
477 {2: 'packets', 4: 17,
478 8: 'src_ip', 12: 'dst_ip'})
480 # expected one template and one cflow packet
481 self.collector.get_capture(3)
483 ipfix.remove_vpp_config()
484 self.logger.info("FFP_TEST_FINISH_0002")
487 """ L4 data on L2 datapath"""
488 self.logger.info("FFP_TEST_START_0003")
489 self.pg_enable_capture(self.pg_interfaces)
492 ipfix = VppCFLOW(test=self, active=10, layer='l4')
493 ipfix.add_vpp_config()
495 ipfix_decoder = IPFIXDecoder()
496 # template packet should arrive immediately
497 templates = ipfix.verify_templates(ipfix_decoder, timeout=3, count=2)
499 self.create_stream(packets=1)
500 capture = self.send_packets()
502 # make sure the one packet we expect actually showed up
503 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 39)
504 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
505 {2: 'packets', 7: 'sport', 11: 'dport'})
507 # expected one template and one cflow packet
508 self.collector.get_capture(3)
510 ipfix.remove_vpp_config()
511 self.logger.info("FFP_TEST_FINISH_0003")
514 class TestFFP_DatapathIP4(MethodHolder):
515 """collect information on IP4 datapath"""
518 """ verify templates on IP4 datapath"""
519 self.logger.info("FFP_TEST_START_0000")
521 self.pg_enable_capture(self.pg_interfaces)
523 ipfix = VppCFLOW(test=self, active=10, datapath='ip4')
524 ipfix.add_vpp_config()
526 # template packet should arrive immediately
527 ipfix.verify_templates(timeout=3, count=1)
528 self.collector.get_capture(1)
530 ipfix.remove_vpp_config()
532 self.logger.info("FFP_TEST_FINISH_0000")
535 """ L2 data on IP4 datapath"""
536 self.logger.info("FFP_TEST_START_0001")
537 self.pg_enable_capture(self.pg_interfaces)
540 ipfix = VppCFLOW(test=self, intf='pg4', active=10,
541 layer='l2', datapath='ip4')
542 ipfix.add_vpp_config()
544 ipfix_decoder = IPFIXDecoder()
545 # template packet should arrive immediately
546 templates = ipfix.verify_templates(ipfix_decoder, timeout=3, count=1)
548 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
549 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
551 # make sure the one packet we expect actually showed up
552 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 39)
553 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
554 {2: 'packets', 256: 8})
556 # expected two templates and one cflow packet
557 self.collector.get_capture(2)
559 ipfix.remove_vpp_config()
560 self.logger.info("FFP_TEST_FINISH_0001")
563 """ L3 data on IP4 datapath"""
564 self.logger.info("FFP_TEST_START_0002")
565 self.pg_enable_capture(self.pg_interfaces)
568 ipfix = VppCFLOW(test=self, intf='pg4', active=10,
569 layer='l3', datapath='ip4')
570 ipfix.add_vpp_config()
572 ipfix_decoder = IPFIXDecoder()
573 # template packet should arrive immediately
574 templates = ipfix.verify_templates(ipfix_decoder, timeout=3, count=1)
576 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
577 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
579 # make sure the one packet we expect actually showed up
580 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 39)
581 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
582 {1: 'octets', 2: 'packets',
583 8: 'src_ip', 12: 'dst_ip'})
585 # expected two templates and one cflow packet
586 self.collector.get_capture(2)
588 ipfix.remove_vpp_config()
589 self.logger.info("FFP_TEST_FINISH_0002")
592 """ L4 data on IP4 datapath"""
593 self.logger.info("FFP_TEST_START_0003")
594 self.pg_enable_capture(self.pg_interfaces)
597 ipfix = VppCFLOW(test=self, intf='pg4', active=10,
598 layer='l4', datapath='ip4')
599 ipfix.add_vpp_config()
601 ipfix_decoder = IPFIXDecoder()
602 # template packet should arrive immediately
603 templates = ipfix.verify_templates(ipfix_decoder, timeout=3, count=1)
605 self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1)
606 capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4)
608 # make sure the one packet we expect actually showed up
609 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 39)
610 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
611 {2: 'packets', 7: 'sport', 11: 'dport'})
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_0003")
620 class TestFFP_DatapathIP6(MethodHolder):
621 """collect information on IP6 datapath"""
624 """ verify templates on IP6 datapath"""
625 self.logger.info("FFP_TEST_START_0000")
626 self.pg_enable_capture(self.pg_interfaces)
628 ipfix = VppCFLOW(test=self, active=10, datapath='ip6')
629 ipfix.add_vpp_config()
631 # template packet should arrive immediately
632 ipfix.verify_templates(timeout=3, count=1)
633 self.collector.get_capture(1)
635 ipfix.remove_vpp_config()
637 self.logger.info("FFP_TEST_FINISH_0000")
640 """ L2 data on IP6 datapath"""
641 self.logger.info("FFP_TEST_START_0001")
642 self.pg_enable_capture(self.pg_interfaces)
645 ipfix = VppCFLOW(test=self, intf='pg6', active=20,
646 layer='l2', datapath='ip6')
647 ipfix.add_vpp_config()
649 ipfix_decoder = IPFIXDecoder()
650 # template packet should arrive immediately
651 templates = ipfix.verify_templates(ipfix_decoder, timeout=3, count=1)
653 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
655 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
657 # make sure the one packet we expect actually showed up
658 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 39)
659 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
660 {2: 'packets', 256: 56710},
663 # expected two templates and one cflow packet
664 self.collector.get_capture(2)
666 ipfix.remove_vpp_config()
667 self.logger.info("FFP_TEST_FINISH_0001")
670 """ L3 data on IP6 datapath"""
671 self.logger.info("FFP_TEST_START_0002")
672 self.pg_enable_capture(self.pg_interfaces)
675 ipfix = VppCFLOW(test=self, intf='pg6', active=10,
676 layer='l3', datapath='ip6')
677 ipfix.add_vpp_config()
679 ipfix_decoder = IPFIXDecoder()
680 # template packet should arrive immediately
681 templates = ipfix.verify_templates(ipfix_decoder, timeout=3, count=1)
683 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
685 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
687 # make sure the one packet we expect actually showed up
688 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 39)
689 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
691 27: 'src_ip', 28: 'dst_ip'},
694 # expected two templates and one cflow packet
695 self.collector.get_capture(2)
697 ipfix.remove_vpp_config()
698 self.logger.info("FFP_TEST_FINISH_0002")
701 """ L4 data on IP6 datapath"""
702 self.logger.info("FFP_TEST_START_0003")
703 self.pg_enable_capture(self.pg_interfaces)
706 ipfix = VppCFLOW(test=self, intf='pg6', active=10,
707 layer='l4', datapath='ip6')
708 ipfix.add_vpp_config()
710 ipfix_decoder = IPFIXDecoder()
711 # template packet should arrive immediately
712 templates = ipfix.verify_templates(ipfix_decoder, timeout=3, count=1)
714 self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1,
716 capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6)
718 # make sure the one packet we expect actually showed up
719 cflow = self.wait_for_cflow_packet(self.collector, templates[0], 39)
720 self.verify_cflow_data_detail(ipfix_decoder, capture, cflow,
721 {2: 'packets', 7: 'sport', 11: 'dport'},
724 # expected two templates and one cflow packet
725 self.collector.get_capture(2)
727 ipfix.remove_vpp_config()
728 self.logger.info("FFP_TEST_FINISH_0003")
731 class TestFFP_NoTimers(MethodHolder):
735 """ no timers, one CFLOW packet, 9 Flows inside"""
736 self.logger.info("FFP_TEST_START_0001")
737 self.pg_enable_capture(self.pg_interfaces)
740 ipfix = VppCFLOW(test=self, active=0)
741 ipfix.add_vpp_config()
743 ipfix_decoder = IPFIXDecoder()
744 # template packet should arrive immediately
745 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
747 self.create_stream(packets=9)
748 capture = self.send_packets()
750 # make sure the one packet we expect actually showed up
751 cflow = self.wait_for_cflow_packet(self.collector, templates[1], 10)
752 self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow])
753 self.wait_for_cflow_packet(self.collector, templates[1], 10,
755 self.collector.get_capture(4)
757 ipfix.remove_vpp_config()
758 self.logger.info("FFP_TEST_FINISH_0001")
761 """ no timers, two CFLOW packets (mtu=256), 3 Flows in each"""
762 self.logger.info("FFP_TEST_START_0002")
763 self.pg_enable_capture(self.pg_interfaces)
766 ipfix = VppCFLOW(test=self, active=0, mtu=256)
767 ipfix.add_vpp_config()
769 ipfix_decoder = IPFIXDecoder()
770 # template packet should arrive immediately
771 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
773 self.create_stream(packets=6)
774 capture = self.send_packets()
776 # make sure the one packet we expect actually showed up
778 cflows.append(self.wait_for_cflow_packet(self.collector,
780 cflows.append(self.wait_for_cflow_packet(self.collector,
782 self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows)
783 self.collector.get_capture(5)
785 ipfix.remove_vpp_config()
786 self.logger.info("FFP_TEST_FINISH_0002")
789 class TestFFP_DisableIPFIX(MethodHolder):
793 """ disable IPFIX after first packets"""
794 self.logger.info("FFP_TEST_START_0001")
795 self.pg_enable_capture(self.pg_interfaces)
798 ipfix = VppCFLOW(test=self, active=10)
799 ipfix.add_vpp_config()
801 ipfix_decoder = IPFIXDecoder()
802 # template packet should arrive immediately
803 templates = ipfix.verify_templates(ipfix_decoder, timeout=30)
808 # make sure the one packet we expect actually showed up
809 self.wait_for_cflow_packet(self.collector, templates[1], 30)
810 self.collector.get_capture(4)
813 ipfix.disable_exporter()
814 self.pg_enable_capture([self.collector])
818 # make sure no one packet arrived in 1 minute
819 self.wait_for_cflow_packet(self.collector, templates[1], 30,
821 self.collector.get_capture(0)
823 ipfix.remove_vpp_config()
824 self.logger.info("FFP_TEST_FINISH_0001")
827 class TestFFP_ReenableIPFIX(MethodHolder):
828 """Re-enable IPFIX"""
831 """ disable IPFIX after first packets and re-enable after few packets
833 self.logger.info("FFP_TEST_START_0001")
834 self.pg_enable_capture(self.pg_interfaces)
837 ipfix = VppCFLOW(test=self, active=10)
838 ipfix.add_vpp_config()
840 ipfix_decoder = IPFIXDecoder()
841 # template packet should arrive immediately
842 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
847 # make sure the one packet we expect actually showed up
848 self.wait_for_cflow_packet(self.collector, templates[1], 30)
849 self.collector.get_capture(4)
852 ipfix.disable_exporter()
853 self.pg_enable_capture([self.collector])
857 # make sure no one packet arrived in active timer span
858 self.wait_for_cflow_packet(self.collector, templates[1], 30,
860 self.collector.get_capture(0)
863 ipfix.enable_exporter()
864 self.vapi.cli("ipfix flush")
865 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
869 # make sure the next packets (templates and data) we expect actually
871 self.wait_for_cflow_packet(self.collector, templates[1], 30)
872 self.collector.get_capture(4)
874 ipfix.remove_vpp_config()
875 self.logger.info("FFP_TEST_FINISH_0001")
878 class TestFFP_DisableFFP(MethodHolder):
879 """Disable Flowprobe feature"""
882 """ disable flowprobe feature after first packets"""
883 self.logger.info("FFP_TEST_START_0001")
884 self.pg_enable_capture(self.pg_interfaces)
886 ipfix = VppCFLOW(test=self, active=10)
887 ipfix.add_vpp_config()
889 ipfix_decoder = IPFIXDecoder()
890 # template packet should arrive immediately
891 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
896 # make sure the one packet we expect actually showed up
897 self.wait_for_cflow_packet(self.collector, templates[1], 30)
898 self.collector.get_capture(4)
901 ipfix.disable_flowprobe_feature()
902 self.pg_enable_capture([self.collector])
906 # make sure no one packet arrived in active timer span
907 self.wait_for_cflow_packet(self.collector, templates[1], 30,
909 self.collector.get_capture(0)
911 ipfix.remove_vpp_config()
912 self.logger.info("FFP_TEST_FINISH_0001")
915 class TestFFP_ReenableFFP(MethodHolder):
916 """Re-enable Flowprobe feature"""
919 """ disable flowprobe feature after first packets and re-enable
920 after few packets """
921 self.logger.info("FFP_TEST_START_0001")
922 self.pg_enable_capture(self.pg_interfaces)
925 ipfix = VppCFLOW(test=self, active=10)
926 ipfix.add_vpp_config()
928 ipfix_decoder = IPFIXDecoder()
929 # template packet should arrive immediately
930 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
935 # make sure the one packet we expect actually showed up
936 self.wait_for_cflow_packet(self.collector, templates[1], 30)
937 self.collector.get_capture(4)
940 ipfix.disable_flowprobe_feature()
941 self.pg_enable_capture([self.collector])
945 # make sure no one packet arrived in active timer span
946 self.wait_for_cflow_packet(self.collector, templates[1], 30,
948 self.collector.get_capture(0)
951 ipfix.enable_flowprobe_feature()
952 self.vapi.cli("ipfix flush")
953 templates = ipfix.verify_templates(ipfix_decoder, timeout=3)
957 # make sure the next packets (templates and data) we expect actually
959 self.wait_for_cflow_packet(self.collector, templates[1], 30)
960 self.collector.get_capture(4)
962 ipfix.remove_vpp_config()
963 self.logger.info("FFP_TEST_FINISH_0001")
966 if __name__ == '__main__':
967 unittest.main(testRunner=VppTestRunner)