import threading
import select
import multiprocessing
+try:
+ import queue as queue
+except ImportError:
+ import Queue as queue
import logging
-class VppTransport:
+class VppTransportSocketIOError(IOError):
+ pass
+
+
+class VppTransport(object):
+ VppTransportSocketIOError = VppTransportSocketIOError
+
def __init__(self, parent, read_timeout, server_address):
self.connected = False
self.read_timeout = read_timeout if read_timeout > 0 else 1
return
# Put either to local queue or if context == 0
# callback queue
- r = self.parent.decode_incoming_msg(msg)
- if hasattr(r, 'context') and r.context > 0:
+ if self.parent.has_context(msg):
self.q.put(msg)
else:
self.parent.msg_handler_async(msg)
else:
- raise IOError(2, 'Unknown response from select')
+ raise VppTransportSocketIOError(
+ 2, 'Unknown response from select')
def connect(self, name, pfx, msg_handler, rx_qlen):
try:
self.socket.connect(self.server_address)
except socket.error as msg:
- logging.error(msg)
+ logging.error("{} on socket {}".format(msg, self.server_address))
raise
self.connected = True
-
# Initialise sockclnt_create
sockclnt_create = self.parent.messages['sockclnt_create']
sockclnt_create_reply = self.parent.messages['sockclnt_create_reply']
msg = self._read()
hdr, length = self.parent.header.unpack(msg, 0)
if hdr.msgid != 16:
- raise IOError('Invalid reply message')
+ raise VppTransportSocketIOError('Invalid reply message')
r, length = sockclnt_create_reply.unpack(msg)
self.socket_index = r.index
return 0
def disconnect(self):
+ rv = 0
try: # Might fail, if VPP closes socket before packet makes it out
rv = self.parent.api.sockclnt_delete(index=self.socket_index)
except IOError:
self.socket.close()
self.sque.put(True) # Terminate listening thread
self.message_thread.join()
+ return rv
def suspend(self):
pass
pass
def callback(self):
- raise NotImplemented
+ raise NotImplementedError
- def get_callback(self, async):
+ def get_callback(self, do_async):
return self.callback
def get_msg_index(self, name):
def write(self, buf):
"""Send a binary-packed message to VPP."""
if not self.connected:
- raise IOError(1, 'Not connected')
+ raise VppTransportSocketIOError(1, 'Not connected')
# Send header
header = self.header.pack(0, len(buf), 0)
def read(self):
if not self.connected:
- raise IOError(1, 'Not connected')
- return self.q.get()
+ raise VppTransportSocketIOError(1, 'Not connected')
+ try:
+ return self.q.get(True, self.read_timeout)
+ except queue.Empty:
+ return None