diff options
| -rw-r--r-- | resources/libraries/python/InterfaceUtil.py | 7 | ||||
| -rw-r--r-- | resources/libraries/python/PapiExecutor.py | 333 | ||||
| -rw-r--r-- | resources/libraries/python/PapiHistory.py | 17 | ||||
| -rwxr-xr-x | resources/tools/papi/vpp_papi_provider.py | 254 |
4 files changed, 380 insertions, 231 deletions
diff --git a/resources/libraries/python/InterfaceUtil.py b/resources/libraries/python/InterfaceUtil.py index 939d8083dc..a1a9b739e0 100644 --- a/resources/libraries/python/InterfaceUtil.py +++ b/resources/libraries/python/InterfaceUtil.py @@ -1,4 +1,4 @@ -# Copyright (c) 2018 Cisco and/or its affiliates. +# Copyright (c) 2019 Cisco and/or its affiliates. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: @@ -1644,8 +1644,9 @@ class InterfaceUtil(object): cmd=cmd, host=node['host']) with PapiExecutor(node) as papi_exec: for ifc in node['interfaces'].values(): - papi_exec.add(cmd, sw_if_index=ifc['vpp_sw_index']) - papi_resp = papi_exec.execute_should_pass(err_msg) + if ifc['vpp_sw_index'] is not None: + papi_exec.add(cmd, sw_if_index=ifc['vpp_sw_index']) + papi_resp = papi_exec.get_dump(err_msg) thr_mapping = [s[cmd_reply] for r in papi_resp.reply for s in r['api_reply']] return sorted(thr_mapping, key=lambda k: k['sw_if_index']) diff --git a/resources/libraries/python/PapiExecutor.py b/resources/libraries/python/PapiExecutor.py index c103c40d9a..f6df2004f4 100644 --- a/resources/libraries/python/PapiExecutor.py +++ b/resources/libraries/python/PapiExecutor.py @@ -12,14 +12,6 @@ # limitations under the License. """Python API executor library. - -This version supports only simple request / reply VPP API methods. - -TODO: - - Implement: - - Dump functions - - vpp-stats - """ import binascii @@ -44,6 +36,10 @@ class PapiResponse(object): requests=None): """Construct the Papi response by setting the values needed. + TODO: + Implement 'dump' analogue of verify_replies that would concatenate + the values, so that call sites do not have to do that themselves. + :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). @@ -51,7 +47,7 @@ class PapiResponse(object): :param requests: List of used PAPI requests. It is used while verifying replies. If None, expected replies must be provided for verify_reply and verify_replies methods. - :type papi_reply: list + :type papi_reply: list or None :type stdout: str :type stderr: str :type ret_code: int @@ -110,24 +106,26 @@ class PapiResponse(object): Note: Use only with a simple request / reply command. In this case the PAPI reply includes 'retval' which is checked in this method. + Do not use with 'dump' and 'vpp-stats' methods. + Use if PAPI response includes only one command reply. Use it this way (preferred): with PapiExecutor(node) as papi_exec: - data = papi_exec.add('show_version').execute_should_pass().\ - verify_reply() + data = papi_exec.add('show_version').get_replies().verify_reply() or if you must provide the expected reply (not recommended): with PapiExecutor(node) as papi_exec: - data = papi_exec.add('show_version').execute_should_pass().\ + data = papi_exec.add('show_version').get_replies().\ verify_reply('show_version_reply') :param cmd_reply: PAPI reply. If None, list of 'requests' should have been provided to the __init__ method as pre-generated list of replies is used in this method in this case. - The .execute* methods are providing the requests automatically. + The PapiExecutor._execute() method provides the requests + automatically. :param idx: Index to PapiResponse.reply list. :param err_msg: The message used if the verification fails. :type cmd_reply: str @@ -156,31 +154,34 @@ class PapiResponse(object): Note: Use only with request / reply commands. In this case each PAPI reply includes 'retval' which is checked. + Do not use with 'dump' and 'vpp-stats' methods. + Use if PAPI response includes more than one command reply. Use it this way: with PapiExecutor(node) as papi_exec: papi_exec.add(cmd1, **args1).add(cmd2, **args2).add(cmd2, **args3).\ - execute_should_pass(err_msg).verify_replies() + get_replies(err_msg).verify_replies() or if you need the data from the PAPI response: with PapiExecutor(node) as papi_exec: data = papi_exec.add(cmd1, **args1).add(cmd2, **args2).\ - add(cmd2, **args3).execute_should_pass(err_msg).verify_replies() + add(cmd2, **args3).get_replies(err_msg).verify_replies() or if you must provide the list of expected replies (not recommended): with PapiExecutor(node) as papi_exec: data = papi_exec.add(cmd1, **args1).add(cmd2, **args2).\ - add(cmd2, **args3).execute_should_pass(err_msg).\ + add(cmd2, **args3).get_replies(err_msg).\ verify_replies(cmd_replies=cmd_replies) :param cmd_replies: List of PAPI command replies. If None, list of 'requests' should have been provided to the __init__ method as pre-generated list of replies is used in this method in this case. - The .execute* methods are providing the requests automatically. + The PapiExecutor._execute() method provides the requests + automatically. :param err_msg: The message used if the verification fails. :type cmd_replies: list of str or None :type err_msg: str @@ -202,12 +203,73 @@ class PapiResponse(object): class PapiExecutor(object): - """Contains methods for executing Python API commands on DUTs. + """Contains methods for executing VPP Python API commands on DUTs. + + Note: Use only with "with" statement, e.g.: + + with PapiExecutor(node) as papi_exec: + papi_resp = papi_exec.add('show_version').get_replies(err_msg) + + 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'. + + The recommended ways of use are (examples): + + 1. Simple request / reply + + a. One request with no arguments: + + with PapiExecutor(node) as papi_exec: + data = papi_exec.add('show_version').get_replies().\ + verify_reply() + + b. Three requests with arguments, the second and the third ones are the same + but with different arguments. + + with PapiExecutor(node) as papi_exec: + data = papi_exec.add(cmd1, **args1).add(cmd2, **args2).\ + add(cmd2, **args3).get_replies(err_msg).verify_replies() - Use only with "with" statement, e.g.: + 2. Dump functions - with PapiExecutor(node) as papi_exec: - papi_resp = papi_exec.add('show_version').execute_should_pass(err_msg) + cmd = 'sw_interface_rx_placement_dump' + with PapiExecutor(node) as papi_exec: + papi_resp = papi_exec.add(cmd, sw_if_index=ifc['vpp_sw_index']).\ + get_dump(err_msg) + + 3. vpp-stats + + path = ['^/if', '/err/ip4-input', '/sys/node/ip4-input'] + + with PapiExecutor(node) as papi_exec: + data = papi_exec.add(api_name='vpp-stats', path=path).get_stats() + + print('RX interface core 0, sw_if_index 0:\n{0}'.\ + format(data[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: + data = 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(data[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): @@ -237,18 +299,7 @@ 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. - - Use when not sure whether previous usage has left something in the list. - - :returns: self, so that method chaining is possible. - :rtype: PapiExecutor - """ - self._api_command_list = list() - return self - - def add(self, csit_papi_command, **kwargs): + def add(self, csit_papi_command="vpp-stats", **kwargs): """Add next command to internal command list; return self. The argument name 'csit_papi_command' must be unique enough as it cannot @@ -266,65 +317,56 @@ class PapiExecutor(object): 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. + def get_stats(self, err_msg="Failed to get statistics.", timeout=120): + """Get VPP Stats from VPP Python API. - This method also clears the internal command list. + :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 + """ + + paths = [cmd['api_args']['path'] for cmd in self._api_command_list] + self._api_command_list = list() + + ret_code, stdout, _ = self._execute_papi(paths, + method='stats', + err_msg=err_msg, + timeout=timeout) + + return json.loads(stdout) + def get_replies(self, err_msg="Failed to get replies.", + process_reply=True, ignore_errors=False, timeout=120): + """Get reply/replies from VPP Python API. + + :param err_msg: The message used if the PAPI command(s) execution fails. :param process_reply: Process PAPI reply if True. :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 KeyError: If the reply is not correct. """ + response = self._execute(method='request', + process_reply=process_reply, + ignore_errors=ignore_errors, + err_msg=err_msg, + timeout=timeout) + return response - local_list = self._api_command_list - - # Clear first as execution may fail. - self.clear() - - ret_code, stdout, stderr = self._execute_papi(local_list, timeout) - - papi_reply = list() - if process_reply: - try: - json_data = json.loads(stdout) - except ValueError: - logger.error("An error occured while processing the PAPI " - "request:\n{rqst}".format(rqst=local_list)) - raise - 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, - requests=[rqst["api_name"] for rqst in local_list]) - - 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. + def get_dump(self, err_msg="Failed to get dump.", + process_reply=True, ignore_errors=False, timeout=120): + """Get dump from VPP Python API. :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 process_reply: Process PAPI reply if True. :param ignore_errors: If true, the errors in the reply are ignored. :param timeout: Timeout in seconds. :type err_msg: str @@ -334,25 +376,26 @@ class PapiExecutor(object): :returns: Papi response including: papi reply, stdout, stderr and return code. :rtype: PapiResponse - :raises AssertionError: If PAPI command(s) execution failed. """ - response = self.execute(process_reply=process_reply, - ignore_errors=ignore_errors, - timeout=timeout) - - if response.ret_code != 0: - raise AssertionError(err_msg) + response = self._execute(method='dump', + process_reply=process_reply, + ignore_errors=ignore_errors, + err_msg=err_msg, + timeout=timeout) return response - def execute_should_fail(self, - err_msg="Execution of PAPI command did not fail.", - process_reply=False, ignore_errors=False, + 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) did not fail. + Raise exception if the PAPI command(s) failed. - It does not return anything as we expect it fails. + IMPORTANT! + Do not use this method in L1 keywords. Use: + - get_replies() + - get_dump() + This method will be removed soon. :param err_msg: The message used if the PAPI command(s) execution fails. :param process_reply: Indicate whether or not to process PAPI reply. @@ -362,15 +405,17 @@ class PapiExecutor(object): :type process_reply: bool :type ignore_errors: bool :type timeout: int - :raises AssertionError: If PAPI command(s) execution passed. + :returns: Papi response including: papi reply, stdout, stderr and + return code. + :rtype: PapiResponse + :raises AssertionError: If PAPI command(s) execution failed. """ - response = self.execute(process_reply=process_reply, - ignore_errors=ignore_errors, - timeout=timeout) - - if response.ret_code == 0: - raise AssertionError(err_msg) + response = self.get_replies(process_reply=process_reply, + ignore_errors=ignore_errors, + err_msg=err_msg, + timeout=timeout) + return response @staticmethod def _process_api_data(api_d): @@ -400,7 +445,7 @@ 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 @@ -412,9 +457,6 @@ class PapiExecutor(object): 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_dict[reply_key] = reply_value return reply_dict @@ -434,28 +476,35 @@ class PapiExecutor(object): 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 :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) - - cmd = "{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 == "stats" \ + 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, + papi_provider=Constants.RESOURCES_PAPI_PROVIDER, + method=method, + json=json_data) try: ret_code, stdout, stderr = self._ssh.exec_command_sudo( cmd=cmd, timeout=timeout) @@ -468,4 +517,72 @@ class PapiExecutor(object): raise RuntimeError("PAPI command(s) execution on host {host} " "failed: {apis}".format(host=self._node["host"], apis=api_data)) + if ret_code != 0: + raise AssertionError(err_msg) + return ret_code, stdout, stderr + + def _execute(self, method='request', process_reply=True, + ignore_errors=False, err_msg="", timeout=120): + """Turn internal command list into proper data and execute; return + PAPI response. + + This method also clears the internal command list. + + IMPORTANT! + Do not use this method in L1 keywords. Use: + - get_stats() + - get_replies() + - get_dump() + + :param method: VPP Python API method. Supported methods are: 'request', + 'dump' and 'stats'. + :param process_reply: Process PAPI reply if True. + :param ignore_errors: If true, the errors in the reply are ignored. + :param err_msg: The message used if the PAPI command(s) execution fails. + :param timeout: Timeout in seconds. + :type method: str + :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. + """ + + local_list = self._api_command_list + + # Clear first as execution may fail. + self._api_command_list = list() + + ret_code, stdout, stderr = self._execute_papi(local_list, + method=method, + err_msg=err_msg, + timeout=timeout) + papi_reply = list() + if process_reply: + try: + json_data = json.loads(stdout) + except ValueError: + logger.error("An error occured while processing the PAPI " + "request:\n{rqst}".format(rqst=local_list)) + raise + 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, + requests=[rqst["api_name"] for rqst in local_list]) diff --git a/resources/libraries/python/PapiHistory.py b/resources/libraries/python/PapiHistory.py index ec5b1675eb..78279f559a 100644 --- a/resources/libraries/python/PapiHistory.py +++ b/resources/libraries/python/PapiHistory.py @@ -54,6 +54,23 @@ class PapiHistory(object): The argument name 'csit_papi_command' must be unique enough as it cannot be repeated in kwargs. + Examples of PAPI history items: + + Request without parameters: + show_threads() + + Request with parameters: + ipsec_select_backend(index=1,protocol=1) + + Dump: + sw_interface_rx_placement_dump(sw_if_index=4) + + VPP Stats: + vpp-stats(path=['^/if', '/err/ip4-input', '/sys/node/ip4-input']) + + VAT: + sw_interface_set_flags sw_if_index 3 admin-up link-up + :param node: DUT node to add command to PAPI command history for. :param csit_papi_command: Command to be added to PAPI command history. :param papi: Says if the command to store is PAPi or VAT. Remove when diff --git a/resources/tools/papi/vpp_papi_provider.py b/resources/tools/papi/vpp_papi_provider.py index 73f9fe65c0..299cd2c962 100755 --- a/resources/tools/papi/vpp_papi_provider.py +++ b/resources/tools/papi/vpp_papi_provider.py @@ -13,7 +13,24 @@ # See the License for the specific language governing permissions and # limitations under the License. -"""Python API provider. +r"""CSIT PAPI Provider + +TODO: Add description. + +Examples: +--------- + +Request/reply or dump: + + vpp_papi_provider.py \ + --method request \ + --data '[{"api_name": "show_version", "api_args": {}}]' + +VPP-stats: + + vpp_papi_provider.py \ + --method stats \ + --data '[["^/if", "/err/ip4-input", "/sys/node/ip4-input"], ["^/if"]]' """ import argparse @@ -22,21 +39,27 @@ import json import os import sys + +# Client name +CLIENT_NAME = 'csit_papi' + + # Sphinx creates auto-generated documentation by importing the python source # files and collecting the docstrings from them. The NO_VPP_PAPI flag allows # the vpp_papi_provider.py file to be importable without having to build # the whole vpp api if the user only wishes to generate the test documentation. -do_import = True + try: - no_vpp_papi = os.getenv("NO_VPP_PAPI") - if no_vpp_papi == "1": - do_import = False -except: - pass + do_import = False if os.getenv("NO_VPP_PAPI") == "1" else True +except KeyError: + do_import = True if do_import: - # TODO: run os.walk once per whole suite and store the path in environmental - # variable + + # Find the directory where the modules are installed. The directory depends + # on the OS used. + # TODO: Find a better way to import papi modules. + modules_path = None for root, dirs, files in os.walk('/usr/lib'): for name in files: @@ -46,140 +69,57 @@ if do_import: if modules_path: sys.path.append(modules_path) from vpp_papi import VPP + from vpp_papi.vpp_stats import VPPStats else: raise RuntimeError('vpp_papi module not found') -# client name -CLIENT_NAME = 'csit_papi' - - -def papi_init(): - """Construct a VPP instance from VPP JSON API files. - - :param vpp_json_dir: Directory containing all the JSON API files. If VPP is - installed in the system it will be in /usr/share/vpp/api/. - :type vpp_json_dir: str - :returns: VPP instance. - :rtype: VPP object - :raises PapiJsonFileError: If no api.json file found. - :raises PapiInitError: If PAPI initialization failed. - """ - try: - vpp = VPP() - return vpp - except Exception as err: - raise RuntimeError('PAPI init failed:\n{err}'.format(err=repr(err))) - - -def papi_connect(vpp_client, name='vpp_api'): - """Attach to VPP client. - - :param vpp_client: VPP instance to connect to. - :param name: VPP client name. - :type vpp_client: VPP object - :type name: str - :returns: Return code of VPP.connect() method. - :rtype: int - """ - return vpp_client.connect(name) - - -def papi_disconnect(vpp_client): - """Detach from VPP client. - - :param vpp_client: VPP instance to detach from. - :type vpp_client: VPP object - """ - vpp_client.disconnect() - - -def papi_run(vpp_client, api_name, api_args): - """Run PAPI. - - :param vpp_client: VPP instance. - :param api_name: VPP API name. - :param api_args: Input arguments of the API. - :type vpp_client: VPP object - :type api_name: str - :type api_args: dict - :returns: VPP API reply. - :rtype: Vpp_serializer reply object - """ - papi_fn = getattr(vpp_client.api, api_name) - return papi_fn(**api_args) - -def convert_reply(api_r): +def _convert_reply(api_r): """Process API reply / a part of API reply for smooth converting to JSON string. + It is used only with 'request' and 'dump' methods. + Apply binascii.hexlify() method for string values. + TODO: Implement complex solution to process of replies. + :param api_r: API reply. :type api_r: Vpp_serializer reply object (named tuple) :returns: Processed API reply / a part of API reply. :rtype: dict """ - unwanted_fields = ['count', 'index'] + unwanted_fields = ['count', 'index', 'context'] reply_dict = dict() reply_key = repr(api_r).split('(')[0] reply_value = dict() for item in dir(api_r): if not item.startswith('_') and item not in unwanted_fields: - # attr_value = getattr(api_r, item) - # value = binascii.hexlify(attr_value) \ - # if isinstance(attr_value, str) else attr_value - value = getattr(api_r, item) - reply_value[item] = value + reply_value[item] = getattr(api_r, item) reply_dict[reply_key] = reply_value return reply_dict -def process_reply(api_reply): - """Process API reply for smooth converting to JSON string. - - :param api_reply: API reply. - :type api_reply: Vpp_serializer reply object (named tuple) or list of - vpp_serializer reply objects - :returns: Processed API reply. - :rtype: list or dict - """ - - if isinstance(api_reply, list): - converted_reply = list() - for r in api_reply: - converted_reply.append(convert_reply(r)) - else: - converted_reply = convert_reply(api_reply) - return converted_reply - - -def main(): - """Main function for the Python API provider. +def process_json_request(args): + """Process the request/reply and dump classes of VPP API methods. - :raises RuntimeError: If invalid attribute name or invalid value is - used in API call or if PAPI command(s) execution failed. + :param args: Command line arguments passed to VPP PAPI Provider. + :type args: ArgumentParser + :returns: JSON formatted string. + :rtype: str + :raises RuntimeError: If PAPI command error occurs. """ - parser = argparse.ArgumentParser() - parser.add_argument("-j", "--json_data", - required=True, - type=str, - help="JSON string (list) containing API name(s) and " - "its/their input argument(s).") - parser.add_argument("-d", "--json_dir", - type=str, - default='/usr/share/vpp/api/', - help="Directory containing all vpp json api files.") - args = parser.parse_args() - json_string = args.json_data - - vpp = papi_init() + try: + vpp = VPP() + except Exception as err: + raise RuntimeError('PAPI init failed:\n{err}'.format(err=repr(err))) reply = list() - json_data = json.loads(json_string) - papi_connect(vpp, CLIENT_NAME) + + json_data = json.loads(args.data) + vpp.connect(CLIENT_NAME) for data in json_data: api_name = data['api_name'] api_args_unicode = data['api_args'] @@ -187,28 +127,102 @@ def main(): api_args = dict() for a_k, a_v in api_args_unicode.items(): value = binascii.unhexlify(a_v) if isinstance(a_v, unicode) else a_v - api_args[str(a_k)] = value + api_args[str(a_k)] = value if isinstance(value, int) else str(value) try: - rep = papi_run(vpp, api_name, api_args) - api_reply['api_reply'] = process_reply(rep) + papi_fn = getattr(vpp.api, api_name) + rep = papi_fn(**api_args) + + if isinstance(rep, list): + converted_reply = list() + for r in rep: + converted_reply.append(_convert_reply(r)) + else: + converted_reply = _convert_reply(rep) + + api_reply['api_reply'] = converted_reply reply.append(api_reply) except (AttributeError, ValueError) as err: - papi_disconnect(vpp) + vpp.disconnect() raise RuntimeError('PAPI command {api}({args}) input error:\n{err}'. format(api=api_name, args=api_args, err=repr(err))) except Exception as err: - papi_disconnect(vpp) + vpp.disconnect() raise RuntimeError('PAPI command {api}({args}) error:\n{exc}'. format(api=api_name, args=api_args, exc=repr(err))) - papi_disconnect(vpp) + vpp.disconnect() + + return json.dumps(reply) + + +def process_stats(args): + """Process the VPP Stats. + + :param args: Command line arguments passed to VPP PAPI Provider. + :type args: ArgumentParser + :returns: JSON formatted string. + :rtype: str + :raises RuntimeError: If PAPI command error occurs. + """ + + try: + stats = VPPStats(args.socket) + except Exception as err: + raise RuntimeError('PAPI init failed:\n{err}'.format(err=repr(err))) + + json_data = json.loads(args.data) + + reply = list() + + for path in json_data: + directory = stats.ls(path) + data = stats.dump(directory) + reply.append(data) return json.dumps(reply) +def main(): + """Main function for the Python API provider. + """ + + # The functions which process different types of VPP Python API methods. + process_request = dict( + request=process_json_request, + dump=process_json_request, + stats=process_stats + ) + + parser = argparse.ArgumentParser( + formatter_class=argparse.RawDescriptionHelpFormatter, + description=__doc__) + parser.add_argument("-m", "--method", + required=True, + choices=[str(key) for key in process_request.keys()], + help="Specifies the VPP API methods: 1. request - " + "simple request / reply; 2. dump - dump function;" + "3. stats - VPP statistics.") + parser.add_argument("-d", "--data", + required=True, + help="If the method is 'request' or 'dump', data is a " + "JSON string (list) containing API name(s) and " + "its/their input argument(s). " + "If the method is 'stats', data is a JSON string " + "containing the list of path(s) to the required " + "data.") + parser.add_argument("-s", "--socket", + default="/var/run/vpp/stats.sock", + help="A file descriptor over the VPP stats Unix domain " + "socket. It is used only if method=='stats'.") + + args = parser.parse_args() + + return process_request[args.method](args) + + if __name__ == '__main__': sys.stdout.write(main()) sys.stdout.flush() |