-#!/usr/bin/env python
+#!/usr/bin/env python3
#
# Copyright (c) 2016 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
from __future__ import print_function
from __future__ import absolute_import
+import ctypes
+import ipaddress
import sys
+import multiprocessing as mp
import os
+import queue
import logging
-import collections
-import struct
+import functools
import json
import threading
import fnmatch
import weakref
import atexit
-from cffi import FFI
-import cffi
-from . vpp_serializer import VPPType, VPPEnumType, VPPUnionType, BaseTypes
-from . vpp_serializer import VPPMessage
-
-if sys.version[0] == '2':
- import Queue as queue
-else:
- import queue as queue
-
-ffi = FFI()
-ffi.cdef("""
-typedef void (*vac_callback_t)(unsigned char * data, int len);
-typedef void (*vac_error_callback_t)(void *, unsigned char *, int);
-int vac_connect(char * name, char * chroot_prefix, vac_callback_t cb,
- int rx_qlen);
-int vac_disconnect(void);
-int vac_read(char **data, int *l, unsigned short timeout);
-int vac_write(char *data, int len);
-void vac_free(void * msg);
-
-int vac_get_msg_index(unsigned char * name);
-int vac_msg_table_size(void);
-int vac_msg_table_max_index(void);
-
-void vac_rx_suspend (void);
-void vac_rx_resume (void);
-void vac_set_error_handler(vac_error_callback_t);
- """)
-
-# Barfs on failure, no need to check success.
-vpp_api = ffi.dlopen('libvppapiclient.so')
+import time
+from . vpp_format import verify_enum_hint
+from . vpp_serializer import VPPType, VPPEnumType, VPPEnumFlagType, VPPUnionType
+from . vpp_serializer import VPPMessage, vpp_get_type, VPPTypeAlias
+
+try:
+ import VppTransport
+except ModuleNotFoundError:
+ class V:
+ """placeholder for VppTransport as the implementation is dependent on
+ VPPAPIClient's initialization values
+ """
+ VppTransport = V
-def vpp_atexit(vpp_weakref):
- """Clean up VPP connection on shutdown."""
- vpp_instance = vpp_weakref()
- if vpp_instance.connected:
- vpp_instance.logger.debug('Cleaning up VPP on exit')
- vpp_instance.disconnect()
-
+from . vpp_transport_socket import VppTransport
-vpp_object = None
+logger = logging.getLogger('vpp_papi')
+logger.addHandler(logging.NullHandler())
+__all__ = ('FuncWrapper', 'VppApiDynamicMethodHolder',
+ 'VppEnum', 'VppEnumType', 'VppEnumFlag',
+ 'VPPIOError', 'VPPRuntimeError', 'VPPValueError',
+ 'VPPApiClient', )
-def vpp_iterator(d):
- if sys.version[0] == '2':
- return d.iteritems()
- else:
- return d.items()
+def metaclass(metaclass):
+ @functools.wraps(metaclass)
+ def wrapper(cls):
+ return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
-@ffi.callback("void(unsigned char *, int)")
-def vac_callback_sync(data, len):
- vpp_object.msg_handler_sync(ffi.buffer(data, len))
+ return wrapper
-@ffi.callback("void(unsigned char *, int)")
-def vac_callback_async(data, len):
- vpp_object.msg_handler_async(ffi.buffer(data, len))
+class VppEnumType(type):
+ def __getattr__(cls, name):
+ t = vpp_get_type(name)
+ return t.enum
-@ffi.callback("void(void *, unsigned char *, int)")
-def vac_error_handler(arg, msg, msg_len):
- vpp_object.logger.warning("VPP API client:: %s", ffi.string(msg, msg_len))
+@metaclass(VppEnumType)
+class VppEnum:
+ pass
-class VppApiDynamicMethodHolder(object):
+@metaclass(VppEnumType)
+class VppEnumFlag:
pass
-class FuncWrapper(object):
- def __init__(self, func):
- self._func = func
- self.__name__ = func.__name__
+def vpp_atexit(vpp_weakref):
+ """Clean up VPP connection on shutdown."""
+ vpp_instance = vpp_weakref()
+ if vpp_instance and vpp_instance.transport.connected:
+ logger.debug('Cleaning up VPP on exit')
+ vpp_instance.disconnect()
- def __call__(self, **kwargs):
- return self._func(**kwargs)
+def add_convenience_methods():
+ # provide convenience methods to IP[46]Address.vapi_af
+ def _vapi_af(self):
+ if 6 == self._version:
+ return VppEnum.vl_api_address_family_t.ADDRESS_IP6.value
+ if 4 == self._version:
+ return VppEnum.vl_api_address_family_t.ADDRESS_IP4.value
+ raise ValueError("Invalid _version.")
-class VPP():
- """VPP interface.
+ def _vapi_af_name(self):
+ if 6 == self._version:
+ return 'ip6'
+ if 4 == self._version:
+ return 'ip4'
+ raise ValueError("Invalid _version.")
- This class provides the APIs to VPP. The APIs are loaded
- from provided .api.json files and makes functions accordingly.
- These functions are documented in the VPP .api files, as they
- are dynamically created.
+ ipaddress._IPAddressBase.vapi_af = property(_vapi_af)
+ ipaddress._IPAddressBase.vapi_af_name = property(_vapi_af_name)
- Additionally, VPP can send callback messages; this class
- provides a means to register a callback function to receive
- these messages in a background thread.
- """
- def process_json_file(self, apidef_file):
- api = json.load(apidef_file)
- types = {}
- for t in api['enums']:
- t[0] = 'vl_api_' + t[0] + '_t'
- types[t[0]] = {'type': 'enum', 'data': t}
- for t in api['unions']:
- t[0] = 'vl_api_' + t[0] + '_t'
- types[t[0]] = {'type': 'union', 'data': t}
- for t in api['types']:
- t[0] = 'vl_api_' + t[0] + '_t'
- types[t[0]] = {'type': 'type', 'data': t}
+class VppApiDynamicMethodHolder:
+ pass
- i = 0
- while True:
- unresolved = {}
- for k, v in types.items():
- t = v['data']
- if v['type'] == 'enum':
- try:
- VPPEnumType(t[0], t[1:])
- except ValueError:
- unresolved[k] = v
- elif v['type'] == 'union':
- try:
- VPPUnionType(t[0], t[1:])
- except ValueError:
- unresolved[k] = v
- elif v['type'] == 'type':
- try:
- VPPType(t[0], t[1:])
- except ValueError:
- unresolved[k] = v
- if len(unresolved) == 0:
- break
- if i > 3:
- raise ValueError('Unresolved type definitions {}'
- .format(unresolved))
- types = unresolved
- i += 1
- for m in api['messages']:
- try:
- self.messages[m[0]] = VPPMessage(m[0], m[1:])
- except NotImplementedError:
- self.logger.error('Not implemented error for {}'.format(m[0]))
+class FuncWrapper:
+ def __init__(self, func):
+ self._func = func
+ self.__name__ = func.__name__
+ self.__doc__ = func.__doc__
- def __init__(self, apifiles=None, testmode=False, async_thread=True,
- logger=logging.getLogger('vpp_papi'), loglevel='debug',
- read_timeout=0):
- """Create a VPP API object.
+ def __call__(self, **kwargs):
+ return self._func(**kwargs)
- apifiles is a list of files containing API
- descriptions that will be loaded - methods will be
- dynamically created reflecting these APIs. If not
- provided this will load the API files from VPP's
- default install location.
+ def __repr__(self):
+ return '<FuncWrapper(func=<%s(%s)>)>' % (self.__name__, self.__doc__)
- logger, if supplied, is the logging logger object to log to.
- loglevel, if supplied, is the log level this logger is set
- to report at (from the loglevels in the logging module).
- """
- global vpp_object
- vpp_object = self
- if logger is None:
- logger = logging.getLogger(__name__)
- if loglevel is not None:
- logger.setLevel(loglevel)
- self.logger = logger
-
- self.messages = {}
- self.id_names = []
- self.id_msgdef = []
- self.connected = False
- self.header = VPPType('header', [['u16', 'msgid'],
- ['u32', 'client_index']])
- self.apifiles = []
- self.event_callback = None
- self.message_queue = queue.Queue()
- self.read_timeout = read_timeout
- self.vpp_api = vpp_api
- self.async_thread = async_thread
+class VPPApiError(Exception):
+ pass
- if not apifiles:
- # Pick up API definitions from default directory
- try:
- apifiles = self.find_api_files()
- except RuntimeError:
- # In test mode we don't care that we can't find the API files
- if testmode:
- apifiles = []
- else:
- raise
- for file in apifiles:
- with open(file) as apidef_file:
- self.process_json_file(apidef_file)
+class VPPNotImplementedError(NotImplementedError):
+ pass
- self.apifiles = apifiles
- # Basic sanity check
- if len(self.messages) == 0 and not testmode:
- raise ValueError(1, 'Missing JSON message definitions')
+class VPPIOError(IOError):
+ pass
- # Make sure we allow VPP to clean up the message rings.
- atexit.register(vpp_atexit, weakref.ref(self))
- # Register error handler
- if not testmode:
- vpp_api.vac_set_error_handler(vac_error_handler)
+class VPPRuntimeError(RuntimeError):
+ pass
- # Support legacy CFFI
- # from_buffer supported from 1.8.0
- (major, minor, patch) = [int(s) for s in
- cffi.__version__.split('.', 3)]
- if major >= 1 and minor >= 8:
- self._write = self._write_new_cffi
- else:
- self._write = self._write_legacy_cffi
- class ContextId(object):
- """Thread-safe provider of unique context IDs."""
- def __init__(self):
- self.context = 0
- self.lock = threading.Lock()
+class VPPValueError(ValueError):
+ pass
- def __call__(self):
- """Get a new unique (or, at least, not recently used) context."""
- with self.lock:
- self.context += 1
- return self.context
- get_context = ContextId()
+class VPPApiJSONFiles:
@classmethod
- def find_api_dir(cls):
+ def find_api_dir(cls, dirs):
"""Attempt to find the best directory in which API definition
files may reside. If the value VPP_API_DIR exists in the environment
then it is first on the search list. If we're inside a recognized
:returns: A single directory name, or None if no such directory
could be found.
"""
- dirs = []
-
- if 'VPP_API_DIR' in os.environ:
- dirs.append(os.environ['VPP_API_DIR'])
# perhaps we're in the 'src/scripts' or 'src/vpp-api/python' dir;
# in which case, plot a course to likely places in the src tree
# finally, try the location system packages typically install into
dirs.append(os.path.sep.join(('', 'usr', 'share', 'vpp', 'api')))
- # check the directories for existance; first one wins
+ # check the directories for existence; first one wins
for dir in dirs:
if os.path.isdir(dir):
return dir
return None
@classmethod
- def find_api_files(cls, api_dir=None, patterns='*'):
+ def find_api_files(cls, api_dir=None, patterns='*'): # -> list
"""Find API definition files from the given directory tree with the
given pattern. If no directory is given then find_api_dir() is used
to locate one. If no pattern is given then all definition files found
:returns: A list of file paths for the API files found.
"""
if api_dir is None:
- api_dir = cls.find_api_dir()
+ api_dir = cls.find_api_dir([])
if api_dir is None:
- raise RuntimeError("api_dir cannot be located")
+ raise VPPApiError("api_dir cannot be located")
if isinstance(patterns, list) or isinstance(patterns, tuple):
patterns = [p.strip() + '.api.json' for p in patterns]
return api_files
- def status(self):
- """Debug function: report current VPP API status to stdout."""
- print('Connected') if self.connected else print('Not Connected')
- print('Read API definitions from', ', '.join(self.apifiles))
+ @classmethod
+ def process_json_file(self, apidef_file):
+ api = json.load(apidef_file)
+ return self._process_json(api)
+
+ @classmethod
+ def process_json_str(self, json_str):
+ api = json.loads(json_str)
+ return self._process_json(api)
+
+ @staticmethod
+ def _process_json(api): # -> Tuple[Dict, Dict]
+ types = {}
+ services = {}
+ messages = {}
+ try:
+ for t in api['enums']:
+ t[0] = 'vl_api_' + t[0] + '_t'
+ types[t[0]] = {'type': 'enum', 'data': t}
+ except KeyError:
+ pass
+ try:
+ for t in api['enumflags']:
+ t[0] = 'vl_api_' + t[0] + '_t'
+ types[t[0]] = {'type': 'enum', 'data': t}
+ except KeyError:
+ pass
+ try:
+ for t in api['unions']:
+ t[0] = 'vl_api_' + t[0] + '_t'
+ types[t[0]] = {'type': 'union', 'data': t}
+ except KeyError:
+ pass
+
+ try:
+ for t in api['types']:
+ t[0] = 'vl_api_' + t[0] + '_t'
+ types[t[0]] = {'type': 'type', 'data': t}
+ except KeyError:
+ pass
+
+ try:
+ for t, v in api['aliases'].items():
+ types['vl_api_' + t + '_t'] = {'type': 'alias', 'data': v}
+ except KeyError:
+ pass
+
+ try:
+ services.update(api['services'])
+ except KeyError:
+ pass
+
+ i = 0
+ while True:
+ unresolved = {}
+ for k, v in types.items():
+ t = v['data']
+ if not vpp_get_type(k):
+ if v['type'] == 'enum':
+ try:
+ VPPEnumType(t[0], t[1:])
+ except ValueError:
+ unresolved[k] = v
+ if not vpp_get_type(k):
+ if v['type'] == 'enumflag':
+ try:
+ VPPEnumFlagType(t[0], t[1:])
+ except ValueError:
+ unresolved[k] = v
+ elif v['type'] == 'union':
+ try:
+ VPPUnionType(t[0], t[1:])
+ except ValueError:
+ unresolved[k] = v
+ elif v['type'] == 'type':
+ try:
+ VPPType(t[0], t[1:])
+ except ValueError:
+ unresolved[k] = v
+ elif v['type'] == 'alias':
+ try:
+ VPPTypeAlias(k, t)
+ except ValueError:
+ unresolved[k] = v
+ if len(unresolved) == 0:
+ break
+ if i > 3:
+ raise VPPValueError('Unresolved type definitions {}'
+ .format(unresolved))
+ types = unresolved
+ i += 1
+ try:
+ for m in api['messages']:
+ try:
+ messages[m[0]] = VPPMessage(m[0], m[1:])
+ except VPPNotImplementedError:
+ ### OLE FIXME
+ logger.error('Not implemented error for {}'.format(m[0]))
+ except KeyError:
+ pass
+ return messages, services
+
+
+class VPPApiClient:
+ """VPP interface.
+
+ This class provides the APIs to VPP. The APIs are loaded
+ from provided .api.json files and makes functions accordingly.
+ These functions are documented in the VPP .api files, as they
+ are dynamically created.
+
+ Additionally, VPP can send callback messages; this class
+ provides a means to register a callback function to receive
+ these messages in a background thread.
+ """
+ apidir = None
+ VPPApiError = VPPApiError
+ VPPRuntimeError = VPPRuntimeError
+ VPPValueError = VPPValueError
+ VPPNotImplementedError = VPPNotImplementedError
+ VPPIOError = VPPIOError
+
+
+ def __init__(self, *, apifiles=None, testmode=False, async_thread=True,
+ logger=None, loglevel=None,
+ read_timeout=5, use_socket=True,
+ server_address='/run/vpp/api.sock'):
+ """Create a VPP API object.
+
+ apifiles is a list of files containing API
+ descriptions that will be loaded - methods will be
+ dynamically created reflecting these APIs. If not
+ provided this will load the API files from VPP's
+ default install location.
+
+ logger, if supplied, is the logging logger object to log to.
+ loglevel, if supplied, is the log level this logger is set
+ to report at (from the loglevels in the logging module).
+ """
+ if logger is None:
+ logger = logging.getLogger(
+ "{}.{}".format(__name__, self.__class__.__name__))
+ if loglevel is not None:
+ logger.setLevel(loglevel)
+ self.logger = logger
+
+ self.messages = {}
+ self.services = {}
+ self.id_names = []
+ self.id_msgdef = []
+ self.header = VPPType('header', [['u16', 'msgid'],
+ ['u32', 'client_index']])
+ self.apifiles = []
+ self.event_callback = None
+ self.message_queue = queue.Queue()
+ self.read_timeout = read_timeout
+ self.async_thread = async_thread
+ self.event_thread = None
+ self.testmode = testmode
+ self.server_address = server_address
+ self._apifiles = apifiles
+ self.stats = {}
+
+ if not apifiles:
+ # Pick up API definitions from default directory
+ try:
+ apifiles = VPPApiJSONFiles.find_api_files(self.apidir)
+ except (RuntimeError, VPPApiError):
+ # In test mode we don't care that we can't find the API files
+ if testmode:
+ apifiles = []
+ else:
+ raise VPPRuntimeError
+
+ for file in apifiles:
+ with open(file) as apidef_file:
+ m, s = VPPApiJSONFiles.process_json_file(apidef_file)
+ self.messages.update(m)
+ self.services.update(s)
+
+ self.apifiles = apifiles
+
+ # Basic sanity check
+ if len(self.messages) == 0 and not testmode:
+ raise VPPValueError(1, 'Missing JSON message definitions')
+ if not(verify_enum_hint(VppEnum.vl_api_address_family_t)):
+ raise VPPRuntimeError("Invalid address family hints. "
+ "Cannot continue.")
+
+ self.transport = VppTransport(self, read_timeout=read_timeout,
+ server_address=server_address)
+ # Make sure we allow VPP to clean up the message rings.
+ atexit.register(vpp_atexit, weakref.ref(self))
+
+ add_convenience_methods()
+
+ def get_function(self, name):
+ return getattr(self._api, name)
+
+ class ContextId:
+ """Multiprocessing-safe provider of unique context IDs."""
+ def __init__(self):
+ self.context = mp.Value(ctypes.c_uint, 0)
+ self.lock = mp.Lock()
+
+ def __call__(self):
+ """Get a new unique (or, at least, not recently used) context."""
+ with self.lock:
+ self.context.value += 1
+ return self.context.value
+ get_context = ContextId()
+
+ def get_type(self, name):
+ return vpp_get_type(name)
@property
def api(self):
if not hasattr(self, "_api"):
- raise Exception("Not connected, api definitions not available")
+ raise VPPApiError("Not connected, api definitions not available")
return self._api
- def make_function(self, msg, i, multipart, async):
- if (async):
+ def make_function(self, msg, i, multipart, do_async):
+ if (do_async):
def f(**kwargs):
return self._call_vpp_async(i, msg, **kwargs)
else:
f.__doc__ = ", ".join(["%s %s" %
(msg.fieldtypes[j], k)
for j, k in enumerate(msg.fields)])
+ f.msg = msg
+
return f
- def _register_functions(self, async=False):
+ def _register_functions(self, do_async=False):
self.id_names = [None] * (self.vpp_dictionary_maxid + 1)
self.id_msgdef = [None] * (self.vpp_dictionary_maxid + 1)
self._api = VppApiDynamicMethodHolder()
- for name, msg in vpp_iterator(self.messages):
+ for name, msg in self.messages.items():
n = name + '_' + msg.crc[2:]
- i = vpp_api.vac_get_msg_index(n.encode())
+ i = self.transport.get_msg_index(n)
if i > 0:
self.id_msgdef[i] = msg
self.id_names[i] = name
- # TODO: Fix multipart (use services)
- multipart = True if name.find('_dump') > 0 else False
- f = self.make_function(msg, i, multipart, async)
- setattr(self._api, name, FuncWrapper(f))
+
+ # Create function for client side messages.
+ if name in self.services:
+ f = self.make_function(msg, i, self.services[name], do_async)
+ setattr(self._api, name, FuncWrapper(f))
else:
self.logger.debug(
'No such message type or failed CRC checksum: %s', n)
- def _write_new_cffi(self, buf):
- """Send a binary-packed message to VPP."""
- if not self.connected:
- raise IOError(1, 'Not connected')
- return vpp_api.vac_write(ffi.from_buffer(buf), len(buf))
-
- def _write_legacy_cffi(self, buf):
- """Send a binary-packed message to VPP."""
- if not self.connected:
- raise IOError(1, 'Not connected')
- return vpp_api.vac_write(bytes(buf), len(buf))
-
- def _read(self):
- if not self.connected:
- raise IOError(1, 'Not connected')
- mem = ffi.new("char **")
- size = ffi.new("int *")
- rv = vpp_api.vac_read(mem, size, self.read_timeout)
- if rv:
- raise IOError(rv, 'vac_read failed')
- msg = bytes(ffi.buffer(mem[0], size[0]))
- vpp_api.vac_free(mem[0])
- return msg
-
def connect_internal(self, name, msg_handler, chroot_prefix, rx_qlen,
- async):
- pfx = chroot_prefix.encode() if chroot_prefix else ffi.NULL
- rv = vpp_api.vac_connect(name.encode(), pfx, msg_handler, rx_qlen)
+ do_async):
+ pfx = chroot_prefix.encode('utf-8') if chroot_prefix else None
+
+ rv = self.transport.connect(name, pfx,
+ msg_handler, rx_qlen)
if rv != 0:
- raise IOError(2, 'Connect failed')
- self.connected = True
- self.vpp_dictionary_maxid = vpp_api.vac_msg_table_max_index()
- self._register_functions(async=async)
+ raise VPPIOError(2, 'Connect failed')
+ self.vpp_dictionary_maxid = self.transport.msg_table_max_index()
+ self._register_functions(do_async=do_async)
# Initialise control ping
crc = self.messages['control_ping'].crc
- self.control_ping_index = vpp_api.vac_get_msg_index(
- ('control_ping' + '_' + crc[2:]).encode())
+ self.control_ping_index = self.transport.get_msg_index(
+ ('control_ping' + '_' + crc[2:]))
self.control_ping_msgdef = self.messages['control_ping']
if self.async_thread:
self.event_thread = threading.Thread(
target=self.thread_msg_handler)
self.event_thread.daemon = True
self.event_thread.start()
+ else:
+ self.event_thread = None
return rv
- def connect(self, name, chroot_prefix=None, async=False, rx_qlen=32):
+ def connect(self, name, chroot_prefix=None, do_async=False, rx_qlen=32):
"""Attach to VPP.
name - the name of the client.
chroot_prefix - if VPP is chroot'ed, the prefix of the jail
- async - if true, messages are sent without waiting for a reply
+ do_async - if true, messages are sent without waiting for a reply
rx_qlen - the length of the VPP message receive queue between
client and server.
"""
- msg_handler = vac_callback_sync if not async else vac_callback_async
+ msg_handler = self.transport.get_callback(do_async)
return self.connect_internal(name, msg_handler, chroot_prefix, rx_qlen,
- async)
+ do_async)
def connect_sync(self, name, chroot_prefix=None, rx_qlen=32):
"""Attach to VPP in synchronous mode. Application must poll for events.
client and server.
"""
- return self.connect_internal(name, ffi.NULL, chroot_prefix, rx_qlen,
- async=False)
+ return self.connect_internal(name, None, chroot_prefix, rx_qlen,
+ do_async=False)
def disconnect(self):
"""Detach from VPP."""
- rv = vpp_api.vac_disconnect()
- self.connected = False
- self.message_queue.put("terminate event thread")
+ rv = self.transport.disconnect()
+ if self.event_thread is not None:
+ self.message_queue.put("terminate event thread")
return rv
def msg_handler_sync(self, msg):
# No context -> async notification that we feed to the callback
self.message_queue.put_nowait(r)
else:
- raise IOError(2, 'RPC reply message received in event handler')
+ raise VPPIOError(2, 'RPC reply message received in event handler')
+
+ def has_context(self, msg):
+ if len(msg) < 10:
+ return False
- def decode_incoming_msg(self, msg):
+ header = VPPType('header_with_context', [['u16', 'msgid'],
+ ['u32', 'client_index'],
+ ['u32', 'context']])
+
+ (i, ci, context), size = header.unpack(msg, 0)
+ if self.id_names[i] == 'rx_thread_exit':
+ return
+
+ #
+ # Decode message and returns a tuple.
+ #
+ msgobj = self.id_msgdef[i]
+ if 'context' in msgobj.field_by_name and context >= 0:
+ return True
+ return False
+
+ def decode_incoming_msg(self, msg, no_type_conversion=False):
if not msg:
- self.logger.warning('vpp_api.read failed')
+ logger.warning('vpp_api.read failed')
return
- i, ci = self.header.unpack(msg, 0)
+ (i, ci), size = self.header.unpack(msg, 0)
if self.id_names[i] == 'rx_thread_exit':
return
#
msgobj = self.id_msgdef[i]
if not msgobj:
- raise IOError(2, 'Reply message undefined')
-
- r = msgobj.unpack(msg)
+ raise VPPIOError(2, 'Reply message undefined')
+ r, size = msgobj.unpack(msg, ntc=no_type_conversion)
return r
def msg_handler_async(self, msg):
def validate_args(self, msg, kwargs):
d = set(kwargs.keys()) - set(msg.field_by_name.keys())
if d:
- raise ValueError('Invalid argument {} to {}'
- .format(list(d), msg.name))
+ raise VPPValueError('Invalid argument {} to {}'
+ .format(list(d), msg.name))
- def _call_vpp(self, i, msg, multipart, **kwargs):
+ def _add_stat(self, name, ms):
+ if not name in self.stats:
+ self.stats[name] = {'max': ms, 'count': 1, 'avg': ms}
+ else:
+ if ms > self.stats[name]['max']:
+ self.stats[name]['max'] = ms
+ self.stats[name]['count'] += 1
+ n = self.stats[name]['count']
+ self.stats[name]['avg'] = self.stats[name]['avg'] * (n - 1) / n + ms / n
+
+ def get_stats(self):
+ s = '\n=== API PAPI STATISTICS ===\n'
+ s += '{:<30} {:>4} {:>6} {:>6}\n'.format('message', 'cnt', 'avg', 'max')
+ for n in sorted(self.stats.items(), key=lambda v: v[1]['avg'], reverse=True):
+ s += '{:<30} {:>4} {:>6.2f} {:>6.2f}\n'.format(n[0], n[1]['count'],
+ n[1]['avg'], n[1]['max'])
+ return s
+
+ def get_field_options(self, msg, fld_name):
+ # when there is an option, the msgdef has 3 elements.
+ # ['u32', 'ring_size', {'default': 1024}]
+ for _def in self.messages[msg].msgdef:
+ if isinstance(_def, list) and \
+ len(_def) == 3 and \
+ _def[1] == fld_name:
+ return _def[2]
+
+ def _call_vpp(self, i, msgdef, service, **kwargs):
"""Given a message, send the message and await a reply.
msgdef - the message packing definition
the response. It will raise an IOError exception if there was
no response within the timeout window.
"""
-
+ ts = time.time()
if 'context' not in kwargs:
context = self.get_context()
kwargs['context'] = context
context = kwargs['context']
kwargs['_vl_msg_id'] = i
- self.validate_args(msg, kwargs)
- b = msg.pack(kwargs)
- vpp_api.vac_rx_suspend()
- self._write(b)
+ no_type_conversion = kwargs.pop('_no_type_conversion', False)
+ timeout = kwargs.pop('_timeout', None)
+
+ try:
+ if self.transport.socket_index:
+ kwargs['client_index'] = self.transport.socket_index
+ except AttributeError:
+ pass
+ self.validate_args(msgdef, kwargs)
- if multipart:
- # Send a ping after the request - we use its response
- # to detect that we have seen all results.
- self._control_ping(context)
+ s = 'Calling {}({})'.format(msgdef.name,
+ ','.join(['{!r}:{!r}'.format(k, v) for k, v in kwargs.items()]))
+ self.logger.debug(s)
+
+ b = msgdef.pack(kwargs)
+ self.transport.suspend()
+
+ self.transport.write(b)
+
+ msgreply = service['reply']
+ stream = True if 'stream' in service else False
+ if stream:
+ if 'stream_msg' in service:
+ # New service['reply'] = _reply and service['stream_message'] = _details
+ stream_message = service['stream_msg']
+ modern =True
+ else:
+ # Old service['reply'] = _details
+ stream_message = msgreply
+ msgreply = 'control_ping_reply'
+ modern = False
+ # Send a ping after the request - we use its response
+ # to detect that we have seen all results.
+ self._control_ping(context)
# Block until we get a reply.
rl = []
while (True):
- msg = self._read()
- if not msg:
- raise IOError(2, 'VPP API client: read failed')
- r = self.decode_incoming_msg(msg)
+ r = self.read_blocking(no_type_conversion, timeout)
+ if r is None:
+ raise VPPIOError(2, 'VPP API client: read failed')
msgname = type(r).__name__
if context not in r or r.context == 0 or context != r.context:
+ # Message being queued
self.message_queue.put_nowait(r)
continue
-
- if not multipart:
+ if msgname != msgreply and (stream and (msgname != stream_message)):
+ print('REPLY MISMATCH', msgreply, msgname, stream_message, stream)
+ if not stream:
rl = r
break
- if msgname == 'control_ping_reply':
+ if msgname == msgreply:
+ if modern: # Return both reply and list
+ rl = r, rl
break
rl.append(r)
- vpp_api.vac_rx_resume()
+ self.transport.resume()
+ s = 'Return value: {!r}'.format(r)
+ if len(s) > 80:
+ s = s[:80] + "..."
+ self.logger.debug(s)
+ te = time.time()
+ self._add_stat(msgdef.name, (te - ts) * 1000)
return rl
def _call_vpp_async(self, i, msg, **kwargs):
- """Given a message, send the message and await a reply.
+ """Given a message, send the message and return the context.
msgdef - the message packing definition
i - the message type index
context - context number - chosen at random if not
supplied.
The remainder of the kwargs are the arguments to the API call.
+
+ The reply message(s) will be delivered later to the registered callback.
+ The returned context will help with assigning which call
+ the reply belongs to.
"""
if 'context' not in kwargs:
context = self.get_context()
kwargs['context'] = context
else:
context = kwargs['context']
- kwargs['client_index'] = 0
+ try:
+ if self.transport.socket_index:
+ kwargs['client_index'] = self.transport.socket_index
+ except AttributeError:
+ kwargs['client_index'] = 0
kwargs['_vl_msg_id'] = i
b = msg.pack(kwargs)
- self._write(b)
+ self.transport.write(b)
+ return context
+
+ def read_blocking(self, no_type_conversion=False, timeout=None):
+ """Get next received message from transport within timeout, decoded.
+
+ Note that notifications have context zero
+ and are not put into receive queue (at least for socket transport),
+ use async_thread with registered callback for processing them.
+
+ If no message appears in the queue within timeout, return None.
+
+ Optionally, type conversion can be skipped,
+ as some of conversions are into less precise types.
+
+ When r is the return value of this, the caller can get message name as:
+ msgname = type(r).__name__
+ and context number (type long) as:
+ context = r.context
+
+ :param no_type_conversion: If false, type conversions are applied.
+ :type no_type_conversion: bool
+ :returns: Decoded message, or None if no message (within timeout).
+ :rtype: Whatever VPPType.unpack returns, depends on no_type_conversion.
+ :raises VppTransportShmemIOError if timed out.
+ """
+ msg = self.transport.read(timeout=timeout)
+ if not msg:
+ return None
+ return self.decode_incoming_msg(msg, no_type_conversion)
def register_event_callback(self, callback):
"""Register a callback for async messages.
self.event_callback = callback
def thread_msg_handler(self):
- """Python thread calling the user registerd message handler.
+ """Python thread calling the user registered message handler.
This is to emulate the old style event callback scheme. Modern
clients should provide their own thread to poll the event
if self.event_callback:
self.event_callback(msgname, r)
-
-# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
+ def validate_message_table(self, namecrctable):
+ """Take a dictionary of name_crc message names
+ and returns an array of missing messages"""
+
+ missing_table = []
+ for name_crc in namecrctable:
+ i = self.transport.get_msg_index(name_crc)
+ if i <= 0:
+ missing_table.append(name_crc)
+ return missing_table
+
+ def dump_message_table(self):
+ """Return VPPs API message table as name_crc dictionary"""
+ return self.transport.message_table
+
+ def dump_message_table_filtered(self, msglist):
+ """Return VPPs API message table as name_crc dictionary,
+ filtered by message name list."""
+
+ replies = [self.services[n]['reply'] for n in msglist]
+ message_table_filtered = {}
+ for name in msglist + replies:
+ for k,v in self.transport.message_table.items():
+ if k.startswith(name):
+ message_table_filtered[k] = v
+ break
+ return message_table_filtered
+
+ def __repr__(self):
+ return "<VPPApiClient apifiles=%s, testmode=%s, async_thread=%s, " \
+ "logger=%s, read_timeout=%s, " \
+ "server_address='%s'>" % (
+ self._apifiles, self.testmode, self.async_thread,
+ self.logger, self.read_timeout, self.server_address)
+
+ def details_iter(self, f, **kwargs):
+ cursor = 0
+ while True:
+ kwargs['cursor'] = cursor
+ rv, details = f(**kwargs)
+ for d in details:
+ yield d
+ if rv.retval == 0 or rv.retval != -165:
+ break
+ cursor = rv.cursor