VAT-to-PAPI: VPPCounters
[csit.git] / resources / libraries / python / PapiExecutor.py
index a51cb76..5e35422 100644 (file)
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 # 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
 
 
 import binascii
 import json
 
+from pprint import pformat
+
 from robot.api import logger
 
 from resources.libraries.python.Constants import Constants
 from resources.libraries.python.ssh import SSH, SSHTimeout
 from resources.libraries.python.PapiHistory import PapiHistory
 
 from robot.api import logger
 
 from resources.libraries.python.Constants import Constants
 from resources.libraries.python.ssh import SSH, SSHTimeout
 from resources.libraries.python.PapiHistory import PapiHistory
 
+
 __all__ = ["PapiExecutor", "PapiResponse"]
 
 
 __all__ = ["PapiExecutor", "PapiResponse"]
 
 
@@ -30,45 +34,53 @@ class PapiResponse(object):
     code.
     """
 
     code.
     """
 
-    def __init__(self, papi_reply=None, stdout="", stderr="", ret_code=None):
+    def __init__(self, papi_reply=None, stdout="", stderr="", requests=None):
         """Construct the Papi response by setting the values needed.
 
         """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).
         :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
+        :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 or None
         :type stdout: str
         :type stderr: str
         :type stdout: str
         :type stderr: str
-        :type ret_code: int
+        :type requests: list
         """
 
         """
 
-        # API reply from last executed PAPI command(s)
+        # API reply from last executed PAPI command(s).
         self.reply = papi_reply
 
         self.reply = papi_reply
 
-        # stdout from last executed PAPI command(s)
+        # stdout from last executed PAPI command(s).
         self.stdout = stdout
 
         # stderr from last executed PAPI command(s).
         self.stderr = stderr
 
         self.stdout = stdout
 
         # stderr from last executed PAPI command(s).
         self.stderr = stderr
 
-        # return code from last executed PAPI command(s)
-        self.ret_code = ret_code
+        # List of used PAPI requests.
+        self.requests = requests
+
+        # List of expected PAPI replies. It is used while verifying replies.
+        if self.requests:
+            self.expected_replies = \
+                ["{rqst}_reply".format(rqst=rqst) for rqst in self.requests]
 
     def __str__(self):
 
     def __str__(self):
-        """Return string with human readable description of the group.
+        """Return string with human readable description of the PapiResponse.
 
         :returns: Readable description.
         :rtype: str
         """
 
         :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))
+        return (
+            "papi_reply={papi_reply},stdout={stdout},stderr={stderr},"
+            "requests={requests}").format(
+                papi_reply=self.reply, stdout=self.stdout, stderr=self.stderr,
+                requests=self.requests)
 
     def __repr__(self):
         """Return string executable as Python constructor call.
 
     def __repr__(self):
         """Return string executable as Python constructor call.
@@ -76,23 +88,179 @@ class PapiResponse(object):
         :returns: Executable constructor call.
         :rtype: str
         """
         :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))
