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 SSH
  24 from resources.libraries.python.ssh import exec_cmd, exec_cmd_no_error
  25 from resources.libraries.python.DMM.DMMConstants import DMMConstants as con
  26 from resources.libraries.python.topology import Topology
  27
  28 class SingleCliSer:
  29     """Test DMM with single client-server topology."""
  30
  31     @staticmethod
  32     def set_dmm_interface_address(dut_node, ifname, ip_addr, ip4_prefix):
  33         """
  34         Flush ip, set ip, set interface up.
  35
  36         :param dut_node: Node to set the interface address on.
  37         :param ifname: Interface name.
  38         :param ip_addr: IP address to configure.
  39         :param ip4_prefix: Prefix length.
  40         :type dut_node: dict
  41         :type ifname: str
  42         :type ip_addr: str
  43         :type ip4_prefix: int
  44         """
  45         cmd = 'sudo ip -4 addr flush dev {}'.format(ifname)
  46         exec_cmd_no_error(dut_node, cmd)
  47         cmd = 'sudo ip addr add {}/{} dev {}'\
  48             .format(ip_addr, ip4_prefix, ifname)
  49         exec_cmd_no_error(dut_node, cmd)
  50         cmd = 'sudo ip link set {0} up'.format(ifname)
  51         exec_cmd_no_error(dut_node, cmd)
  52
  53     @staticmethod
  54     def setup_dmm_dut(dut1_node, dut2_node, dut1_if_name, dut2_if_name,
  55                       script_name, dut1_ip, dut2_ip, prefix_len):
  56         """
  57         Setup DMM on DUT nodes.
  58
  59         :param dut1_node: Node to setup DMM on.
  60         :param dut2_node: Node to setup DMM on.
  61         :param dut1_if_name: DUT1 to DUT2 interface name.
  62         :param dut2_if_name: DUT2 to DUT1 interface name.
  63         :param script_name: Name of the script to run.
  64         :param dut1_ip: IP address to configure on DUT1.
  65         :param dut2_ip: IP address to configure on DUT2.
  66         :param prefix_len: Prefix length.
  67         :type dut1_node: dict
  68         :type dut2_node: dict
  69         :type dut1_if_name: str
  70         :type dut2_if_name: str
  71         :type script_name: str
  72         :type dut1_ip: str
  73         :type dut2_ip: str
  74         :type prefix_len: int
  75         """
  76         SingleCliSer.set_dmm_interface_address(dut1_node, dut1_if_name,
  77                                                dut1_ip, prefix_len)
  78         SingleCliSer.set_dmm_interface_address(dut2_node, dut2_if_name,
  79                                                dut2_ip, prefix_len)
  80         cmd = 'cd {0}/{1} && ./{2} setup 0 {3} {4} {5}'\
  81             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name,
  82                     dut1_if_name, dut1_ip, dut2_ip)
  83         exec_cmd(dut1_node, cmd)
  84
  85         cmd = 'cd {0}/{1} && ./{2} setup 1 {3} {4} {5}'\
  86             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name,
  87                     dut2_if_name, dut1_ip, dut2_ip)
  88         exec_cmd(dut2_node, cmd)
  89
  90     @staticmethod
  91     def execute_test(dut1_node, dut2_node, dut1_if_name, dut2_if_name,
  92                      script_name, dut1_ip, dut2_ip):
  93         """
  94         Run the given test case.
  95
  96         :param dut1_node: Node to run an app with DMM on.
  97         :param dut2_node: Node to run an app with DMM on.
  98         :param dut1_if_name: DUT1 to DUT2 interface name.
  99         :param dut2_if_name: DUT2 to DUT1 interface name.
 100         :param script_name: Name of the script to run.
 101         :param dut1_ip: DUT1 IP address.
 102         :param dut2_ip: DUT2 IP address.
 103         :type dut1_node: dict
 104         :type dut2_node: dict
 105         :type dut1_if_name: str
 106         :type dut2_if_name: str
 107         :type script_name: str
 108         :type dut1_ip: str
 109         :type dut2_ip: str
 110         """
 111         cmd = 'cd {0}/{1} && ./{2} run 0 {3} {4} {5} ' \
 112             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name,
 113                     dut1_if_name, dut1_ip, dut2_ip)
 114         cmd += '2>&1 | tee log_{0}.txt &'.format(script_name)
 115         exec_cmd(dut1_node, cmd)
 116         time.sleep(10)
 117
 118         cmd = 'cd {0}/{1} && ./{2} run 1 {3} {4} {5} ' \
 119             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name,
 120                     dut2_if_name, dut1_ip, dut2_ip)
 121         cmd += '2>&1 | tee log_{0}.txt'.format(script_name)
 122         exec_cmd(dut2_node, cmd)
 123
 124     @staticmethod
 125     def verify_test_result(dut1_node, dut2_node, script_name):
 126         """
 127         Verify the test and return result.
 128
 129         :param dut1_node: Node to verify test result on.
 130         :param dut2_node: Node to verify test result on.
 131         :param script_name: Name of the script to run.
 132         :type dut1_node: dict
 133         :type dut2_node: dict
 134         :type script_name: str
 135         :returns: test result PASS/FAIL.
 136         :rtype: str
 137         """
 138         cmd = 'cd {0}/{1} && ./{2} verify 0' \
 139             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 140         (_, stdout_ser, _) = exec_cmd(dut1_node, cmd)
 141
 142         cmd = 'cd {0}/{1} && ./{2} verify 1' \
 143             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 144         (_, stdout_cli, _) = exec_cmd(dut2_node, cmd)
 145
 146         if stdout_ser.find('DMM_CSIT_TEST_PASSED') != -1 \
 147                 and stdout_cli.find('DMM_CSIT_TEST_PASSED') != -1:
 148             return "PASS"
 149         else:
 150             return "FAIL"
 151
 152     @staticmethod
 153     def print_dmm_log(dut1_node, dut2_node, script_name):
 154         """
 155         Print DMM logs.
 156
 157         :param dut1_node: Node to print DMM logs of.
 158         :param dut2_node: Node to print DMM logs of.
 159         :param script_name: Name of the script to run.
 160         :type dut1_node: dict
 161         :type dut2_node: dict
 162         :type script_name: str
 163         """
 164         cmd = 'cd {0}/{1} && ./{2} log 0'\
 165             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 166         exec_cmd(dut1_node, cmd)
 167
 168         cmd = 'cd {0}/{1} && ./{2} log 1'\
 169             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 170         exec_cmd(dut2_node, cmd)
 171         cmd = 'mv /var/log/nStack/running.log /var/log/nStack/{0}_ser.log'\
 172             .format(script_name)
 173         exec_cmd(dut1_node, cmd, sudo=True)
 174         cmd = 'mv /var/log/nStack/running.log /var/log/nStack/{0}_cli.log'\
 175             .format(script_name)
 176         exec_cmd(dut2_node, cmd, sudo=True)
 177
 178     @staticmethod
 179     def cleanup_dmm_dut(dut1_node, dut2_node, script_name):
 180         """
 181         Cleanup DMM DUT node.
 182
 183         :param dut1_node: DMM node to be cleaned up.
 184         :param dut2_node: DMM node to be cleaned up.
 185         :param script_name: Name of the script to run.
 186         :type dut1_node: dict
 187         :type dut2_node: dict
 188         :type script_name: str
 189         """
 190         cmd = 'cd {0}/{1} && ./{2} cleanup 0'\
 191             .format(con.REMOTE_FW_DIR, con.DMM_RUN_SCRIPTS, script_name)
 192         exec_cmd(dut1_node, cmd)
 193         exec_cmd(dut2_node, cmd)
 194         time.sleep(5)
 195
 196     @staticmethod
 197     def run_dmm_func_test_cases(dut1_node, dut2_node, dut1_if_name,
 198                                 dut2_if_name, dut1_ip, dut2_ip, prefix_len):
 199         """
 200         Execute all the functional test cases and return result.
 201
 202         :param dut1_node: Node to run an app with DMM on.
 203         :param dut2_node: Node to run an app with DMM on.
 204         :param dut1_if_name: DUT1 to DUT2 interface name.
 205         :param dut2_if_name: DUT2 to DUT1 interface name.
 206         :param dut1_ip: IP address to configure on DUT1.
 207         :param dut2_ip: IP address to configure on DUT2.
 208         :param prefix_len: Prefix length.
 209         :type dut1_node: dict
 210         :type dut2_node: dict
 211         :type dut1_if_name: str
 212         :type dut2_if_name: str
 213         :type dut1_ip: str
 214         :type dut2_ip: str
 215         :type prefix_len: int
 216         :returns: Total testcase count, Passed testcase count.
 217         :rtype: tuple(int, int)
 218         """
 219         passed = 0
 220         total = 0
 221         failed = 0
 222         path = '{0}/*'.format(con.DMM_RUN_SCRIPTS)
 223         files = [os.path.basename(x) for x in glob.glob(path)]
 224         print "list of files : {0}".format(files)
 225
 226         for name in files:
 227             print("file name : {}").format(name)
 228             total += 1
 229             SingleCliSer.setup_dmm_dut(dut1_node, dut2_node, dut1_if_name,
 230                                        dut2_if_name, name, dut1_ip, dut2_ip,
 231                                        prefix_len)
 232             SingleCliSer.execute_test(dut1_node, dut2_node, dut1_if_name,
 233                                       dut2_if_name, name, dut1_ip, dut2_ip)
 234             result = SingleCliSer.verify_test_result(dut1_node, dut2_node,
 235                                                      '{0}'.format(name))
 236             if result == "PASS":
 237                 passed += 1
 238             elif result == "FAIL":
 239                 failed += 1
 240
 241             SingleCliSer.print_dmm_log(dut1_node, dut2_node, name)
 242             SingleCliSer.cleanup_dmm_dut(dut1_node, dut2_node, name)
 243             print("TOTAL :{} PASSED : {} FAILED: {}").format\
 244                 (total, passed, failed)
 245
 246         return total, passed
 247
 248     @staticmethod
 249     def dmm_get_interface_name(dut_node, dut_interface):
 250         """
 251         Get the interface name.
 252
 253         :param dut_node: Node to get the interface name on.
 254         :param dut_interface: Interface key.
 255         :type dut_node: dict
 256         :type dut_interface: str
 257         :returns: Interface name.
 258         :rtype: str
 259         """
 260         mac = Topology.get_interface_mac(dut_node, dut_interface)
 261         cmd = 'ifconfig -a | grep {0}'.format(mac)
 262         (stdout, _) = exec_cmd_no_error(dut_node, cmd)
 263         interface_name = stdout.split(' ', 1)[0]
 264         return interface_name
 265
 266     @staticmethod
 267     def get_logs_from_node(dut_node):
 268         """
 269         Get logs from node to the test executor machine.
 270
 271         :param dut_node: Node to artifact the logs of.
 272         :type dut_node: dict
 273         """
 274         ssh = SSH()
 275         ssh.connect(dut_node)
 276         ssh.scp(".", '/var/log/nStack/*.log',
 277                 get=True, timeout=60, wildcard=True)
 278
 279         (ret, _, _) = exec_cmd(dut_node, 'ls -l /var/log/app*.log')
 280         if ret == 0:
 281             ssh.scp(".", '/var/log/app*.log',
 282                     get=True, timeout=60, wildcard=True)
 283
 284         exec_cmd(dut_node, 'rm -rf /var/log/nStack/*.log', sudo=True)
 285         exec_cmd(dut_node, 'rm -rf /var/log/app*.log', sudo=True)
 286
 287     @staticmethod
 288     def archive_dmm_logs(dut1_node, dut2_node):
 289         """
 290         Get logs from both DUT's to the test executor machine.
 291
 292         :param dut1_node: DUT1 node.
 293         :param dut2_node: DUT2 node.
 294         :type dut1_node: dict
 295         :type dut2_node: dict
 296         """
 297         SingleCliSer.get_logs_from_node(dut1_node)
 298         SingleCliSer.get_logs_from_node(dut2_node)