Examples with EthMessage org.hyperledger.besu.ethereum.eth.manager.EthMessage used on opensource projects

Example 1 with EthMessage

use of org.hyperledger.besu.ethereum.eth.manager.EthMessage in project besu by hyperledger.

the class SnapProtocolManager method processMessage.

/**
 * This function is called by the P2P framework when an "SNAP message has been received.
 *
 * @param cap The capability under which the message was transmitted.
 * @param message The message to be decoded.
 */
@Override
public void processMessage(final Capability cap, final Message message) {
    final MessageData messageData = AbstractSnapMessageData.create(message);
    final int code = messageData.getCode();
    LOG.trace("Process snap message {}, {}", cap, code);
    final EthPeer ethPeer = ethPeers.peer(message.getConnection());
    if (ethPeer == null) {
        LOG.debug("Ignoring message received from unknown peer connection: " + message.getConnection());
        return;
    }
    final EthMessage ethMessage = new EthMessage(ethPeer, messageData);
    if (!ethPeer.validateReceivedMessage(ethMessage, getSupportedProtocol())) {
        LOG.debug("Unsolicited message received from, disconnecting: {}", ethPeer);
        ethPeer.disconnect(DisconnectReason.BREACH_OF_PROTOCOL);
        return;
    }
    // This will handle responses
    ethPeers.dispatchMessage(ethPeer, ethMessage, getSupportedProtocol());
    // This will handle requests
    Optional<MessageData> maybeResponseData = Optional.empty();
    try {
        final Map.Entry<BigInteger, MessageData> requestIdAndEthMessage = ethMessage.getData().unwrapMessageData();
        maybeResponseData = snapMessages.dispatch(new EthMessage(ethPeer, requestIdAndEthMessage.getValue())).map(responseData -> responseData.wrapMessageData(requestIdAndEthMessage.getKey()));
    } catch (final RLPException e) {
        LOG.debug("Received malformed message {} , disconnecting: {}", messageData.getData(), ethPeer, e);
        ethPeer.disconnect(DisconnectReason.BREACH_OF_PROTOCOL);
    }
    maybeResponseData.ifPresent(responseData -> {
        try {
            ethPeer.send(responseData, getSupportedProtocol());
        } catch (final PeerConnection.PeerNotConnected error) {
            // Peer disconnected before we could respond - nothing to do
            LOG.trace("Peer disconnected before we could respond - nothing to do " + error.getMessage());
        }
    });
}

Example 2 with EthMessage

use of org.hyperledger.besu.ethereum.eth.manager.EthMessage in project besu by hyperledger.

the class BlockPropagationManager method handleNewBlockHashesFromNetwork.

private void handleNewBlockHashesFromNetwork(final EthMessage message) {
    final Blockchain blockchain = protocolContext.getBlockchain();
    final NewBlockHashesMessage newBlockHashesMessage = NewBlockHashesMessage.readFrom(message.getData());
    try {
        // Register announced blocks
        final List<NewBlockHash> announcedBlocks = Lists.newArrayList(newBlockHashesMessage.getNewHashes());
        traceLambda(LOG, "New block hashes from network {} from peer {}. Current status {}", () -> toLogString(announcedBlocks), message::getPeer, () -> this);
        for (final NewBlockHash announcedBlock : announcedBlocks) {
            message.getPeer().registerKnownBlock(announcedBlock.hash());
            message.getPeer().registerHeight(announcedBlock.hash(), announcedBlock.number());
        }
        // Filter announced blocks for blocks we care to import
        final long localChainHeight = protocolContext.getBlockchain().getChainHeadBlockNumber();
        final long bestChainHeight = syncState.bestChainHeight(localChainHeight);
        final List<NewBlockHash> relevantAnnouncements = announcedBlocks.stream().filter(a -> shouldImportBlockAtHeight(a.number(), localChainHeight, bestChainHeight)).collect(Collectors.toList());
        // Filter for blocks we don't yet know about
        final List<NewBlockHash> newBlocks = new ArrayList<>();
        for (final NewBlockHash announcedBlock : relevantAnnouncements) {
            if (pendingBlocksManager.contains(announcedBlock.hash())) {
                LOG.trace("New block hash from network {} is already pending", announcedBlock);
                continue;
            }
            if (importingBlocks.contains(announcedBlock.hash())) {
                LOG.trace("New block hash from network {} is already importing", announcedBlock);
                continue;
            }
            if (blockchain.contains(announcedBlock.hash())) {
                LOG.trace("New block hash from network {} was already imported", announcedBlock);
                continue;
            }
            if (requestedBlocks.add(announcedBlock.hash())) {
                newBlocks.add(announcedBlock);
            } else {
                LOG.trace("New block hash from network {} was already requested", announcedBlock);
            }
        }
        // Process known blocks we care about
        for (final NewBlockHash newBlock : newBlocks) {
            processAnnouncedBlock(message.getPeer(), newBlock);
        }
    } catch (final RLPException e) {
        LOG.debug("Malformed NEW_BLOCK_HASHES message received from peer, disconnecting: {}", message.getPeer(), e);
        message.getPeer().disconnect(DisconnectReason.BREACH_OF_PROTOCOL);
    }
}