resources/libraries/python/DMM/SingleCliSer.py

   1 # Copyright (c) 2018 Huawei Technologies Co.,Ltd.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14
  15 """
  16 This module exists to provide single client-server test for DMM
  17 on topology nodes.
  18 """
  19 import time
  20 import os
  21 import glob
  22
  23 from resources.libraries.python.ssh import exec_cmd, exec_cmd_no_error
  24 from resources.libraries.python.DMM.DMMConstants import DMMConstants as con
  25 from resources.libraries.python.topology import Topology
  26
  27 class SingleCliSer(object):
  28     """Test DMM with single client-server topology."""
  29
  30     @staticmethod
  31     def set_dmm_interface_address(dut_node, ifname, ip_addr, ip4_prefix):
  32         """
  33         Flush ip, set ip, set interface up.
  34
  35         :param dut_node: Node to set the interface address on.
  36         :param ifname: Interface name.
  37         :param ip_addr: IP address to configure.
  38         :param ip4_prefix: Prefix length.
  39         :type dut_node: dict
  40         :type ifname: str
  41         :type ip_addr: str
  42         :type ip4_prefix: int
  43         """
  44         cmd = 'sudo ip -4 addr flush dev {}'.format(ifname)
  45         exec_cmd_no_error(dut_node, cmd)
  46         cmd = 'sudo ip addr add {}/{} dev {}'\
  47             .format(ip_addr, ip4_prefix, ifname)
  48         exec_cmd_no_error(dut_node, cmd)
  49         cmd = 'sudo ip link set {0} up'.format(ifname)
  50         exec_cmd_no_error(dut_node, cmd)
  51
  52     @staticmethod
  53     def setup_dmm_dut(dut1_node, dut2_node, dut1_if_name, dut2_if_name,
  54                       script_name, dut1_ip, dut2_ip, prefix_len):
  55         """
  56         Setup DMM on DUT nodes.
  57
  58         :param dut1_node: Node to setup DMM on.
  59         :param dut2_node: Node to setup DMM on.
  60         :param dut1_if_name: DUT1 to DUT2 interface name.
  61         :param dut2_if_name: DUT2 to DUT1 interface name.
  62         :param script_name: Name of the script to run.
  63         :param dut1_ip: IP address to configure on DUT1.
  64         :param dut2_ip: IP address to configure on DUT2.
  65         :param prefix_len: Prefix length.
  66         :type dut1_node: dict
  67         :type dut2_node: dict
  68         :type dut1_if_name: str
  69         :type dut2_if_name: str
  70         :type script_name: str
  71         :type dut1_ip: str
  72         :type dut2_ip: str
  73         :type prefix_len: int
  74         """
  75         SingleCliSer.set_dmm_interface_address(dut1_node, dut1_if_name,
  76                                                dut1_ip, prefix_len)
  77         SingleCliSer.set_dmm_interface_address(dut2_node, dut2_if_name,
  78                                                dut2_ip, prefix_len)
  79         cmd = 'cd {0}/{1} && ./{2} setup 0 {3} {4} {5}'\
  80             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name,
  81                     dut1_if_name, dut1_ip, dut2_ip)
  82         exec_cmd(dut1_node, cmd)
  83
  84         cmd = 'cd {0}/{1} && ./{2} setup 1 {3} {4} {5}'\
  85             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name,
  86                     dut2_if_name, dut1_ip, dut2_ip)
  87         exec_cmd(dut2_node, cmd)
  88
  89     @staticmethod
  90     def execute_test(dut1_node, dut2_node, dut1_if_name, dut2_if_name,
  91                      script_name, dut1_ip, dut2_ip):
  92         """
  93         Run the given test case.
  94
  95         :param dut1_node: Node to run an app with DMM on.
  96         :param dut2_node: Node to run an app with DMM on.
  97         :param dut1_if_name: DUT1 to DUT2 interface name.
  98         :param dut2_if_name: DUT2 to DUT1 interface name.
  99         :param script_name: Name of the script to run.
 100         :param dut1_ip: DUT1 IP address.
 101         :param dut2_ip: DUT2 IP address.
 102         :type dut1_node: dict
 103         :type dut2_node: dict
 104         :type dut1_if_name: str
 105         :type dut2_if_name: str
 106         :type script_name: str
 107         :type dut1_ip: str
 108         :type dut2_ip: str
 109         """
 110         cmd = 'cd {0}/{1} && ./{2} run 0 {3} {4} {5} ' \
 111             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name,
 112                     dut1_if_name, dut1_ip, dut2_ip)
 113         cmd += '2>&1 | tee log_{0}.txt &'.format(script_name)
 114         exec_cmd(dut1_node, cmd)
 115         time.sleep(10)
 116
 117         cmd = 'cd {0}/{1} && ./{2} run 1 {3} {4} {5} ' \
 118             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name,
 119                     dut2_if_name, dut1_ip, dut2_ip)
 120         cmd += '2>&1 | tee log_{0}.txt'.format(script_name)
 121         exec_cmd(dut2_node, cmd)
 122
 123     @staticmethod
 124     def verify_test_result(dut1_node, dut2_node, script_name):
 125         """
 126         Verify the test and return result.
 127
 128         :param dut1_node: Node to verify test result on.
 129         :param dut2_node: Node to verify test result on.
 130         :param script_name: Name of the script to run.
 131         :type dut1_node: dict
 132         :type dut2_node: dict
 133         :type script_name: str
 134         :returns: test result PASS/FAIL.
 135         :rtype: str
 136         """
 137         cmd = 'cd {0}/{1} && ./{2} verify 0' \
 138             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 139         (_, stdout_ser, _) = exec_cmd(dut1_node, cmd)
 140
 141         cmd = 'cd {0}/{1} && ./{2} verify 1' \
 142             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 143         (_, stdout_cli, _) = exec_cmd(dut2_node, cmd)
 144
 145         if stdout_ser.find('DMM_CSIT_TEST_PASSED') != -1 \
 146                 and stdout_cli.find('DMM_CSIT_TEST_PASSED') != -1:
 147             return "PASS"
 148         else:
 149             return "FAIL"
 150
 151     @staticmethod
 152     def print_dmm_log(dut1_node, dut2_node, script_name):
 153         """
 154         Print DMM logs.
 155
 156         :param dut1_node: Node to print DMM logs of.
 157         :param dut2_node: Node to print DMM logs of.
 158         :param script_name: Name of the script to run.
 159         :type dut1_node: dict
 160         :type dut2_node: dict
 161         :type script_name: str
 162         """
 163         cmd = 'cd {0}/{1} && ./{2} log 0'\
 164             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 165         exec_cmd(dut1_node, cmd)
 166
 167         cmd = 'cd {0}/{1} && ./{2} log 1'\
 168             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 169         exec_cmd(dut2_node, cmd)
 170
 171     @staticmethod
 172     def cleanup_dmm_dut(dut1_node, dut2_node, script_name):
 173         """
 174         Cleanup DMM DUT node.
 175
 176         :param dut1_node: DMM node to be cleaned up.
 177         :param dut2_node: DMM node to be cleaned up.
 178         :param script_name: Name of the script to run.
 179         :type dut1_node: dict
 180         :type dut2_node: dict
 181         :type script_name: str
 182         """
 183         cmd = 'cd {0}/{1} && ./{2} cleanup 0'\
 184             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 185         exec_cmd(dut1_node, cmd)
 186         exec_cmd(dut2_node, cmd)
 187         time.sleep(5)
 188
 189     @staticmethod
 190     def run_dmm_func_test_cases(dut1_node, dut2_node, dut1_if_name,
 191                                 dut2_if_name, dut1_ip, dut2_ip, prefix_len):
 192         """
 193         Execute all the functional test cases and return result.
 194
 195         :param dut1_node: Node to run an app with DMM on.
 196         :param dut2_node: Node to run an app with DMM on.
 197         :param dut1_if_name: DUT1 to DUT2 interface name.
 198         :param dut2_if_name: DUT2 to DUT1 interface name.
 199         :param dut1_ip: IP address to configure on DUT1.
 200         :param dut2_ip: IP address to configure on DUT2.
 201         :param prefix_len: Prefix length.
 202         :type dut1_node: dict
 203         :type dut2_node: dict
 204         :type dut1_if_name: str
 205         :type dut2_if_name: str
 206         :type dut1_ip: str
 207         :type dut2_ip: str
 208         :type prefix_len: int
 209         :returns: Total testcase count, Passed testcase count.
 210         :rtype: tuple(int, int)
 211         """
 212         passed = 0
 213         total = 0
 214         failed = 0
 215         path = '{0}/*'.format(con.DMM_RUN_SCRIPTS)
 216         files = [os.path.basename(x) for x in glob.glob(path)]
 217         print "list of files : {0}".format(files)
 218
 219         for name in files:
 220             print("file name : {}").format(name)
 221             total += 1
 222             SingleCliSer.setup_dmm_dut(dut1_node, dut2_node, dut1_if_name,
 223                                        dut2_if_name, name, dut1_ip, dut2_ip,
 224                                        prefix_len)
 225             SingleCliSer.execute_test(dut1_node, dut2_node, dut1_if_name,
 226                                       dut2_if_name, name, dut1_ip, dut2_ip)
 227             result = SingleCliSer.verify_test_result(dut1_node, dut2_node,
 228                                                      '{0}'.format(name))
 229             if result == "PASS":
 230                 passed += 1
 231             elif result == "FAIL":
 232                 failed += 1
 233
 234             SingleCliSer.print_dmm_log(dut1_node, dut2_node, name)
 235             SingleCliSer.cleanup_dmm_dut(dut1_node, dut2_node, name)
 236             print("TOTAL :{} PASSED : {} FAILED: {}").format\
 237                 (total, passed, failed)
 238
 239         return total, passed
 240
 241     @staticmethod
 242     def dmm_get_interface_name(dut_node, dut_interface):
 243         """
 244         Get the interface name.
 245
 246         :param dut_node: Node to get the interface name on.
 247         :param dut_interface: Interface key.
 248         :type dut_node: dict
 249         :type dut_interface: str
 250         :returns: Interface name.
 251         :rtype: str
 252         """
 253         mac = Topology.get_interface_mac(dut_node, dut_interface)
 254         cmd = 'ifconfig -a | grep {0}'.format(mac)
 255         (stdout, _) = exec_cmd_no_error(dut_node, cmd)
 256         interface_name = stdout.split(' ', 1)[0]
 257         return interface_name