X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Flibraries%2Fpython%2FPapiExecutor.py;h=9ca34d88ae6d481d2e49e7ebda78e0e986ae4fd8;hp=03132844059aa1dc6e6ee2d6efa0a960f56d20fe;hb=33fb34665214bbbd0a4b3154169b21c2da01f69b;hpb=935734b04269b8fe5348e1c2b168dd5c6cd9339a diff --git a/resources/libraries/python/PapiExecutor.py b/resources/libraries/python/PapiExecutor.py index 0313284405..9ca34d88ae 100644 --- a/resources/libraries/python/PapiExecutor.py +++ b/resources/libraries/python/PapiExecutor.py @@ -11,90 +11,91 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Python API executor library.""" +"""Python API executor library. +""" import binascii import json +from pprint import pformat from robot.api import logger from resources.libraries.python.Constants import Constants +from resources.libraries.python.PapiHistory import PapiHistory +from resources.libraries.python.PythonThree import raise_from from resources.libraries.python.ssh import SSH, SSHTimeout -__all__ = ["PapiExecutor", "PapiResponse"] -# TODO: Implement Papi History -# from resources.libraries.python.PapiHistory import PapiHistory +__all__ = ["PapiExecutor"] -class PapiResponse(object): - """Class for metadata specifying the Papi reply, stdout, stderr and return - code. - """ +class PapiExecutor(object): + """Contains methods for executing VPP Python API commands on DUTs. - def __init__(self, papi_reply=None, stdout="", stderr="", ret_code=None): - """Construct the Papi response by setting the values needed. - - :param papi_reply: API reply from last executed PAPI command(s). - :param stdout: stdout from last executed PAPI command(s). - :param stderr: stderr from last executed PAPI command(s). - :param ret_code: ret_code from last executed PAPI command(s). - :type papi_reply: list - :type stdout: str - :type stderr: str - :type ret_code: int - """ + Note: Use only with "with" statement, e.g.: - # API reply from last executed PAPI command(s) - self.reply = papi_reply + with PapiExecutor(node) as papi_exec: + replies = papi_exec.add('show_version').get_replies(err_msg) - # stdout from last executed PAPI command(s) - self.stdout = stdout + This class processes three classes of VPP PAPI methods: + 1. simple request / reply: method='request', + 2. dump functions: method='dump', + 3. vpp-stats: method='stats'. - # stderr from last executed PAPI command(s). - self.stderr = stderr + The recommended ways of use are (examples): - # return code from last executed PAPI command(s) - self.ret_code = ret_code + 1. Simple request / reply - def __str__(self): - """Return string with human readable description of the group. + a. One request with no arguments: - :returns: Readable description. - :rtype: str - """ - return ("papi_reply={papi_reply} " - "stdout={stdout} " - "stderr={stderr} " - "ret_code={ret_code}". - format(papi_reply=self.reply, - stdout=self.stdout, - stderr=self.stderr, - ret_code=self.ret_code)) - - def __repr__(self): - """Return string executable as Python constructor call. - - :returns: Executable constructor call. - :rtype: str - """ - return ("PapiResponse(papi_reply={papi_reply} " - "stdout={stdout} " - "stderr={stderr} " - "ret_code={ret_code})". - format(papi_reply=self.reply, - stdout=self.stdout, - stderr=self.stderr, - ret_code=self.ret_code)) + with PapiExecutor(node) as papi_exec: + reply = papi_exec.add('show_version').get_reply() + b. Three requests with arguments, the second and the third ones are the same + but with different arguments. -class PapiExecutor(object): - """Contains methods for executing Python API commands on DUTs. + with PapiExecutor(node) as papi_exec: + replies = papi_exec.add(cmd1, **args1).add(cmd2, **args2).\ + add(cmd2, **args3).get_replies(err_msg) + + 2. Dump functions + + cmd = 'sw_interface_rx_placement_dump' + with PapiExecutor(node) as papi_exec: + details = papi_exec.add(cmd, sw_if_index=ifc['vpp_sw_index']).\ + get_details(err_msg) + + 3. vpp-stats + + path = ['^/if', '/err/ip4-input', '/sys/node/ip4-input'] - Use only with "with" statement, e.g.: + with PapiExecutor(node) as papi_exec: + stats = papi_exec.add(api_name='vpp-stats', path=path).get_stats() - with PapiExecutor(node) as papi_exec: - papi_resp = papi_exec.add('show_version').execute_should_pass(err_msg) + print('RX interface core 0, sw_if_index 0:\n{0}'.\ + format(stats[0]['/if/rx'][0][0])) + + or + + path_1 = ['^/if', ] + path_2 = ['^/if', '/err/ip4-input', '/sys/node/ip4-input'] + + with PapiExecutor(node) as papi_exec: + stats = papi_exec.add('vpp-stats', path=path_1).\ + add('vpp-stats', path=path_2).get_stats() + + print('RX interface core 0, sw_if_index 0:\n{0}'.\ + format(stats[1]['/if/rx'][0][0])) + + Note: In this case, when PapiExecutor method 'add' is used: + - its parameter 'csit_papi_command' is used only to keep information + that vpp-stats are requested. It is not further processed but it is + included in the PAPI history this way: + vpp-stats(path=['^/if', '/err/ip4-input', '/sys/node/ip4-input']) + Always use csit_papi_command="vpp-stats" if the VPP PAPI method + is "stats". + - the second parameter must be 'path' as it is used by PapiExecutor + method 'add'. """ def __init__(self, node): @@ -110,9 +111,6 @@ class PapiExecutor(object): # The list of PAPI commands to be executed on the node. self._api_command_list = list() - # The response on the PAPI commands. - self.response = PapiResponse() - self._ssh = SSH() def __enter__(self): @@ -127,137 +125,165 @@ class PapiExecutor(object): def __exit__(self, exc_type, exc_val, exc_tb): self._ssh.disconnect(self._node) - def clear(self): - """Empty the internal command list; return self. + def add(self, csit_papi_command="vpp-stats", history=True, **kwargs): + """Add next command to internal command list; return self. - Use when not sure whether previous usage has left something in the list. + The argument name 'csit_papi_command' must be unique enough as it cannot + be repeated in kwargs. + :param csit_papi_command: VPP API command. + :param history: Enable/disable adding command to PAPI command history. + :param kwargs: Optional key-value arguments. + :type csit_papi_command: str + :type history: bool + :type kwargs: dict :returns: self, so that method chaining is possible. :rtype: PapiExecutor """ - self._api_command_list = list() + if history: + PapiHistory.add_to_papi_history( + self._node, csit_papi_command, **kwargs) + self._api_command_list.append(dict(api_name=csit_papi_command, + api_args=kwargs)) return self - def add(self, command, **kwargs): - """Add next command to internal command list; return self. + def get_stats(self, err_msg="Failed to get statistics.", timeout=120): + """Get VPP Stats from VPP Python API. - :param command: VPP API command. - :param kwargs: Optional key-value arguments. - :type command: str - :type kwargs: dict - :returns: self, so that method chaining is possible. - :rtype: PapiExecutor + :param err_msg: The message used if the PAPI command(s) execution fails. + :param timeout: Timeout in seconds. + :type err_msg: str + :type timeout: int + :returns: Requested VPP statistics. + :rtype: list of dict """ - self._api_command_list.append(dict(api_name=command, api_args=kwargs)) - return self - def execute(self, process_reply=True, ignore_errors=False, timeout=120): - """Turn internal command list into proper data and execute; return - PAPI response. + paths = [cmd['api_args']['path'] for cmd in self._api_command_list] + self._api_command_list = list() + + stdout = self._execute_papi( + paths, method='stats', err_msg=err_msg, timeout=timeout) - This method also clears the internal command list. + return json.loads(stdout) + + def get_replies(self, err_msg="Failed to get replies.", timeout=120): + """Get replies from VPP Python API. - :param process_reply: Process PAPI reply if True. - :param ignore_errors: If true, the errors in the reply are ignored. + The replies are parsed into dict-like objects, + "retval" field is guaranteed to be zero on success. + + :param err_msg: The message used if the PAPI command(s) execution fails. :param timeout: Timeout in seconds. - :type process_reply: bool - :type ignore_errors: bool + :type err_msg: str :type timeout: int - :returns: Papi response including: papi reply, stdout, stderr and - return code. - :rtype: PapiResponse - :raises KeyError: If the reply is not correct. + :returns: Responses, dict objects with fields due to API and "retval". + :rtype: list of dict + :raises RuntimeError: If retval is nonzero, parsing or ssh error. """ + return self._execute(method='request', err_msg=err_msg, timeout=timeout) - local_list = self._api_command_list + def get_reply(self, err_msg="Failed to get reply.", timeout=120): + """Get reply from VPP Python API. - # Clear first as execution may fail. - self.clear() + The reply is parsed into dict-like object, + "retval" field is guaranteed to be zero on success. - ret_code, stdout, stderr = self._execute_papi(local_list, timeout) - - papi_reply = list() - if process_reply: - json_data = json.loads(stdout) - for data in json_data: - try: - api_reply_processed = dict( - api_name=data["api_name"], - api_reply=self._process_reply(data["api_reply"])) - except KeyError: - if ignore_errors: - continue - else: - raise - papi_reply.append(api_reply_processed) - - return PapiResponse(papi_reply=papi_reply, - stdout=stdout, - stderr=stderr, - ret_code=ret_code) - - def execute_should_pass(self, err_msg="Failed to execute PAPI command.", - process_reply=True, ignore_errors=False, - timeout=120): - """Execute the PAPI commands and check the return code. - Raise exception if the PAPI command(s) failed. - - Note: There are two exceptions raised to distinguish two situations. If - not needed, re-implement using only RuntimeError. + TODO: Discuss exception types to raise, unify with inner methods. :param err_msg: The message used if the PAPI command(s) execution fails. - :param process_reply: Indicate whether or not to process PAPI reply. - :param ignore_errors: If true, the errors in the reply are ignored. :param timeout: Timeout in seconds. :type err_msg: str - :type process_reply: bool - :type ignore_errors: bool :type timeout: int - :returns: Papi response including: papi reply, stdout, stderr and - return code. - :rtype: PapiResponse - :raises RuntimeError: If no PAPI command(s) executed. - :raises AssertionError: If PAPI command(s) execution passed. + :returns: Response, dict object with fields due to API and "retval". + :rtype: dict + :raises AssertionError: If retval is nonzero, parsing or ssh error. """ + replies = self.get_replies(err_msg=err_msg, timeout=timeout) + if len(replies) != 1: + raise RuntimeError("Expected single reply, got {replies!r}".format( + replies=replies)) + return replies[0] - response = self.execute(process_reply=process_reply, - ignore_errors=ignore_errors, - timeout=timeout) + def get_sw_if_index(self, err_msg="Failed to get reply.", timeout=120): + """Get sw_if_index from reply from VPP Python API. - if response.ret_code != 0: - raise AssertionError(err_msg) - return response + Frequently, the caller is only interested in sw_if_index field + of the reply, this wrapper makes such call sites shorter. + + TODO: Discuss exception types to raise, unify with inner methods. - def execute_should_fail(self, - err_msg="Execution of PAPI command did not fail.", - process_reply=False, ignore_errors=False, - timeout=120): - """Execute the PAPI commands and check the return code. - Raise exception if the PAPI command(s) did not fail. + :param err_msg: The message used if the PAPI command(s) execution fails. + :param timeout: Timeout in seconds. + :type err_msg: str + :type timeout: int + :returns: Response, sw_if_index value of the reply. + :rtype: int + :raises AssertionError: If retval is nonzero, parsing or ssh error. + """ + return self.get_reply(err_msg=err_msg, timeout=timeout)["sw_if_index"] - It does not return anything as we expect it fails. + def get_details(self, err_msg="Failed to get dump details.", timeout=120): + """Get dump details from VPP Python API. - Note: There are two exceptions raised to distinguish two situations. If - not needed, re-implement using only RuntimeError. + The details are parsed into dict-like objects. + The number of details per single dump command can vary, + and all association between details and dumps is lost, + so if you care about the association (as opposed to + logging everything at once for debugging purposes), + it is recommended to call get_details for each dump (type) separately. :param err_msg: The message used if the PAPI command(s) execution fails. - :param process_reply: Indicate whether or not to process PAPI reply. - :param ignore_errors: If true, the errors in the reply are ignored. :param timeout: Timeout in seconds. :type err_msg: str - :type process_reply: bool - :type ignore_errors: bool :type timeout: int - :raises RuntimeError: If no PAPI command(s) executed. - :raises AssertionError: If PAPI command(s) execution passed. + :returns: Details, dict objects with fields due to API without "retval". + :rtype: list of dict + """ + return self._execute(method='dump', err_msg=err_msg, timeout=timeout) + + @staticmethod + def dump_and_log(node, cmds): + """Dump and log requested information, return None. + + :param node: DUT node. + :param cmds: Dump commands to be executed. + :type node: dict + :type cmds: list of str """ + with PapiExecutor(node) as papi_exec: + for cmd in cmds: + details = papi_exec.add(cmd).get_details() + logger.debug("{cmd}:\n{details}".format( + cmd=cmd, details=pformat(details))) - response = self.execute(process_reply=process_reply, - ignore_errors=ignore_errors, - timeout=timeout) + @staticmethod + def run_cli_cmd(node, cmd, log=True): + """Run a CLI command as cli_inband, return the "reply" field of reply. - if response.ret_code == 0: - raise AssertionError(err_msg) + Optionally, log the field value. + + :param node: Node to run command on. + :param cmd: The CLI command to be run on the node. + :param log: If True, the response is logged. + :type node: dict + :type cmd: str + :type log: bool + :returns: CLI output. + :rtype: str + """ + + cli = 'cli_inband' + args = dict(cmd=cmd) + err_msg = "Failed to run 'cli_inband {cmd}' PAPI command on host " \ + "{host}".format(host=node['host'], cmd=cmd) + + with PapiExecutor(node) as papi_exec: + reply = papi_exec.add(cli, **args).get_reply(err_msg)["reply"] + + if log: + logger.info("{cmd}:\n{reply}".format(cmd=cmd, reply=reply)) + + return reply @staticmethod def _process_api_data(api_d): @@ -271,12 +297,30 @@ class PapiExecutor(object): :rtype: list """ + def process_value(val): + """Process value. + + :param val: Value to be processed. + :type val: object + :returns: Processed value. + :rtype: dict or str or int + """ + if isinstance(val, dict): + for val_k, val_v in val.iteritems(): + val[str(val_k)] = process_value(val_v) + return val + elif isinstance(val, list): + for idx, val_l in enumerate(val): + val[idx] = process_value(val_l) + return val + else: + return binascii.hexlify(val) if isinstance(val, str) else val + api_data_processed = list() for api in api_d: api_args_processed = dict() for a_k, a_v in api["api_args"].iteritems(): - value = binascii.hexlify(a_v) if isinstance(a_v, str) else a_v - api_args_processed[str(a_k)] = value + api_args_processed[str(a_k)] = process_value(a_v) api_data_processed.append(dict(api_name=api["api_name"], api_args=api_args_processed)) return api_data_processed @@ -287,22 +331,39 @@ class PapiExecutor(object): Apply binascii.unhexlify() method for unicode values. - TODO: Remove the disabled code when definitely not needed. + TODO: Implement complex solution to process of replies. :param api_r: API reply. :type api_r: dict :returns: Processed API reply / a part of API reply. :rtype: dict """ + def process_value(val): + """Process value. + + :param val: Value to be processed. + :type val: object + :returns: Processed value. + :rtype: dict or str or int + """ + if isinstance(val, dict): + for val_k, val_v in val.iteritems(): + val[str(val_k)] = process_value(val_v) + return val + elif isinstance(val, list): + for idx, val_l in enumerate(val): + val[idx] = process_value(val_l) + return val + elif isinstance(val, unicode): + return binascii.unhexlify(val) + else: + return val reply_dict = dict() reply_value = dict() for reply_key, reply_v in api_r.iteritems(): for a_k, a_v in reply_v.iteritems(): - # value = binascii.unhexlify(a_v) if isinstance(a_v, unicode) \ - # else a_v - # reply_value[a_k] = value - reply_value[a_k] = a_v + reply_value[a_k] = process_value(a_v) reply_dict[reply_key] = reply_value return reply_dict @@ -314,45 +375,121 @@ class PapiExecutor(object): :returns: Processed API reply. :rtype: list or dict """ - if isinstance(api_reply, list): reverted_reply = [self._revert_api_reply(a_r) for a_r in api_reply] else: reverted_reply = self._revert_api_reply(api_reply) return reverted_reply - def _execute_papi(self, api_data, timeout=120): + def _execute_papi(self, api_data, method='request', err_msg="", + timeout=120): """Execute PAPI command(s) on remote node and store the result. :param api_data: List of APIs with their arguments. + :param method: VPP Python API method. Supported methods are: 'request', + 'dump' and 'stats'. + :param err_msg: The message used if the PAPI command(s) execution fails. :param timeout: Timeout in seconds. :type api_data: list + :type method: str + :type err_msg: str :type timeout: int + :returns: Stdout from remote python utility, to be parsed by caller. + :rtype: str :raises SSHTimeout: If PAPI command(s) execution has timed out. :raises RuntimeError: If PAPI executor failed due to another reason. + :raises AssertionError: If PAPI command(s) execution has failed. """ if not api_data: - RuntimeError("No API data provided.") - - api_data_processed = self._process_api_data(api_data) - json_data = json.dumps(api_data_processed) + raise RuntimeError("No API data provided.") - cmd = "python {fw_dir}/{papi_provider} --json_data '{json}'".format( - fw_dir=Constants.REMOTE_FW_DIR, - papi_provider=Constants.RESOURCES_PAPI_PROVIDER, - json=json_data) + json_data = json.dumps(api_data) \ + if method in ("stats", "stats_request") \ + else json.dumps(self._process_api_data(api_data)) + cmd = "{fw_dir}/{papi_provider} --method {method} --data '{json}'".\ + format( + fw_dir=Constants.REMOTE_FW_DIR, method=method, json=json_data, + papi_provider=Constants.RESOURCES_PAPI_PROVIDER) try: - ret_code, stdout, stderr = self._ssh.exec_command_sudo( - cmd=cmd, timeout=timeout) + ret_code, stdout, _ = self._ssh.exec_command_sudo( + cmd=cmd, timeout=timeout, log_stdout_err=False) + # TODO: Fail on non-empty stderr? except SSHTimeout: logger.error("PAPI command(s) execution timeout on host {host}:" "\n{apis}".format(host=self._node["host"], apis=api_data)) raise - except Exception: - raise RuntimeError("PAPI command(s) execution on host {host} " - "failed: {apis}".format(host=self._node["host"], - apis=api_data)) - return ret_code, stdout, stderr + except Exception as exc: + raise_from(RuntimeError( + "PAPI command(s) execution on host {host} " + "failed: {apis}".format( + host=self._node["host"], apis=api_data)), exc) + if ret_code != 0: + raise AssertionError(err_msg) + + return stdout + + def _execute(self, method='request', err_msg="", timeout=120): + """Turn internal command list into data and execute; return replies. + + This method also clears the internal command list. + + IMPORTANT! + Do not use this method in L1 keywords. Use: + - get_stats() + - get_replies() + - get_details() + + :param method: VPP Python API method. Supported methods are: 'request', + 'dump' and 'stats'. + :param err_msg: The message used if the PAPI command(s) execution fails. + :param timeout: Timeout in seconds. + :type method: str + :type err_msg: str + :type timeout: int + :returns: Papi responses parsed into a dict-like object, + with field due to API or stats hierarchy. + :rtype: list of dict + :raises KeyError: If the reply is not correct. + """ + + local_list = self._api_command_list + + # Clear first as execution may fail. + self._api_command_list = list() + + stdout = self._execute_papi( + local_list, method=method, err_msg=err_msg, timeout=timeout) + replies = list() + try: + json_data = json.loads(stdout) + except ValueError as err: + raise_from(RuntimeError(err_msg), err) + for data in json_data: + if method == "request": + api_reply = self._process_reply(data["api_reply"]) + # api_reply contains single key, *_reply. + obj = api_reply.values()[0] + retval = obj["retval"] + if retval != 0: + # TODO: What exactly to log and raise here? + err = AssertionError("Got retval {rv!r}".format(rv=retval)) + raise_from(AssertionError(err_msg), err, level="INFO") + replies.append(obj) + elif method == "dump": + api_reply = self._process_reply(data["api_reply"]) + # api_reply is a list where item contas single key, *_details. + for item in api_reply: + obj = item.values()[0] + replies.append(obj) + else: + # TODO: Implement support for stats. + raise RuntimeError("Unsuported method {method}".format( + method=method)) + + # TODO: Make logging optional? + logger.debug("PAPI replies: {replies}".format(replies=replies)) + + return replies