resources/libraries/python/VatExecutor.py

   1 # Copyright (c) 2018 Cisco and/or its affiliates.
   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 """VAT executor library."""
  15
  16 import json
  17
  18 from paramiko.ssh_exception import SSHException
  19 from robot.api import logger
  20
  21 from resources.libraries.python.ssh import SSH, SSHTimeout
  22 from resources.libraries.python.constants import Constants
  23 from resources.libraries.python.VatHistory import VatHistory
  24
  25 __all__ = ['VatExecutor']
  26
  27
  28 def cleanup_vat_json_output(json_output, vat_name=None):
  29     """Return VAT JSON output cleaned from VAT clutter.
  30
  31     Clean up VAT JSON output from clutter like vat# prompts and such.
  32
  33     :param json_output: Cluttered JSON output.
  34     :param vat_name: Name of the VAT script.
  35     :type json_output: JSON
  36     :type vat_name: str
  37     :returns: Cleaned up output JSON string.
  38     :rtype: JSON
  39     """
  40
  41     retval = json_output
  42     clutter = ['vat#', 'dump_interface_table error: Misc']
  43     if vat_name:
  44         remote_file_path = '{0}/{1}/{2}'.format(Constants.REMOTE_FW_DIR,
  45                                                 Constants.RESOURCES_TPL_VAT,
  46                                                 vat_name)
  47         clutter.append("{0}(2):".format(remote_file_path))
  48     for garbage in clutter:
  49         retval = retval.replace(garbage, '')
  50     return retval
  51
  52
  53 def get_vpp_pid(node):
  54     """Get PID of running VPP process.
  55
  56     :param node: DUT node.
  57     :type node: dict
  58     :returns: PID of VPP process / List of PIDs if more VPP processes are
  59         running on the DUT node.
  60     :rtype: int or list
  61     """
  62     import resources.libraries.python.DUTSetup as PidLib
  63     pid = PidLib.DUTSetup.get_vpp_pid(node)
  64     return pid
  65
  66
  67 class VatExecutor(object):
  68     """Contains methods for executing VAT commands on DUTs."""
  69     def __init__(self):
  70         self._stdout = None
  71         self._stderr = None
  72         self._ret_code = None
  73         self._script_name = None
  74
  75     def execute_script(self, vat_name, node, timeout=120, json_out=True,
  76                        copy_on_execute=False):
  77         """Execute VAT script on remote node, and store the result. There is an
  78         option to copy script from local host to remote host before execution.
  79         Path is defined automatically.
  80
  81         :param vat_name: Name of the vat script file. Only the file name of
  82             the script is required, the resources path is prepended
  83             automatically.
  84         :param node: Node to execute the VAT script on.
  85         :param timeout: Seconds to allow the script to run.
  86         :param json_out: Require JSON output.
  87         :param copy_on_execute: If true, copy the file from local host to remote
  88             before executing.
  89         :type vat_name: str
  90         :type node: dict
  91         :type timeout: int
  92         :type json_out: bool
  93         :type copy_on_execute: bool
  94         :raises SSHException: If cannot open connection for VAT.
  95         :raises SSHTimeout: If VAT execution is timed out.
  96         :raises RuntimeError: If VAT script execution fails.
  97         """
  98         ssh = SSH()
  99         try:
 100             ssh.connect(node)
 101         except:
 102             raise SSHException("Cannot open SSH connection to execute VAT "
 103                                "command(s) from vat script {name}"
 104                                .format(name=vat_name))
 105
 106         if copy_on_execute:
 107             ssh.scp(vat_name, vat_name)
 108             remote_file_path = vat_name
 109         else:
 110             remote_file_path = '{0}/{1}/{2}'.format(Constants.REMOTE_FW_DIR,
 111                                                     Constants.RESOURCES_TPL_VAT,
 112                                                     vat_name)
 113
 114         cmd = "{vat_bin} {json} in {vat_path} script".format(
 115             vat_bin=Constants.VAT_BIN_NAME,
 116             json="json" if json_out is True else "",
 117             vat_path=remote_file_path)
 118
 119         try:
 120             ret_code, stdout, stderr = ssh.exec_command_sudo(cmd=cmd,
 121                                                              timeout=timeout)
 122         except SSHTimeout:
 123             logger.error("VAT script execution timeout: {0}".format(cmd))
 124             raise
 125         except:
 126             raise RuntimeError("VAT script execution failed: {0}".format(cmd))
 127
 128         self._ret_code = ret_code
 129         self._stdout = stdout
 130         self._stderr = stderr
 131         self._script_name = vat_name
 132
 133     def execute_script_json_out(self, vat_name, node, timeout=120):
 134         """Pass all arguments to 'execute_script' method, then cleanup returned
 135         json output.
 136
 137         :param vat_name: Name of the vat script file. Only the file name of
 138             the script is required, the resources path is prepended
 139             automatically.
 140         :param node: Node to execute the VAT script on.
 141         :param timeout: Seconds to allow the script to run.
 142         :type vat_name: str
 143         :type node: dict
 144         :type timeout: int
 145         """
 146         self.execute_script(vat_name, node, timeout, json_out=True)
 147         self._stdout = cleanup_vat_json_output(self._stdout, vat_name=vat_name)
 148
 149     def script_should_have_failed(self):
 150         """Read return code from last executed script and raise exception if the
 151         script didn't fail."""
 152         if self._ret_code is None:
 153             raise Exception("First execute the script!")
 154         if self._ret_code == 0:
 155             raise AssertionError(
 156                 "VAT Script execution passed, but failure was expected: {cmd}"
 157                 .format(cmd=self._script_name))
 158
 159     def script_should_have_passed(self):
 160         """Read return code from last executed script and raise exception if the
 161         script failed."""
 162         if self._ret_code is None:
 163             raise Exception("First execute the script!")
 164         if self._ret_code != 0:
 165             raise AssertionError(
 166                 "VAT Script execution failed, but success was expected: {cmd}"
 167                 .format(cmd=self._script_name))
 168
 169     def get_script_stdout(self):
 170         """Returns value of stdout from last executed script."""
 171         return self._stdout
 172
 173     def get_script_stderr(self):
 174         """Returns value of stderr from last executed script."""
 175         return self._stderr
 176
 177     @staticmethod
 178     def cmd_from_template(node, vat_template_file, **vat_args):
 179         """Execute VAT script on specified node. This method supports
 180         script templates with parameters.
 181
 182         :param node: Node in topology on witch the script is executed.
 183         :param vat_template_file: Template file of VAT script.
 184         :param vat_args: Arguments to the template file.
 185         :returns: List of JSON objects returned by VAT.
 186         """
 187         with VatTerminal(node) as vat:
 188             return vat.vat_terminal_exec_cmd_from_template(vat_template_file,
 189                                                            **vat_args)
 190
 191
 192 class VatTerminal(object):
 193     """VAT interactive terminal.
 194
 195     :param node: Node to open VAT terminal on.
 196     :param json_param: Defines if outputs from VAT are in JSON format.
 197         Default is True.
 198     :type node: dict
 199     :type json_param: bool
 200
 201     """
 202
 203     __VAT_PROMPT = ("vat# ", )
 204     __LINUX_PROMPT = (":~$ ", "~]$ ", "~]# ")
 205
 206     def __init__(self, node, json_param=True):
 207         json_text = ' json' if json_param else ''
 208         self.json = json_param
 209         self._node = node
 210         self._ssh = SSH()
 211         self._ssh.connect(self._node)
 212         try:
 213             self._tty = self._ssh.interactive_terminal_open()
 214         except Exception:
 215             raise RuntimeError("Cannot open interactive terminal on node {0}".
 216                                format(self._node))
 217
 218         for _ in range(3):
 219             try:
 220                 self._ssh.interactive_terminal_exec_command(
 221                     self._tty,
 222                     'sudo -S {0}{1}'.format(Constants.VAT_BIN_NAME, json_text),
 223                     self.__VAT_PROMPT)
 224             except Exception:
 225                 continue
 226             else:
 227                 break
 228         else:
 229             vpp_pid = get_vpp_pid(self._node)
 230             if vpp_pid:
 231                 if isinstance(vpp_pid, int):
 232                     logger.trace("VPP running on node {0}".
 233                                  format(self._node['host']))
 234                 else:
 235                     logger.error("More instances of VPP running on node {0}.".
 236                                  format(self._node['host']))
 237             else:
 238                 logger.error("VPP not running on node {0}.".
 239                              format(self._node['host']))
 240             raise RuntimeError("Failed to open VAT console on node {0}".
 241                                format(self._node['host']))
 242
 243         self._exec_failure = False
 244         self.vat_stdout = None
 245
 246     def __enter__(self):
 247         return self
 248
 249     def __exit__(self, exc_type, exc_val, exc_tb):
 250         self.vat_terminal_close()
 251
 252     def vat_terminal_exec_cmd(self, cmd):
 253         """Execute command on the opened VAT terminal.
 254
 255         :param cmd: Command to be executed.
 256
 257         :returns: Command output in python representation of JSON format or
 258             None if not in JSON mode.
 259         """
 260         VatHistory.add_to_vat_history(self._node, cmd)
 261         logger.debug("Executing command in VAT terminal: {0}".format(cmd))
 262         try:
 263             out = self._ssh.interactive_terminal_exec_command(self._tty, cmd,
 264                                                               self.__VAT_PROMPT)
 265             self.vat_stdout = out
 266         except Exception:
 267             self._exec_failure = True
 268             vpp_pid = get_vpp_pid(self._node)
 269             if vpp_pid:
 270                 if isinstance(vpp_pid, int):
 271                     raise RuntimeError("VPP running on node {0} but VAT command"
 272                                        " {1} execution failed.".
 273                                        format(self._node['host'], cmd))
 274                 else:
 275                     raise RuntimeError("More instances of VPP running on node "
 276                                        "{0}. VAT command {1} execution failed.".
 277                                        format(self._node['host'], cmd))
 278             else:
 279                 raise RuntimeError("VPP not running on node {0}. VAT command "
 280                                    "{1} execution failed.".
 281                                    format(self._node['host'], cmd))
 282
 283         logger.debug("VAT output: {0}".format(out))
 284         if self.json:
 285             obj_start = out.find('{')
 286             obj_end = out.rfind('}')
 287             array_start = out.find('[')
 288             array_end = out.rfind(']')
 289
 290             if obj_start == -1 and array_start == -1:
 291                 raise RuntimeError("VAT command {0}: no JSON data.".format(cmd))
 292
 293             if obj_start < array_start or array_start == -1:
 294                 start = obj_start
 295                 end = obj_end + 1
 296             else:
 297                 start = array_start
 298                 end = array_end + 1
 299             out = out[start:end]
 300             json_out = json.loads(out)
 301             return json_out
 302         else:
 303             return None
 304
 305     def vat_terminal_close(self):
 306         """Close VAT terminal."""
 307         # interactive terminal is dead, we only need to close session
 308         if not self._exec_failure:
 309             try:
 310                 self._ssh.interactive_terminal_exec_command(self._tty,
 311                                                             'quit',
 312                                                             self.__LINUX_PROMPT)
 313             except Exception:
 314                 vpp_pid = get_vpp_pid(self._node)
 315                 if vpp_pid:
 316                     if isinstance(vpp_pid, int):
 317                         logger.trace("VPP running on node {0}.".
 318                                      format(self._node['host']))
 319                     else:
 320                         logger.error("More instances of VPP running on node "
 321                                      "{0}.".format(self._node['host']))
 322                 else:
 323                     logger.error("VPP not running on node {0}.".
 324                                  format(self._node['host']))
 325                 raise RuntimeError("Failed to close VAT console on node {0}".
 326                                    format(self._node['host']))
 327         try:
 328             self._ssh.interactive_terminal_close(self._tty)
 329         except:
 330             raise RuntimeError("Cannot close interactive terminal on node {0}".
 331                                format(self._node['host']))
 332
 333     def vat_terminal_exec_cmd_from_template(self, vat_template_file, **args):
 334         """Execute VAT script from a file.
 335
 336         :param vat_template_file: Template file name of a VAT script.
 337         :param args: Dictionary of parameters for VAT script.
 338         :returns: List of JSON objects returned by VAT.
 339         """
 340         file_path = '{}/{}'.format(Constants.RESOURCES_TPL_VAT,
 341                                    vat_template_file)
 342         with open(file_path, 'r') as template_file:
 343             cmd_template = template_file.readlines()
 344         ret = []
 345         for line_tmpl in cmd_template:
 346             vat_cmd = line_tmpl.format(**args)
 347             ret.append(self.vat_terminal_exec_cmd(vat_cmd.replace('\n', '')))
 348         return ret