From 7436d8bdf60bca9b80fb76781e1f709bbcd435da Mon Sep 17 00:00:00 2001 From: Qun Wan Date: Thu, 30 Mar 2017 14:36:56 -0400 Subject: TLDK udwfwd test case: - ip fragement for ipv4 - ip reassemble for ipv4 - ip checksum for ipv4 - ip checksum for ipv6 - ip fragment for ipv6 added the genpcap.py script to generate the pcap files and corresponding test scripts Change-Id: I01329dbb0ecd3c3a5dd7a63ef1dea01b2e717da5 Signed-off-by: qun wan --- resources/libraries/python/TLDK/SetupTLDKTest.py | 239 +++++++++++++++++++++++ resources/libraries/python/TLDK/TLDKConstants.py | 31 +++ resources/libraries/python/TLDK/UdpTest.py | 126 ++++++++++++ resources/libraries/python/TLDK/__init__.py | 16 ++ resources/libraries/python/TLDK/gen_pcap.py | 100 ++++++++++ 5 files changed, 512 insertions(+) create mode 100644 resources/libraries/python/TLDK/SetupTLDKTest.py create mode 100644 resources/libraries/python/TLDK/TLDKConstants.py create mode 100644 resources/libraries/python/TLDK/UdpTest.py create mode 100644 resources/libraries/python/TLDK/__init__.py create mode 100644 resources/libraries/python/TLDK/gen_pcap.py (limited to 'resources/libraries/python') diff --git a/resources/libraries/python/TLDK/SetupTLDKTest.py b/resources/libraries/python/TLDK/SetupTLDKTest.py new file mode 100644 index 0000000000..3e3511c382 --- /dev/null +++ b/resources/libraries/python/TLDK/SetupTLDKTest.py @@ -0,0 +1,239 @@ +# Copyright (c) 2017 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""This module exists to provide setup utilities for the framework on topology +nodes. All tasks required to be run before the actual tests are started is +supposed to end up here. +""" + +from shlex import split +from subprocess import Popen, PIPE, call +from multiprocessing import Pool +from tempfile import NamedTemporaryFile +from os.path import basename +import os + +from robot.api import logger +from robot.libraries.BuiltIn import BuiltIn + +from resources.libraries.python.ssh import SSH +from resources.libraries.python.TLDK.TLDKConstants import TLDKConstants as con +from resources.libraries.python.topology import NodeType +from resources.libraries.python.TLDK.gen_pcap import gen_all_pcap + +__all__ = ["SetupTLDKTest"] + + +def pack_framework_dir(): + """Pack the testing WS into temp file, return its name. + :returns: file_name + :rtype: str + :raises RuntimeError: If pack the testing framework failed. + """ + # Remove the TLDK and DPDK dir existted. + os.system("rm -rf tldk") + os.system("rm -rf dpdk") + os.system("rm -f dpdk-16.11.1.tar.xz") + + # Get the latest TLDK and dpdk code. + os.system("git clone https://gerrit.fd.io/r/tldk") + os.system("wget http://fast.dpdk.org/rel/dpdk-16.11.1.tar.xz") + + # Generate pcap file used to execute test case. + gen_all_pcap() + + tmpfile = NamedTemporaryFile(suffix=".tgz", prefix="TLDK-testing-") + file_name = tmpfile.name + tmpfile.close() + + proc = Popen( + split("tar --exclude-vcs -zcf {0} .".format(file_name)), + stdout=PIPE, stderr=PIPE) + (stdout, stderr) = proc.communicate() + + logger.debug(stdout) + logger.debug(stderr) + + return_code = proc.wait() + if return_code != 0: + raise RuntimeError("Could not pack testing framework.") + + return file_name + + +def copy_tarball_to_node(tarball, node): + """Copy tarball file from local host to remote node. + + :param tarball: Path to tarball to upload. + :param node: Dictionary created from topology. + :type tarball: str + :type node: dict + :returns: nothing. + """ + logger.console('Copying tarball to {0}'.format(node['host'])) + ssh = SSH() + ssh.connect(node) + + ssh.scp(tarball, "/tmp/") + + +def extract_tarball_at_node(tarball, node): + """Extract tarball at given node. + + Extracts tarball using tar on given node to specific CSIT location. + Raise runtime errors when failed. + + :param tarball: Path to tarball to upload. + :param node: Dictionary created from topology. + :type tarball: str + :type node: dict + :return: nothing + :raises RuntimeError: If extract tarball failed. + """ + logger.console('Extracting tarball to {0} on {1}'.format( + con.REMOTE_FW_DIR, node['host'])) + ssh = SSH() + ssh.connect(node) + + cmd = 'sudo rm -rf {1}; mkdir {1} ; tar -zxf {0} -C {1}; ' \ + 'rm -f {0}'.format(tarball, con.REMOTE_FW_DIR) + (ret_code, _, stderr) = ssh.exec_command(cmd, timeout=30) + if ret_code != 0: + logger.error('Unpack error: {0}'.format(stderr)) + raise RuntimeError('Failed to unpack {0} at node {1}'.format( + tarball, node['host'])) + + +def create_env_directory_at_node(node): + """ + Create fresh virtualenv to a directory, install pip requirements. + + :param node: Dictionary created from topology, will only install in the TG. + :type node: dict + :returns: nothing + :raises RuntimeError: If the setup of virtualenv failed. + """ + logger.console('Extracting virtualenv, installing requirements.txt ' + 'on {0}'.format(node['host'])) + ssh = SSH() + ssh.connect(node) + (ret_code, stdout, stderr) = ssh.exec_command( + 'cd {0} && rm -rf env && ' + '. virtualenv --system-site-packages --never-download env && ' + '. env/bin/activate && pip install -r requirements.txt' + .format(con.REMOTE_FW_DIR), timeout=100) + if ret_code != 0: + logger.error('Virtualenv creation error: {0}'.format(stdout + stderr)) + raise RuntimeError('Virtualenv setup failed') + else: + logger.console('Virtualenv created on {0}'.format(node['host'])) + +def install_tldk_test(node): + """Prepare the TLDK test envrionment. + Raise errors when failed. + + :param node: Dictionary created from topology. + :type node: dict + :returns: nothing. + :raises RuntimeError: If install tldk failed. + """ + logger.console('Install the TLDK on {0}'.format(node['host'])) + + ssh = SSH() + ssh.connect(node) + + (ret_code, _, stderr) = ssh.exec_command( + 'cd {0}/{1} && ./install_tldk.sh' + .format(con.REMOTE_FW_DIR, con.TLDK_SCRIPTS), timeout=600) + + if ret_code != 0: + logger.error('Install the TLDK error: {0}'.format(stderr)) + raise RuntimeError('Install the TLDK failed') + else: + logger.console('Install the TLDK on {0} success!'.format(node['host'])) + +def setup_node(args): + """Run all set-up methods for a node. + + This method is used as map_async parameter. It receives tuple with all + parameters as passed to map_async function. + + :param args: All parameters needed to setup one node. + :type args: tuple + :returns: True - success, False - error + :rtype: bool + :raises RuntimeError: If node setup failed. + """ + tarball, remote_tarball, node = args + try: + copy_tarball_to_node(tarball, node) + extract_tarball_at_node(remote_tarball, node) + if node['type'] == NodeType.DUT: + install_tldk_test(node) + if node['type'] == NodeType.TG: + create_env_directory_at_node(node) + except RuntimeError as exc: + logger.error("Node setup failed, error:'{0}'".format(exc.message)) + return False + else: + logger.console('Setup of node {0} done'.format(node['host'])) + return True + +def delete_local_tarball(tarball): + """Delete local tarball to prevent disk pollution. + + :param tarball: Path to tarball to upload. + :type tarball: str + :returns: nothing. + """ + call(split('sh -c "rm {0} > /dev/null 2>&1"'.format(tarball))) + + +class SetupTLDKTest(object): + """Setup suite run on topology nodes. + + Many VAT/CLI based tests need the scripts at remote hosts before executing + them. This class packs the whole testing directory and copies it over + to all nodes in topology under /tmp/ + """ + + @staticmethod + def setup_tldk_test(nodes): + """Pack the whole directory and extract in temp on each node.""" + + tarball = pack_framework_dir() + msg = 'Framework packed to {0}'.format(tarball) + logger.console(msg) + logger.trace(msg) + remote_tarball = "/tmp/{0}".format(basename(tarball)) + + # Turn off logging since we use multiprocessing. + log_level = BuiltIn().set_log_level('NONE') + params = ((tarball, remote_tarball, node) for node in nodes.values()) + pool = Pool(processes=len(nodes)) + result = pool.map_async(setup_node, params) + pool.close() + pool.join() + + # Turn on logging. + BuiltIn().set_log_level(log_level) + + logger.info( + 'Executed node setups in parallel, waiting for processes to end') + result.wait() + + logger.info('Results: {0}'.format(result.get())) + + logger.trace('Test framework copied to all topology nodes') + delete_local_tarball(tarball) + logger.console('All nodes are ready') diff --git a/resources/libraries/python/TLDK/TLDKConstants.py b/resources/libraries/python/TLDK/TLDKConstants.py new file mode 100644 index 0000000000..af9ebf2a8d --- /dev/null +++ b/resources/libraries/python/TLDK/TLDKConstants.py @@ -0,0 +1,31 @@ +# Copyright (c) 2017 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +"""This file defines the constants variables for the TLDK test.""" + + +class TLDKConstants(object): + """Define the directory path for the TLDK test.""" + + # TLDK testing directory location at topology nodes + REMOTE_FW_DIR = '/tmp/TLDK-testing' + + # Shell scripts location + TLDK_SCRIPTS = 'TLDK-tests/tldk_scripts' + + # Libraries location + TLDK_DEPLIBS = 'TLDK-tests/tldk_deplibs' + + # Config files location for the TLDK test + TLDK_TESTCONFIG = 'TLDK-tests/tldk_testconfig' diff --git a/resources/libraries/python/TLDK/UdpTest.py b/resources/libraries/python/TLDK/UdpTest.py new file mode 100644 index 0000000000..adf0888724 --- /dev/null +++ b/resources/libraries/python/TLDK/UdpTest.py @@ -0,0 +1,126 @@ +# Copyright (c) 2017 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +""" +This module exists to provide the UDP test for TLDK on topology nodes. +""" + +from scapy.utils import rdpcap +from scapy.layers.inet import IP +from scapy.layers.inet6 import IPv6 + +from robot.libraries.BuiltIn import BuiltIn + +from resources.libraries.python.ssh import SSH +from resources.libraries.python.TLDK.TLDKConstants import TLDKConstants as con +from resources.libraries.python.topology import Topology + +class UdpTest(object): + """Test the TLDK UDP function.""" + + @staticmethod + def get_pcap_info(file_prefix): + """Get the Dest IP from the RX pcap file + + :param file_prefix: the test case pcap file prefix + :type file_prefix: str + :returns: packet counts, dest ip, is or not ipv4 + :rtype: tuple(int, str, bool). + """ + exec_dir = BuiltIn().get_variable_value("${EXECDIR}") + + rx_pcapfile = '{0}/{1}/{2}_rx.pcap' \ + .format(exec_dir, con.TLDK_TESTCONFIG, file_prefix) + packets = rdpcap(rx_pcapfile) + count = len(packets) + + ### the first packet + pkt = packets[0] + if pkt.type == 0x0800: + ### this is a IPv4 packet + dest_ip = pkt[IP].dst + is_ipv4 = True + elif pkt.type == 0x86dd: + ### this is a IPv6 packet + dest_ip = pkt[IPv6].dst + is_ipv4 = False + + return count, dest_ip, is_ipv4 + + @staticmethod + def exec_the_udpfwd_test(dut_node, dut_if, file_prefix, \ + dest_ip, is_ipv4=True): + """Execute the udpfwd on the dut_node. + + :param dut_node: Will execute the udpfwd on this node. + :param dut_if: DUT interface name. + :param file_prefix: The test case config file prefix. + :param dest_ip: The UDP packet dest IP. + :param is_ipv4: Execute the IPv4 or IPv6 test. + :type dut_node: dict + :type dut_if: str + :type file_prefix: str + :type dest_ip: str + :type is_ipv4: bool + :returns: none. + :raises RuntimeError: If failed to execute udpfwd test on the dut node. + """ + pci_address = Topology.get_interface_pci_addr(dut_node, dut_if) + ssh = SSH() + ssh.connect(dut_node) + if is_ipv4: + cmd = 'cd {0}/{4} && ./run_tldk.sh {0}/{5}/{2}_rx.pcap ' \ + '{0}/{5}/{2}_tx.pcap {1} {0}/{5}/{2}_fe.cfg ' \ + '{0}/{5}/{2}_be.cfg {3} NONE' \ + .format(con.REMOTE_FW_DIR, pci_address, file_prefix, \ + dest_ip, con.TLDK_SCRIPTS, con.TLDK_TESTCONFIG) + else: + cmd = 'cd {0}/{4} && ./run_tldk.sh {0}/{5}/{2}_rx.pcap ' \ + '{0}/{5}/{2}_tx.pcap {1} {0}/{5}/{2}_fe.cfg ' \ + '{0}/{5}/{2}_be.cfg NONE {3}' \ + .format(con.REMOTE_FW_DIR, pci_address, file_prefix, \ + dest_ip, con.TLDK_SCRIPTS, con.TLDK_TESTCONFIG) + + (ret_code, _, _) = ssh.exec_command(cmd, timeout=600) + if ret_code != 0: + raise RuntimeError('Failed to execute udpfwd test at node {0}' + .format(dut_node['host'])) + + @staticmethod + def get_the_test_result(dut_node, file_prefix): + """ + After execute the udpfwd cmd, use this to get the test result. + + :param dut_node: will get the test result in this dut node + :param dut_if: the dut interface name + :param file_prefix: the test case output file prefix + :type dut_node: dice + :type dut_if: str + :type file_prefix: str + :returns: str. + :rtype: str + :raises RuntimeError: If failed to get the test result. + """ + ssh = SSH() + ssh.connect(dut_node) + cmd = 'cd {0}; tcpdump -nnnn -vvv -r ./{2}/{1}_tx.pcap | ' \ + 'grep \'udp sum ok\' | wc -l' \ + .format(con.REMOTE_FW_DIR, file_prefix, con.TLDK_TESTCONFIG) + + (ret_code, stdout, _) = ssh.exec_command(cmd, timeout=100) + if ret_code != 0: + raise RuntimeError('Failed to get test result at node {0}' + .format(dut_node['host'])) + + return stdout diff --git a/resources/libraries/python/TLDK/__init__.py b/resources/libraries/python/TLDK/__init__.py new file mode 100644 index 0000000000..9cb1aeee44 --- /dev/null +++ b/resources/libraries/python/TLDK/__init__.py @@ -0,0 +1,16 @@ +# Copyright (c) 2017 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +__init__ file for directory resources/libraries/python/TLDK +""" diff --git a/resources/libraries/python/TLDK/gen_pcap.py b/resources/libraries/python/TLDK/gen_pcap.py new file mode 100644 index 0000000000..bd9d2b1743 --- /dev/null +++ b/resources/libraries/python/TLDK/gen_pcap.py @@ -0,0 +1,100 @@ +#! /usr/bin/python +# Copyright (c) 2017 Cisco and/or its affiliates. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at: +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +This module is used to generate pcap file used to execute UDP test cases. +""" + +from scapy.layers.inet import Ether, IP, UDP, fragment +from scapy.layers.inet6 import IPv6 +from scapy.utils import PcapWriter +from resources.libraries.python.TLDK.TLDKConstants import TLDKConstants as con + +def create_packet(psz, is_ipv6, frag_size=None): + """Create a packet to use scapy send to DUT.""" + if is_ipv6 != True: + packet = Ether()/IP()/UDP()/("X" * psz) + packet[IP].src = "192.168.1.56" + packet[IP].dst = "192.168.1.233" + else: + packet = Ether()/IPv6()/UDP()/("X" * psz) + packet[IPv6].src = "2001:4860:b002::56" + packet[IPv6].dst = "2001:4860:b002::28" + packet[Ether].src = "DE:AD:BE:EF:02:01" + packet[Ether].dst = "DE:AD:BE:EF:01:02" + packet[UDP].sport = 1111 + packet[UDP].dport = 32768 + if frag_size != None: + packet = fragment(packet, fragsize=frag_size) + return packet + +def gen_ipv4_checksum_pcap(): + """Generate ipv4 checksum test case input pcap file.""" + writer = PcapWriter(con.TLDK_TESTCONFIG + "/test_ipv4_checksum_rx.pcap", + append=False) + for i in range(1, 1474): + packets = create_packet(i, False) + for packet in packets: + writer.write(packet) + writer.close() + +def gen_ipv6_checksum_pcap(): + """Generate ipv6 checksum test case input pcap file.""" + writer = PcapWriter(con.TLDK_TESTCONFIG + "/test_ipv6_checksum_rx.pcap", + append=False) + for i in range(1, 1454): + packets = create_packet(i, True) + for packet in packets: + writer.write(packet) + writer.close() + +def gen_ipv4_fragment_pcap(): + """Generate ipv4 fragment test case input pcap file.""" + writer = PcapWriter(con.TLDK_TESTCONFIG + "/test_ipv4_fragment_rx.pcap", + append=False) + for i in range(1, 1474): + packets = create_packet(i, False) + for packet in packets: + writer.write(packet) + writer.close() + +def gen_ipv6_fragment_pcap(): + """Generate ipv6 fragment test case input pcap file.""" + writer = PcapWriter(con.TLDK_TESTCONFIG + "/test_ipv6_fragment_rx.pcap", + append=False) + for i in range(1, 1454): + packets = create_packet(i, True) + for packet in packets: + writer.write(packet) + writer.close() + +def gen_ipv4_assemble_pcap(): + """Generate ipv4 assemble test case input pcap file.""" + writer = PcapWriter(con.TLDK_TESTCONFIG + "/test_ipv4_assemble_rx.pcap", + append=False) + packets = create_packet(1066, False, 1024) + for packet in packets: + writer.write(packet) + writer.close() + +def gen_all_pcap(): + """Generate all test cases input pcap file.""" + gen_ipv4_checksum_pcap() + gen_ipv6_checksum_pcap() + gen_ipv4_fragment_pcap() + gen_ipv6_fragment_pcap() + gen_ipv4_assemble_pcap() + +if __name__ == "__main__": + gen_all_pcap() -- cgit 1.2.3-korg