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."""
19 from paramiko.ssh_exception import SSHException
20 from robot.api import logger
22 from resources.libraries.python.ssh import SSH, SSHTimeout
23 from resources.libraries.python.Constants import Constants
24 from resources.libraries.python.PapiHistory import PapiHistory
26 __all__ = ['VatExecutor']
29 def cleanup_vat_json_output(json_output, vat_name=None):
30 """Return VAT JSON output cleaned from VAT clutter.
32 Clean up VAT JSON output from clutter like vat# prompts and such.
34 :param json_output: Cluttered JSON output.
35 :param vat_name: Name of the VAT script.
36 :type json_output: JSON
38 :returns: Cleaned up output JSON string.
43 clutter = ['vat#', 'dump_interface_table error: Misc']
45 remote_file_path = '{0}/{1}/{2}'.format(Constants.REMOTE_FW_DIR,
46 Constants.RESOURCES_TPL_VAT,
48 clutter.append("{0}(2):".format(remote_file_path))
49 for garbage in clutter:
50 retval = retval.replace(garbage, '')
54 def get_vpp_pid(node):
55 """Get PID of running VPP process.
57 :param node: DUT node.
59 :returns: PID of VPP process / List of PIDs if more VPP processes are
60 running on the DUT node.
63 import resources.libraries.python.DUTSetup as PidLib
64 pid = PidLib.DUTSetup.get_vpp_pid(node)
68 class VatExecutor(object):
69 """Contains methods for executing VAT commands on DUTs."""
74 self._script_name = None
76 def execute_script(self, vat_name, node, timeout=120, json_out=True,
77 copy_on_execute=False, history=True):
78 """Execute VAT script on remote node, and store the result. There is an
79 option to copy script from local host to remote host before execution.
80 Path is defined automatically.
82 :param vat_name: Name of the vat script file. Only the file name of
83 the script is required, the resources path is prepended
85 :param node: Node to execute the VAT script on.
86 :param timeout: Seconds to allow the script to run.
87 :param json_out: Require JSON output.
88 :param copy_on_execute: If true, copy the file from local host to remote
90 :param history: If true, add command to history.
95 :type copy_on_execute: bool
97 :raises SSHException: If cannot open connection for VAT.
98 :raises SSHTimeout: If VAT execution is timed out.
99 :raises RuntimeError: If VAT script execution fails.
105 raise SSHException("Cannot open SSH connection to execute VAT "
106 "command(s) from vat script {name}"
107 .format(name=vat_name))
110 ssh.scp(vat_name, vat_name)
111 remote_file_path = vat_name
113 with open(vat_name, 'r') as vat_file:
114 for line in vat_file:
115 PapiHistory.add_to_papi_history(node,
116 line.replace('\n', ''),
119 remote_file_path = '{0}/{1}/{2}'.format(Constants.REMOTE_FW_DIR,
120 Constants.RESOURCES_TPL_VAT,
123 cmd = "{vat_bin} {json} in {vat_path} script".format(
124 vat_bin=Constants.VAT_BIN_NAME,
125 json="json" if json_out is True else "",
126 vat_path=remote_file_path)
129 ret_code, stdout, stderr = ssh.exec_command_sudo(cmd=cmd,
132 logger.error("VAT script execution timeout: {0}".format(cmd))
135 raise RuntimeError("VAT script execution failed: {0}".format(cmd))
137 self._ret_code = ret_code
138 self._stdout = stdout
139 self._stderr = stderr
140 self._script_name = vat_name
142 def write_and_execute_script(self, node, tmp_fn, commands, timeout=300,
144 """Write VAT commands to the script, copy it to node and execute it.
146 :param node: VPP node.
147 :param tmp_fn: Path to temporary file script.
148 :param commands: VAT command list.
149 :param timeout: Seconds to allow the script to run.
150 :param json_out: Require JSON output.
157 with open(tmp_fn, 'w') as tmp_f:
158 tmp_f.writelines(commands)
160 self.execute_script(tmp_fn, node, timeout=timeout, json_out=json_out,
161 copy_on_execute=True)
164 def execute_script_json_out(self, vat_name, node, timeout=120):
165 """Pass all arguments to 'execute_script' method, then cleanup returned
168 :param vat_name: Name of the vat script file. Only the file name of
169 the script is required, the resources path is prepended
171 :param node: Node to execute the VAT script on.
172 :param timeout: Seconds to allow the script to run.
177 self.execute_script(vat_name, node, timeout, json_out=True)
178 self._stdout = cleanup_vat_json_output(self._stdout, vat_name=vat_name)
180 def script_should_have_failed(self):
181 """Read return code from last executed script and raise exception if the
182 script didn't fail."""
183 if self._ret_code is None:
184 raise Exception("First execute the script!")
185 if self._ret_code == 0:
186 raise AssertionError(
187 "VAT Script execution passed, but failure was expected: {cmd}"
188 .format(cmd=self._script_name))
190 def script_should_have_passed(self):
191 """Read return code from last executed script and raise exception if the
193 if self._ret_code is None:
194 raise Exception("First execute the script!")
195 if self._ret_code != 0:
196 raise AssertionError(
197 "VAT Script execution failed, but success was expected: {cmd}"
198 .format(cmd=self._script_name))
200 def get_script_stdout(self):
201 """Returns value of stdout from last executed script."""
204 def get_script_stderr(self):
205 """Returns value of stderr from last executed script."""
209 def cmd_from_template(node, vat_template_file, json_param=True, **vat_args):
210 """Execute VAT script on specified node. This method supports
211 script templates with parameters.
213 :param node: Node in topology on witch the script is executed.
214 :param vat_template_file: Template file of VAT script.
215 :param vat_args: Arguments to the template file.
216 :returns: List of JSON objects returned by VAT.
218 with VatTerminal(node, json_param=json_param) as vat:
219 return vat.vat_terminal_exec_cmd_from_template(vat_template_file,
223 class VatTerminal(object):
224 """VAT interactive terminal.
226 :param node: Node to open VAT terminal on.
227 :param json_param: Defines if outputs from VAT are in JSON format.
230 :type json_param: bool
234 __VAT_PROMPT = ("vat# ", )
235 __LINUX_PROMPT = (":~# ", ":~$ ", "~]$ ", "~]# ")
237 def __init__(self, node, json_param=True):
238 json_text = ' json' if json_param else ''
239 self.json = json_param
242 self._ssh.connect(self._node)
244 self._tty = self._ssh.interactive_terminal_open()
246 raise RuntimeError("Cannot open interactive terminal on node {0}".
251 self._ssh.interactive_terminal_exec_command(
253 'sudo -S {0}{1}'.format(Constants.VAT_BIN_NAME, json_text),
260 vpp_pid = get_vpp_pid(self._node)
262 if isinstance(vpp_pid, int):
263 logger.trace("VPP running on node {0}".
264 format(self._node['host']))
266 logger.error("More instances of VPP running on node {0}.".
267 format(self._node['host']))
269 logger.error("VPP not running on node {0}.".
270 format(self._node['host']))
271 raise RuntimeError("Failed to open VAT console on node {0}".
272 format(self._node['host']))
274 self._exec_failure = False
275 self.vat_stdout = None
280 def __exit__(self, exc_type, exc_val, exc_tb):
281 self.vat_terminal_close()
283 def vat_terminal_exec_cmd(self, cmd):
284 """Execute command on the opened VAT terminal.
286 :param cmd: Command to be executed.
288 :returns: Command output in python representation of JSON format or
289 None if not in JSON mode.
291 PapiHistory.add_to_papi_history(self._node, cmd, papi=False)
292 logger.debug("Executing command in VAT terminal: {0}".format(cmd))
294 out = self._ssh.interactive_terminal_exec_command(self._tty, cmd,
296 self.vat_stdout = out
298 self._exec_failure = True
299 vpp_pid = get_vpp_pid(self._node)
301 if isinstance(vpp_pid, int):
302 raise RuntimeError("VPP running on node {0} but VAT command"
303 " {1} execution failed.".
304 format(self._node['host'], cmd))
306 raise RuntimeError("More instances of VPP running on node "
307 "{0}. VAT command {1} execution failed.".
308 format(self._node['host'], cmd))
309 raise RuntimeError("VPP not running on node {0}. VAT command "
310 "{1} execution failed.".
311 format(self._node['host'], cmd))
313 logger.debug("VAT output: {0}".format(out))
315 obj_start = out.find('{')
316 obj_end = out.rfind('}')
317 array_start = out.find('[')
318 array_end = out.rfind(']')
320 if obj_start == -1 and array_start == -1:
321 raise RuntimeError("VAT command {0}: no JSON data.".format(cmd))
323 if obj_start < array_start or array_start == -1:
330 json_out = json.loads(out)
335 def vat_terminal_close(self):
336 """Close VAT terminal."""
337 # interactive terminal is dead, we only need to close session
338 if not self._exec_failure:
340 self._ssh.interactive_terminal_exec_command(self._tty,
344 vpp_pid = get_vpp_pid(self._node)
346 if isinstance(vpp_pid, int):
347 logger.trace("VPP running on node {0}.".
348 format(self._node['host']))
350 logger.error("More instances of VPP running on node "
351 "{0}.".format(self._node['host']))
353 logger.error("VPP not running on node {0}.".
354 format(self._node['host']))
355 raise RuntimeError("Failed to close VAT console on node {0}".
356 format(self._node['host']))
358 self._ssh.interactive_terminal_close(self._tty)
360 raise RuntimeError("Cannot close interactive terminal on node {0}".
361 format(self._node['host']))
363 def vat_terminal_exec_cmd_from_template(self, vat_template_file, **args):
364 """Execute VAT script from a file.
366 :param vat_template_file: Template file name of a VAT script.
367 :param args: Dictionary of parameters for VAT script.
368 :returns: List of JSON objects returned by VAT.
370 file_path = '{}/{}'.format(Constants.RESOURCES_TPL_VAT,
372 with open(file_path, 'r') as template_file:
373 cmd_template = template_file.readlines()
375 for line_tmpl in cmd_template:
376 vat_cmd = line_tmpl.format(**args)
377 ret.append(self.vat_terminal_exec_cmd(vat_cmd.replace('\n', '')))