def connect(self):
"""Rewrite of KQMLModule connect, only handles send_socket and output
connections"""
try:
self.send_socket = socket()
self.send_socket.connect((self.host, self.port))
socket_write = SocketIO(self.send_socket, 'w')
self.out = BufferedWriter(socket_write)
except OSError as error_msg:
LOGGER.error('Connection failed: %s', error_msg)
# Verify that you can send messages...
assert self.out is not None, \
'Connection formed but output (%s) not set.' % (self.out)
def listen(self):
"""Socket server, listens for new KQML messages and dispatches them
accordingly.
Doesn't necessarily need threading; Could just start dispatcher and
after it returns accept next connection. This couldn't handle loads of
inputs while being bogged down processing. To avoid this issue we
thread the dispatching so the functions that get called are run in a
separate Thread. We're using ThreadPoolExecutor because sockets use io,
io is blocking and threads allow you to not block.
"""
with ThreadPoolExecutor(max_workers=5) as executor:
while self.ready:
connection, _ = self.listen_socket.accept()
LOGGER.debug('Received connection: %s', connection)
socket_write = SocketIO(connection, 'w')
self.local_out = BufferedWriter(socket_write)
socket_read = SocketIO(connection, 'r')
read_input = KQMLReader(BufferedReader(socket_read))
self.dispatcher = KQMLDispatcher(self, read_input, self.name)
LOGGER.debug('Starting dispatcher: %s', self.dispatcher)
executor.submit(self.dispatcher.start)
self.state = 'dispatching'
def backport_makefile(self,
mode="r",
buffering=None,
encoding=None,
errors=None,
newline=None):
"""
Backport of ``socket.makefile`` from Python 3.5.
"""
if not set(mode) <= set(["r", "w", "b"]):
raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode, ))
writing = "w" in mode
reading = "r" in mode or not writing
assert reading or writing
binary = "b" in mode
rawmode = ""
if reading:
rawmode += "r"
if writing:
rawmode += "w"
raw = SocketIO(self, rawmode)
self._makefile_refs += 1
if buffering is None:
buffering = -1
if buffering < 0:
buffering = io.DEFAULT_BUFFER_SIZE
if buffering == 0:
if not binary:
raise ValueError("unbuffered streams must be binary")
return raw
if reading and writing:
buffer = io.BufferedRWPair(raw, raw, buffering)
elif reading:
buffer = io.BufferedReader(raw, buffering)
else:
assert writing
buffer = io.BufferedWriter(raw, buffering)
if binary:
return buffer
text = io.TextIOWrapper(buffer, encoding, errors, newline)
text.mode = mode
return text
raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,))
=======
raise ValueError(
"invalid mode %r (only r, w, b allowed)" % (mode,)
)
>>>>>>> 71358189c5e72ee2ac9883b408a2f540a7f5745e
writing = "w" in mode
reading = "r" in mode or not writing
assert reading or writing
binary = "b" in mode
rawmode = ""
if reading:
rawmode += "r"
if writing:
rawmode += "w"
raw = SocketIO(self, rawmode)
self._makefile_refs += 1
if buffering is None:
buffering = -1
if buffering < 0:
buffering = io.DEFAULT_BUFFER_SIZE
if buffering == 0:
if not binary:
raise ValueError("unbuffered streams must be binary")
return raw
if reading and writing:
buffer = io.BufferedRWPair(raw, raw, buffering)
elif reading:
buffer = io.BufferedReader(raw, buffering)
else:
assert writing
def makefile(self, *args, **kwargs):
return SocketIO(self, *args, **kwargs)
