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