def _peer_callback(self, request, result, connection_id, endpoint=None):
with self._lock:
ack = NetworkAcknowledgement()
ack.ParseFromString(result.content)
if ack.status == ack.ERROR:
LOGGER.debug("Peering request to %s was NOT successful",
connection_id)
self._remove_temporary_connection(connection_id)
elif ack.status == ack.OK:
LOGGER.debug("Peering request to %s was successful",
connection_id)
if endpoint:
try:
self._gossip.register_peer(connection_id, endpoint)
self._connection_statuses[connection_id] = \
PeerStatus.PEER
self._gossip.send_block_request("HEAD", connection_id)
except PeeringException:
# Remove unsuccessful peer
self._remove_temporary_connection(connection_id)
else:
LOGGER.debug(
"Cannot register peer with no endpoint for "
"connection_id: %s", connection_id)
self._remove_temporary_connection(connection_id)
def handle(self, connection_id, message_content):
ack = NetworkAcknowledgement()
ack.status = ack.OK
batch_response_message = GossipBatchResponse()
batch_response_message.ParseFromString(message_content)
return HandlerResult(HandlerStatus.RETURN_AND_PASS,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, identity, message_content):
ack = NetworkAcknowledgement()
ack.status = ack.OK
gossip_message = GossipMessage()
gossip_message.ParseFromString(message_content)
return HandlerResult(HandlerStatus.RETURN_AND_PASS,
message_out=ack,
message_type=validator_pb2.Message.GOSSIP_ACK)
def handle(self, connection_id, message_content):
request = PingRequest()
request.ParseFromString(message_content)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
ack = NetworkAcknowledgement()
ack.status = ack.OK
batch_response_message = GossipBatchResponse()
batch_response_message.ParseFromString(message_content)
return HandlerResult(
HandlerStatus.RETURN_AND_PASS,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, identity, message_content):
request = PeerRegisterRequest()
request.ParseFromString(message_content)
LOGGER.debug("got peer register message "
"from %s. sending ack", identity)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.GOSSIP_ACK)
def handle(self, connection_id, message_content):
request = PingRequest()
request.ParseFromString(message_content)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def _peer_callback(self, request, result, connection_id):
ack = NetworkAcknowledgement()
ack.ParseFromString(result.content)
if ack.status == ack.ERROR:
LOGGER.debug("Peering request to %s was NOT successful",
connection_id)
elif ack.status == ack.OK:
LOGGER.debug("Peering request to %s was successful", connection_id)
self._peers.append(connection_id)
self.broadcast_block_request("HEAD")
def handle(self, identity, message_content):
ack = NetworkAcknowledgement()
ack.status = ack.OK
gossip_message = GossipMessage()
gossip_message.ParseFromString(message_content)
return HandlerResult(
HandlerStatus.RETURN_AND_PASS,
message_out=ack,
message_type=validator_pb2.Message.GOSSIP_ACK)
def handle(self, identity, message_content):
request = PeerRegisterRequest()
request.ParseFromString(message_content)
LOGGER.debug("got peer register message "
"from %s. sending ack", identity)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.GOSSIP_ACK)
def handle(self, connection_id, message_content):
message = DisconnectMessage()
message.ParseFromString(message_content)
LOGGER.debug("got disconnect message from %s. sending ack",
connection_id)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
request = PeerUnregisterRequest()
request.ParseFromString(message_content)
LOGGER.debug("got peer unregister message "
"from %s. sending ack", connection_id)
self._gossip.unregister_peer(connection_id)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
request = PeerUnregisterRequest()
request.ParseFromString(message_content)
LOGGER.debug("got peer unregister message "
"from %s. sending ack", connection_id)
self._gossip.unregister_peer(connection_id)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
message = DisconnectMessage()
message.ParseFromString(message_content)
LOGGER.debug("got disconnect message from %s. sending ack",
connection_id)
ack = NetworkAcknowledgement()
ack.status = ack.OK
self._network.remove_connection(connection_id)
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
request = GetPeersRequest()
request.ParseFromString(message_content)
LOGGER.debug("Got peers request message from %s", connection_id)
self._gossip.send_peers(connection_id)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
request = GetPeersRequest()
request.ParseFromString(message_content)
LOGGER.debug("Got peers request message from %s", connection_id)
self._gossip.send_peers(connection_id)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
request = PeerRegisterRequest()
request.ParseFromString(message_content)
LOGGER.debug("Got peer register message from %s", connection_id)
ack = NetworkAcknowledgement()
try:
self._gossip.register_peer(connection_id, request.endpoint)
ack.status = ack.OK
except PeeringException:
ack.status = ack.ERROR
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
response = GetPeersResponse()
response.ParseFromString(message_content)
LOGGER.debug("got peers response message "
"from %s. sending ack", connection_id)
LOGGER.debug("PEERS RESPONSE ENDPOINTS: %s", response.peer_endpoints)
self._gossip.add_candidate_peer_endpoints(response.peer_endpoints)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, message, peer):
LOGGER.debug("PingHandler message: %s", message)
request = PingRequest()
request.ParseFromString(message.content)
LOGGER.debug("Got ping message %s "
"from %s. sending ack", message.content, message.sender)
ack = NetworkAcknowledgement()
ack.status = ack.OK
peer.send(
validator_pb2.Message(sender=message.sender,
message_type='gossip/ack',
correlation_id=message.correlation_id,
content=ack.SerializeToString()))
def handle(self, connection_id, message_content):
batch, _ = message_content
batch_id = batch.header_signature
ack = NetworkAcknowledgement()
ack.status = ack.OK
if not self._has_open_requests(batch_id) and self._has_batch(batch_id):
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
return HandlerResult(HandlerStatus.RETURN_AND_PASS,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, message, peer):
request = PeerUnregisterRequest()
request.ParseFromString(message.content)
self._service.unregister_peer(message.sender, request.identity)
LOGGER.debug("Got peer unregister message "
"from %s. Sending ack", message.sender)
ack = NetworkAcknowledgement()
ack.status = ack.OK
peer.send(
validator_pb2.Message(sender=message.sender,
message_type='gossip/ack',
correlation_id=message.correlation_id,
content=ack.SerializeToString()))
def handle(self, message, peer):
LOGGER.debug("GossipMessageHandler message: %s", message.sender)
LOGGER.debug("Got gossip message %s "
"from %s. sending ack", message.content, message.sender)
self._ingest_message(message)
ack = NetworkAcknowledgement()
ack.status = ack.OK
peer.send(
validator_pb2.Message(
sender=message.sender,
message_type=validator_pb2.Message.GOSSIP_ACK,
correlation_id=message.correlation_id,
content=ack.SerializeToString()))
def handle(self, connection_id, message_content):
response = GetPeersResponse()
response.ParseFromString(message_content)
LOGGER.debug("got peers response message "
"from %s. sending ack", connection_id)
LOGGER.debug("PEERS RESPONSE ENDPOINTS: %s", response.peer_endpoints)
self._gossip.add_candidate_peer_endpoints(response.peer_endpoints)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
batch_response_message = GossipBatchResponse()
batch_response_message.ParseFromString(message_content)
batch = Batch()
batch.ParseFromString(batch_response_message.content)
batch_id = batch.header_signature
if not self._has_open_requests(batch_id) and self._has_batch(batch_id):
LOGGER.debug('Drop duplicate batch: %s', batch_id)
return HandlerResult(HandlerStatus.RETURN)
ack = NetworkAcknowledgement()
ack.status = ack.OK
return HandlerResult(HandlerStatus.RETURN_AND_PASS,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
request = PeerRegisterRequest()
request.ParseFromString(message_content)
LOGGER.debug("Got peer register message from %s (%s, protocol v%s)",
connection_id, request.endpoint, request.protocol_version)
ack = NetworkAcknowledgement()
try:
self._gossip.register_peer(connection_id, request.endpoint)
ack.status = ack.OK
except PeeringException:
ack.status = ack.ERROR
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, message, peer):
LOGGER.debug("GossipMessageHandler message: {}".format(message))
request = GossipMessage()
request.ParseFromString(message.content)
LOGGER.debug("Got gossip message {} "
"from {}. sending ack".format(message.content,
message.sender))
self._service._put_on_inbound(request)
ack = NetworkAcknowledgement()
ack.status = ack.OK
peer.send(validator_pb2.Message(
sender=message.sender,
message_type='gossip/ack',
correlation_id=message.correlation_id,
content=ack.SerializeToString()))
def handle(self, connection_id, message_content):
batch, _ = message_content
batch_id = batch.header_signature
ack = NetworkAcknowledgement()
ack.status = ack.OK
if not self._has_open_requests(batch_id) and self._has_batch(batch_id):
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK
)
return HandlerResult(
HandlerStatus.RETURN_AND_PASS,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
message = ConnectMessage()
message.ParseFromString(message_content)
LOGGER.debug("got connect message from %s. sending ack",
connection_id)
ack = NetworkAcknowledgement()
if self._network.allow_inbound_connection():
LOGGER.debug("Allowing incoming connection: %s",
connection_id)
ack.status = ack.OK
else:
LOGGER.debug("At max connections, sending error response")
ack.status = ack.ERROR
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def _connect_callback(self, request, result,
connection=None,
success_callback=None,
failure_callback=None):
ack = NetworkAcknowledgement()
ack.ParseFromString(result.content)
if ack.status == ack.ERROR:
LOGGER.debug("Received an error response to the NETWORK_CONNECT "
"we sent. Removing connection: %s",
connection.connection_id)
self.remove_connection(connection.connection_id)
if failure_callback:
failure_callback(connection_id=connection.connection_id)
elif ack.status == ack.OK:
LOGGER.debug("Connection to %s was acknowledged",
connection.connection_id)
if success_callback:
success_callback(connection_id=connection.connection_id)
def _peer_callback(self, request, result, connection_id, endpoint=None):
with self._condition:
ack = NetworkAcknowledgement()
ack.ParseFromString(result.content)
if ack.status == ack.ERROR:
LOGGER.debug("Peering request to %s was NOT successful",
connection_id)
elif ack.status == ack.OK:
LOGGER.debug("Peering request to %s was successful",
connection_id)
if endpoint:
self._gossip.register_peer(connection_id, endpoint)
else:
LOGGER.debug(
"Cannot register peer with no endpoint for "
"connection_id: %s", connection_id)
self._gossip.send_block_request("HEAD", connection_id)
def handle(self, connection_id, message_content):
block_response_message = GossipBlockResponse()
block_response_message.ParseFromString(message_content)
block = Block()
block.ParseFromString(block_response_message.content)
block_id = block.header_signature
ack = NetworkAcknowledgement()
ack.status = ack.OK
if not self._has_open_requests(block_id) and self._has_block(block_id):
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
return HandlerResult(HandlerStatus.RETURN_AND_PASS,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
request = PingRequest()
request.ParseFromString(message_content)
ack = NetworkAcknowledgement()
ack.status = ack.OK
if self._network.get_connection_status(connection_id) == \
ConnectionStatus.CONNECTED:
if connection_id in self._last_message:
del self._last_message[connection_id]
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
if connection_id in self._last_message:
if time.time() - self._last_message[connection_id] < \
self._allowed_frequency:
LOGGER.debug(
"Too many Pings in %s seconds before"
"authorization is complete: %s", self._allowed_frequency,
connection_id)
violation = AuthorizationViolation(
violation=RoleType.Value("NETWORK"))
return HandlerResult(
HandlerStatus.RETURN_AND_CLOSE,
message_out=violation,
message_type=validator_pb2.Message.AUTHORIZATION_VIOLATION)
self._last_message[connection_id] = time.time()
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
def handle(self, connection_id, message_content):
message = ConnectMessage()
message.ParseFromString(message_content)
LOGGER.debug("got connect message from %s. sending ack",
connection_id)
LOGGER.debug("Endpoint of connecting node is %s",
message.endpoint)
self._network.update_connection_endpoint(connection_id,
message.endpoint)
ack = NetworkAcknowledgement()
if self._network.allow_inbound_connection():
LOGGER.debug("Allowing incoming connection: %s",
connection_id)
ack.status = ack.OK
else:
LOGGER.debug("At max connections, sending error response")
ack.status = ack.ERROR
return HandlerResult(HandlerStatus.RETURN,
message_out=ack,
message_type=validator_pb2.Message.NETWORK_ACK)
