def block_to_bx_block(
self, block_msg: OntConsensusMessage,
tx_service: TransactionService) -> Tuple[memoryview, BlockInfo]:
compress_start_datetime = datetime.utcnow()
compress_start_timestamp = time.time()
extension_tx_service = typing.cast(ExtensionTransactionService,
tx_service)
self._default_block_size = max(self._default_block_size,
len(block_msg.buf))
tsk = self.compression_tasks.borrow_task()
tsk.init(tpe.InputBytes(block_msg.buf), extension_tx_service.proxy)
try:
task_pool_proxy.run_task(tsk)
except tpe.AggregatedException as e:
self.compression_tasks.return_task(tsk)
raise message_conversion_error.btc_block_compression_error(
block_msg.block_hash(), e)
bx_block = tsk.bx_block()
block = memoryview(bx_block)
compressed_size = len(block)
original_size = len(block_msg.rawbytes())
block_hash = OntObjectHash(
binary=convert.hex_to_bytes(tsk.block_hash().hex_string()))
block_info = BlockInfo(
block_hash, tsk.short_ids(), compress_start_datetime,
datetime.utcnow(), (time.time() - compress_start_timestamp) * 1000,
tsk.txn_count(),
tsk.compressed_block_hash().hex_string(),
tsk.prev_block_hash().hex_string(), original_size, compressed_size,
100 - float(compressed_size) / original_size * 100)
self.compression_tasks.return_task(tsk)
return block, block_info
def msg_consensus(self, msg: OntConsensusMessage):
if not self.node.opts.is_consensus:
return
if msg.consensus_data_type() != ont_constants.BLOCK_PROPOSAL_CONSENSUS_MESSAGE_TYPE:
return
block_hash = msg.block_hash()
node = self.connection.node
if not node.should_process_block_hash(block_hash):
return
node.block_cleanup_service.on_new_block_received(block_hash, msg.prev_block_hash())
block_stats.add_block_event_by_block_hash(block_hash,
BlockStatEventType.BLOCK_RECEIVED_FROM_BLOCKCHAIN_NODE,
network_num=self.connection.network_num,
broadcast_type=BroadcastMessageType.CONSENSUS,
more_info="Protocol: {}, Network: {}".format(
node.opts.blockchain_protocol,
node.opts.blockchain_network
),
msg_size=len(msg.rawbytes())
)
if block_hash in self.connection.node.blocks_seen.contents:
self.node.on_block_seen_by_blockchain_node(block_hash, self.connection)
block_stats.add_block_event_by_block_hash(block_hash,
BlockStatEventType.BLOCK_RECEIVED_FROM_BLOCKCHAIN_NODE_IGNORE_SEEN,
network_num=self.connection.network_num,
broadcast_type=BroadcastMessageType.CONSENSUS)
self.connection.log_info(
"Discarding duplicate consensus block {} from local blockchain node.",
block_hash
)
return
node.track_block_from_node_handling_started(block_hash)
self.connection.log_info(
"Processing consensus block {} from local blockchain node.",
block_hash
)
# Broadcast BlockHoldingMessage through relays and gateways
conns = self.node.broadcast(BlockHoldingMessage(block_hash, self.node.network_num),
broadcasting_conn=self.connection, prepend_to_queue=True,
connection_types=[ConnectionType.RELAY_BLOCK, ConnectionType.GATEWAY])
if len(conns) > 0:
block_stats.add_block_event_by_block_hash(block_hash,
BlockStatEventType.BLOCK_HOLD_SENT_BY_GATEWAY_TO_PEERS,
network_num=self.node.network_num,
broadcast_type=BroadcastMessageType.CONSENSUS,
peers=conns
)
try:
bx_block, block_info = self.node.consensus_message_converter.block_to_bx_block(
msg,
self.node.get_tx_service(),
self.node.opts.enable_block_compression,
self.node.network.min_tx_age_seconds
)
except MessageConversionError as e:
block_stats.add_block_event_by_block_hash(
e.msg_hash,
BlockStatEventType.BLOCK_CONVERSION_FAILED,
network_num=self.connection.network_num,
broadcast_type=BroadcastMessageType.CONSENSUS,
conversion_type=e.conversion_type.value
)
self.connection.log_error(log_messages.BLOCK_COMPRESSION_FAIL_ONT_CONSENSUS, e.msg_hash, e)
return
if block_info.ignored_short_ids:
self.connection.log_debug(
"Ignoring {} new SIDs for {}: {}",
len(block_info.ignored_short_ids), block_info.block_hash, block_info.ignored_short_ids
)
block_stats.add_block_event_by_block_hash(block_hash,
BlockStatEventType.BLOCK_COMPRESSED,
start_date_time=block_info.start_datetime,
end_date_time=block_info.end_datetime,
network_num=self.connection.network_num,
broadcast_type=BroadcastMessageType.CONSENSUS,
prev_block_hash=block_info.prev_block_hash,
original_size=block_info.original_size,
txs_count=block_info.txn_count,
blockchain_network=self.node.opts.blockchain_network,
blockchain_protocol=self.node.opts.blockchain_protocol,
matching_block_hash=block_info.compressed_block_hash,
matching_block_type=StatBlockType.COMPRESSED.value,
more_info="Consensus compression: {}->{} bytes, {}, {}; "
"Tx count: {}".format(
block_info.original_size,
block_info.compressed_size,
stats_format.percentage(block_info.compression_rate),
stats_format.duration(block_info.duration_ms),
block_info.txn_count
)
)
self.node.block_processing_service._process_and_broadcast_compressed_block(
bx_block, self.connection, block_info, block_hash
)