def dispatch(self, connection, message, connection_id):
if message.message_type in self._msg_type_handlers:
priority = self._priority.get(message.message_type, Priority.LOW)
message_id = _gen_message_id()
LOGGER.info("Received a message of type %s priority %d from %s",
get_enum_name(message.message_type), priority,
connection_id)
self._message_information[message_id] = \
_MessageInformation(
connection=connection,
connection_id=connection_id,
content=message.content,
correlation_id=message.correlation_id,
message_type=message.message_type,
collection=_ManagerCollection(
self._msg_type_handlers[message.message_type]))
self._in_queue.put_nowait((priority, message_id))
queue_size = self._in_queue.qsize()
LOGGER.info("Queue size %s", queue_size)
if queue_size > 10:
LOGGER.debug("Dispatch incoming queue size: %s", queue_size)
else:
LOGGER.info(
"received a message of type %s "
"from %s but have no handler for that type",
get_enum_name(message.message_type), connection_id)
def _determine_next(self, message_id, future):
if future.result().status == HandlerStatus.DROP:
del self._message_information[message_id]
elif future.result().status == HandlerStatus.PASS:
self._process(message_id)
elif future.result().status == HandlerStatus.RETURN_AND_PASS:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
message = validator_pb2.Message(
content=future.result().message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=future.result().message_type)
try:
self._send_message[connection](msg=message,
connection_id=connection_id)
except KeyError:
LOGGER.info(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type), connection_id,
connection)
self._process(message_id)
elif future.result().status == HandlerStatus.RETURN:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
del self._message_information[message_id]
message = validator_pb2.Message(
content=future.result().message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=future.result().message_type)
try:
self._send_message[connection](msg=message,
connection_id=connection_id)
except KeyError:
LOGGER.info(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type), connection_id,
connection)
with self._condition:
if len(self._message_information) == 0:
self._condition.notify()
def broadcast(self, gossip_message, message_type, exclude=None):
"""Broadcast gossip messages.
Broadcast the message to all peers unless they are in the excluded
list.
Args:
gossip_message: The message to be broadcast.
message_type: Type of the message.
exclude: A list of connection_ids that should be excluded from this
broadcast.
"""
LOGGER.debug("broadcast...")
with self._lock:
LOGGER.debug("broadcast start peers=%d", len(self._peers))
if exclude is None:
exclude = []
for connection_id in self._peers.copy():
LOGGER.debug("broadcast for %s", connection_id)
if connection_id not in exclude and \
self._network.is_connection_handshake_complete(
connection_id):
LOGGER.info("gossip:broadcast: send %s to %s",
get_enum_name(message_type), connection_id)
self.send(message_type,
gossip_message.SerializeToString(),
connection_id,
one_way=True)
def dispatch(self, connection, message, connection_id):
if message.message_type in self._msg_type_handlers:
priority = self._priority.get(message.message_type, Priority.LOW)
message_id = _gen_message_id()
self._message_information[message_id] = \
_MessageInformation(
connection=connection,
connection_id=connection_id,
content=message.content,
correlation_id=message.correlation_id,
message_type=message.message_type,
collection=_ManagerCollection(
self._msg_type_handlers[message.message_type]))
self._in_queue.put_nowait((priority, message_id))
queue_size = self._in_queue.qsize()
if queue_size > 10:
LOGGER.debug("Dispatch incoming queue size: %s", queue_size)
else:
LOGGER.info("received a message of type %s "
"from %s but have no handler for that type",
get_enum_name(message.message_type),
connection_id)
def _determine_next(self, message_id, future):
if future.result().status == HandlerStatus.DROP:
del self._message_information[message_id]
elif future.result().status == HandlerStatus.PASS:
self._process(message_id)
elif future.result().status == HandlerStatus.RETURN_AND_PASS:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
message = validator_pb2.Message(
content=future.result().message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=future.result().message_type)
try:
self._send_message[connection](msg=message,
connection_id=connection_id)
except KeyError:
LOGGER.info("Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type), connection_id,
connection)
self._process(message_id)
elif future.result().status == HandlerStatus.RETURN:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
del self._message_information[message_id]
message = validator_pb2.Message(
content=future.result().message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=future.result().message_type)
try:
self._send_message[connection](msg=message,
connection_id=connection_id)
except KeyError:
LOGGER.info("Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type), connection_id,
connection)
with self._condition:
if not self._message_information:
self._condition.notify()
def do_next(result):
message_info = self._message_information[message_id]
LOGGER.debug("do_next: result %s",str(result))
try:
# check for a None result
if result is None:
LOGGER.error(
"%s preprocessor returned None result for messsage %s",
preprocessor,
message_id)
return
LOGGER.debug("do_next: status %s",str(result.status))
# check for result status
if result.status == HandlerStatus.DROP:
del self._message_information[message_id]
return
if result.status == HandlerStatus.RETURN:
del self._message_information[message_id]
message = validator_pb2.Message(
content=result.message_out.SerializeToString(),
correlation_id=message_info.correlation_id,
message_type=result.message_type)
try:
self._send_message[message_info.connection](
msg=message,
connection_id=message_info.connection_id)
except KeyError:
LOGGER.warning(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
message_info.connection_id,
message_info.connection)
return
# store the preprocessor result
self._message_information[message_id] = \
_MessageInformation(
connection=message_info.connection,
connection_id=message_info.connection_id,
content=result.content,
correlation_id=message_info.correlation_id,
collection=message_info.collection,
message_type=message_info.message_type)
self._process_next(message_id)
except Exception: # pylint: disable=broad-except
LOGGER.exception(
"Unhandled exception after preprocessing")
def do_next(result):
message_info = self._message_information[message_id]
try:
# check for a None result
if result is None:
LOGGER.error(
"%s preprocessor returned None result for messsage %s",
preprocessor,
message_id)
return
# check for result status
if result.status == HandlerStatus.DROP:
del self._message_information[message_id]
return
if result.status == HandlerStatus.RETURN:
del self._message_information[message_id]
message = validator_pb2.Message(
content=result.message_out.SerializeToString(),
correlation_id=message_info.correlation_id,
message_type=result.message_type)
try:
self._send_message[message_info.connection](
msg=message,
connection_id=message_info.connection_id)
except KeyError:
LOGGER.warning(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
message_info.connection_id,
message_info.connection)
return
# store the preprocessor result
self._message_information[message_id] = \
_MessageInformation(
connection=message_info.connection,
connection_id=message_info.connection_id,
content=result.content,
correlation_id=message_info.correlation_id,
collection=message_info.collection,
message_type=message_info.message_type)
self._process_next(message_id)
except Exception: # pylint: disable=broad-except
LOGGER.exception(
"Unhandled exception after preprocessing")
def notify(self, message_type, message):
self._queue_backlog(message_type, message)
active_engine = self._consensus_registry.get_active_engine_info()
if active_engine is not None:
for (queued_type, queued_msg) in self._drain_backlog():
try:
self._service.send(queued_type, bytes(queued_msg),
active_engine.connection_id).result(
timeout=NOTIFICATION_TIMEOUT)
except FutureTimeoutError:
LOGGER.warning("Consensus notification %s timed out",
get_enum_name(queued_type))
def dispatch(self, connection, message, connection_id):
if message.message_type in self._msg_type_handlers:
message_id = _gen_message_id()
self._message_information[message_id] = (
connection, connection_id, message,
_ManagerCollection(
self._msg_type_handlers[message.message_type]))
self._in_queue.put_nowait(message_id)
else:
LOGGER.info(
"received a message of type %s "
"from %s but have no handler for that type",
get_enum_name(message.message_type), connection_id)
def notify(self, message_type, message):
self._queue_backlog(message_type, message)
active_engine = self._consensus_registry.get_active_engine_info()
if active_engine is not None:
for (queued_type, queued_msg) in self._drain_backlog():
try:
self._service.send(
queued_type,
bytes(queued_msg),
active_engine.connection_id
).result(timeout=NOTIFICATION_TIMEOUT)
except FutureTimeoutError:
LOGGER.warning(
"Consensus notification %s timed out",
get_enum_name(queued_type))
def dispatch(self, identity, message):
if message.message_type in self._msg_type_handlers:
message_id = _gen_message_id()
self._message_information[message_id] = (
identity,
message,
_ManagerCollection(
self._msg_type_handlers[message.message_type])
)
self._in_queue.put_nowait(message_id)
else:
LOGGER.info("received a message of type %s "
"from %s but have no handler for that type",
get_enum_name(message.message_type),
identity)
def dispatch(self, connection, message, connection_id):
if message.message_type in self._msg_type_handlers:
priority = self._priority.get(message.message_type, LOW_PRIORITY)
message_id = _gen_message_id()
self._message_information[message_id] = (
connection, connection_id, message,
_ManagerCollection(
self._msg_type_handlers[message.message_type]))
self._in_queue.put_nowait((priority, message_id))
queue_size = self._in_queue.qsize()
if queue_size > 10:
LOGGER.debug("Dispatch incoming queue size: %s", queue_size)
else:
LOGGER.info(
"received a message of type %s from %s but have no handler for that type",
get_enum_name(message.message_type), connection_id)
def _determine_next(self, message_id, future):
try:
res = future.result(timeout=self._timeout)
except TimeoutError:
LOGGER.exception("Dispatcher timeout waiting on handler result.")
raise
if res.status == HandlerStatus.DROP:
del self._message_information[message_id]
elif res.status == HandlerStatus.PASS:
self._process(message_id)
elif res.status == HandlerStatus.RETURN_AND_PASS:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
message = validator_pb2.Message(
content=res.message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=res.message_type)
try:
self._send_message[connection](msg=message,
connection_id=connection_id)
except KeyError:
LOGGER.info(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type), connection_id,
connection)
self._process(message_id)
elif res.status == HandlerStatus.RETURN:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
del self._message_information[message_id]
message = validator_pb2.Message(
content=res.message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=res.message_type)
try:
self._send_message[connection](msg=message,
connection_id=connection_id)
except KeyError:
LOGGER.info(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type), connection_id,
connection)
elif res.status == HandlerStatus.RETURN_AND_CLOSE:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
del self._message_information[message_id]
message = validator_pb2.Message(
content=res.message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=res.message_type)
try:
self._send_last_message[connection](
msg=message, connection_id=connection_id)
except KeyError:
LOGGER.info(
"Can't send last message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type), connection_id,
connection)
with self._condition:
if not self._message_information:
self._condition.notify()
def _determine_next(self, message_id, future):
try:
res = future.result(timeout=self._timeout)
except TimeoutError:
LOGGER.exception("Dispatcher timeout waiting on handler result.")
raise
if res is None:
LOGGER.debug('Ignoring None handler result, likely due to an '
'unhandled error while executing the handler')
return
if res.status == HandlerStatus.DROP:
del self._message_information[message_id]
elif res.status == HandlerStatus.PASS:
self._process(message_id)
elif res.status == HandlerStatus.RETURN_AND_PASS:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
if res.message_out and res.message_type:
message = validator_pb2.Message(
content=res.message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=res.message_type)
try:
self._send_message[connection](msg=message,
connection_id=connection_id)
except KeyError:
LOGGER.info("Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
connection_id,
connection)
self._process(message_id)
else:
LOGGER.error("HandlerResult with status of RETURN_AND_PASS "
"is missing message_out or message_type")
elif res.status == HandlerStatus.RETURN:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
del self._message_information[message_id]
if res.message_out and res.message_type:
message = validator_pb2.Message(
content=res.message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=res.message_type)
try:
self._send_message[connection](msg=message,
connection_id=connection_id)
except KeyError:
LOGGER.info("Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
connection_id,
connection)
else:
LOGGER.error("HandlerResult with status of RETURN "
"is missing message_out or message_type")
elif res.status == HandlerStatus.RETURN_AND_CLOSE:
connection, connection_id, \
original_message, _ = self._message_information[message_id]
del self._message_information[message_id]
if res.message_out and res.message_type:
message = validator_pb2.Message(
content=res.message_out.SerializeToString(),
correlation_id=original_message.correlation_id,
message_type=res.message_type)
try:
self._send_last_message[connection](
msg=message,
connection_id=connection_id)
except KeyError:
LOGGER.info("Can't send last message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
connection_id,
connection)
else:
LOGGER.error("HandlerResult with status of RETURN_AND_CLOSE "
"is missing message_out or message_type")
with self._condition:
if not self._message_information:
self._condition.notify()
def _determine_next(self, message_id, result):
if result is None:
LOGGER.debug('Ignoring None handler result, likely due to an '
'unhandled error while executing the handler')
return
if result.status == HandlerStatus.DROP:
del self._message_information[message_id]
elif result.status == HandlerStatus.PASS:
self._process_next(message_id)
elif result.status == HandlerStatus.RETURN_AND_PASS:
message_info = self._message_information[message_id]
if result.message_out and result.message_type:
message = validator_pb2.Message(
content=result.message_out.SerializeToString(),
correlation_id=message_info.correlation_id,
message_type=result.message_type)
try:
self._send_message[message_info.connection](
msg=message, connection_id=message_info.connection_id)
except KeyError:
LOGGER.warning(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
message_info.connection_id, message_info.connection)
self._process_next(message_id)
else:
LOGGER.error("HandlerResult with status of RETURN_AND_PASS "
"is missing message_out or message_type")
elif result.status == HandlerStatus.RETURN:
message_info = self._message_information[message_id]
del self._message_information[message_id]
if result.message_out and result.message_type:
message = validator_pb2.Message(
content=result.message_out.SerializeToString(),
correlation_id=message_info.correlation_id,
message_type=result.message_type)
try:
self._send_message[message_info.connection](
msg=message, connection_id=message_info.connection_id)
except KeyError:
LOGGER.warning(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
message_info.connection_id, message_info.connection)
else:
LOGGER.error("HandlerResult with status of RETURN "
"is missing message_out or message_type")
elif result.status == HandlerStatus.RETURN_AND_CLOSE:
message_info = self._message_information[message_id]
del self._message_information[message_id]
if result.message_out and result.message_type:
message = validator_pb2.Message(
content=result.message_out.SerializeToString(),
correlation_id=message_info.correlation_id,
message_type=result.message_type)
try:
LOGGER.warning(
"Sending hang-up in reply to %s to connection %s",
get_enum_name(message_info.message_type),
message_info.connection_id)
self._send_last_message[message_info.connection](
msg=message, connection_id=message_info.connection_id)
except KeyError:
LOGGER.warning(
"Can't send last message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
message_info.connection_id, message_info.connection)
else:
LOGGER.error("HandlerResult with status of RETURN_AND_CLOSE "
"is missing message_out or message_type")
with self._condition:
if not self._message_information:
self._condition.notify()
def _determine_next(self, message_id, result):
if result is None:
LOGGER.debug('Ignoring None handler result, likely due to an '
'unhandled error while executing the handler')
return
if result.status == HandlerStatus.DROP:
del self._message_information[message_id]
elif result.status == HandlerStatus.PASS:
self._process_next(message_id)
elif result.status == HandlerStatus.RETURN_AND_PASS:
message_info = self._message_information[message_id]
if result.message_out and result.message_type:
message = validator_pb2.Message(
content=result.message_out.SerializeToString(),
correlation_id=message_info.correlation_id,
message_type=result.message_type)
try:
self._send_message[message_info.connection](
msg=message,
connection_id=message_info.connection_id)
except KeyError:
LOGGER.warning(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
message_info.connection_id,
message_info.connection)
self._process_next(message_id)
else:
LOGGER.error("HandlerResult with status of RETURN_AND_PASS "
"is missing message_out or message_type")
elif result.status == HandlerStatus.RETURN:
message_info = self._message_information[message_id]
del self._message_information[message_id]
if result.message_out and result.message_type:
message = validator_pb2.Message(
content=result.message_out.SerializeToString(),
correlation_id=message_info.correlation_id,
message_type=result.message_type)
try:
self._send_message[message_info.connection](
msg=message,
connection_id=message_info.connection_id)
except KeyError:
LOGGER.warning(
"Can't send message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
message_info.connection_id,
message_info.connection)
else:
LOGGER.error("HandlerResult with status of RETURN "
"is missing message_out or message_type")
elif result.status == HandlerStatus.RETURN_AND_CLOSE:
message_info = self._message_information[message_id]
del self._message_information[message_id]
if result.message_out and result.message_type:
message = validator_pb2.Message(
content=result.message_out.SerializeToString(),
correlation_id=message_info.correlation_id,
message_type=result.message_type)
try:
LOGGER.warning(
"Sending hang-up in reply to %s to connection %s",
get_enum_name(message_info.message_type),
message_info.connection_id)
self._send_last_message[message_info.connection](
msg=message,
connection_id=message_info.connection_id)
except KeyError:
LOGGER.warning(
"Can't send last message %s back to "
"%s because connection %s not in dispatcher",
get_enum_name(message.message_type),
message_info.connection_id,
message_info.connection)
else:
LOGGER.error("HandlerResult with status of RETURN_AND_CLOSE "
"is missing message_out or message_type")
with self._condition:
if not self._message_information:
self._condition.notify()
