CSIT-1460: Add VPP-stats to PAPI Provider 19/18419/13
authorTibor Frank <tifrank@cisco.com>
Wed, 20 Mar 2019 12:15:40 +0000 (13:15 +0100)
committerJan Gelety <jgelety@cisco.com>
Wed, 27 Mar 2019 14:20:07 +0000 (14:20 +0000)
Change-Id: I2665700a4948c481585d66c987f94af748f102c3
Signed-off-by: Tibor Frank <tifrank@cisco.com>
resources/libraries/python/InterfaceUtil.py
resources/libraries/python/PapiExecutor.py
resources/libraries/python/PapiHistory.py
resources/tools/papi/vpp_papi_provider.py

index 939d808..a1a9b73 100644 (file)
@@ -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'])
index c103c40..f6df200 100644 (file)
 # 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])
index ec5b167..78279f5 100644 (file)
@@ -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
index 73f9fe6..299cd2c 100755 (executable)
 # 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()

©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.