Re: [dts] [PATCH V4 1/1] [examples/flow_classify]: upload automation test script

["Lin, Xueqin" <xueqin.lin@intel.com>]

Acked-by: Lin Xueqin <xueqin.lin@intel.com>

-----Original Message-----
From: Mo, YufengX 
Sent: Friday, September 20, 2019 10:22 AM
To: dts@dpdk.org; Tu, Lijuan <lijuan.tu@intel.com>; Lin, Xueqin <xueqin.lin@intel.com>; Yu, PingX <pingx.yu@intel.com>
Cc: Mo, YufengX <yufengx.mo@intel.com>
Subject: [dts][PATCH V4 1/1] [examples/flow_classify]: upload automation test script


This automation test script is for flow classify feature.
flow_classify is the tool to call flow_classify lib for group of packets, just after receiving them or before transmitting them.

Signed-off-by: yufengmx <yufengx.mo@intel.com>
---
 tests/TestSuite_flow_classify.py | 509 +++++++++++++++++++++++++++++++
 1 file changed, 509 insertions(+)
 create mode 100644 tests/TestSuite_flow_classify.py

diff --git a/tests/TestSuite_flow_classify.py b/tests/TestSuite_flow_classify.py
new file mode 100644
index 0000000..ffa6136
--- /dev/null
+++ b/tests/TestSuite_flow_classify.py
@@ -0,0 +1,509 @@
+# BSD LICENSE
+#
+# Copyright(c) 2010-2019 Intel Corporation. All rights reserved.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without # 
+modification, are permitted provided that the following conditions # 
+are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in
+#     the documentation and/or other materials provided with the
+#     distribution.
+#   * Neither the name of Intel Corporation nor the names of its
+#     contributors may be used to endorse or promote products derived
+#     from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # 
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # 
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import os
+import time
+import re
+from collections import Counter
+from datetime import datetime
+
+from packet import Packet
+from scapy.sendrecv import sendp
+
+from utils import create_mask as dts_create_mask from test_case import 
+TestCase from exception import VerifyFailure from settings import 
+HEADER_SIZE
+
+
+class TestFlowClassify(TestCase):
+
+    def get_cores_mask(self, config='all'):
+        sockets = [self.dut.get_numa_id(index) for index in self.dut_ports]
+        socket_count = Counter(sockets)
+        port_socket = socket_count.keys()[0] if len(socket_count) == 1 else -1
+        mask = dts_create_mask(self.dut.get_core_list(config,
+                                                      socket=port_socket))
+        return mask
+
+    @property
+    def output_path(self):
+        suiteName = self.__class__.__name__[4:].lower()
+        if self.logger.log_path.startswith(os.sep):
+            output_path = os.path.join(self.logger.log_path, suiteName)
+        else:
+            cur_path = os.path.dirname(
+                os.path.dirname(os.path.realpath(__file__)))
+            output_path = os.path.join(
+                                cur_path, self.logger.log_path, suiteName)
+        if not os.path.exists(output_path):
+            os.makedirs(output_path)
+
+        return output_path
+
+    def get_ixia_peer_port(self):
+        for cnt in self.dut_ports:
+            if self.tester.get_local_port_type(cnt) != 'ixia':
+                continue
+            tester_port = self.tester.get_local_port(cnt)
+            return tester_port
+
+    def d_console(self, cmds):
+        return self.execute_cmds(cmds, con_name='dut')
+
+    def d_a_console(self, cmds):
+        return self.execute_cmds(cmds, con_name='dut_alt')
+
+    def get_console(self, name):
+        if name == 'dut':
+            console = self.dut.send_expect
+            msg_pipe = self.dut.get_session_output
+        elif name == 'dut_alt':
+            console = self.dut.alt_session.send_expect
+            msg_pipe = self.dut.alt_session.session.get_output_all
+        else:
+            msg = 'not support <{}> session'.format(name)
+            raise VerifyFailure(msg)
+        return console, msg_pipe
+
+    def execute_cmds(self, cmds, con_name):
+        console, msg_pipe = self.get_console(con_name)
+        if len(cmds) == 0:
+            return
+        if isinstance(cmds, (str, unicode)):
+            cmds = [cmds, '# ', 5]
+        if not isinstance(cmds[0], list):
+            cmds = [cmds]
+        outputs = [] if len(cmds) > 1 else ''
+        for item in cmds:
+            expected_items = item[1]
+            expected_str = expected_items or '# '
+            try:
+                if len(item) == 3:
+                    timeout = int(item[2])
+                    output = console(item[0], expected_str, timeout)
+                    output = msg_pipe() if not output else output
+                else:
+                    # timeout = 5
+                    output = console(item[0], expected_str)
+                    output = msg_pipe() if not output else output
+            except Exception as e:
+                # self.check_process_status()
+                msg = "execute '{0}' timeout".format(item[0])
+                raise Exception(msg)
+            time.sleep(1)
+            if len(cmds) > 1:
+                outputs.append(output)
+            else:
+                outputs = output
+        return outputs
+
+    def get_pkt_len(self, pkt_type):
+        # packet size
+        frame_size = 256
+        headers_size = sum(
+            map(lambda x: 132 if x == 'sctp' else HEADER_SIZE[x],
+                ['eth', 'ip', pkt_type]))
+        pktlen = frame_size - headers_size
+        return pktlen
+
+    def set_stream(self, stm_names=None):
+        ''' set streams for traffic '''
+        pkt_configs = {
+            # UDP_1:
+            #    Frame Data/Protocols: Ethernet 2 0800, IPv4,UDP/IP, Fixed 64.
+            #    IPv4 Header Page: Dest Address: 2.2.2.7 Src  Address: 2.2.2.3
+            #    UDP Header: Src Port: 32  Dest Port: 33
+            #
+            #    Stream Control: Stop after this Stream, Packet Count 32.
+            #
+            'UDP_1': {
+                'type': 'UDP',
+                'pkt_layers': {
+                    'ipv4': {'src': '2.2.2.3', 'dst': '2.2.2.7'},
+                    'udp': {'src': 32, 'dst': 33},
+                    'raw': {'payload': ['58'] * self.get_pkt_len('udp')}}},
+            # UDP_2:
+            #    Frame Data/Protocols: Ethernet 2 0800, IPv4,UDP/IP, Fixed 64.
+            #    IPv4 Header Page: Dest Address: 9.9.9.7 Src  Address: 9.9.9.3
+            #    UDP Header: Src Port: 32  Dest Port: 33
+            #
+            #    Stream Control: Stop after this Stream, Packet Count 32.
+            #
+            'UDP_2': {
+                'type': 'UDP',
+                'pkt_layers': {
+                    'ipv4': {'src': '9.9.9.3', 'dst': '9.9.9.7'},
+                    'udp': {'src': 32, 'dst': 33},
+                    'raw': {'payload': ['58'] * self.get_pkt_len('udp')}}},
+            'invalid_UDP': {
+                'type': 'UDP',
+                'pkt_layers': {
+                    'ipv4': {'src': '9.8.7.6', 'dst': '192.168.0.36'},
+                    'udp': {'src': 10, 'dst': 11},
+                    'raw': {'payload': ['58'] * self.get_pkt_len('udp')}}},
+            # TCP_1:
+            #    Frame Data/Protocols: Ethernet 2 0800, IPv4,TCP/IP, Fixed 64.
+            #    IPv4 Header Page: Dest Address: 9.9.9.7 Src  Address: 9.9.9.3
+            #    TCP Header: Src Port: 32  Dest Port: 33
+            #
+            #    Stream Control: Stop after this Stream, Packet Count 32.
+            #
+            'TCP_1': {
+                'type': 'TCP',
+                'pkt_layers': {
+                    'ipv4': {'src': '9.9.9.3', 'dst': '9.9.9.7'},
+                    'tcp': {'src': 32, 'dst': 33},
+                    'raw': {'payload': ['58'] * self.get_pkt_len('tcp')}}},
+            # TCP_2:
+            #    Frame Data/Protocols: Ethernet 2 0800, IPv4,TCP/IP, Fixed 64.
+            #    IPv4 Header Page: Dest Address: 9.9.8.7 Src  Address: 9.9.8.3
+            #    TCP Header: Src Port: 32  Dest Port: 33
+            #
+            #    Stream Control: Stop after this Stream, Packet Count 32.
+            #
+            'TCP_2': {
+                'type': 'TCP',
+                'pkt_layers': {
+                    'ipv4': {'src': '9.9.8.3', 'dst': '9.9.8.7'},
+                    'tcp': {'src': 32, 'dst': 33},
+                    'raw': {'payload': ['58'] * self.get_pkt_len('tcp')}}},
+            'invalid_TCP': {
+                'type': 'TCP',
+                'pkt_layers': {
+                    'ipv4': {'src': '9.8.7.6', 'dst': '192.168.0.36'},
+                    'tcp': {'src': 10, 'dst': 11},
+                    'raw': {'payload': ['58'] * self.get_pkt_len('tcp')}}},
+            # SCTP_1:
+            #    Frame Data/Protocols: Ethernet 2 0800, IPv4, None, Fixed 256.
+            #    IPv4 Header Page: Dest Address: 2.3.4.5 Src  Address: 6.7.8.9
+            #    Protocol: 132-SCTP
+            #    Stream Control: Stop after this Stream, Packet Count 32.
+            #
+            'SCTP_1': {
+                'type': 'SCTP',
+                'pkt_layers': {
+                    'ipv4': {'src': '6.7.8.9', 'dst': '2.3.4.5'},
+                    'sctp': {'src': 32, 'dst': 33},
+                    'raw': {'payload': ['58'] * self.get_pkt_len('sctp')}}},
+            'invalid_SCTP': {
+                'type': 'SCTP',
+                'pkt_layers': {
+                    'ipv4': {'src': '9.8.7.6', 'dst': '192.168.0.36'},
+                    'sctp': {'src': 10, 'dst': 11},
+                    'raw': {'payload': ['58'] * self.get_pkt_len('sctp')}}},
+        }
+
+        # create packet for send
+        streams = []
+        for stm_name in stm_names:
+            if stm_name not in pkt_configs.keys():
+                continue
+            values = pkt_configs[stm_name]
+            savePath = os.sep.join([self.output_path,
+                                    "pkt_{0}.pcap".format(stm_name)])
+            pkt_type = values.get('type')
+            pkt_layers = values.get('pkt_layers')
+            pkt = Packet(pkt_type=pkt_type)
+            for layer in pkt_layers.keys():
+                pkt.config_layer(layer, pkt_layers[layer])
+            pkt.pktgen.pkt.show()
+            streams.append(pkt.pktgen.pkt)
+
+        return streams
+
+    def send_packet_by_scapy(self, config):
+        tx_iface = config.get('tx_intf')
+        cmd = "ifconfig {0} up".format(tx_iface)
+        self.tester.send_expect(cmd, '# ', 30)
+        pkts = config.get('stream')
+        # stream config
+        stream_configs = config.get('stream configs')
+        frame_config = stream_configs.get('frame config')
+        gapUnit = frame_config.get('gapUnit')
+        if gapUnit == 'gapMilliSeconds':
+            time_unit = 10e-4
+        elif gapUnit == 'gapMicroSeconds':
+            time_unit = 10e-7
+        else:
+            time_unit = 1
+        time_unit = 10e-4
+        ifg = frame_config.get('ifg')
+        count = stream_configs.get('count')
+        interval = ifg * time_unit
+        # run traffic
+        sendp(pkts, iface=tx_iface, inter=interval, verbose=False, 
+ count=count)
+
+    @property
+    def target_dir(self):
+        ''' get absolute directory of target source code '''
+        target_dir = '/root' + self.dut.base_dir[1:] \
+                     if self.dut.base_dir.startswith('~') else \
+                     self.dut.base_dir
+        return target_dir
+
+    @property
+    def target_name(self):
+        return self.dut.target
+
+    def prepare_binary(self, name):
+        example_dir = "examples/" + name
+        out = self.dut.build_dpdk_apps('./' + example_dir)
+        self.verify("Error" not in out, "Compilation error")
+        self.verify("No such" not in out, "Compilation error")
+        binary_dir = os.path.join(self.target_dir, example_dir, 'build')
+        cmd = ["ls -F {0} | grep '*'".format(binary_dir), '# ', 5]
+        exec_file = self.d_a_console(cmd)
+        binary_file = os.path.join(binary_dir, exec_file[:-1])
+        return binary_file
+
+    def start_flow_classify(self):
+        ''' boot up flow_classify '''
+        rule_config = os.sep.join([self.target_dir,
+                                   'examples',
+                                   'flow_classify',
+                                   'ipv4_rules_file.txt'])
+        if not os.path.exists(rule_config):
+            raise VerifyFailure("rules file doesn't existed")
+        core = "1S/1C/1T"
+        option = r" -c {0} -n 4 --file-prefix=test -- --rule_ipv4={1}".format(
+            self.get_cores_mask(core), rule_config)
+        prompt = 'table_entry_delete succeeded'
+        cmd = [' '.join([self.flow_classify, option]), prompt, 30]
+        output = self.d_console(cmd)
+        return output
+
+    def close_flow_classify(self):
+        output = self.dut.get_session_output()
+        dt = datetime.now()
+        timestamp = dt.strftime('%Y-%m-%d_%H%M%S')
+        self.test_data = '{0}/{1}_{2}.log'.format(
+            self.output_path, 'flow_classify', timestamp)
+        with open(self.test_data, 'wb') as fp:
+            fp.write(output)
+        cmds = ['killall flow_classify', '# ', 10]
+        self.d_a_console(cmds)
+
+    def get_stream_rule_priority(self, stream_type):
+        stream_types = {
+            'UDP_1': 0,
+            'UDP_2': 1,
+            'TCP_1': 2,
+            'TCP_2': 3,
+            'SCTP_1': 4}
+        return stream_types.get(stream_type, None)
+
+    def run_traffic(self, config):
+        stm_types = config.get('stm_types')
+        total_packets = config.get('total_packets')
+        gap = config.get('gap')
+        flow_type = config.get('flow_type')
+        # set traffic topology
+        pktgen_name = 'ixia' if self._enable_perf else 'scapy'
+        tx_port = self.get_ixia_peer_port() if pktgen_name == 'ixia' else \
+            self.tester.get_interface(self.tester.get_local_port(0))
+        # set traffic configuration
+        ports_topo = {
+            'tx_intf': tx_port,
+            'rx_intf': 0,
+            'stream': self.set_stream(stm_types),
+            'stream configs': {
+                'count': total_packets,
+                'frame config': {
+                    'gapUnit': 'gapMilliSeconds',
+                    'ifg': gap},
+                'flow_type': flow_type,
+            }, }
+        # begin traffic checking
+        self.logger.info("begin traffic ... ")
+        method_name = 'send_packet_by_' + pktgen_name
+        pkt_gen_func = getattr(self, 'send_packet_by_' + pktgen_name)
+        if pkt_gen_func:
+            result = pkt_gen_func(ports_topo)
+        else:
+            msg = 'not support {}'.format(method_name)
+            raise VerifyFailure(msg)
+        # end traffic
+        self.logger.info("complete transmission")
+
+    def check_filter_pkts(self, log, rule_priority):
+        pat = "rule\[{0}\] count=(\d+)".format(rule_priority) \
+              if rule_priority is not None else \
+              "rule\[\d+\] count=(\d+)"
+        with open(log, 'rb') as fp:
+            content = fp.read()
+        if content:
+            grp = re.findall(pat, content, re.M)
+            total = reduce(lambda x, y: x + y, [int(i) for i in grp]) \
+                if grp and len(grp) else 0
+        return total
+
+    def check_test_result(self, config):
+        stm_types = config.get('stm_types')
+        total_packets = config.get('total_packets')
+        flow_type = config.get('flow_type')
+        self.logger.info(stm_types)
+        check_results = []
+        for stm_type in stm_types:
+            rule_priority = self.get_stream_rule_priority(stm_type)
+            captured_pkts = self.check_filter_pkts(self.test_data,
+                                                   rule_priority)
+            self.logger.info("%s %d %d" % (stm_type, rule_priority or 0,
+                                           captured_pkts or 0))
+            msg = None
+            if flow_type == 'multi_stream':
+                # check if packets are multiple rules' pkts
+                # ignore invalid rule
+                if rule_priority and captured_pkts % total_packets != 0:
+                    msg = ("captured packets are not multiples of "
+                           "rules' {0} packets".format(total_packets))
+                else:
+                    continue
+            elif flow_type == 'single_stream':
+                if rule_priority is None and captured_pkts != 0:
+                    msg = "invalid stream hasn't been filtered out"
+                elif rule_priority is None and captured_pkts != total_packets:
+                    msg = "expect {0} ".format(total_packets) + \
+                          "captured {0}".format(captured_pkts)
+                else:
+                    continue
+            else:
+                continue
+            if msg:
+                check_results.append(msg)
+
+        if check_results:
+            self.logger.error(os.linesep.join(check_results))
+            raise VerifyFailure("test result fail")
+
+    def init_params(self):
+        self.test_data = None
+
+    def verify_traffic(self, stm_types=None, gap=10,
+                       flow_type="single_stream"):
+        self.logger.info('begin to check ...... ')
+        info = {
+            'stm_types': stm_types,
+            'flow_type': flow_type,
+            'total_packets': 32,
+            'gap': gap, }
+
+        try:
+            self.init_params()
+            # preset test environment
+            self.start_flow_classify()
+            # run traffic
+            self.run_traffic(info)
+            # close flow_classify
+            self.close_flow_classify()
+        except Exception as e:
+            # close flow_classify
+            self.close_flow_classify()
+            msg = 'failed to run traffic'
+            self.verify(False, msg)
+        # analysis test result
+        self.check_test_result(info)
+
+    def verify_multiple_rules(self):
+        stream_list = [
+            'UDP_1', 'UDP_2', 'invalid_UDP',
+            'TCP_1', 'TCP_2', 'invalid_TCP',
+            'SCTP_1', 'invalid_SCTP']
+        self.verify_traffic(stm_types=stream_list, 
+ flow_type="multi_stream")
+
+    def verify_supported_nic(self):
+        supported_drivers = ['i40e', 'ixgbe']
+        result = all([self.dut.ports_info[index]['port'].default_driver in
+                      supported_drivers
+                      for index in self.dut_ports])
+        msg = "current nic is not supported"
+        self.verify(result, msg)
+    #
+    # Test cases.
+    #
+
+    def set_up_all(self):
+        """
+        Run before each test suite
+        """
+        # initialize ports topology
+        self.dut_ports = self.dut.get_ports()
+        self.verify(len(self.dut_ports) >= 2, "Insufficient ports")
+        # set binary process setting
+        self.flow_classify = self.prepare_binary('flow_classify')
+        self.verify_supported_nic()
+
+    def set_up(self):
+        """
+        Run before each test case.
+        """
+        pass
+
+    def tear_down(self):
+        """
+        Run after each test case.
+        """
+        pass
+
+    def tear_down_all(self):
+        """
+        Run after each test suite.
+        """
+        pass
+
+    def test_udp_valid_rule(self):
+        stream_list = ['UDP_1', 'UDP_2']
+        for stm_type in stream_list:
+            self.verify_traffic([stm_type])
+
+    def test_udp_invalid_rule(self):
+        stream_list = ['invalid_UDP']
+        self.verify_traffic(stream_list)
+
+    def test_tcp_valid_rule(self):
+        stream_list = ['TCP_1', 'TCP_2']
+        for stm_type in stream_list:
+            self.verify_traffic([stm_type])
+
+    def test_tcp_invalid_rule(self):
+        stream_list = ['invalid_TCP']
+        self.verify_traffic(stream_list)
+
+    def test_sctp_valid_rule(self):
+        stream_list = ['SCTP_1']
+        self.verify_traffic(stream_list)
+
+    def test_sctp_invalid_rule(self):
+        stream_list = ['invalid_SCTP']
+        self.verify_traffic(stream_list)
+
+    def test_multiple_rules(self):
+        self.verify_multiple_rules()
--
2.21.0