-#!/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 sys
+import multiprocessing as mp
import os
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
+from . vpp_serializer import VPPType, VPPEnumType, VPPUnionType
+from . vpp_serializer import VPPMessage, vpp_get_type, VPPTypeAlias
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);
+__all__ = ('FuncWrapper', 'VPP', 'VppApiDynamicMethodHolder',
+ 'VppEnum', 'VppEnumType',
+ 'VPPIOError', 'VPPRuntimeError', 'VPPValueError',
+ 'VPPApiClient', )
-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);
- """)
+def metaclass(metaclass):
+ @functools.wraps(metaclass)
+ def wrapper(cls):
+ return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
-# Barfs on failure, no need to check success.
-vpp_api = ffi.dlopen('libvppapiclient.so')
+ return wrapper
+
+
+class VppEnumType(type):
+ def __getattr__(cls, name):
+ t = vpp_get_type(name)
+ return t.enum
+
+
+@metaclass(VppEnumType)
+class VppEnum(object):
+ pass
def vpp_atexit(vpp_weakref):
"""Clean up VPP connection on shutdown."""
vpp_instance = vpp_weakref()
- if vpp_instance.connected:
+ if vpp_instance and vpp_instance.transport.connected:
vpp_instance.logger.debug('Cleaning up VPP on exit')
vpp_instance.disconnect()
-vpp_object = None
-
-
-def vpp_iterator(d):
- if sys.version[0] == '2':
+if sys.version[0] == '2':
+ def vpp_iterator(d):
return d.iteritems()
- else:
+else:
+ def vpp_iterator(d):
return d.items()
-@ffi.callback("void(unsigned char *, int)")
-def vac_callback_sync(data, len):
- vpp_object.msg_handler_sync(ffi.buffer(data, len))
-
-
-@ffi.callback("void(unsigned char *, int)")
-def vac_callback_async(data, len):
- vpp_object.msg_handler_async(ffi.buffer(data, len))
-
-
-@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))
-
-
class VppApiDynamicMethodHolder(object):
pass
def __init__(self, func):
self._func = func
self.__name__ = func.__name__
+ self.__doc__ = func.__doc__
def __call__(self, **kwargs):
return self._func(**kwargs)
+ def __repr__(self):
+ return '<FuncWrapper(func=<%s(%s)>)>' % (self.__name__, self.__doc__)
-class VPP():
- """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.
- """
-
- 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}
-
- 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]))
-
- 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.
-
- 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).
- """
- 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
-
- 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
+class VPPApiError(Exception):
+ pass
- for file in apifiles:
- with open(file) as apidef_file:
- self.process_json_file(apidef_file)
- self.apifiles = apifiles
+class VPPNotImplementedError(NotImplementedError):
+ pass
- # Basic sanity check
- if len(self.messages) == 0 and not testmode:
- raise ValueError(1, 'Missing JSON message definitions')
- # Make sure we allow VPP to clean up the message rings.
- atexit.register(vpp_atexit, weakref.ref(self))
+class VPPIOError(IOError):
+ pass
- # Register error handler
- if not testmode:
- vpp_api.vac_set_error_handler(vac_error_handler)
- # 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 VPPRuntimeError(RuntimeError):
+ pass
- class ContextId(object):
- """Thread-safe provider of unique context IDs."""
- def __init__(self):
- self.context = 0
- self.lock = threading.Lock()
- 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 VPPValueError(ValueError):
+ pass
+class VPPApiJSONFiles(object):
@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
: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)
+ types = {}
+ services = {}
+ messages = {}
+ 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}
+ for t, v in api['aliases'].items():
+ types['vl_api_' + t + '_t'] = {'type': 'alias', 'data': v}
+ services.update(api['services'])
+
+ 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
+ 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
+
+ for m in api['messages']:
+ try:
+ messages[m[0]] = VPPMessage(m[0], m[1:])
+ except VPPNotImplementedError:
+ ### OLE FIXME
+ self.logger.error('Not implemented error for {}'.format(m[0]))
+ return messages, services
+
+class VPPApiClient(object):
+ """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=False,
+ 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.use_socket = use_socket
+ self.server_address = server_address
+ self._apifiles = apifiles
+
+ if use_socket:
+ from . vpp_transport_socket import VppTransport
+ else:
+ from . vpp_transport_shmem import VppTransport
+
+ if not apifiles:
+ # Pick up API definitions from default directory
+ try:
+ apifiles = VPPApiJSONFiles.find_api_files(self.apidir)
+ except RuntimeError:
+ # 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')
+
+ 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))
+
+ def get_function(self, name):
+ return getattr(self._api, name)
+
+
+ class ContextId(object):
+ """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):
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:
+ if 'stream' in self.services[name] and \
+ self.services[name]['stream']:
+ multipart = True
+ else:
+ multipart = False
+ f = self.make_function(msg, i, multipart, 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
+
+ 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):
+ def decode_incoming_msg(self, msg, no_type_conversion=False):
if not msg:
self.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 _call_vpp(self, i, msgdef, multipart, **kwargs):
"""Given a message, send the message and await a reply.
msgdef - the message packing definition
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)
+
+ try:
+ if self.transport.socket_index:
+ kwargs['client_index'] = self.transport.socket_index
+ except AttributeError:
+ pass
+ self.validate_args(msgdef, kwargs)
+
+ 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)
if multipart:
# Send a ping after the request - we use its response
# 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)
+ 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
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)
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):
+ """Get next received message from transport within timeout, decoded.
+
+ Note that noticifations 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.
+ """
+ msg = self.transport.read()
+ 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)
+ def __repr__(self):
+ return "<VPPApiClient apifiles=%s, testmode=%s, async_thread=%s, " \
+ "logger=%s, read_timeout=%s, use_socket=%s, " \
+ "server_address='%s'>" % (
+ self._apifiles, self.testmode, self.async_thread,
+ self.logger, self.read_timeout, self.use_socket,
+ self.server_address)
+
+
+# Provide the old name for backward compatibility.
+VPP = VPPApiClient
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4