X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvpp-api%2Fpython%2Fvpp_papi%2Fvpp_papi.py;h=b4d4686183249e4c61480a845be2f2dbaa7f1698;hb=3825d93af;hp=2b73023025b25c79b2beb307c9906fc86a6fd3ec;hpb=5fced04ba58a14c370c60c275302519de5e15893;p=vpp.git diff --git a/src/vpp-api/python/vpp_papi/vpp_papi.py b/src/vpp-api/python/vpp_papi/vpp_papi.py index 2b73023025b..b4d46861832 100644 --- a/src/vpp-api/python/vpp_papi/vpp_papi.py +++ b/src/vpp-api/python/vpp_papi/vpp_papi.py @@ -1,4 +1,4 @@ -#!/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"); @@ -16,27 +16,41 @@ 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 . vpp_serializer import VPPType, VPPEnumType, VPPUnionType, BaseTypes +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 -from . macaddress import MACAddress, mac_pton, mac_ntop -logger = logging.getLogger(__name__) +try: + import VppTransport +except ModuleNotFoundError: + class V: + """placeholder for VppTransport as the implementation is dependent on + VPPAPIClient's initialization values + """ + + VppTransport = V + +logger = logging.getLogger('vpp_papi') +logger.addHandler(logging.NullHandler()) -if sys.version[0] == '2': - import Queue as queue -else: - import queue as queue +__all__ = ('FuncWrapper', 'VPP', 'VppApiDynamicMethodHolder', + 'VppEnum', 'VppEnumType', 'VppEnumFlag', + 'VPPIOError', 'VPPRuntimeError', 'VPPValueError', + 'VPPApiClient', ) def metaclass(metaclass): @@ -54,7 +68,12 @@ class VppEnumType(type): @metaclass(VppEnumType) -class VppEnum(object): +class VppEnum: + pass + + +@metaclass(VppEnumType) +class VppEnumFlag: pass @@ -62,43 +81,46 @@ def vpp_atexit(vpp_weakref): """Clean up VPP connection on shutdown.""" vpp_instance = vpp_weakref() if vpp_instance and vpp_instance.transport.connected: - vpp_instance.logger.debug('Cleaning up VPP on exit') + logger.debug('Cleaning up VPP on exit') vpp_instance.disconnect() -if sys.version[0] == '2': - def vpp_iterator(d): - return d.iteritems() -else: - def vpp_iterator(d): - return d.items() - +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.") -def call_logger(msgdef, kwargs): - s = 'Calling {}('.format(msgdef.name) - for k, v in kwargs.items(): - s += '{}:{} '.format(k, v) - s += ')' - return s + def _vapi_af_name(self): + if 6 == self._version: + return 'ip6' + if 4 == self._version: + return 'ip4' + raise ValueError("Invalid _version.") + ipaddress._IPAddressBase.vapi_af = property(_vapi_af) + ipaddress._IPAddressBase.vapi_af_name = property(_vapi_af_name) -def return_logger(r): - s = 'Return from {}'.format(r) - return s - -class VppApiDynamicMethodHolder(object): +class VppApiDynamicMethodHolder: pass -class FuncWrapper(object): +class FuncWrapper: 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 ')>' % (self.__name__, self.__doc__) + class VPPApiError(Exception): pass @@ -120,163 +142,9 @@ class VPPValueError(ValueError): pass -class VPP(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. - """ - VPPApiError = VPPApiError - VPPRuntimeError = VPPRuntimeError - VPPValueError = VPPValueError - VPPNotImplementedError = VPPNotImplementedError - VPPIOError = VPPIOError - - 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} - for t, v in api['aliases'].items(): - types['vl_api_' + t + '_t'] = {'type': 'alias', 'data': v} - self.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: - self.messages[m[0]] = VPPMessage(m[0], m[1:]) - except VPPNotImplementedError: - self.logger.error('Not implemented error for {}'.format(m[0])) - - 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(__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 - - 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 = 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 VPPRuntimeError - - for file in apifiles: - with open(file) as apidef_file: - self.process_json_file(apidef_file) - - 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)) - - 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() - - def get_type(self, name): - return vpp_get_type(name) - +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 @@ -287,10 +155,6 @@ class VPP(object): :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 @@ -352,7 +216,7 @@ class VPP(object): # 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 @@ -360,7 +224,7 @@ class VPP(object): 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 @@ -381,7 +245,7 @@ class VPP(object): :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 VPPApiError("api_dir cannot be located") @@ -399,6 +263,227 @@ class VPP(object): return api_files + @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=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 + self.stats = {} + + 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, 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"): @@ -417,27 +502,24 @@ class VPP(object): 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.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 = 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']: - multipart = True - else: - multipart = False - f = self.make_function(msg, i, multipart, do_async) + f = self.make_function(msg, i, self.services[name], do_async) setattr(self._api, name, FuncWrapper(f)) else: self.logger.debug( @@ -445,9 +527,10 @@ class VPP(object): 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() @@ -456,13 +539,15 @@ class VPP(object): # 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): @@ -493,7 +578,8 @@ class VPP(object): 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): @@ -539,7 +625,7 @@ class VPP(object): 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), size = self.header.unpack(msg, 0) @@ -582,7 +668,25 @@ class VPP(object): raise VPPValueError('Invalid argument {} to {}' .format(list(d), msg.name)) - def _call_vpp(self, i, msgdef, 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 _call_vpp(self, i, msgdef, service, **kwargs): """Given a message, send the message and await a reply. msgdef - the message packing definition @@ -597,7 +701,7 @@ class VPP(object): 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 @@ -606,6 +710,7 @@ class VPP(object): kwargs['_vl_msg_id'] = i no_type_conversion = kwargs.pop('_no_type_conversion', False) + timeout = kwargs.pop('_timeout', None) try: if self.transport.socket_index: @@ -614,52 +719,76 @@ class VPP(object): 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.write(b) - if multipart: - # Send a ping after the request - we use its response - # to detect that we have seen all results. - self._control_ping(context) + 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.transport.read() - if not msg: + r = self.read_blocking(no_type_conversion, timeout) + if r is None: raise VPPIOError(2, 'VPP API client: read failed') - r = self.decode_incoming_msg(msg, no_type_conversion) 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) self.transport.resume() - logger.debug(return_logger(rl)) + 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() @@ -675,6 +804,35 @@ class VPP(object): b = msg.pack(kwargs) 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. @@ -709,5 +867,57 @@ class VPP(object): if self.event_callback: self.event_callback(msgname, r) + 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 "" % ( + self._apifiles, self.testmode, self.async_thread, + self.logger, self.read_timeout, self.use_socket, + self.server_address) + + def details_iter(self, f, **kwargs): + cursor = 0 + while True: + kwargs['cursor'] = cursor + rv, details = f(**kwargs) + # + # Convert to yield from details when we only support python 3 + # + for d in details: + yield d + if rv.retval == 0 or rv.retval != -165: + break + cursor = rv.cursor + +# Provide the old name for backward compatibility. +VPP = VPPApiClient # vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4