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 . macaddress import MACAddress, mac_pton, mac_ntop
-
-logger = logging.getLogger(__name__)
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)
return d.items()
-def call_logger(msgdef, kwargs):
- s = 'Calling {}('.format(msgdef.name)
- for k, v in kwargs.items():
- s += '{}:{} '.format(k, v)
- s += ')'
- return s
-
-
-def return_logger(r):
- s = 'Return from {}'.format(r)
- return s
-
-
class VppApiDynamicMethodHolder(object):
pass
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 VPPApiClient(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.
- """
- apidir = None
- 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
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):
"""Multiprocessing-safe provider of unique context IDs."""
def __init__(self):
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 = [cls.apidir] if cls.apidir else []
-
- # 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 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
-
@property
def api(self):
if not hasattr(self, "_api"):
pass
self.validate_args(msgdef, kwargs)
- logging.debug(call_logger(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.resume()
- logger.debug(return_logger(rl))
+ self.logger.debug('Return from {!r}'.format(r))
return rl
def _call_vpp_async(self, i, msg, **kwargs):