2 # A transport class. With two implementations.
3 # One for socket and one for shared memory.
10 logger = logging.getLogger('vpp_papi.transport')
11 logger.addHandler(logging.NullHandler())
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,
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);
24 int vac_get_msg_index(unsigned char * name);
25 int vac_msg_table_size(void);
26 int vac_msg_table_max_index(void);
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);
36 # allow file to be imported so it can be mocked in tests.
37 # If the shared library fails, VppTransport cannot be initialized.
39 vpp_api = ffi.dlopen('libvppapiclient.so')
44 @ffi.callback("void(unsigned char *, int)")
45 def vac_callback_sync(data, len):
46 vpp_object.msg_handler_sync(ffi.buffer(data, len))
49 @ffi.callback("void(unsigned char *, int)")
50 def vac_callback_async(data, len):
51 vpp_object.msg_handler_async(ffi.buffer(data, len))
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))
59 class VppTransportShmemIOError(IOError):
60 """ exception communicating with vpp over shared memory """
62 def __init__(self, rv, descr):
66 super(VppTransportShmemIOError, self).__init__(rv, descr)
69 class VppTransport(object):
70 VppTransportShmemIOError = VppTransportShmemIOError
72 def __init__(self, parent, read_timeout, server_address):
73 self.connected = False
74 self.read_timeout = read_timeout
79 vpp_api.vac_mem_init(0)
81 # Register error handler
82 vpp_api.vac_set_error_handler(vac_error_handler)
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
91 self.write = self._write_legacy_cffi
93 def connect(self, name, pfx, msg_handler, rx_qlen):
97 return vpp_api.vac_connect(name.encode('ascii'), pfx, msg_handler, rx_qlen)
100 self.connected = False
101 return vpp_api.vac_disconnect()
104 vpp_api.vac_rx_suspend()
107 vpp_api.vac_rx_resume()
109 def get_callback(self, do_async):
110 return vac_callback_sync if not do_async else vac_callback_async
112 def get_msg_index(self, name):
113 return vpp_api.vac_get_msg_index(name.encode('ascii'))
115 def msg_table_max_index(self):
116 return vpp_api.vac_msg_table_max_index()
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))
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))
130 def read(self, timeout=None):
131 if not self.connected:
132 raise VppTransportShmemIOError(1, 'Not connected')
134 timeout = self.read_timeout
135 mem = ffi.new("char **")
136 size = ffi.new("int *")
137 rv = vpp_api.vac_read(mem, size, timeout)
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])