+        return "PapiResponse({str})".format(str=str(self))
+
+    def verify_reply(self, cmd_reply=None, idx=0,
+                     err_msg="Failed to verify PAPI reply."):
+        """Verify and return data from the PAPI response.
+
+        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').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').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 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
+        :type idx: int
+        :type err_msg: str or None
+        :returns: Verified data from PAPI response.
+        :rtype: dict
+        :raises AssertionError: If the PAPI return value is not 0, so the reply
+            is not valid.
+        :raises KeyError, IndexError: If the reply does not have expected
+            structure.
+        """
+        cmd_rpl = self.expected_replies[idx] if cmd_reply is None else cmd_reply
+
+        data = self.reply[idx]['api_reply'][cmd_rpl]
+        if data['retval'] != 0:
+            raise AssertionError("{msg}\nidx={idx}, cmd_reply={reply}".
+                                 format(msg=err_msg, idx=idx, reply=cmd_rpl))
+
+        return data
+
+    def verify_replies(self, cmd_replies=None,
+                       err_msg="Failed to verify PAPI reply."):
+        """Verify and return data from the PAPI response.
+
+        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).\
+                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).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).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 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
+        :returns: List of verified data from PAPI response.
+        :rtype list
+        :raises AssertionError: If the PAPI response does not include at least
+            one of specified command replies.
+        """
+        data = list()
+
+        cmd_rpls = self.expected_replies if cmd_replies is None else cmd_replies
+
+        if len(self.reply) != len(cmd_rpls):
+            raise AssertionError(err_msg)
+        for idx, cmd_reply in enumerate(cmd_rpls):
+            data.append(self.verify_reply(cmd_reply, idx, err_msg))
+
+        return data
 
 
 class PapiExecutor(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()
+
+    2. Dump functions
+
+        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()
 
 
-    Use only with "with" statement, e.g.:
+        print('RX interface core 0, sw_if_index 0:\n{0}'.\
+            format(data[0]['/if/rx'][0][0]))
 
 
-    with PapiExecutor(node) as papi_exec:
-        papi_resp = papi_exec.add('show_version').execute_should_pass(err_msg)
+        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):
     """
 
     def __init__(self, node):
@@ -108,9 +276,6 @@ class PapiExecutor(object):
         # The list of PAPI commands to be executed on the node.
         self._api_command_list = list()
 
         # 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):
         self._ssh = SSH()
 
     def __enter__(self):
@@ -125,18 +290,7 @@ class PapiExecutor(object):
     def __exit__(self, exc_type, exc_val, exc_tb):
         self._ssh.disconnect(self._node)
 
     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
         """Add next command to internal command list; return self.
 
         The argument name 'csit_papi_command' must be unique enough as it cannot
@@ -154,62 +308,70 @@ class PapiExecutor(object):
                                            api_args=kwargs))
         return self
 
                                            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()
 
 
+        stdout, _ = self._execute_papi(
+            paths, method='stats', err_msg=err_msg, timeout=timeout)
+
+        return json.loads(stdout)
+
+    def get_stats_reply(self, err_msg="Failed to get statistics.", timeout=120):
+        """Get VPP Stats reply from VPP Python API.
+
+        :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
+        """
+
+        args = self._api_command_list[0]['api_args']
+        self._api_command_list = list()
+
+        stdout, _ = self._execute_papi(
+            args, method='stats_request', 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.
         :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
         :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.
         """
         """
+        return self._execute(
+            method='request', process_reply=process_reply,
+            ignore_errors=ignore_errors, err_msg=err_msg, timeout=timeout)
 
 
-        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:
-            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.
+    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 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
         :param ignore_errors: If true, the errors in the reply are ignored.
         :param timeout: Timeout in seconds.
         :type err_msg: str
@@ -219,29 +381,65 @@ class PapiExecutor(object):
         :returns: Papi response including: papi reply, stdout, stderr and
             return code.
         :rtype: PapiResponse
         :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.
         """
         """
+        return self._execute(
+            method='dump', process_reply=process_reply,
+            ignore_errors=ignore_errors, err_msg=err_msg, timeout=timeout)
 
 
-        response = self.execute(process_reply=process_reply,
-                                ignore_errors=ignore_errors,
-                                timeout=timeout)
+    @staticmethod
+    def dump_and_log(node, cmds):
+        """Dump and log requested information.
 
 
-        if response.ret_code != 0:
-            raise AssertionError(err_msg)
-        return response
+        :param node: DUT node.
+        :param cmds: Dump commands to be executed.
+        :type node: dict
+        :type cmds: list
+        """
+        with PapiExecutor(node) as papi_exec:
+            for cmd in cmds:
+                dump = papi_exec.add(cmd).get_dump()
+                logger.debug("{cmd}:\n{data}".format(
+                    cmd=cmd, data=pformat(dump.reply[0]["api_reply"])))
+
+    @staticmethod
+    def run_cli_cmd(node, cmd, log=True):
+        """Run a CLI command.
+
+        :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: Verified data from PAPI response.
+        :rtype: dict
+        """
+
+        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:
+            data = papi_exec.add(cli, **args).get_replies(err_msg). \
+                verify_reply(err_msg=err_msg)
+
+        if log:
+            logger.info("{cmd}:\n{data}".format(cmd=cmd, data=data["reply"]))
+
+        return data
 
 
-    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.
                             timeout=120):
         """Execute the PAPI commands and check the return code.
-        Raise exception if the PAPI command(s) did not fail.
-
-        It does not return anything as we expect it fails.
+        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.
+        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.
 
         :param err_msg: The message used if the PAPI command(s) execution fails.
         :param process_reply: Indicate whether or not to process PAPI reply.
@@ -251,16 +449,15 @@ class PapiExecutor(object):
         :type process_reply: bool
         :type ignore_errors: bool
         :type timeout: int
         :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: 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)
+        # TODO: Migrate callers to get_replies and delete this method.
+        return self.get_replies(
+            process_reply=process_reply, ignore_errors=ignore_errors,
+            err_msg=err_msg, timeout=timeout)
 
     @staticmethod
     def _process_api_data(api_d):
 
     @staticmethod
     def _process_api_data(api_d):
@@ -274,12 +471,27 @@ class PapiExecutor(object):
         :rtype: list
         """
 
         :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):
