aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--resources/libraries/python/InterfaceUtil.py7
-rw-r--r--resources/libraries/python/PapiExecutor.py333
-rw-r--r--resources/libraries/python/PapiHistory.py17
-rwxr-xr-xresources/tools/papi/vpp_papi_provider.py254
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()