src/vpp-api/python/vpp_papi/vpp_transport_shmem.py

   1 #
   2 # A transport class. With two implementations.
   3 # One for socket and one for shared memory.
   4 #
   5 import logging
   6
   7 from cffi import FFI
   8 import cffi
   9
  10 logger = logging.getLogger('vpp_papi.transport')
  11 logger.addHandler(logging.NullHandler())
  12
  13 ffi = FFI()
  14 ffi.cdef("""
  15 typedef void (*vac_callback_t)(unsigned char * data, int len);
  16 typedef void (*vac_error_callback_t)(void *, unsigned char *, int);
  17 int vac_connect(char * name, char * chroot_prefix, vac_callback_t cb,
  18     int rx_qlen);
  19 int vac_disconnect(void);
  20 int vac_read(char **data, int *l, unsigned short timeout);
  21 int vac_write(char *data, int len);
  22 void vac_free(void * msg);
  23
  24 int vac_get_msg_index(unsigned char * name);
  25 int vac_msg_table_size(void);
  26 int vac_msg_table_max_index(void);
  27
  28 void vac_rx_suspend (void);
  29 void vac_rx_resume (void);
  30 void vac_set_error_handler(vac_error_callback_t);
  31 void vac_mem_init (size_t size);
  32 """)
  33
  34 vpp_object = None
  35
  36 # allow file to be imported so it can be mocked in tests.
  37 # If the shared library fails, VppTransport cannot be initialized.
  38 try:
  39     vpp_api = ffi.dlopen('libvppapiclient.so')
  40 except OSError:
  41     vpp_api = None
  42
  43
  44 @ffi.callback("void(unsigned char *, int)")
  45 def vac_callback_sync(data, len):
  46     vpp_object.msg_handler_sync(ffi.buffer(data, len))
  47
  48
  49 @ffi.callback("void(unsigned char *, int)")
  50 def vac_callback_async(data, len):
  51     vpp_object.msg_handler_async(ffi.buffer(data, len))
  52
  53
  54 @ffi.callback("void(void *, unsigned char *, int)")
  55 def vac_error_handler(arg, msg, msg_len):
  56     vpp_object.logger.warning("VPP API client:: %s", ffi.string(msg, msg_len))
  57
  58
  59 class VppTransportShmemIOError(IOError):
  60     """ exception communicating with vpp over shared memory """
  61
  62     def __init__(self, rv, descr):
  63         self.rv = rv
  64         self.desc = descr
  65
  66         super(VppTransportShmemIOError, self).__init__(rv, descr)
  67
  68
  69 class VppTransport:
  70     VppTransportShmemIOError = VppTransportShmemIOError
  71
  72     def __init__(self, parent, read_timeout, server_address):
  73         self.connected = False
  74         self.read_timeout = read_timeout
  75         self.parent = parent
  76         global vpp_object
  77         vpp_object = parent
  78
  79         vpp_api.vac_mem_init(0)
  80
  81         # Register error handler
  82         vpp_api.vac_set_error_handler(vac_error_handler)
  83
  84         # Support legacy CFFI
  85         # from_buffer supported from 1.8.0
  86         (major, minor, patch) = [int(s) for s in
  87                                  cffi.__version__.split('.', 3)]
  88         if major >= 1 and minor >= 8:
  89             self.write = self._write_new_cffi
  90         else:
  91             self.write = self._write_legacy_cffi
  92
  93     def connect(self, name, pfx, msg_handler, rx_qlen):
  94         self.connected = True
  95         if not pfx:
  96             pfx = ffi.NULL
  97         return vpp_api.vac_connect(name.encode('ascii'), pfx, msg_handler, rx_qlen)
  98
  99     def disconnect(self):
 100         self.connected = False
 101         return vpp_api.vac_disconnect()
 102
 103     def suspend(self):
 104         vpp_api.vac_rx_suspend()
 105
 106     def resume(self):
 107         vpp_api.vac_rx_resume()
 108
 109     def get_callback(self, do_async):
 110         return vac_callback_sync if not do_async else vac_callback_async
 111
 112     def get_msg_index(self, name):
 113         return vpp_api.vac_get_msg_index(name.encode('ascii'))
 114
 115     def msg_table_max_index(self):
 116         return vpp_api.vac_msg_table_max_index()
 117
 118     def _write_new_cffi(self, buf):
 119         """Send a binary-packed message to VPP."""
 120         if not self.connected:
 121             raise VppTransportShmemIOError(1, 'Not connected')
 122         return vpp_api.vac_write(ffi.from_buffer(buf), len(buf))
 123
 124     def _write_legacy_cffi(self, buf):
 125         """Send a binary-packed message to VPP."""
 126         if not self.connected:
 127             raise VppTransportShmemIOError(1, 'Not connected')
 128         return vpp_api.vac_write(bytes(buf), len(buf))
 129
 130     def read(self, timeout=None):
 131         if not self.connected:
 132             raise VppTransportShmemIOError(1, 'Not connected')
 133         if timeout is None:
 134             timeout = self.read_timeout
 135         mem = ffi.new("char **")
 136         size = ffi.new("int *")
 137         rv = vpp_api.vac_read(mem, size, timeout)
 138         if rv:
 139             strerror = 'vac_read failed.  It is likely that VPP died.'
 140             raise VppTransportShmemIOError(rv, strerror)
 141         msg = bytes(ffi.buffer(mem[0], size[0]))
 142         vpp_api.vac_free(mem[0])
 143         return msg