def handle_slave(self, source, message: qrllegacy_pb2.LegacyMessage):
"""
Receives Lattice Public Key Transaction
:param message:
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.SL)
try:
tx = Transaction.from_pbdata(message.slData)
except Exception as e:
logger.error(
'slave_txn rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
source.loseConnection()
return
if not source.factory.master_mr.isRequested(tx.get_message_hash(),
source):
return
if not tx.validate():
logger.warning('>>>Slave Txn %s invalid state validation failed..',
tx.hash)
return
source.factory.add_unprocessed_txn(tx, source.peer_ip)
def handle_peer_list(self, source, message: qrllegacy_pb2.LegacyMessage):
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.PL)
if not config.user.enable_peer_discovery:
return
if not message.plData.peer_ips:
return
# If public port is invalid, ignore rest of the data
if not (0 < message.plData.public_port < 65536):
return
source.set_public_port(message.plData.public_port)
self.insert_to_last_connected_peer(source.ip_public_port, True)
sender_peer = IPMetadata(source.peer.ip, message.plData.public_port)
# Check if peer list contains global ip, if it was sent by peer from a global ip address
new_peers = self.combine_peer_lists(message.plData.peer_ips,
[sender_peer.full_address],
check_global=IPv4Address(source.peer.ip).is_global)
logger.info('%s peers data received: %s', source.peer.ip, new_peers)
if self._p2p_factory is not None:
self._p2p_factory.add_new_peers_to_peer_q(new_peers)
def handle_message_transaction(self, source,
message: qrllegacy_pb2.LegacyMessage):
"""
Message Transaction
This function processes whenever a Transaction having
subtype MESSAGE is received.
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.MT)
try:
tx = Transaction.from_pbdata(message.mtData)
except Exception as e:
logger.error(
'Message Txn rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
source.loseConnection()
return
if not source.factory.master_mr.isRequested(tx.get_message_hash(),
source):
return
if tx.txhash in source.factory.buffered_chain.tx_pool.pending_tx_pool_hash:
return
source.factory.add_unprocessed_txn(tx, source.peer_ip)
def handle_transfer_token_transaction(
source, message: qrllegacy_pb2.LegacyMessage):
"""
Transfer Token Transaction
This function processes whenever a Transaction having
subtype TRANSFERTOKEN is received.
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.TT)
try:
tx = Transaction.from_pbdata(message.ttData)
except Exception as e:
logger.error(
'Transfer Token Txn rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
source.loseConnection()
return
if not source.factory.master_mr.isRequested(tx.get_message_hash(),
source):
return
source.factory.add_unprocessed_txn(tx, source.peer_ip)
def handle_block(self, source,
message: qrllegacy_pb2.LegacyMessage): # block received
"""
Block
This function processes any new block received.
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.BK)
try:
block = Block(message.block)
except Exception as e:
logger.error(
'block rejected - unable to decode serialised data %s',
source.addr_remote)
logger.exception(e)
return
logger.info('>>>Received block from %s %s %s', source.addr_remote,
block.block_number, bin2hstr(block.headerhash))
if not source.factory.master_mr.isRequested(block.headerhash, source,
block):
return
source.factory.pow.pre_block_logic(
block) # FIXME: Ignores return value
source.factory.master_mr.register(qrllegacy_pb2.LegacyMessage.BK,
block.headerhash, message.block)
def handle_chain_state(self, source, message: qrllegacy_pb2.LegacyMessage):
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.CHAINSTATE)
message.chainStateData.timestamp = ntp.getTime() # Receiving time
if len(message.chainStateData.cumulative_difficulty) != 32:
logger.warning('Invalid Cumulative Difficulty sent by peer')
source.loseConnection()
return
self._peer_node_status[source] = message.chainStateData
def handle_sync(self, source, message: qrllegacy_pb2.LegacyMessage):
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.SYNC)
# FIXME: Refactor this
if message.syncData.state == 'Synced':
source.factory.set_peer_synced(source, True)
elif message.syncData.state == '':
if source.factory.synced:
source.send_sync(synced=True)
source.factory.set_peer_synced(source, False)
def handle_p2p_acknowledgement(self, source, message: qrllegacy_pb2.LegacyMessage):
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.P2P_ACK)
source.bytes_sent -= message.p2pAckData.bytes_processed
if source.bytes_sent < 0:
logger.warning('Disconnecting Peer %s', source.addr_remote)
logger.warning('Reason: negative bytes_sent value')
logger.warning('bytes_sent %s', source.bytes_sent)
logger.warning('Ack bytes_processed %s', message.p2pAckData.bytes_processed)
source.loseConnection()
source.send_next()
def handle_peer_list(self, source, message: qrllegacy_pb2.LegacyMessage):
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.PL)
if not config.user.enable_peer_discovery:
return
if message.plData.peer_ips is None:
return
new_peers = set(ip for ip in message.plData.peer_ips)
new_peers.discard(source.host_ip) # Remove local address
logger.info('%s peers data received: %s', source.peer_ip, new_peers)
self.update_peer_addresses(new_peers)
def handle_chain_state(self, source, message: qrllegacy_pb2.LegacyMessage):
# FIXME: Not sure this belongs to peer management
P2PBaseObserver._validate_message(
message, qrllegacy_pb2.LegacyMessage.CHAINSTATE)
message.chainStateData.timestamp = ntp.getTime() # Receiving time
try:
UInt256ToString(message.chainStateData.cumulative_difficulty)
except ValueError:
logger.warning('Invalid Cumulative Difficulty sent by peer')
source.loseConnection()
return
self._peer_node_status[source] = message.chainStateData
def handle_fetch_block(self, source, message: qrllegacy_pb2.LegacyMessage): # Fetch Request for block
"""
Fetch Block
Sends the request for the block.
:return:
"""
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.FB)
block_number = message.fbData.index
logger.info(' Request for %s by %s', block_number, source.peer)
if 0 < block_number <= source.factory.chain_height:
block = source.factory.get_block_by_number(block_number)
msg = qrllegacy_pb2.LegacyMessage(func_name=qrllegacy_pb2.LegacyMessage.PB,
pbData=qrllegacy_pb2.PBData(block=block.pbdata))
source.send(msg)
def handle_tx(self, source, message: qrllegacy_pb2.LegacyMessage):
"""
Transaction
Executed whenever a new TX type message is received.
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.TX)
tx = Transaction.from_pbdata(message.txData)
# NOTE: Connects to MR
if not source.factory.master_mr.isRequested(tx.get_message_hash(),
source):
return
source.factory.add_unprocessed_txn(tx, source.peer_ip)
def handle_tx(source, message: qrllegacy_pb2.LegacyMessage):
"""
Transaction
Executed whenever a new TX type message is received.
:return:
"""
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.TX)
try:
tx = Transaction.from_pbdata(message.txData)
except Exception as e:
logger.error('Message Txn rejected - unable to decode serialised data - closing connection')
logger.exception(e)
source.loseConnection()
return
# NOTE: Connects to MR
if source.factory.master_mr.isRequested(tx.get_message_hash(), source):
source.factory.add_unprocessed_txn(tx, source.peer.ip)
def handle_slave(source, message: qrllegacy_pb2.LegacyMessage):
"""
Receives Slave Transaction
:param source:
:param message:
:return:
"""
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.SL)
try:
tx = Transaction.from_pbdata(message.slData)
except Exception as e:
logger.error('slave_txn rejected - unable to decode serialised data - closing connection')
logger.exception(e)
source.loseConnection()
return
if source.factory.master_mr.isRequested(tx.get_message_hash(), source):
source.factory.add_unprocessed_txn(tx, source.peer.ip)
def handle_peer_list(self, source, message: qrllegacy_pb2.LegacyMessage):
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.PL)
if not config.user.enable_peer_discovery:
return
if not message.plData.peer_ips:
return
sender_peer = IPMetadata(source.peer.ip, message.plData.public_port)
new_peers = self.combine_peer_lists(message.plData.peer_ips,
[sender_peer.full_address],
check_global=True)
new_peers.discard(source.host.full_address) # Remove local address
logger.info('%s peers data received: %s', source.peer.ip, new_peers)
self.extend_known_peers(new_peers)
def handle_chain_state(self, source, message: qrllegacy_pb2.LegacyMessage):
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.CHAINSTATE)
message.chainStateData.timestamp = ntp.getTime() # Receiving time
try:
UInt256ToString(message.chainStateData.cumulative_difficulty)
except ValueError:
logger.warning('Invalid Cumulative Difficulty sent by peer')
source.loseConnection()
return
self._peer_node_status[source] = message.chainStateData
if not self._get_version_compatibility(message.chainStateData.version):
logger.warning("Disconnecting from Peer %s running incompatible node version %s",
source.peer.ip,
message.veData.version)
source.loseConnection()
return
def handle_push_block(self, source, message: qrllegacy_pb2.LegacyMessage):
"""
Push Block
This function processes requested blocks received while syncing.
Block received under this function are directly added to the main
chain i.e. chain.blockchain
It is expected to receive only one block for a given blocknumber.
:return:
"""
# FIXME: Later rename
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.PB)
if message.pbData is None:
return
try:
block = Block(message.pbData.block)
source.factory.block_received(source, block)
except Exception as e:
logger.error('block rejected - unable to decode serialised data %s', source.peer)
logger.exception(e)
def handle_lattice(source, message: qrllegacy_pb2.LegacyMessage):
"""
Receives Lattice Public Key Transaction
:param source:
:param message:
:return:
"""
P2PBaseObserver._validate_message(message,
qrllegacy_pb2.LegacyMessage.LT)
try:
tx = Transaction.from_pbdata(message.ltData)
except Exception as e:
logger.error(
'lattice_public_key rejected - unable to decode serialised data - closing connection'
)
logger.exception(e)
source.loseConnection()
return
if not source.factory.master_mr.isRequested(tx.get_message_hash(),
source):
return
source.factory.add_unprocessed_txn(tx, source.peer_ip)
def handle_sync(self, source, message: qrllegacy_pb2.LegacyMessage):
P2PBaseObserver._validate_message(message, qrllegacy_pb2.LegacyMessage.SYNC)
if message.syncData.state == '':
if source.factory.synced:
source.send_sync(synced=True)
def handle_chain_state(self, source, message: qrllegacy_pb2.LegacyMessage):
P2PBaseObserver._validate_message(
message, qrllegacy_pb2.LegacyMessage.CHAINSTATE)
message.chainStateData.timestamp = int(time.time()) # Receiving time
self._peer_node_status[source] = message.chainStateData
