def handle_request(transport, request_message):
"""
Reads a request from a client and processes it
If user inputs 'quit' stops the event loop
otherwise just echoes user input
"""
logger.debug('Receive request: --|' + str(request_message) + '|--')
try:
output_batch = execute_query_fetch_all(request_message)
except Exception as e:
logger.warn(e)
response = Response(status=ResponseStatus.FAIL,
batch=None,
error=str(e))
else:
response = Response(status=ResponseStatus.SUCCESS, batch=output_batch)
responseData = response.to_json()
# Send data length, because response can be very large
data = (str(len(responseData)) + '|' + responseData).encode('ascii')
logger.debug('Response to client: --|' + str(response) + '|--\n' +
'Length: ' + str(len(responseData)))
transport.write(data)
return response
def send_message(self, message):
logger.debug("[ " + str(self.id) + " ]" + " Request to server: --|" +
str(message) + "|--")
request_chunk = (str(len(message)) + '|' + message).encode('ascii')
# Send request
self.transport.write(request_chunk)
def frames(self, values):
if isinstance(values, DataFrame):
self._frames = values
else:
logger.debug('Batch constructor not properly called!')
raise ValueError('Batch constructor not properly called. \
Expected pandas.DataFrame')
self._batch_size = len(values)
def start_server(host: string, port: int, loop, socket_timeout: int,
stop_server_future):
"""
Start the server.
Server objects are asynchronous context managers.
hostname: hostname of the server
stop_server_future: future for externally stopping the server
"""
logger.critical('Start Server')
# Register signal handler
def raiseSystemExit(_, __):
raise SystemExit
signals = [SIGINT, SIGTERM, SIGHUP, SIGUSR1]
for handled_signal in signals:
signal(handled_signal, raiseSystemExit)
# Get a reference to the event loop
# loop = asyncio.get_event_loop()
# Start the eva server
coro = loop.create_server(lambda: EvaServer(socket_timeout), host, port)
server = loop.run_until_complete(coro)
for socket in server.sockets:
logger.critical('PID(' + str(os.getpid()) + ') serving on ' +
str(socket.getsockname()))
server_closed = loop.create_task(server.wait_closed())
# Start the realtime status monitor
monitor = loop.create_task(realtime_server_status(EvaServer,
server_closed))
try:
loop.run_until_complete(stop_server_future)
except KeyboardInterrupt:
logger.debug("Server process interrupted")
finally:
# Stop monitor
monitor.cancel()
# Close server
server.close()
# Stop event loop
loop.run_until_complete(server.wait_closed())
loop.close()
logger.debug("Successfully shutdown server.")
def connection_made(self, transport):
self.transport = transport
if not set_socket_io_timeouts(self.transport, 60, 0):
self.transport.abort()
logger.debug("[ " + str(self.id) + " ]" + " Could not set timeout")
return
logger.debug("[ " + str(self.id) + " ]" + " Connected to server")
def data_received(self, data):
response_chunk = data.decode()
logger.debug("[ " + str(self.id) + " ]" +
" Response from server: --|" + str(response_chunk) +
"|--")
self.buffer.feed_data(response_chunk)
while self.buffer.has_complete_message():
message = self.buffer.read_message()
self.queue.put_nowait(message)
def connection_made(self, transport):
self.transport = transport
# Set timeout for sockets
if not set_socket_io_timeouts(self.transport, self._socket_timeout, 0):
self.transport.abort()
return
# Each client connection creates a new protocol instance
peername = transport.get_extra_info('peername')
logger.debug('Connection from client: ' + str(peername) +
str(self._socket_timeout))
EvaServer.__connections__ += 1
def __init__(self, loop=None):
self.done = asyncio.Future()
self.transport = None
self.buffer = EvaProtocolBuffer()
if loop is None:
loop = asyncio.get_event_loop()
self.queue = asyncio.Queue(loop=loop)
self.loop = loop
self.id = EvaClient.__connections__
EvaClient.__connections__ += 1
logger.debug("[ " + str(self.id) + " ]" + " Init Client")
def _read(self) -> Iterator[Dict]:
video = cv2.VideoCapture(self.file_url)
video_offset = self.offset if self.offset else 0
video.set(cv2.CAP_PROP_POS_FRAMES, video_offset)
logger.debug("Reading frames")
_, frame = video.read()
frame_id = self._start_frame_id
while frame is not None:
yield {'id': frame_id, 'data': frame}
_, frame = video.read()
frame_id += 1
def connection_lost(self, exc, exc2=None):
logger.debug("[ " + str(self.id) + " ]" + " Disconnected from server")
try:
self.transport.abort() # free sockets early, free sockets often
self.transport = None
except Exception as e:
logger.exception(e)
exc2 = e
finally:
if exc or exc2:
EvaClient.__errors__ += 1
self.done.set_exception(exc or exc2)
self.done.exception() # remove _tb_logger
else:
self.done.set_result(None)
def data_received(self, data):
message = data.decode()
logger.debug('Request from client: --|' + str(message) + '|--')
self.buffer.feed_data(message)
while self.buffer.has_complete_message():
request_message = self.buffer.read_message()
if request_message in ["quit", "exit"]:
logger.debug('Close client socket')
return self.transport.close()
else:
logger.debug('Handle request')
asyncio.create_task(
handle_request(self.transport, request_message))
