def receive_eof(self):
connection, _ = self.listen_socket.accept()
print(connection)
# socket_write = socket.SocketIO(connection, 'w')
# self.out = io.BufferedWriter(socket_write)
socket_read = socket.SocketIO(connection, 'r')
inp_reader = KQMLReader(io.BufferedReader(socket_read))
# self.inp = inp_reader
self.dispatcher = KQMLDispatcher(self, inp_reader, self.name)
self.dispatcher.start()
def __init__(self, argv=None, **kwargs):
defaults = dict(host='localhost',
port=6200,
is_application=False,
testing=False,
socket=None,
name=None,
group_name=None,
scan_for_port=False,
debug=False,
do_register=True)
self.dispatcher = None
self.MAX_PORT_TRIES = 100
self.reply_id_counter = 1
if isinstance(argv, list):
kwargs.update(translate_argv(argv))
elif argv is not None:
raise KQMLException("Unusable type for keyord argument `argv`.")
for kw, arg in kwargs.items():
if kw not in defaults.keys():
raise ValueError('Unexpected keyword argument: %s' % kw)
else:
defaults.pop(kw)
self.__setattr__(kw, arg)
for kw, arg in defaults.items():
self.__setattr__(kw, arg)
if self.debug:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
if not self.testing:
self.out = None
self.inp = None
logger.info('Using socket connection')
conn = self.connect(self.host, self.port)
if not conn:
logger.error('Connection failed')
self.exit(-1)
assert self.inp is not None and self.out is not None, \
"Connection formed but input (%s) and output (%s) not set." % \
(self.inp, self.out)
else:
logger.info('Using stdio connection')
self.out = io.BytesIO()
self.inp = KQMLReader(io.BytesIO())
self.dispatcher = KQMLDispatcher(self, self.inp, self.name)
if self.do_register:
self.register()
def listen(self):
logger.debug('listening')
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
while self.ready:
conn, addr = self.listenSoc.accept()
logger.debug('received connection')
sw = socket.SocketIO(conn, 'w')
self.out = io.BufferedWriter(sw)
sr = socket.SocketIO(conn, 'r')
inp = KQMLReader(io.BufferedReader(sr))
self.dispatcher = KQMLDispatcher(self, inp, self.name)
executor.submit(self.dispatcher.start)
def connect1(self, host, port, verbose=True):
try:
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((host, port))
sw = socket.SocketIO(self.socket, 'w')
self.out = io.BufferedWriter(sw)
sr = socket.SocketIO(self.socket, 'r')
self.inp = KQMLReader(io.BufferedReader(sr))
return True
except socket.error as e:
if verbose:
logger.error(e)
return False
def _listen(self):
"""Sets up input and output socket connections to our listener.
Infinite loop while ready to connect to our listener socket. On connect
we get the write socket as a Buffered Writer and the read socket as a
KQML Reader (which passes through a Buffered Reader). The reader is
then attached to a KQML Dispatcher which is subsequently started, and
passed along to the executor (which is a thread pool manager).
"""
LOGGER.debug('listening')
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
while self.ready:
connection, _ = self.listen_socket.accept()
LOGGER.debug('received connection')
socket_write = socket.SocketIO(connection, 'w')
self.out = io.BufferedWriter(socket_write)
socket_read = socket.SocketIO(connection, 'r')
read_input = KQMLReader(io.BufferedReader(socket_read))
self.dispatcher = KQMLDispatcher(self, read_input, self.name)
executor.submit(self.dispatcher.start)
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'