+                val_dict = dict()
+                for val_k, val_v in val.iteritems():
+                    val_dict[str(val_k)] = process_value(val_v)
+                return val_dict
+            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():
         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
             api_data_processed.append(dict(api_name=api["api_name"],
                                            api_args=api_args_processed))
         return api_data_processed
@@ -290,22 +502,19 @@ class PapiExecutor(object):
 
         Apply binascii.unhexlify() method for unicode values.
 
 
         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
         """
 
         :param api_r: API reply.
         :type api_r: dict
         :returns: Processed API reply / a part of API reply.
         :rtype: dict
         """
-
         reply_dict = dict()
         reply_value = dict()
         for reply_key, reply_v in api_r.iteritems():
             for a_k, a_v in reply_v.iteritems():
         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] = binascii.unhexlify(a_v) \
+                    if isinstance(a_v, unicode) else a_v
             reply_dict[reply_key] = reply_value
         return reply_dict
 
             reply_dict[reply_key] = reply_value
         return reply_dict
 
@@ -317,38 +526,47 @@ class PapiExecutor(object):
         :returns: Processed API reply.
         :rtype: list or dict
         """
         :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
 
         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.
         """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
         :param timeout: Timeout in seconds.
         :type api_data: list
+        :type method: str
+        :type err_msg: str
         :type timeout: int
         :type timeout: int
+        :returns: Stdout and stderr.
+        :rtype: 2-tuple of str
         :raises SSHTimeout: If PAPI command(s) execution has timed out.
         :raises RuntimeError: If PAPI executor failed due to another reason.
         :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.")
 
         """
 
         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 = "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,
+                   papi_provider=Constants.RESOURCES_PAPI_PROVIDER,
+                   method=method,
+                   json=json_data)
         try:
             ret_code, stdout, stderr = self._ssh.exec_command_sudo(
         try:
             ret_code, stdout, stderr = self._ssh.exec_command_sudo(
-                cmd=cmd, timeout=timeout)
+                cmd=cmd, timeout=timeout, log_stdout_err=False)
         except SSHTimeout:
             logger.error("PAPI command(s) execution timeout on host {host}:"
                          "\n{apis}".format(host=self._node["host"],
         except SSHTimeout:
             logger.error("PAPI command(s) execution timeout on host {host}:"
                          "\n{apis}".format(host=self._node["host"],
@@ -358,4 +576,71 @@ class PapiExecutor(object):
             raise RuntimeError("PAPI command(s) execution on host {host} "
                                "failed: {apis}".format(host=self._node["host"],
                                                        apis=api_data))
             raise RuntimeError("PAPI command(s) execution on host {host} "
                                "failed: {apis}".format(host=self._node["host"],
                                                        apis=api_data))
-        return ret_code, stdout, stderr
+        if ret_code != 0:
+            raise AssertionError(err_msg)
+
+        return 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()
+
+        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)
+
+        # Log processed papi reply to be able to check API replies changes
+        logger.debug("Processed PAPI reply: {reply}".format(reply=papi_reply))
+
+        return PapiResponse(
+            papi_reply=papi_reply, stdout=stdout, stderr=stderr,
+            requests=[rqst["api_name"] for rqst in local_list])