def _receive_message(self):
"""
Internal coroutine for receiving messages
"""
zmq_identity = None
while True:
try:
if self._socket.getsockopt(zmq.TYPE) == zmq.ROUTER:
zmq_identity, msg_bytes = \
yield from self._socket.recv_multipart()
self._received_from_identity(zmq_identity)
else:
msg_bytes = yield from self._socket.recv()
self._last_message_time = time.time()
message = validator_pb2.Message()
message.ParseFromString(msg_bytes)
LOGGER.debug("%s receiving %s message: %s bytes",
self._connection,
get_enum_name(message.message_type),
sys.getsizeof(msg_bytes))
tag = get_enum_name(message.message_type)
self._get_received_message_counter(tag).inc()
if zmq_identity is not None:
connection_id = \
self._identity_to_connection_id(zmq_identity)
else:
connection_id = \
self._identity_to_connection_id(
self._connection.encode())
try:
self._futures.set_result(
message.correlation_id,
future.FutureResult(message_type=message.message_type,
content=message.content,
connection_id=connection_id))
except future.FutureCollectionKeyError:
self._dispatcher.dispatch(self._connection, message,
connection_id)
else:
my_future = self._futures.get(message.correlation_id)
LOGGER.debug("message round "
"trip: %s %s",
get_enum_name(message.message_type),
my_future.get_duration())
my_future.timer_stop()
self._futures.remove(message.correlation_id)
except CancelledError:
# The concurrent.futures.CancelledError is caught by asyncio
# when the Task associated with the coroutine is cancelled.
# The raise is required to stop this component.
raise
except Exception as e: # pylint: disable=broad-except
LOGGER.exception(
"Received a message on address %s that "
"caused an error: %s", self._address, e)
def _receive_message(self):
"""
Internal coroutine for receiving messages
"""
with self._condition:
self._condition.wait_for(lambda: self._socket is not None)
while True:
if self._socket.getsockopt(zmq.TYPE) == zmq.ROUTER:
identity, msg_bytes = yield from self._socket.recv_multipart()
else:
msg_bytes = yield from self._socket.recv()
message = validator_pb2.Message()
message.ParseFromString(msg_bytes)
LOGGER.debug("receiving %s message",
get_enum_name(message.message_type))
try:
self._futures.set_result(
message.correlation_id,
future.FutureResult(message_type=message.message_type,
content=message.content))
except future.FutureCollectionKeyError:
if self._socket.getsockopt(zmq.TYPE) == zmq.ROUTER:
self._dispatcher.dispatch(identity, message)
else:
LOGGER.info(
"received a first message on the zmq dealer.")
else:
my_future = self._futures.get(message.correlation_id)
LOGGER.debug("message round "
"trip: %s %s",
get_enum_name(message.message_type),
my_future.get_duration())
self._futures.remove(message.correlation_id)
def _receive_message(self):
"""
Internal coroutine for receiving messages
"""
zmq_identity = None
with self._condition:
self._condition.wait_for(lambda: self._socket is not None)
while True:
if self._socket.getsockopt(zmq.TYPE) == zmq.ROUTER:
zmq_identity, msg_bytes = \
yield from self._socket.recv_multipart()
self._received_from_identity(zmq_identity)
else:
msg_bytes = yield from self._socket.recv()
self._last_message_time = time.time()
message = validator_pb2.Message()
message.ParseFromString(msg_bytes)
LOGGER.debug("%s receiving %s message: %s bytes",
self._connection,
get_enum_name(message.message_type),
sys.getsizeof(msg_bytes))
try:
self._futures.set_result(
message.correlation_id,
future.FutureResult(message_type=message.message_type,
content=message.content))
except future.FutureCollectionKeyError:
if zmq_identity is not None:
connection_id = \
self._identity_to_connection_id(zmq_identity)
else:
connection_id = \
self._identity_to_connection_id(
self._connection.encode())
self._dispatcher.dispatch(self._connection,
message,
connection_id)
else:
my_future = self._futures.get(message.correlation_id)
LOGGER.debug("message round "
"trip: %s %s",
get_enum_name(message.message_type),
my_future.get_duration())
self._futures.remove(message.correlation_id)
def _receive_message(self):
"""
Internal coroutine for receiving messages
"""
with self._condition:
self._condition.wait_for(lambda: self._socket is not None)
while True:
if self._socket.getsockopt(zmq.TYPE) == zmq.ROUTER:
identity, msg_bytes = yield from self._socket.recv_multipart()
else:
msg_bytes = yield from self._socket.recv()
message = validator_pb2.Message()
message.ParseFromString(msg_bytes)
LOGGER.debug("%s receiving %s message: %s bytes",
self._connection,
get_enum_name(message.message_type),
sys.getsizeof(msg_bytes))
try:
self._futures.set_result(
message.correlation_id,
future.FutureResult(message_type=message.message_type,
content=message.content))
except future.FutureCollectionKeyError:
if self._socket.getsockopt(zmq.TYPE) == zmq.ROUTER:
self._dispatcher.dispatch(self._connection,
message,
identity=identity)
else:
# Because this is a zmq.DEALER socket, there is no
# outbound identity
self._dispatcher.dispatch(self._connection,
message)
else:
my_future = self._futures.get(message.correlation_id)
LOGGER.debug("message round "
"trip: %s %s",
get_enum_name(message.message_type),
my_future.get_duration())
self._futures.remove(message.correlation_id)
