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:
6 # http://www.apache.org/licenses/LICENSE-2.0
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.
14 """VAT executor library."""
18 from paramiko.ssh_exception import SSHException
19 from robot.api import logger
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
25 __all__ = ['VatExecutor']
28 def cleanup_vat_json_output(json_output, vat_name=None):
29 """Return VAT JSON output cleaned from VAT clutter.
31 Clean up VAT JSON output from clutter like vat# prompts and such.
33 :param json_output: Cluttered JSON output.
34 :param vat_name: Name of the VAT script.
35 :type json_output: JSON
37 :returns: Cleaned up output JSON string.
42 clutter = ['vat#', 'dump_interface_table error: Misc']
44 remote_file_path = '{0}/{1}/{2}'.format(Constants.REMOTE_FW_DIR,
45 Constants.RESOURCES_TPL_VAT,
47 clutter.append("{0}(2):".format(remote_file_path))
48 for garbage in clutter:
49 retval = retval.replace(garbage, '')
53 def get_vpp_pid(node):
54 """Get PID of running VPP process.
56 :param node: DUT node.
58 :returns: PID of VPP process / List of PIDs if more VPP processes are
59 running on the DUT node.
62 import resources.libraries.python.DUTSetup as PidLib
63 pid = PidLib.DUTSetup.get_vpp_pid(node)
67 class VatExecutor(object):
68 """Contains methods for executing VAT commands on DUTs."""
73 self._script_name = None
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.
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
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
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.
102 raise SSHException("Cannot open SSH connection to execute VAT "
103 "command(s) from vat script {name}"
104 .format(name=vat_name))
107 ssh.scp(vat_name, vat_name)
108 remote_file_path = vat_name
110 remote_file_path = '{0}/{1}/{2}'.format(Constants.REMOTE_FW_DIR,
111 Constants.RESOURCES_TPL_VAT,
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)
120 ret_code, stdout, stderr = ssh.exec_command_sudo(cmd=cmd,
123 logger.error("VAT script execution timeout: {0}".format(cmd))
126 raise RuntimeError("VAT script execution failed: {0}".format(cmd))
128 self._ret_code = ret_code
129 self._stdout = stdout
130 self._stderr = stderr
131 self._script_name = vat_name
133 def execute_script_json_out(self, vat_name, node, timeout=120):
134 """Pass all arguments to 'execute_script' method, then cleanup returned
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
140 :param node: Node to execute the VAT script on.
141 :param timeout: Seconds to allow the script to run.
146 self.execute_script(vat_name, node, timeout, json_out=True)
147 self._stdout = cleanup_vat_json_output(self._stdout, vat_name=vat_name)
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))
159 def script_should_have_passed(self):
160 """Read return code from last executed script and raise exception if the
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))
169 def get_script_stdout(self):
170 """Returns value of stdout from last executed script."""
173 def get_script_stderr(self):
174 """Returns value of stderr from last executed script."""
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.
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.
187 with VatTerminal(node) as vat:
188 return vat.vat_terminal_exec_cmd_from_template(vat_template_file,
192 class VatTerminal(object):
193 """VAT interactive terminal.
195 :param node: Node to open VAT terminal on.
196 :param json_param: Defines if outputs from VAT are in JSON format.
199 :type json_param: bool
203 __VAT_PROMPT = ("vat# ", )
204 __LINUX_PROMPT = (":~$ ", "~]$ ", "~]# ")
206 def __init__(self, node, json_param=True):
207 """TODO: Should we document this constructor can raise RuntimeError?"""
208 json_text = ' json' if json_param else ''
209 self.json = json_param
212 self._ssh.connect(self._node)
214 self._tty = self._ssh.interactive_terminal_open()
216 raise RuntimeError("Cannot open interactive terminal on node {0}".
221 self._ssh.interactive_terminal_exec_command(
223 'sudo -S {0}{1}'.format(Constants.VAT_BIN_NAME, json_text),
230 vpp_pid = get_vpp_pid(self._node)
232 if isinstance(vpp_pid, int):
233 logger.trace("VPP running on node {0}".
234 format(self._node['host']))
236 logger.error("More instances of VPP running on node {0}.".
237 format(self._node['host']))
239 logger.error("VPP not running on node {0}.".
240 format(self._node['host']))
241 raise RuntimeError("Failed to open VAT console on node {0}".
242 format(self._node['host']))
244 self._exec_failure = False
245 self.vat_stdout = None
250 def __exit__(self, exc_type, exc_val, exc_tb):
251 self.vat_terminal_close()
253 def vat_terminal_exec_cmd(self, cmd):
254 """Execute command on the opened VAT terminal.
256 :param cmd: Command to be executed.
257 :returns: Command output in python representation of JSON format or
258 None if not in JSON mode.
259 :raise RuntimeError: If VAT command execution fails.
261 VatHistory.add_to_vat_history(self._node, cmd)
262 logger.debug("Executing command in VAT terminal: {0}".format(cmd))
264 out = self._ssh.interactive_terminal_exec_command(self._tty, cmd,
266 self.vat_stdout = out
268 self._exec_failure = True
269 vpp_pid = get_vpp_pid(self._node)
271 if isinstance(vpp_pid, int):
272 raise RuntimeError("VPP running on node {0} but VAT command"
273 " {1} execution failed.".
274 format(self._node['host'], cmd))
276 raise RuntimeError("More instances of VPP running on node "
277 "{0}. VAT command {1} execution failed.".
278 format(self._node['host'], cmd))
280 raise RuntimeError("VPP not running on node {0}. VAT command "
281 "{1} execution failed.".
282 format(self._node['host'], cmd))
284 logger.debug("VAT output: {0}".format(out))
286 obj_start = out.find('{')
287 obj_end = out.rfind('}')
288 array_start = out.find('[')
289 array_end = out.rfind(']')
291 if obj_start == -1 and array_start == -1:
292 raise RuntimeError("VAT command {0}: no JSON data.".format(cmd))
294 if obj_start < array_start or array_start == -1:
301 json_out = json.loads(out)
306 def vat_terminal_close(self):
307 """Close VAT terminal."""
308 # interactive terminal is dead, we only need to close session
309 if not self._exec_failure:
311 self._ssh.interactive_terminal_exec_command(self._tty,
315 vpp_pid = get_vpp_pid(self._node)
317 if isinstance(vpp_pid, int):
318 logger.trace("VPP running on node {0}.".
319 format(self._node['host']))
321 logger.error("More instances of VPP running on node "
322 "{0}.".format(self._node['host']))
324 logger.error("VPP not running on node {0}.".
325 format(self._node['host']))
326 raise RuntimeError("Failed to close VAT console on node {0}".
327 format(self._node['host']))
329 self._ssh.interactive_terminal_close(self._tty)
331 raise RuntimeError("Cannot close interactive terminal on node {0}".
332 format(self._node['host']))
334 def vat_terminal_exec_cmd_from_template(self, vat_template_file, **args):
335 """Execute VAT script from a file.
337 :param vat_template_file: Template file name of a VAT script.
338 :param args: Dictionary of parameters for VAT script.
339 :returns: List of JSON objects returned by VAT.
341 file_path = '{}/{}'.format(Constants.RESOURCES_TPL_VAT,
343 with open(file_path, 'r') as template_file:
344 cmd_template = template_file.readlines()
346 for line_tmpl in cmd_template:
347 vat_cmd = line_tmpl.format(**args)
348 ret.append(self.vat_terminal_exec_cmd(vat_cmd.replace('\n', '')))