def _receive_result(self):
socket = JSONSocket(
self._server_address,
self._server_port + 1
)
try:
dictionary = socket.receive_dict()
except Exception as e:
print(e)
return None
if "_type" in dictionary.keys():
if dictionary["_type"] in CommandTranscoder.type_class_map.keys():
response = CommandTranscoder.decode_command(dictionary)
return response
return dictionary
class QueueWorker(Thread):
"""
A thread which operates on networking message queues
via JSONSocket in two different modes:
1. receive
The worker thread will accept JSONSocket connections,
receive dictionaries, creates command objects and inserts them
into the appropriate queue (in_queue)
2. send
The worker thread will wait for command objects to appear inside
the outgoing queue (out_queue), convert them to dictionaries
and send them to the client via a JSONSocket.
"""
def __init__(
self,
queue: List[dict],
mode: str,
address: str,
port: int
):
self._queue = queue
self._mode = mode
self._address = address
self._port = port
super().__init__()
self.start()
def run(self):
while True:
if thread_should_end_mutex.acquire(timeout=1000): # TODO: put socket in timeout mode
if thread_should_end:
return
thread_should_end_mutex.release()
if self._mode == "receive":
self._work_receive()
else:
self._work_send()
def _work_receive(self):
try:
self.socket = JSONSocket(self._address, self._port)
message = self.socket.receive_dict()
except Exception:
return
in_free.acquire()
in_mutex.acquire()
self._queue.append(message)
in_mutex.release()
in_full.release()
def _work_send(self):
self.socket = JSONSocket(self._address, self._port)
out_full.acquire()
out_mutex.acquire()
message = self._queue.pop(0)
out_mutex.release()
out_free.release()
try:
self.socket.send_dict(message)
except Exception:
out_free.acquire()
out_mutex.acquire()
self._queue.insert(0, message)
out_mutex.release()
out_full.release()