-#!/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 . vpp_serializer import VPPType, VPPEnumType, VPPUnionType, BaseTypes
+from . vpp_serializer import VPPType, VPPEnumType, VPPUnionType
from . vpp_serializer import VPPMessage, vpp_get_type, VPPTypeAlias
-from . vpp_format import VPPFormat
if sys.version[0] == '2':
import Queue as queue
else:
import queue as queue
+__all__ = ('FuncWrapper', 'VPP', 'VppApiDynamicMethodHolder',
+ 'VppEnum', 'VppEnumType',
+ 'VPPIOError', 'VPPRuntimeError', 'VPPValueError',
+ 'VPPApiClient', )
+
+
+def metaclass(metaclass):
+ @functools.wraps(metaclass)
+ def wrapper(cls):
+ return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
+
+ return wrapper
+
class VppEnumType(type):
def __getattr__(cls, name):
return t.enum
-# Python3
-# class VppEnum(metaclass=VppEnumType):
-# pass
+@metaclass(VppEnumType)
class VppEnum(object):
- __metaclass__ = VppEnumType
+ pass
def vpp_atexit(vpp_weakref):
vpp_instance.disconnect()
-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()
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 VPPApiError(Exception):
pass
class VPPValueError(ValueError):
pass
+class VPPApiJSONFiles(object):
+ @classmethod
+ 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
+ location in a VPP source tree (src/scripts and src/vpp-api/python)
+ then entries from there to the likely locations in build-root are
+ added. Finally the location used by system packages is added.
-class VPP(object):
- """VPP interface.
+ :returns: A single directory name, or None if no such directory
+ could be found.
+ """
- 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.
+ # 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
+ import __main__ as main
+ if hasattr(main, '__file__'):
+ # get the path of the calling script
+ localdir = os.path.dirname(os.path.realpath(main.__file__))
+ else:
+ # use cwd if there is no calling script
+ localdir = os.getcwd()
+ localdir_s = localdir.split(os.path.sep)
- Additionally, VPP can send callback messages; this class
- provides a means to register a callback function to receive
- these messages in a background thread.
- """
- VPPApiError = VPPApiError
- VPPRuntimeError = VPPRuntimeError
- VPPValueError = VPPValueError
- VPPNotImplementedError = VPPNotImplementedError
- VPPIOError = VPPIOError
+ def dmatch(dir):
+ """Match dir against right-hand components of the script dir"""
+ d = dir.split('/') # param 'dir' assumes a / separator
+ length = len(d)
+ return len(localdir_s) > length and localdir_s[-length:] == d
+
+ def sdir(srcdir, variant):
+ """Build a path from srcdir to the staged API files of
+ 'variant' (typically '' or '_debug')"""
+ # Since 'core' and 'plugin' files are staged
+ # in separate directories, we target the parent dir.
+ return os.path.sep.join((
+ srcdir,
+ 'build-root',
+ 'install-vpp%s-native' % variant,
+ 'vpp',
+ 'share',
+ 'vpp',
+ 'api',
+ ))
+
+ srcdir = None
+ if dmatch('src/scripts'):
+ srcdir = os.path.sep.join(localdir_s[:-2])
+ elif dmatch('src/vpp-api/python'):
+ srcdir = os.path.sep.join(localdir_s[:-3])
+ elif dmatch('test'):
+ # we're apparently running tests
+ srcdir = os.path.sep.join(localdir_s[:-1])
+
+ if srcdir:
+ # we're in the source tree, try both the debug and release
+ # variants.
+ dirs.append(sdir(srcdir, '_debug'))
+ dirs.append(sdir(srcdir, ''))
+ # Test for staged copies of the scripts
+ # For these, since we explicitly know if we're running a debug versus
+ # release variant, target only the relevant directory
+ if dmatch('build-root/install-vpp_debug-native/vpp/bin'):
+ srcdir = os.path.sep.join(localdir_s[:-4])
+ dirs.append(sdir(srcdir, '_debug'))
+ if dmatch('build-root/install-vpp-native/vpp/bin'):
+ srcdir = os.path.sep.join(localdir_s[:-4])
+ dirs.append(sdir(srcdir, ''))
+
+ # finally, try the location system packages typically install into
+ dirs.append(os.path.sep.join(('', 'usr', 'share', 'vpp', 'api')))
+
+ # 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='*'):
+ """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
+ in the directory tree are used.
+
+ :param api_dir: A directory tree in which to locate API definition
+ files; subdirectories are descended into.
+ If this is None then find_api_dir() is called to discover it.
+ :param patterns: A list of patterns to use in each visited directory
+ when looking for files.
+ This can be a list/tuple object or a comma-separated string of
+ patterns. Each value in the list will have leading/trialing
+ whitespace stripped.
+ The pattern specifies the first part of the filename, '.api.json'
+ is appended.
+ The results are de-duplicated, thus overlapping patterns are fine.
+ If this is None it defaults to '*' meaning "all API files".
+ :returns: A list of file paths for the API files found.
+ """
+ if api_dir is None:
+ api_dir = cls.find_api_dir([])
+ if api_dir is None:
+ raise VPPApiError("api_dir cannot be located")
+
+ if isinstance(patterns, list) or isinstance(patterns, tuple):
+ patterns = [p.strip() + '.api.json' for p in patterns]
+ else:
+ patterns = [p.strip() + '.api.json' for p in patterns.split(",")]
+
+ api_files = []
+ for root, dirnames, files in os.walk(api_dir):
+ # iterate all given patterns and de-dup the result
+ files = set(sum([fnmatch.filter(files, p) for p in patterns], []))
+ for filename in files:
+ api_files.append(os.path.join(root, filename))
+
+ return api_files
+
+ @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}
types[t[0]] = {'type': 'type', 'data': t}
for t, v in api['aliases'].items():
types['vl_api_' + t + '_t'] = {'type': 'alias', 'data': v}
- self.services.update(api['services'])
+ services.update(api['services'])
i = 0
while True:
for m in api['messages']:
try:
- self.messages[m[0]] = VPPMessage(m[0], m[1:])
+ 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'):
+ server_address='/run/vpp/api.sock'):
"""Create a VPP API object.
apifiles is a list of files containing API
to report at (from the loglevels in the logging module).
"""
if logger is None:
- logger = logging.getLogger(__name__)
+ logger = logging.getLogger(
+ "{}.{}".format(__name__, self.__class__.__name__))
if loglevel is not None:
logger.setLevel(loglevel)
self.logger = logger
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
if not apifiles:
# Pick up API definitions from default directory
try:
- apifiles = self.find_api_files()
+ 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:
for file in apifiles:
with open(file) as apidef_file:
- self.process_json_file(apidef_file)
+ m, s = VPPApiJSONFiles.process_json_file(apidef_file)
+ self.messages.update(m)
+ self.services.update(s)
self.apifiles = apifiles
# 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):
- """Thread-safe provider of unique context IDs."""
+ """Multiprocessing-safe provider of unique context IDs."""
def __init__(self):
- self.context = 0
- self.lock = threading.Lock()
+ 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 += 1
- return self.context
+ self.context.value += 1
+ return self.context.value
get_context = ContextId()
def get_type(self, name):
return vpp_get_type(name)
- @classmethod
- def find_api_dir(cls):
- """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
- location in a VPP source tree (src/scripts and src/vpp-api/python)
- then entries from there to the likely locations in build-root are
- added. Finally the location used by system packages is added.
-
- :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
- import __main__ as main
- if hasattr(main, '__file__'):
- # get the path of the calling script
- localdir = os.path.dirname(os.path.realpath(main.__file__))
- else:
- # use cwd if there is no calling script
- localdir = os.getcwd()
- localdir_s = localdir.split(os.path.sep)
-
- def dmatch(dir):
- """Match dir against right-hand components of the script dir"""
- d = dir.split('/') # param 'dir' assumes a / separator
- length = len(d)
- return len(localdir_s) > length and localdir_s[-length:] == d
-
- def sdir(srcdir, variant):
- """Build a path from srcdir to the staged API files of
- 'variant' (typically '' or '_debug')"""
- # Since 'core' and 'plugin' files are staged
- # in separate directories, we target the parent dir.
- return os.path.sep.join((
- srcdir,
- 'build-root',
- 'install-vpp%s-native' % variant,
- 'vpp',
- 'share',
- 'vpp',
- 'api',
- ))
-
- srcdir = None
- if dmatch('src/scripts'):
- srcdir = os.path.sep.join(localdir_s[:-2])
- elif dmatch('src/vpp-api/python'):
- srcdir = os.path.sep.join(localdir_s[:-3])
- elif dmatch('test'):
- # we're apparently running tests
- srcdir = os.path.sep.join(localdir_s[:-1])
-
- if srcdir:
- # we're in the source tree, try both the debug and release
- # variants.
- dirs.append(sdir(srcdir, '_debug'))
- dirs.append(sdir(srcdir, ''))
-
- # Test for staged copies of the scripts
- # For these, since we explicitly know if we're running a debug versus
- # release variant, target only the relevant directory
- if dmatch('build-root/install-vpp_debug-native/vpp/bin'):
- srcdir = os.path.sep.join(localdir_s[:-4])
- dirs.append(sdir(srcdir, '_debug'))
- if dmatch('build-root/install-vpp-native/vpp/bin'):
- srcdir = os.path.sep.join(localdir_s[:-4])
- dirs.append(sdir(srcdir, ''))
-
- # 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
- for dir in dirs:
- if os.path.isdir(dir):
- return dir
-
- return None
-
- @classmethod
- def find_api_files(cls, api_dir=None, patterns='*'):
- """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
- in the directory tree are used.
-
- :param api_dir: A directory tree in which to locate API definition
- files; subdirectories are descended into.
- If this is None then find_api_dir() is called to discover it.
- :param patterns: A list of patterns to use in each visited directory
- when looking for files.
- This can be a list/tuple object or a comma-separated string of
- patterns. Each value in the list will have leading/trialing
- whitespace stripped.
- The pattern specifies the first part of the filename, '.api.json'
- is appended.
- The results are de-duplicated, thus overlapping patterns are fine.
- If this is None it defaults to '*' meaning "all API files".
- :returns: A list of file paths for the API files found.
- """
- if api_dir is None:
- api_dir = cls.find_api_dir()
- if api_dir is None:
- raise VPPApiError("api_dir cannot be located")
-
- if isinstance(patterns, list) or isinstance(patterns, tuple):
- patterns = [p.strip() + '.api.json' for p in patterns]
- else:
- patterns = [p.strip() + '.api.json' for p in patterns.split(",")]
-
- api_files = []
- for root, dirnames, files in os.walk(api_dir):
- # iterate all given patterns and de-dup the result
- files = set(sum([fnmatch.filter(files, p) for p in patterns], []))
- for filename in files:
- api_files.append(os.path.join(root, filename))
-
- return api_files
-
@property
def api(self):
if not hasattr(self, "_api"):
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, do_async=False):
self._api = VppApiDynamicMethodHolder()
for name, msg in vpp_iterator(self.messages):
n = name + '_' + msg.crc[2:]
- i = self.transport.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
# Create function for client side messages.
if name in self.services:
- if 'stream' in self.services[name] and self.services[name]['stream']:
+ if 'stream' in self.services[name] and \
+ self.services[name]['stream']:
multipart = True
else:
multipart = False
def connect_internal(self, name, msg_handler, chroot_prefix, rx_qlen,
do_async):
- pfx = chroot_prefix.encode() if chroot_prefix else None
+ pfx = chroot_prefix.encode('utf-8') if chroot_prefix else None
- rv = self.transport.connect(name.encode(), pfx, msg_handler, rx_qlen)
+ rv = self.transport.connect(name, pfx,
+ msg_handler, rx_qlen)
if rv != 0:
raise VPPIOError(2, 'Connect failed')
self.vpp_dictionary_maxid = self.transport.msg_table_max_index()
# Initialise control ping
crc = self.messages['control_ping'].crc
self.control_ping_index = self.transport.get_msg_index(
- ('control_ping' + '_' + crc[2:]).encode())
+ ('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, do_async=False, rx_qlen=32):
def disconnect(self):
"""Detach from VPP."""
rv = self.transport.disconnect()
- self.message_queue.put("terminate event thread")
+ if self.event_thread is not None:
+ self.message_queue.put("terminate event thread")
return rv
def msg_handler_sync(self, msg):
else:
raise VPPIOError(2, 'RPC reply message received in event handler')
- def decode_incoming_msg(self, msg):
+ 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, no_type_conversion=False):
if not msg:
self.logger.warning('vpp_api.read failed')
return
+
(i, ci), size = self.header.unpack(msg, 0)
if self.id_names[i] == 'rx_thread_exit':
return
if not msgobj:
raise VPPIOError(2, 'Reply message undefined')
- r, size = msgobj.unpack(msg)
+ r, size = msgobj.unpack(msg, ntc=no_type_conversion)
return r
def msg_handler_async(self, msg):
d = set(kwargs.keys()) - set(msg.field_by_name.keys())
if d:
raise VPPValueError('Invalid argument {} to {}'
- .format(list(d), msg.name))
+ .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
+ 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(msg, kwargs)
- b = msg.pack(kwargs)
+ 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)
# Block until we get a reply.
rl = []
while (True):
- msg = self.transport.read()
- if not msg:
+ r = self.read_blocking(no_type_conversion)
+ if r is None:
raise VPPIOError(2, 'VPP API client: read failed')
- r = self.decode_incoming_msg(msg)
msgname = type(r).__name__
if context not in r or r.context == 0 or context != r.context:
# Message being queued
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()
b = msg.pack(kwargs)
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.
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