Fix warnings reported by gen_doc.sh
[csit.git] / 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

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.