target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void processGetBlockHeaderMessageUsingBlockInBlockchain() throws UnknownHostException { final Blockchain blockchain = new BlockChainBuilder().ofSize(10); final Block block = blockchain.getBlockByNumber(5); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); processor.processBlockHeadersRequest(sender, 1, block.getHash().getBytes(), 1); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_HEADERS_RESPONSE_MESSAGE, message.getMessageType()); final BlockHeadersResponseMessage bMessage = (BlockHeadersResponseMessage) message; Assert.assertEquals(block.getHeader().getHash(), bMessage.getBlockHeaders().get(0).getHash()); }
|
@Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processGetBlockMessageUsingBlockInStore() throws UnknownHostException { final Block block = new BlockGenerator().getBlock(3); final Keccak256 blockHash = block.getHash(); final NetBlockStore store = new NetBlockStore(); store.saveBlock(block); final Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).isEmpty()); processor.processGetBlock(sender, block.getHash().getBytes()); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).contains(sender.getPeerNodeID())); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_MESSAGE, message.getMessageType()); final BlockMessage bMessage = (BlockMessage) message; Assert.assertEquals(block.getHash(), bMessage.getBlock().getHash()); }
|
@Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processGetBlockMessageUsingEmptyStore() throws UnknownHostException { final Block block = new BlockGenerator().getBlock(3); final NetBlockStore store = new NetBlockStore(); final Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).isEmpty()); processor.processGetBlock(sender, block.getHash().getBytes()); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).isEmpty()); Assert.assertTrue(sender.getMessages().isEmpty()); }
|
@Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void testECKey() { ECKey key = new ECKey(); assertTrue(key.isPubKeyCanonical()); assertNotNull(key.getPubKey()); assertNotNull(key.getPrivKeyBytes()); log.debug(ByteUtil.toHexString(key.getPrivKeyBytes()) + " :Generated privkey"); log.debug(ByteUtil.toHexString(key.getPubKey()) + " :Generated pubkey"); }
|
public ECKey() { this(secureRandom); }
|
ECKey { public ECKey() { this(secureRandom); } }
|
ECKey { public ECKey() { this(secureRandom); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { public ECKey() { this(secureRandom); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { public ECKey() { this(secureRandom); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void processGetBlockMessageUsingBlockInBlockchain() throws UnknownHostException { final Blockchain blockchain = new BlockChainBuilder().ofSize(10); final Block block = blockchain.getBlockByNumber(5); final Keccak256 blockHash = block.getHash(); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).isEmpty()); processor.processGetBlock(sender, block.getHash().getBytes()); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).contains(sender.getPeerNodeID())); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_MESSAGE, message.getMessageType()); final BlockMessage bMessage = (BlockMessage) message; Assert.assertEquals(block.getHash(), bMessage.getBlock().getHash()); }
|
@Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash) { logger.trace("Processing get block {} from {}", ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockMessage(block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processBlockRequestMessageUsingBlockInStore() throws UnknownHostException { final Block block = new BlockGenerator().getBlock(3); final Keccak256 blockHash = block.getHash(); final NetBlockStore store = new NetBlockStore(); store.saveBlock(block); final Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).isEmpty()); processor.processBlockRequest(sender, 100, block.getHash().getBytes()); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).contains(sender.getPeerNodeID())); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_RESPONSE_MESSAGE, message.getMessageType()); final BlockResponseMessage bMessage = (BlockResponseMessage) message; Assert.assertEquals(100, bMessage.getId()); Assert.assertEquals(block.getHash(), bMessage.getBlock().getHash()); }
|
@Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processBodyRequestMessageUsingBlockInBlockchain() throws UnknownHostException { final Blockchain blockchain = new BlockChainBuilder().ofSize(10); final Block block = blockchain.getBlockByNumber(3); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); processor.processBodyRequest(sender, 100, block.getHash().getBytes()); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BODY_RESPONSE_MESSAGE, message.getMessageType()); final BodyResponseMessage bMessage = (BodyResponseMessage) message; Assert.assertEquals(100, bMessage.getId()); Assert.assertEquals(block.getTransactionsList(), bMessage.getTransactions()); Assert.assertEquals(block.getUncleList(), bMessage.getUncles()); }
|
@Override public void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing body request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } Message responseMessage = new BodyResponseMessage(requestId, block.getTransactionsList(), block.getUncleList()); sender.sendMessage(responseMessage); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing body request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } Message responseMessage = new BodyResponseMessage(requestId, block.getTransactionsList(), block.getUncleList()); sender.sendMessage(responseMessage); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing body request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } Message responseMessage = new BodyResponseMessage(requestId, block.getTransactionsList(), block.getUncleList()); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing body request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } Message responseMessage = new BodyResponseMessage(requestId, block.getTransactionsList(), block.getUncleList()); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing body request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } Message responseMessage = new BodyResponseMessage(requestId, block.getTransactionsList(), block.getUncleList()); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processBlockHashRequestMessageUsingEmptyStore() throws UnknownHostException { final Block block = new BlockGenerator().getBlock(3); final Keccak256 blockHash = block.getHash(); final NetBlockStore store = new NetBlockStore(); final Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).isEmpty()); processor.processBlockRequest(sender, 100, block.getHash().getBytes()); Assert.assertFalse(nodeInformation.getNodesByBlock(block.getHash()).contains(sender.getPeerNodeID())); Assert.assertTrue(sender.getMessages().isEmpty()); }
|
@Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processBlockHashRequestMessageUsingBlockInBlockchain() throws UnknownHostException { final Blockchain blockchain = new BlockChainBuilder().ofSize(10); final Block block = blockchain.getBlockByNumber(5); final Keccak256 blockHash = block.getHash(); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).isEmpty()); processor.processBlockRequest(sender, 100, block.getHash().getBytes()); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).contains(sender.getPeerNodeID())); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_RESPONSE_MESSAGE, message.getMessageType()); final BlockResponseMessage bMessage = (BlockResponseMessage) message; Assert.assertEquals(100, bMessage.getId()); Assert.assertEquals(block.getHash(), bMessage.getBlock().getHash()); }
|
@Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash) { logger.trace("Processing get block by hash {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); final Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } nodeInformation.addBlockToNode(new Keccak256(hash), sender.getPeerNodeID()); sender.sendMessage(new BlockResponseMessage(requestId, block)); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processBlockHashRequestMessageUsingOutOfBoundsHeight() throws UnknownHostException { final Blockchain blockchain = new BlockChainBuilder().ofSize(10); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); processor.processBlockHashRequest(sender, 100, 99999); Assert.assertTrue(sender.getMessages().isEmpty()); }
|
@Override public void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height) { logger.trace("Processing block hash request {} {} from {}", requestId, height, sender.getPeerNodeID()); if (height == 0){ return; } final Block block = this.getBlockFromBlockchainStore(height); if (block == null) { return; } BlockHashResponseMessage responseMessage = new BlockHashResponseMessage(requestId, block.getHash().getBytes()); sender.sendMessage(responseMessage); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height) { logger.trace("Processing block hash request {} {} from {}", requestId, height, sender.getPeerNodeID()); if (height == 0){ return; } final Block block = this.getBlockFromBlockchainStore(height); if (block == null) { return; } BlockHashResponseMessage responseMessage = new BlockHashResponseMessage(requestId, block.getHash().getBytes()); sender.sendMessage(responseMessage); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height) { logger.trace("Processing block hash request {} {} from {}", requestId, height, sender.getPeerNodeID()); if (height == 0){ return; } final Block block = this.getBlockFromBlockchainStore(height); if (block == null) { return; } BlockHashResponseMessage responseMessage = new BlockHashResponseMessage(requestId, block.getHash().getBytes()); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height) { logger.trace("Processing block hash request {} {} from {}", requestId, height, sender.getPeerNodeID()); if (height == 0){ return; } final Block block = this.getBlockFromBlockchainStore(height); if (block == null) { return; } BlockHashResponseMessage responseMessage = new BlockHashResponseMessage(requestId, block.getHash().getBytes()); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height) { logger.trace("Processing block hash request {} {} from {}", requestId, height, sender.getPeerNodeID()); if (height == 0){ return; } final Block block = this.getBlockFromBlockchainStore(height); if (block == null) { return; } BlockHashResponseMessage responseMessage = new BlockHashResponseMessage(requestId, block.getHash().getBytes()); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processBlockHeadersRequestMessageUsingBlockInBlockchain() throws UnknownHostException { final Blockchain blockchain = new BlockChainBuilder().ofSize(100); final Block block = blockchain.getBlockByNumber(60); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); processor.processBlockHeadersRequest(sender, 100, block.getHash().getBytes(), 20); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_HEADERS_RESPONSE_MESSAGE, message.getMessageType()); final BlockHeadersResponseMessage response = (BlockHeadersResponseMessage) message; Assert.assertEquals(100, response.getId()); Assert.assertNotNull(response.getBlockHeaders()); Assert.assertEquals(20, response.getBlockHeaders().size()); for (int k = 0; k < 20; k++) Assert.assertEquals(blockchain.getBlockByNumber(60 - k).getHash(), response.getBlockHeaders().get(k).getHash()); }
|
@Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processBlockHeadersRequestMessageUsingUnknownHash() throws UnknownHostException { final Blockchain blockchain = new BlockChainBuilder().ofSize(100); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); processor.processBlockHeadersRequest(sender, 100, HashUtil.randomHash(), 20); Assert.assertTrue(sender.getMessages().isEmpty()); }
|
@Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processSkeletonRequestWithGenesisPlusBestBlockInSkeleton() throws UnknownHostException { int skeletonStep = 192; final Blockchain blockchain = new BlockChainBuilder().ofSize(skeletonStep / 2); final Block blockStart = blockchain.getBlockByNumber(5); final Block blockEnd = blockchain.getBlockByNumber(skeletonStep / 2); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); processor.processSkeletonRequest(sender, 100, 5); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.SKELETON_RESPONSE_MESSAGE, message.getMessageType()); final SkeletonResponseMessage bMessage = (SkeletonResponseMessage) message; Assert.assertEquals(100, bMessage.getId()); Block genesis = blockchain.getBlockByNumber(0); Block bestBlock = blockchain.getBestBlock(); BlockIdentifier[] expected = { new BlockIdentifier(genesis.getHash().getBytes(), genesis.getNumber()), new BlockIdentifier(bestBlock.getHash().getBytes(), bestBlock.getNumber()), }; assertBlockIdentifiers(expected, bMessage.getBlockIdentifiers()); }
|
@Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processSkeletonRequestWithThreeResults() throws UnknownHostException { int skeletonStep = 192; final Blockchain blockchain = new BlockChainBuilder().ofSize(300); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); processor.processSkeletonRequest(sender, 100, 5); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.SKELETON_RESPONSE_MESSAGE, message.getMessageType()); final SkeletonResponseMessage bMessage = (SkeletonResponseMessage) message; Assert.assertEquals(100, bMessage.getId()); Block b1 = blockchain.getBlockByNumber(0); Block b2 = blockchain.getBlockByNumber(skeletonStep); Block b3 = blockchain.getBestBlock(); BlockIdentifier[] expected = { new BlockIdentifier(b1.getHash().getBytes(), b1.getNumber()), new BlockIdentifier(b2.getHash().getBytes(), b2.getNumber()), new BlockIdentifier(b3.getHash().getBytes(), b3.getNumber()), }; assertBlockIdentifiers(expected, bMessage.getBlockIdentifiers()); }
|
@Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void testIsPubKeyOnly() { ECKey key = ECKey.fromPublicOnly(pubKey); assertTrue(key.isPubKeyCanonical()); assertTrue(key.isPubKeyOnly()); assertArrayEquals(key.getPubKey(), pubKey); }
|
public boolean isPubKeyOnly() { return priv == null; }
|
ECKey { public boolean isPubKeyOnly() { return priv == null; } }
|
ECKey { public boolean isPubKeyOnly() { return priv == null; } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { public boolean isPubKeyOnly() { return priv == null; } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { public boolean isPubKeyOnly() { return priv == null; } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void processSkeletonRequestNotIncludingGenesis() throws UnknownHostException { int skeletonStep = 192; final Blockchain blockchain = new BlockChainBuilder().ofSize(400); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); processor.processSkeletonRequest(sender, 100, skeletonStep + 5); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.SKELETON_RESPONSE_MESSAGE, message.getMessageType()); final SkeletonResponseMessage bMessage = (SkeletonResponseMessage) message; Assert.assertEquals(100, bMessage.getId()); Block b1 = blockchain.getBlockByNumber(skeletonStep); Block b2 = blockchain.getBlockByNumber(2 * skeletonStep); Block b3 = blockchain.getBestBlock(); BlockIdentifier[] expected = { new BlockIdentifier(b1.getHash().getBytes(), b1.getNumber()), new BlockIdentifier(b2.getHash().getBytes(), b2.getNumber()), new BlockIdentifier(b3.getHash().getBytes(), b3.getNumber()), }; assertBlockIdentifiers(expected, bMessage.getBlockIdentifiers()); }
|
@Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber) { logger.trace("Processing skeleton request {} {} from {}", requestId, startNumber, sender.getPeerNodeID()); int skeletonStep = syncConfiguration.getChunkSize(); Block blockStart = this.getBlockFromBlockchainStore(startNumber); if (blockStart == null) { return; } long skeletonStartHeight = (blockStart.getNumber() / skeletonStep) * skeletonStep; List<BlockIdentifier> blockIdentifiers = new ArrayList<>(); long skeletonNumber = skeletonStartHeight; int maxSkeletonChunks = syncConfiguration.getMaxSkeletonChunks(); long maxSkeletonNumber = Math.min(this.getBestBlockNumber(), skeletonStartHeight + skeletonStep * maxSkeletonChunks); for (; skeletonNumber < maxSkeletonNumber; skeletonNumber += skeletonStep) { byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); } skeletonNumber = Math.min(this.getBestBlockNumber(), skeletonNumber); byte[] skeletonHash = getSkeletonHash(skeletonNumber); blockIdentifiers.add(new BlockIdentifier(skeletonHash, skeletonNumber)); SkeletonResponseMessage responseMessage = new SkeletonResponseMessage(requestId, blockIdentifiers); sender.sendMessage(responseMessage); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void failIfProcessBlockHeadersRequestCountHigher() { final Peer sender = mock(Peer.class); final Block block = new BlockGenerator().getBlock(3); final NetBlockStore store = new NetBlockStore(); store.saveBlock(block); final Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final Integer size = syncConfiguration.getChunkSize() + 1; processor.processBlockHeadersRequest(sender, 1, block.getHash().getBytes(), size); verify(sender, never()).sendMessage(any()); }
|
@Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void getUnknownBlockAsNull() { BlockCache store = getSubject(); assertThat(store.getBlockByHash(HASH_1), nullValue()); }
|
public Block getBlockByHash(byte[] hash) { return blockMap.get(new Keccak256(hash)); }
|
BlockCache { public Block getBlockByHash(byte[] hash) { return blockMap.get(new Keccak256(hash)); } }
|
BlockCache { public Block getBlockByHash(byte[] hash) { return blockMap.get(new Keccak256(hash)); } BlockCache(int cacheSize); }
|
BlockCache { public Block getBlockByHash(byte[] hash) { return blockMap.get(new Keccak256(hash)); } BlockCache(int cacheSize); void removeBlock(Block block); void addBlock(Block block); Block getBlockByHash(byte[] hash); }
|
BlockCache { public Block getBlockByHash(byte[] hash) { return blockMap.get(new Keccak256(hash)); } BlockCache(int cacheSize); void removeBlock(Block block); void addBlock(Block block); Block getBlockByHash(byte[] hash); }
|
@Test public void channelRead0_get_block_message() throws Exception { NodeStatistics.StatHandler statHandler = mock(NodeStatistics.StatHandler.class); NodeStatistics nodeStatistics = mock(NodeStatistics.class); when(channel.getNodeStatistics()).thenReturn(nodeStatistics); when(nodeStatistics.getEthInbound()).thenReturn(statHandler); Message message = new GetBlockMessage(new byte[32]); EthMessage rskMessage = new RskMessage(message); target.channelRead0(ctx, rskMessage); verify(messageHandler).postMessage(eq(channel), eq(message)); }
|
@Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } RskWireProtocol(RskSystemProperties config,
PeerScoringManager peerScoringManager,
MessageHandler messageHandler,
CompositeEthereumListener ethereumListener,
Genesis genesis,
MessageRecorder messageRecorder,
StatusResolver statusResolver,
MessageQueue msgQueue,
Channel channel); }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } RskWireProtocol(RskSystemProperties config,
PeerScoringManager peerScoringManager,
MessageHandler messageHandler,
CompositeEthereumListener ethereumListener,
Genesis genesis,
MessageRecorder messageRecorder,
StatusResolver statusResolver,
MessageQueue msgQueue,
Channel channel); @Override void channelRead0(final ChannelHandlerContext ctx, EthMessage msg); @Override void sendStatus(); @Override boolean hasStatusPassed(); @Override boolean hasStatusSucceeded(); @Override SyncStatistics getStats(); @Override EthVersion getVersion(); @Override void dropConnection(); @Override boolean isUsingNewProtocol(); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void handlerRemoved(ChannelHandlerContext ctx); void activate(); @Override void sendMessage(EthMessage message); }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } RskWireProtocol(RskSystemProperties config,
PeerScoringManager peerScoringManager,
MessageHandler messageHandler,
CompositeEthereumListener ethereumListener,
Genesis genesis,
MessageRecorder messageRecorder,
StatusResolver statusResolver,
MessageQueue msgQueue,
Channel channel); @Override void channelRead0(final ChannelHandlerContext ctx, EthMessage msg); @Override void sendStatus(); @Override boolean hasStatusPassed(); @Override boolean hasStatusSucceeded(); @Override SyncStatistics getStats(); @Override EthVersion getVersion(); @Override void dropConnection(); @Override boolean isUsingNewProtocol(); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void handlerRemoved(ChannelHandlerContext ctx); void activate(); @Override void sendMessage(EthMessage message); }
|
@Test public void channelRead0_block_message() throws Exception { NodeStatistics.StatHandler statHandler = mock(NodeStatistics.StatHandler.class); NodeStatistics nodeStatistics = mock(NodeStatistics.class); when(channel.getNodeStatistics()).thenReturn(nodeStatistics); when(nodeStatistics.getEthInbound()).thenReturn(statHandler); Block block = mock(Block.class); when(block.getHash()).thenReturn(new Keccak256(new byte[32])); Message message = new BlockMessage(block); EthMessage rskMessage = new RskMessage(message); target.channelRead0(ctx, rskMessage); verify(messageHandler).postMessage(eq(channel), eq(message)); }
|
@Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } RskWireProtocol(RskSystemProperties config,
PeerScoringManager peerScoringManager,
MessageHandler messageHandler,
CompositeEthereumListener ethereumListener,
Genesis genesis,
MessageRecorder messageRecorder,
StatusResolver statusResolver,
MessageQueue msgQueue,
Channel channel); }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } RskWireProtocol(RskSystemProperties config,
PeerScoringManager peerScoringManager,
MessageHandler messageHandler,
CompositeEthereumListener ethereumListener,
Genesis genesis,
MessageRecorder messageRecorder,
StatusResolver statusResolver,
MessageQueue msgQueue,
Channel channel); @Override void channelRead0(final ChannelHandlerContext ctx, EthMessage msg); @Override void sendStatus(); @Override boolean hasStatusPassed(); @Override boolean hasStatusSucceeded(); @Override SyncStatistics getStats(); @Override EthVersion getVersion(); @Override void dropConnection(); @Override boolean isUsingNewProtocol(); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void handlerRemoved(ChannelHandlerContext ctx); void activate(); @Override void sendMessage(EthMessage message); }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } RskWireProtocol(RskSystemProperties config,
PeerScoringManager peerScoringManager,
MessageHandler messageHandler,
CompositeEthereumListener ethereumListener,
Genesis genesis,
MessageRecorder messageRecorder,
StatusResolver statusResolver,
MessageQueue msgQueue,
Channel channel); @Override void channelRead0(final ChannelHandlerContext ctx, EthMessage msg); @Override void sendStatus(); @Override boolean hasStatusPassed(); @Override boolean hasStatusSucceeded(); @Override SyncStatistics getStats(); @Override EthVersion getVersion(); @Override void dropConnection(); @Override boolean isUsingNewProtocol(); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void handlerRemoved(ChannelHandlerContext ctx); void activate(); @Override void sendMessage(EthMessage message); }
|
@Test public void channelRead0_status_message() throws Exception { NodeStatistics.StatHandler statHandler = mock(NodeStatistics.StatHandler.class); NodeStatistics nodeStatistics = mock(NodeStatistics.class); when(channel.getNodeStatistics()).thenReturn(nodeStatistics); when(nodeStatistics.getEthInbound()).thenReturn(statHandler); Status status = mock(Status.class); when(status.getBestBlockHash()).thenReturn(new byte[32]); Message message = new co.rsk.net.messages.StatusMessage(status); EthMessage rskMessage = new RskMessage(message); target.channelRead0(ctx, rskMessage); verify(messageHandler).postMessage(eq(channel), eq(message)); }
|
@Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } RskWireProtocol(RskSystemProperties config,
PeerScoringManager peerScoringManager,
MessageHandler messageHandler,
CompositeEthereumListener ethereumListener,
Genesis genesis,
MessageRecorder messageRecorder,
StatusResolver statusResolver,
MessageQueue msgQueue,
Channel channel); }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } RskWireProtocol(RskSystemProperties config,
PeerScoringManager peerScoringManager,
MessageHandler messageHandler,
CompositeEthereumListener ethereumListener,
Genesis genesis,
MessageRecorder messageRecorder,
StatusResolver statusResolver,
MessageQueue msgQueue,
Channel channel); @Override void channelRead0(final ChannelHandlerContext ctx, EthMessage msg); @Override void sendStatus(); @Override boolean hasStatusPassed(); @Override boolean hasStatusSucceeded(); @Override SyncStatistics getStats(); @Override EthVersion getVersion(); @Override void dropConnection(); @Override boolean isUsingNewProtocol(); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void handlerRemoved(ChannelHandlerContext ctx); void activate(); @Override void sendMessage(EthMessage message); }
|
RskWireProtocol extends SimpleChannelInboundHandler<EthMessage> implements Eth { @Override public void channelRead0(final ChannelHandlerContext ctx, EthMessage msg) throws InterruptedException { loggerNet.debug("Read message: {}", msg); if (EthMessageCodes.inRange(msg.getCommand().asByte(), version)) { loggerNet.trace("EthHandler invoke: [{}]", msg.getCommand()); } ethereumListener.trace(String.format("EthHandler invoke: [%s]", msg.getCommand())); channel.getNodeStatistics().getEthInbound().add(); msgQueue.receivedMessage(msg); if (this.messageRecorder != null) { this.messageRecorder.recordMessage(channel.getPeerNodeID(), msg); } if (!hasGoodReputation(ctx)) { ctx.disconnect(); return; } switch (msg.getCommand()) { case STATUS: processStatus((org.ethereum.net.eth.message.StatusMessage) msg, ctx); break; case RSK_MESSAGE: RskMessage rskmessage = (RskMessage)msg; Message message = rskmessage.getMessage(); switch (message.getMessageType()) { case BLOCK_MESSAGE: loggerNet.trace("RSK Block Message: Block {} {} from {}", ((BlockMessage)message).getBlock().getNumber(), ((BlockMessage)message).getBlock().getPrintableHash(), channel.getPeerNodeID()); syncStats.addBlocks(1); break; case GET_BLOCK_MESSAGE: loggerNet.trace("RSK Get Block Message: Block {} from {}", ByteUtil.toHexString(((GetBlockMessage)message).getBlockHash()), channel.getPeerNodeID()); syncStats.getBlock(); break; case STATUS_MESSAGE: loggerNet.trace("RSK Status Message: Block {} {} from {}", ((StatusMessage)message).getStatus().getBestBlockNumber(), ByteUtil.toHexString(((StatusMessage)message).getStatus().getBestBlockHash()), channel.getPeerNodeID()); syncStats.addStatus(); break; } if (this.messageHandler != null) { this.messageHandler.postMessage(channel, rskmessage.getMessage()); } break; default: break; } } RskWireProtocol(RskSystemProperties config,
PeerScoringManager peerScoringManager,
MessageHandler messageHandler,
CompositeEthereumListener ethereumListener,
Genesis genesis,
MessageRecorder messageRecorder,
StatusResolver statusResolver,
MessageQueue msgQueue,
Channel channel); @Override void channelRead0(final ChannelHandlerContext ctx, EthMessage msg); @Override void sendStatus(); @Override boolean hasStatusPassed(); @Override boolean hasStatusSucceeded(); @Override SyncStatistics getStats(); @Override EthVersion getVersion(); @Override void dropConnection(); @Override boolean isUsingNewProtocol(); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void handlerRemoved(ChannelHandlerContext ctx); void activate(); @Override void sendMessage(EthMessage message); }
|
@Test public void remascTx() { TxValidatorNotRemascTxValidator validator = new TxValidatorNotRemascTxValidator(); Transaction tx1 = Mockito.mock(RemascTransaction.class); Mockito.when(tx1.getHash()).thenReturn(Keccak256.ZERO_HASH); Assert.assertFalse(validator.validate(tx1, null, null, null, 0, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); }
|
TxValidatorNotRemascTxValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); } }
|
TxValidatorNotRemascTxValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); } }
|
TxValidatorNotRemascTxValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorNotRemascTxValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void commonTx() { TxValidatorNotRemascTxValidator validator = new TxValidatorNotRemascTxValidator(); Assert.assertTrue(validator.validate(Mockito.mock(Transaction.class), null, null, null, 0, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); }
|
TxValidatorNotRemascTxValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); } }
|
TxValidatorNotRemascTxValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); } }
|
TxValidatorNotRemascTxValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorNotRemascTxValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (!(tx instanceof RemascTransaction)) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction is a remasc transaction"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void validIntrinsicGasPrice() { Transaction tx1 = new Transaction(BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), BigInteger.valueOf(21000).toByteArray(), new ECKey().getAddress(), BigInteger.ZERO.toByteArray(), null, Constants.REGTEST_CHAIN_ID); tx1.sign(new ECKey().getPrivKeyBytes()); Transaction tx2 = new Transaction(BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), BigInteger.valueOf(30000).toByteArray(), new ECKey().getAddress(), BigInteger.ZERO.toByteArray(), Hex.decode("0001"), Constants.REGTEST_CHAIN_ID); tx2.sign(new ECKey().getPrivKeyBytes()); Transaction tx3 = new Transaction(BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), BigInteger.valueOf(21072).toByteArray(), new ECKey().getAddress(), BigInteger.ZERO.toByteArray(), Hex.decode("0001"), Constants.REGTEST_CHAIN_ID); tx3.sign(new ECKey().getPrivKeyBytes()); Transaction tx4 = new Transaction(BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), PrecompiledContracts.BRIDGE_ADDR.getBytes(), BigInteger.ZERO.toByteArray(), null, Constants.REGTEST_CHAIN_ID); BridgeRegTestConstants bridgeRegTestConstants = BridgeRegTestConstants.getInstance(); tx4.sign(BridgeRegTestConstants.REGTEST_FEDERATION_PRIVATE_KEYS.get(0).getPrivKeyBytes()); TxValidatorIntrinsicGasLimitValidator tvigpv = new TxValidatorIntrinsicGasLimitValidator(constants, activationConfig); Assert.assertTrue(tvigpv.validate(tx1, new AccountState(), null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertTrue(tvigpv.validate(tx2, new AccountState(), null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertTrue(tvigpv.validate(tx3, new AccountState(), null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertTrue(tvigpv.validate(tx4, new AccountState(), null, null, Long.MAX_VALUE, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); }
|
TxValidatorIntrinsicGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); } }
|
TxValidatorIntrinsicGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); } TxValidatorIntrinsicGasLimitValidator(Constants constants, ActivationConfig activationConfig); }
|
TxValidatorIntrinsicGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); } TxValidatorIntrinsicGasLimitValidator(Constants constants, ActivationConfig activationConfig); @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorIntrinsicGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); } TxValidatorIntrinsicGasLimitValidator(Constants constants, ActivationConfig activationConfig); @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void invalidIntrinsicGasPrice() { Transaction tx1 = new Transaction(BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), BigInteger.valueOf(21071).toByteArray(), new ECKey().getAddress(), BigInteger.ZERO.toByteArray(), Hex.decode("0001"), Constants.REGTEST_CHAIN_ID); tx1.sign(new ECKey().getPrivKeyBytes()); Transaction tx2 = new Transaction(BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), BigInteger.valueOf(20999).toByteArray(), new ECKey().getAddress(), BigInteger.ZERO.toByteArray(), null, Constants.REGTEST_CHAIN_ID); tx2.sign(new ECKey().getPrivKeyBytes()); Transaction tx3 = new Transaction(BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), new ECKey().getAddress(), BigInteger.ZERO.toByteArray(), Hex.decode("0001"), Constants.REGTEST_CHAIN_ID); tx3.sign(new ECKey().getPrivKeyBytes()); Transaction tx4 = new Transaction(BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), BigInteger.ZERO.toByteArray(), new ECKey().getAddress(), BigInteger.ZERO.toByteArray(), null, Constants.REGTEST_CHAIN_ID); tx4.sign(new ECKey().getPrivKeyBytes()); TxValidatorIntrinsicGasLimitValidator tvigpv = new TxValidatorIntrinsicGasLimitValidator(constants, activationConfig); Assert.assertFalse(tvigpv.validate(tx1, new AccountState(), null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertFalse(tvigpv.validate(tx2, new AccountState(), null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertFalse(tvigpv.validate(tx3, new AccountState(), null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertFalse(tvigpv.validate(tx4, new AccountState(), null, null, Long.MAX_VALUE, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); }
|
TxValidatorIntrinsicGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); } }
|
TxValidatorIntrinsicGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); } TxValidatorIntrinsicGasLimitValidator(Constants constants, ActivationConfig activationConfig); }
|
TxValidatorIntrinsicGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); } TxValidatorIntrinsicGasLimitValidator(Constants constants, ActivationConfig activationConfig); @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorIntrinsicGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (BigInteger.valueOf(tx.transactionCost(constants, activationConfig.forBlock(bestBlockNumber))).compareTo(tx.getGasLimitAsInteger()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("transaction's basic cost is above the gas limit"); } TxValidatorIntrinsicGasLimitValidator(Constants constants, ActivationConfig activationConfig); @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void testPublicKeyFromPrivate() { byte[] pubFromPriv = ECKey.publicKeyFromPrivate(privateKey, false); assertArrayEquals(pubKey, pubFromPriv); }
|
public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); }
|
ECKey { public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); } }
|
ECKey { public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void validGasLimit() { Transaction tx1 = Mockito.mock(Transaction.class); Transaction tx2 = Mockito.mock(Transaction.class); Mockito.when(tx1.getGasLimitAsInteger()).thenReturn(BigInteger.valueOf(1)); Mockito.when(tx2.getGasLimitAsInteger()).thenReturn(BigInteger.valueOf(6)); BigInteger gl = BigInteger.valueOf(6); TxValidatorGasLimitValidator tvglv = new TxValidatorGasLimitValidator(); Assert.assertTrue(tvglv.validate(tx1, null, gl, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertTrue(tvglv.validate(tx2, null, gl, null, Long.MAX_VALUE, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); }
|
TxValidatorGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); } }
|
TxValidatorGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); } }
|
TxValidatorGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void invalidGasLimit() { Transaction tx1 = Mockito.mock(Transaction.class); Mockito.when(tx1.getGasLimitAsInteger()).thenReturn(BigInteger.valueOf(6)); Mockito.when(tx1.getHash()).thenReturn(Keccak256.ZERO_HASH); BigInteger gl = BigInteger.valueOf(3); TxValidatorGasLimitValidator tvglv = new TxValidatorGasLimitValidator(); Assert.assertFalse(tvglv.validate(tx1, null, gl, null, Long.MAX_VALUE, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); }
|
TxValidatorGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); } }
|
TxValidatorGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); } }
|
TxValidatorGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorGasLimitValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger txGasLimit = tx.getGasLimitAsInteger(); if (txGasLimit.compareTo(gasLimit) <= 0 && txGasLimit.compareTo(Constants.getTransactionGasCap()) <= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError(String.format( "transaction's gas limit of %s is higher than the block's gas limit of %s", txGasLimit, gasLimit )); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void validAccountState() { AccountState state = Mockito.mock(AccountState.class); Mockito.when(state.isDeleted()).thenReturn(false); TxValidatorAccountStateValidator tvasv = new TxValidatorAccountStateValidator(); Assert.assertTrue(tvasv.validate(null, state, null, null, Long.MAX_VALUE, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); }
|
TxValidatorAccountStateValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); } }
|
TxValidatorAccountStateValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); } }
|
TxValidatorAccountStateValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorAccountStateValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void invalidAccountState() { AccountState state = Mockito.mock(AccountState.class); Mockito.when(state.isDeleted()).thenReturn(true); TxValidatorAccountStateValidator tvasv = new TxValidatorAccountStateValidator(); Assert.assertFalse(tvasv.validate(null, state, null, null, Long.MAX_VALUE, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); }
|
TxValidatorAccountStateValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); } }
|
TxValidatorAccountStateValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); } }
|
TxValidatorAccountStateValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorAccountStateValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } if (state.isDeleted()) { return TransactionValidationResult.withError("the sender account is deleted"); } return TransactionValidationResult.ok(); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void oneSlotRange() { Transaction tx1 = Mockito.mock(Transaction.class); Transaction tx2 = Mockito.mock(Transaction.class); Transaction tx3 = Mockito.mock(Transaction.class); AccountState as = Mockito.mock(AccountState.class); Mockito.when(tx1.getNonceAsInteger()).thenReturn(BigInteger.valueOf(0)); Mockito.when(tx2.getNonceAsInteger()).thenReturn(BigInteger.valueOf(1)); Mockito.when(tx3.getNonceAsInteger()).thenReturn(BigInteger.valueOf(2)); Mockito.when(as.getNonce()).thenReturn(BigInteger.valueOf(1)); TxValidatorNonceRangeValidator tvnrv = new TxValidatorNonceRangeValidator(1); Assert.assertFalse(tvnrv.validate(tx1, as, null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertTrue(tvnrv.validate(tx2, as, null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertFalse(tvnrv.validate(tx3, as, null, null, Long.MAX_VALUE, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); }
|
TxValidatorNonceRangeValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); } }
|
TxValidatorNonceRangeValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); } TxValidatorNonceRangeValidator(int accountSlots); }
|
TxValidatorNonceRangeValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); } TxValidatorNonceRangeValidator(int accountSlots); @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorNonceRangeValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); } TxValidatorNonceRangeValidator(int accountSlots); @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void fiveSlotsRange() { Transaction[] txs = new Transaction[7]; for (int i = 0; i < 7; i++) { txs[i] = Mockito.mock(Transaction.class); Mockito.when(txs[i].getNonceAsInteger()).thenReturn(BigInteger.valueOf(i)); } AccountState as = Mockito.mock(AccountState.class); Mockito.when(as.getNonce()).thenReturn(BigInteger.valueOf(1)); TxValidatorNonceRangeValidator tvnrv = new TxValidatorNonceRangeValidator(5); for (int i = 0; i < 7; i++) { Transaction tx = txs[i]; long txNonce = tx.getNonceAsInteger().longValue(); boolean isValid = tvnrv.validate(tx, as, null, null, Long.MAX_VALUE, false).transactionIsValid(); Assert.assertEquals(isValid, txNonce >= 1 && txNonce <= 5); } }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); }
|
TxValidatorNonceRangeValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); } }
|
TxValidatorNonceRangeValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); } TxValidatorNonceRangeValidator(int accountSlots); }
|
TxValidatorNonceRangeValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); } TxValidatorNonceRangeValidator(int accountSlots); @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorNonceRangeValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { BigInteger nonce = tx.getNonceAsInteger(); BigInteger stateNonce = state == null ? BigInteger.ZERO : state.getNonce(); if (stateNonce.compareTo(nonce) > 0) { return TransactionValidationResult.withError("transaction nonce too low"); } if (stateNonce.add(accountSlots).compareTo(nonce) <= 0) { return TransactionValidationResult.withError("transaction nonce too high"); } return TransactionValidationResult.ok(); } TxValidatorNonceRangeValidator(int accountSlots); @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void validAccountBalance() { Transaction tx1 = Mockito.mock(Transaction.class); Transaction tx2 = Mockito.mock(Transaction.class); Transaction tx3 = Mockito.mock(Transaction.class); AccountState as = Mockito.mock(AccountState.class); Mockito.when(tx1.getGasLimitAsInteger()).thenReturn(BigInteger.valueOf(1)); Mockito.when(tx2.getGasLimitAsInteger()).thenReturn(BigInteger.valueOf(1)); Mockito.when(tx3.getGasLimitAsInteger()).thenReturn(BigInteger.valueOf(2)); Mockito.when(tx1.getGasPrice()).thenReturn(Coin.valueOf(1)); Mockito.when(tx2.getGasPrice()).thenReturn(Coin.valueOf(10000)); Mockito.when(tx3.getGasPrice()).thenReturn(Coin.valueOf(5000)); Mockito.when(as.getBalance()).thenReturn(Coin.valueOf(10000)); TxValidatorAccountBalanceValidator tvabv = new TxValidatorAccountBalanceValidator(); Assert.assertTrue(tvabv.validate(tx1, as, null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertTrue(tvabv.validate(tx2, as, null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertTrue(tvabv.validate(tx3, as, null, null, Long.MAX_VALUE, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void invalidAccountBalance() { Transaction tx1 = Mockito.mock(Transaction.class); Transaction tx2 = Mockito.mock(Transaction.class); AccountState as = Mockito.mock(AccountState.class); Mockito.when(tx1.getGasLimitAsInteger()).thenReturn(BigInteger.valueOf(1)); Mockito.when(tx2.getGasLimitAsInteger()).thenReturn(BigInteger.valueOf(2)); Mockito.when(tx1.getGasPrice()).thenReturn(Coin.valueOf(20)); Mockito.when(tx2.getGasPrice()).thenReturn(Coin.valueOf(10)); Mockito.when(as.getBalance()).thenReturn(Coin.valueOf(19)); TxValidatorAccountBalanceValidator tvabv = new TxValidatorAccountBalanceValidator(); Assert.assertFalse(tvabv.validate(tx1, as, null, null, Long.MAX_VALUE, false).transactionIsValid()); Assert.assertFalse(tvabv.validate(tx2, as, null, null, Long.MAX_VALUE, false).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void balanceIsNotValidatedIfFreeTx() { Transaction tx = new Transaction(BigInteger.ZERO.toByteArray(), BigInteger.ONE.toByteArray(), BigInteger.valueOf(21071).toByteArray(), new ECKey().getAddress(), BigInteger.ZERO.toByteArray(), Hex.decode("0001"), Constants.REGTEST_CHAIN_ID); tx.sign(new ECKey().getPrivKeyBytes()); TxValidatorAccountBalanceValidator tv = new TxValidatorAccountBalanceValidator(); Assert.assertTrue(tv.validate(tx, new AccountState(), BigInteger.ONE, Coin.valueOf(1L), Long.MAX_VALUE, true).transactionIsValid()); }
|
@Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
TxValidatorAccountBalanceValidator implements TxValidatorStep { @Override public TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx) { if (isFreeTx) { return TransactionValidationResult.ok(); } if (state == null) { return TransactionValidationResult.withError("the sender account doesn't exist"); } BigInteger txGasLimit = tx.getGasLimitAsInteger(); Coin maximumPrice = tx.getGasPrice().multiply(txGasLimit); if (state.getBalance().compareTo(maximumPrice) >= 0) { return TransactionValidationResult.ok(); } return TransactionValidationResult.withError("insufficient funds"); } @Override TransactionValidationResult validate(Transaction tx, @Nullable AccountState state, BigInteger gasLimit, Coin minimumGasPrice, long bestBlockNumber, boolean isFreeTx); }
|
@Test public void containsNoTransactions() { TxsPerAccount txspa = new TxsPerAccount(); Assert.assertNotNull(txspa.getTransactions()); Assert.assertTrue(txspa.getTransactions().isEmpty()); }
|
public List<Transaction> getTransactions(){ return txs; }
|
TxsPerAccount { public List<Transaction> getTransactions(){ return txs; } }
|
TxsPerAccount { public List<Transaction> getTransactions(){ return txs; } }
|
TxsPerAccount { public List<Transaction> getTransactions(){ return txs; } List<Transaction> getTransactions(); void setTransactions(List<Transaction> txs); @VisibleForTesting BigInteger getNextNonce(); }
|
TxsPerAccount { public List<Transaction> getTransactions(){ return txs; } List<Transaction> getTransactions(); void setTransactions(List<Transaction> txs); @VisibleForTesting BigInteger getNextNonce(); }
|
@Test public void testPublicKeyFromPrivateCompressed() { byte[] pubFromPriv = ECKey.publicKeyFromPrivate(privateKey, true); assertArrayEquals(compressedPubKey, pubFromPriv); }
|
public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); }
|
ECKey { public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); } }
|
ECKey { public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { public static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed) { ECPoint point = CURVE.getG().multiply(privKey); return point.getEncoded(compressed); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void nextNonceIsNull() { TxsPerAccount txspa = new TxsPerAccount(); Assert.assertNull(txspa.getNextNonce()); }
|
@VisibleForTesting public BigInteger getNextNonce() { return this.nextNonce; }
|
TxsPerAccount { @VisibleForTesting public BigInteger getNextNonce() { return this.nextNonce; } }
|
TxsPerAccount { @VisibleForTesting public BigInteger getNextNonce() { return this.nextNonce; } }
|
TxsPerAccount { @VisibleForTesting public BigInteger getNextNonce() { return this.nextNonce; } List<Transaction> getTransactions(); void setTransactions(List<Transaction> txs); @VisibleForTesting BigInteger getNextNonce(); }
|
TxsPerAccount { @VisibleForTesting public BigInteger getNextNonce() { return this.nextNonce; } List<Transaction> getTransactions(); void setTransactions(List<Transaction> txs); @VisibleForTesting BigInteger getNextNonce(); }
|
@Test public void doesNotCointainNonce() { TxsPerAccount txspa = new TxsPerAccount(); Assert.assertFalse(txspa.containsNonce(BigInteger.ONE)); }
|
boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; }
|
TxsPerAccount { boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; } }
|
TxsPerAccount { boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; } }
|
TxsPerAccount { boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; } List<Transaction> getTransactions(); void setTransactions(List<Transaction> txs); @VisibleForTesting BigInteger getNextNonce(); }
|
TxsPerAccount { boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; } List<Transaction> getTransactions(); void setTransactions(List<Transaction> txs); @VisibleForTesting BigInteger getNextNonce(); }
|
@Test public void containsNonce() { TxsPerAccount txspa = new TxsPerAccount(); Transaction tx = buildTransaction(1); txspa.getTransactions().add(tx); Assert.assertTrue(txspa.containsNonce(BigInteger.ONE)); }
|
boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; }
|
TxsPerAccount { boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; } }
|
TxsPerAccount { boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; } }
|
TxsPerAccount { boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; } List<Transaction> getTransactions(); void setTransactions(List<Transaction> txs); @VisibleForTesting BigInteger getNextNonce(); }
|
TxsPerAccount { boolean containsNonce(BigInteger nonce) { for (Transaction tx : txs) { if (new BigInteger(1, tx.getNonce()).equals(nonce)) { return true; } } return false; } List<Transaction> getTransactions(); void setTransactions(List<Transaction> txs); @VisibleForTesting BigInteger getNextNonce(); }
|
@Test public void status() { Block bestBlock = mock(Block.class); Keccak256 blockHash = mock(Keccak256.class); byte[] hashBytes = new byte[]{0x00}; long blockNumber = 52; BlockDifficulty totalDifficulty = mock(BlockDifficulty.class); when(blockStore.getBestBlock()).thenReturn(bestBlock); when(bestBlock.getHash()).thenReturn(blockHash); when(bestBlock.getParentHash()).thenReturn(blockHash); when(blockHash.getBytes()).thenReturn(hashBytes); when(bestBlock.getNumber()).thenReturn(blockNumber); when(blockStore.getTotalDifficultyForHash(eq(hashBytes))).thenReturn(totalDifficulty); Status status = target.currentStatus(); Assert.assertEquals(blockNumber, status.getBestBlockNumber()); Assert.assertEquals(hashBytes, status.getBestBlockHash()); Assert.assertEquals(hashBytes, status.getBestBlockParentHash()); Assert.assertEquals(totalDifficulty, status.getTotalDifficulty()); }
|
public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; }
|
StatusResolver { public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; } }
|
StatusResolver { public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; } StatusResolver(BlockStore blockStore, Genesis genesis); }
|
StatusResolver { public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; } StatusResolver(BlockStore blockStore, Genesis genesis); Status currentStatus(); }
|
StatusResolver { public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; } StatusResolver(BlockStore blockStore, Genesis genesis); Status currentStatus(); }
|
@Test public void status_incompleteBlockchain() { when(blockStore.getMinNumber()).thenReturn(1L); Keccak256 genesisHash = new Keccak256("ee5c851e70650111887bb6c04e18ef4353391abe37846234c17895a9ca2b33d5"); Keccak256 parentHash = new Keccak256("133e83bb305ef21ea7fc86fcced355db2300887274961a136ca5e8c8763687d9"); when(genesis.getHash()).thenReturn(genesisHash); when(genesis.getParentHash()).thenReturn(parentHash); when(genesis.getNumber()).thenReturn(0L); BlockDifficulty genesisDifficulty = new BlockDifficulty(BigInteger.valueOf(10L)); when(genesis.getCumulativeDifficulty()).thenReturn(genesisDifficulty); Status status = target.currentStatus(); Assert.assertEquals(0L, status.getBestBlockNumber()); Assert.assertEquals(genesisHash.getBytes(), status.getBestBlockHash()); Assert.assertEquals(parentHash.getBytes(), status.getBestBlockParentHash()); Assert.assertEquals(genesisDifficulty, status.getTotalDifficulty()); }
|
public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; }
|
StatusResolver { public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; } }
|
StatusResolver { public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; } StatusResolver(BlockStore blockStore, Genesis genesis); }
|
StatusResolver { public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; } StatusResolver(BlockStore blockStore, Genesis genesis); Status currentStatus(); }
|
StatusResolver { public Status currentStatus() { Status status; if (blockStore.getMinNumber() != 0) { status = new Status( genesis.getNumber(), genesis.getHash().getBytes(), genesis.getParentHash().getBytes(), genesis.getCumulativeDifficulty()); } else { Block block = blockStore.getBestBlock(); BlockDifficulty totalDifficulty = blockStore.getTotalDifficultyForHash(block.getHash().getBytes()); status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), totalDifficulty); } return status; } StatusResolver(BlockStore blockStore, Genesis genesis); Status currentStatus(); }
|
@Test public void buildSimpleLogMessage() { String blockHash = "0x01020304"; Duration processingTime = Duration.ofNanos(123_000_000L); String result = BlockProcessResult.buildLogMessage(blockHash, processingTime, null); Assert.assertNotNull(result); Assert.assertEquals("[MESSAGE PROCESS] Block[0x01020304] After[0.123000] seconds, process result. No block connections were made", result); }
|
@VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); }
|
BlockProcessResult { @VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); } }
|
BlockProcessResult { @VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); } BlockProcessResult(boolean additionalValidations, Map<Keccak256, ImportResult> result, String blockHash, Duration processingTime); }
|
BlockProcessResult { @VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); } BlockProcessResult(boolean additionalValidations, Map<Keccak256, ImportResult> result, String blockHash, Duration processingTime); boolean wasBlockAdded(Block block); static boolean importOk(ImportResult blockResult); boolean isBest(); boolean isInvalidBlock(); @VisibleForTesting static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result); }
|
BlockProcessResult { @VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); } BlockProcessResult(boolean additionalValidations, Map<Keccak256, ImportResult> result, String blockHash, Duration processingTime); boolean wasBlockAdded(Block block); static boolean importOk(ImportResult blockResult); boolean isBest(); boolean isInvalidBlock(); @VisibleForTesting static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result); static final Duration LOG_TIME_LIMIT; }
|
@Test public void buildLogMessageWithConnections() { String blockHash = "0x01020304"; Duration processingTime = Duration.ofNanos(123_000_000L); Map<Keccak256, ImportResult> connections = new HashMap<>(); Random random = new Random(); byte[] bytes = new byte[32]; random.nextBytes(bytes); Keccak256 hash = new Keccak256(bytes); connections.put(hash, ImportResult.IMPORTED_BEST); String result = BlockProcessResult.buildLogMessage(blockHash, processingTime, connections); Assert.assertNotNull(result); Assert.assertEquals("[MESSAGE PROCESS] Block[0x01020304] After[0.123000] seconds, process result. Connections attempts: 1 | " + hash.toHexString() + " - IMPORTED_BEST | ", result); }
|
@VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); }
|
BlockProcessResult { @VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); } }
|
BlockProcessResult { @VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); } BlockProcessResult(boolean additionalValidations, Map<Keccak256, ImportResult> result, String blockHash, Duration processingTime); }
|
BlockProcessResult { @VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); } BlockProcessResult(boolean additionalValidations, Map<Keccak256, ImportResult> result, String blockHash, Duration processingTime); boolean wasBlockAdded(Block block); static boolean importOk(ImportResult blockResult); boolean isBest(); boolean isInvalidBlock(); @VisibleForTesting static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result); }
|
BlockProcessResult { @VisibleForTesting public static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result) { StringBuilder sb = new StringBuilder("[MESSAGE PROCESS] Block[") .append(blockHash) .append("] After[") .append(FormatUtils.formatNanosecondsToSeconds(processingTime.toNanos())) .append("] seconds, process result."); if (result == null || result.isEmpty()) { sb.append(" No block connections were made"); } else { sb.append(" Connections attempts: ") .append(result.size()) .append(" | "); for (Map.Entry<Keccak256, ImportResult> entry : result.entrySet()) { sb.append(entry.getKey().toString()) .append(" - ") .append(entry.getValue()) .append(" | "); } } return sb.toString(); } BlockProcessResult(boolean additionalValidations, Map<Keccak256, ImportResult> result, String blockHash, Duration processingTime); boolean wasBlockAdded(Block block); static boolean importOk(ImportResult blockResult); boolean isBest(); boolean isInvalidBlock(); @VisibleForTesting static String buildLogMessage(String blockHash, Duration processingTime, Map<Keccak256, ImportResult> result); static final Duration LOG_TIME_LIMIT; }
|
@Test public void processBlockMessageUsingProcessor() { SimplePeer sender = new SimplePeer(); PeerScoringManager scoring = createPeerScoringManager(); SimpleBlockProcessor sbp = new SimpleBlockProcessor(); NodeMessageHandler processor = new NodeMessageHandler(config, sbp, null, null, null, scoring, mock(StatusResolver.class)); Block block = new BlockChainBuilder().ofSize(1, true).getBestBlock(); Message message = new BlockMessage(block); processor.processMessage(sender, message); Assert.assertNotNull(sbp.getBlocks()); Assert.assertEquals(1, sbp.getBlocks().size()); Assert.assertSame(block, sbp.getBlocks().get(0)); Assert.assertFalse(scoring.isEmpty()); PeerScoring pscoring = scoring.getPeerScoring(sender.getPeerNodeID()); Assert.assertNotNull(pscoring); Assert.assertFalse(pscoring.isEmpty()); Assert.assertEquals(1, pscoring.getTotalEventCounter()); Assert.assertEquals(1, pscoring.getEventCounter(EventType.VALID_BLOCK)); pscoring = scoring.getPeerScoring(sender.getAddress()); Assert.assertNotNull(pscoring); Assert.assertFalse(pscoring.isEmpty()); Assert.assertEquals(1, pscoring.getTotalEventCounter()); Assert.assertEquals(1, pscoring.getEventCounter(EventType.VALID_BLOCK)); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void skipProcessGenesisBlock() throws UnknownHostException { SimplePeer sender = new SimplePeer(); PeerScoringManager scoring = createPeerScoringManager(); SimpleBlockProcessor sbp = new SimpleBlockProcessor(); NodeMessageHandler processor = new NodeMessageHandler(config, sbp, null, null, null, scoring, mock(StatusResolver.class)); Block block = new BlockGenerator().getGenesisBlock(); Message message = new BlockMessage(block); processor.processMessage(sender, message); Assert.assertNotNull(sbp.getBlocks()); Assert.assertEquals(0, sbp.getBlocks().size()); Assert.assertTrue(scoring.isEmpty()); PeerScoring pscoring = scoring.getPeerScoring(sender.getPeerNodeID()); Assert.assertNotNull(pscoring); Assert.assertTrue(pscoring.isEmpty()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void skipAdvancedBlock() throws UnknownHostException { SimplePeer sender = new SimplePeer(); PeerScoringManager scoring = createPeerScoringManager(); SimpleBlockProcessor sbp = new SimpleBlockProcessor(); sbp.setBlockGap(100000); NodeMessageHandler processor = new NodeMessageHandler(config, sbp, null, null, null, scoring, mock(StatusResolver.class)); Block block = new BlockGenerator().createBlock(200000, 0); Message message = new BlockMessage(block); processor.processMessage(sender, message); Assert.assertNotNull(sbp.getBlocks()); Assert.assertEquals(0, sbp.getBlocks().size()); Assert.assertTrue(scoring.isEmpty()); PeerScoring pscoring = scoring.getPeerScoring(sender.getPeerNodeID()); Assert.assertNotNull(pscoring); Assert.assertTrue(pscoring.isEmpty()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void testGetAddress() { ECKey key = ECKey.fromPublicOnly(pubKey); assertArrayEquals(Hex.decode(address), key.getAddress()); }
|
public byte[] getAddress() { if (pubKeyHash == null) { byte[] pubBytes = this.pub.getEncoded(false); pubKeyHash = HashUtil.keccak256Omit12(Arrays.copyOfRange(pubBytes, 1, pubBytes.length)); } return pubKeyHash; }
|
ECKey { public byte[] getAddress() { if (pubKeyHash == null) { byte[] pubBytes = this.pub.getEncoded(false); pubKeyHash = HashUtil.keccak256Omit12(Arrays.copyOfRange(pubBytes, 1, pubBytes.length)); } return pubKeyHash; } }
|
ECKey { public byte[] getAddress() { if (pubKeyHash == null) { byte[] pubBytes = this.pub.getEncoded(false); pubKeyHash = HashUtil.keccak256Omit12(Arrays.copyOfRange(pubBytes, 1, pubBytes.length)); } return pubKeyHash; } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { public byte[] getAddress() { if (pubKeyHash == null) { byte[] pubBytes = this.pub.getEncoded(false); pubKeyHash = HashUtil.keccak256Omit12(Arrays.copyOfRange(pubBytes, 1, pubBytes.length)); } return pubKeyHash; } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { public byte[] getAddress() { if (pubKeyHash == null) { byte[] pubBytes = this.pub.getEncoded(false); pubKeyHash = HashUtil.keccak256Omit12(Arrays.copyOfRange(pubBytes, 1, pubBytes.length)); } return pubKeyHash; } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void postBlockMessageTwice() throws InterruptedException, UnknownHostException { Peer sender = new SimplePeer(); PeerScoringManager scoring = createPeerScoringManager(); SimpleBlockProcessor sbp = new SimpleBlockProcessor(); NodeMessageHandler processor = new NodeMessageHandler(config, sbp, null, null, null, scoring, mock(StatusResolver.class)); Block block = new BlockChainBuilder().ofSize(1, true).getBestBlock(); Message message = new BlockMessage(block); processor.postMessage(sender, message); processor.postMessage(sender, message); PeerScoring pscoring = scoring.getPeerScoring(sender.getPeerNodeID()); Assert.assertNotNull(pscoring); Assert.assertFalse(pscoring.isEmpty()); Assert.assertEquals(1, pscoring.getTotalEventCounter()); Assert.assertEquals(1, pscoring.getEventCounter(EventType.REPEATED_MESSAGE)); }
|
@Override public void postMessage(Peer sender, Message message) { logger.trace("Start post message (queue size {}) (message type {})", this.queue.size(), message.getMessageType()); cleanExpiredMessages(); tryAddMessage(sender, message); logger.trace("End post message (queue size {})", this.queue.size()); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { @Override public void postMessage(Peer sender, Message message) { logger.trace("Start post message (queue size {}) (message type {})", this.queue.size(), message.getMessageType()); cleanExpiredMessages(); tryAddMessage(sender, message); logger.trace("End post message (queue size {})", this.queue.size()); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { @Override public void postMessage(Peer sender, Message message) { logger.trace("Start post message (queue size {}) (message type {})", this.queue.size(), message.getMessageType()); cleanExpiredMessages(); tryAddMessage(sender, message); logger.trace("End post message (queue size {})", this.queue.size()); } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { @Override public void postMessage(Peer sender, Message message) { logger.trace("Start post message (queue size {}) (message type {})", this.queue.size(), message.getMessageType()); cleanExpiredMessages(); tryAddMessage(sender, message); logger.trace("End post message (queue size {})", this.queue.size()); } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { @Override public void postMessage(Peer sender, Message message) { logger.trace("Start post message (queue size {}) (message type {})", this.queue.size(), message.getMessageType()); cleanExpiredMessages(); tryAddMessage(sender, message); logger.trace("End post message (queue size {})", this.queue.size()); } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processMissingPoWBlockMessageUsingProcessor() throws UnknownHostException { SimplePeer sender = new SimplePeer(); PeerScoringManager scoring = createPeerScoringManager(); SimpleBlockProcessor sbp = new SimpleBlockProcessor(); NodeMessageHandler processor = new NodeMessageHandler(config, sbp, null, null, null, scoring, mock(StatusResolver.class)); BlockGenerator blockGenerator = new BlockGenerator(); Block block = blockGenerator.getGenesisBlock(); for (int i = 0; i < 50; i++) { block = blockGenerator.createChildBlock(block); } Message message = new BlockMessage(block); processor.processMessage(sender, message); Assert.assertNotNull(sbp.getBlocks()); Assert.assertEquals(1, sbp.getBlocks().size()); Assert.assertFalse(scoring.isEmpty()); PeerScoring pscoring = scoring.getPeerScoring(sender.getPeerNodeID()); Assert.assertNotNull(pscoring); Assert.assertFalse(pscoring.isEmpty()); Assert.assertEquals(1, pscoring.getTotalEventCounter()); Assert.assertEquals(1, pscoring.getEventCounter(EventType.VALID_BLOCK)); Assert.assertEquals(0, pscoring.getEventCounter(EventType.INVALID_BLOCK)); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processFutureBlockMessageUsingProcessor() throws UnknownHostException { SimpleBlockProcessor sbp = new SimpleBlockProcessor(); NodeMessageHandler processor = new NodeMessageHandler(config, sbp, null, null, null, null, mock(StatusResolver.class)); Block block = new BlockGenerator().getGenesisBlock(); Message message = new BlockMessage(block); SimplePeer sender = new SimplePeer(); processor.processMessage(sender, message); Assert.assertNotNull(sbp.getBlocks()); Assert.assertEquals(0, sbp.getBlocks().size()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test @Ignore("This should be reviewed with sync processor or deleted") public void processStatusMessageUsingNodeBlockProcessor() throws UnknownHostException { final World world = new World(); final Blockchain blockchain = world.getBlockChain(); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor bp = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); final NodeMessageHandler handler = new NodeMessageHandler(config, bp, null, null, null, null, mock(StatusResolver.class)); BlockGenerator blockGenerator = new BlockGenerator(); final Block block = blockGenerator.createChildBlock(blockGenerator.getGenesisBlock()); final Status status = new Status(block.getNumber(), block.getHash().getBytes()); final Message message = new StatusMessage(status); handler.processMessage(sender, message); Assert.assertNotNull(sender.getGetBlockMessages()); Assert.assertEquals(1, sender.getGetBlockMessages().size()); final Message msg = sender.getGetBlockMessages().get(0); Assert.assertEquals(MessageType.GET_BLOCK_MESSAGE, msg.getMessageType()); final GetBlockMessage gbMessage = (GetBlockMessage) msg; Assert.assertArrayEquals(block.getHash().getBytes(), gbMessage.getBlockHash()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test() public void processStatusMessageUsingSyncProcessor() { final SimplePeer sender = new SimplePeer(); final ChannelManager channelManager = mock(ChannelManager.class); when(channelManager.getActivePeers()).thenReturn(Collections.singletonList(sender)); final NodeMessageHandler handler = NodeMessageHandlerUtil.createHandlerWithSyncProcessor(SyncConfiguration.IMMEDIATE_FOR_TESTING, channelManager); BlockGenerator blockGenerator = new BlockGenerator(); final Block block = blockGenerator.createChildBlock(blockGenerator.getGenesisBlock()); final Status status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), new BlockDifficulty(BigInteger.TEN)); final Message message = new StatusMessage(status); handler.processMessage(sender, message); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(MessageType.BLOCK_HEADERS_REQUEST_MESSAGE, sender.getMessages().get(0).getMessageType()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processStatusMessageWithKnownBestBlock() { final World world = new World(); final Blockchain blockchain = world.getBlockChain(); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor bp = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); final SyncProcessor syncProcessor = new SyncProcessor( blockchain, mock(BlockStore.class), mock(ConsensusValidationMainchainView.class), blockSyncService, syncConfiguration, blockFactory, new DummyBlockValidationRule(), new SyncBlockValidatorRule(new BlockUnclesHashValidationRule(), new BlockRootValidationRule(config.getActivationConfig())), null, new PeersInformation(RskMockFactory.getChannelManager(), syncConfiguration, blockchain, RskMockFactory.getPeerScoringManager()), mock(Genesis.class)); final NodeMessageHandler handler = new NodeMessageHandler(config, bp, syncProcessor, null, null, null, mock(StatusResolver.class)); BlockGenerator blockGenerator = new BlockGenerator(); final Block block = blockGenerator.createChildBlock(blockGenerator.getGenesisBlock()); final Status status = new Status(block.getNumber(), block.getHash().getBytes(), block.getParentHash().getBytes(), blockchain.getTotalDifficulty()); final Message message = new StatusMessage(status); store.saveBlock(block); handler.processMessage(sender, message); Assert.assertNotNull(sender.getMessages()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processGetBlockMessageUsingBlockInStore() throws UnknownHostException { final Block block = new BlockGenerator().getBlock(3); final World world = new World(); final Blockchain blockchain = world.getBlockChain(); final NetBlockStore store = new NetBlockStore(); store.saveBlock(block); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor bp = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final NodeMessageHandler handler = new NodeMessageHandler(config, bp, null, null, null, null, mock(StatusResolver.class)); final SimplePeer sender = new SimplePeer(); handler.processMessage(sender, new GetBlockMessage(block.getHash().getBytes())); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_MESSAGE, message.getMessageType()); final BlockMessage bMessage = (BlockMessage) message; Assert.assertEquals(block.getHash(), bMessage.getBlock().getHash()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processGetBlockMessageUsingBlockInBlockchain() throws UnknownHostException { final World world = new World(); final Blockchain blockchain = world.getBlockChain(); final NetBlockStore store = new NetBlockStore(); List<Block> blocks = new BlockGenerator().getBlockChain(blockchain.getBestBlock(), 10); for (Block b: blocks) blockchain.tryToConnect(b); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); NodeBlockProcessor bp = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); NodeMessageHandler handler = new NodeMessageHandler(config, bp, null, null, null, null, mock(StatusResolver.class)); SimplePeer sender = new SimplePeer(); handler.processMessage(sender, new GetBlockMessage(blocks.get(4).getHash().getBytes())); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_MESSAGE, message.getMessageType()); BlockMessage bmessage = (BlockMessage) message; Assert.assertEquals(blocks.get(4).getHash(), bmessage.getBlock().getHash()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processGetBlockMessageUsingEmptyStore() throws UnknownHostException { final Block block = new BlockGenerator().getBlock(3); final World world = new World(); final Blockchain blockchain = world.getBlockChain(); final NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor bp = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final NodeMessageHandler handler = new NodeMessageHandler(config, bp, null, null, null, null, mock(StatusResolver.class)); final SimplePeer sender = new SimplePeer(); handler.processMessage(sender, new GetBlockMessage(block.getHash().getBytes())); Assert.assertTrue(sender.getMessages().isEmpty()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processBlockHeaderRequestMessageUsingBlockInStore() throws UnknownHostException { final Block block = new BlockGenerator().getBlock(3); final World world = new World(); final Blockchain blockchain = world.getBlockChain(); final NetBlockStore store = new NetBlockStore(); store.saveBlock(block); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor bp = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final NodeMessageHandler handler = new NodeMessageHandler(config, bp, null, null, null, null, mock(StatusResolver.class)); final SimplePeer sender = new SimplePeer(); handler.processMessage(sender, new BlockHeadersRequestMessage(1,block.getHash().getBytes(), 1)); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_HEADERS_RESPONSE_MESSAGE, message.getMessageType()); final BlockHeadersResponseMessage bMessage = (BlockHeadersResponseMessage) message; Assert.assertEquals(block.getHash(), bMessage.getBlockHeaders().get(0).getHash()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void testToString() { ECKey key = ECKey.fromPrivate(BigInteger.TEN); assertEquals("pub:04a0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c7893aba425419bc27a3b6c7e693a24c696f794c2ed877a1593cbee53b037368d7", key.toString()); }
|
public String toString() { StringBuilder b = new StringBuilder(); b.append("pub:").append(ByteUtil.toHexString(pub.getEncoded(false))); return b.toString(); }
|
ECKey { public String toString() { StringBuilder b = new StringBuilder(); b.append("pub:").append(ByteUtil.toHexString(pub.getEncoded(false))); return b.toString(); } }
|
ECKey { public String toString() { StringBuilder b = new StringBuilder(); b.append("pub:").append(ByteUtil.toHexString(pub.getEncoded(false))); return b.toString(); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { public String toString() { StringBuilder b = new StringBuilder(); b.append("pub:").append(ByteUtil.toHexString(pub.getEncoded(false))); return b.toString(); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { public String toString() { StringBuilder b = new StringBuilder(); b.append("pub:").append(ByteUtil.toHexString(pub.getEncoded(false))); return b.toString(); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void processBlockHeaderRequestMessageUsingBlockInBlockchain() throws UnknownHostException { final World world = new World(); final Blockchain blockchain = world.getBlockChain(); final NetBlockStore store = new NetBlockStore(); List<Block> blocks = new BlockGenerator().getBlockChain(blockchain.getBestBlock(), 10); for (Block b: blocks) blockchain.tryToConnect(b); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); NodeBlockProcessor bp = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); NodeMessageHandler handler = new NodeMessageHandler(config, bp, null, null, null, null, mock(StatusResolver.class)); SimplePeer sender = new SimplePeer(); handler.processMessage(sender, new BlockHeadersRequestMessage(1, blocks.get(4).getHash().getBytes(), 1)); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_HEADERS_RESPONSE_MESSAGE, message.getMessageType()); BlockHeadersResponseMessage bMessage = (BlockHeadersResponseMessage) message; Assert.assertEquals(blocks.get(4).getHash(), bMessage.getBlockHeaders().get(0).getHash()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processNewBlockHashesMessage() throws UnknownHostException { final World world = new World(); final Blockchain blockchain = world.getBlockChain(); final NetBlockStore store = new NetBlockStore(); final List<Block> blocks = new BlockGenerator().getBlockChain(blockchain.getBestBlock(), 15); final List<Block> bcBlocks = blocks.subList(0, 10); for (Block b: bcBlocks) blockchain.tryToConnect(b); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor bp = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final NodeMessageHandler handler = new NodeMessageHandler(config, bp, null, null, null, null, mock(StatusResolver.class)); class TestCase { protected final NewBlockHashesMessage message; protected final List<Block> expected; public TestCase(@Nonnull final NewBlockHashesMessage message, final List<Block> expected) { this.message = message; this.expected = expected; } } TestCase[] testCases = { new TestCase( new NewBlockHashesMessage(new LinkedList<>()), null ), new TestCase( new NewBlockHashesMessage( Arrays.asList( new BlockIdentifier(blocks.get(5).getHash().getBytes(), blocks.get(5).getNumber()) ) ), null ), new TestCase( new NewBlockHashesMessage( Arrays.asList( new BlockIdentifier(blocks.get(11).getHash().getBytes(), blocks.get(5).getNumber()) ) ), Arrays.asList(blocks.get(11)) ), new TestCase( new NewBlockHashesMessage( Arrays.asList( new BlockIdentifier(blocks.get(11).getHash().getBytes(), blocks.get(5).getNumber()), new BlockIdentifier(blocks.get(5).getHash().getBytes(), blocks.get(5).getNumber()) ) ), Arrays.asList(blocks.get(11)) ), new TestCase( new NewBlockHashesMessage( Arrays.asList( new BlockIdentifier(blocks.get(11).getHash().getBytes(), blocks.get(5).getNumber()), new BlockIdentifier(blocks.get(12).getHash().getBytes(), blocks.get(5).getNumber()) ) ), Arrays.asList(blocks.get(11), blocks.get(12)) ), new TestCase( new NewBlockHashesMessage( Arrays.asList( new BlockIdentifier(blocks.get(11).getHash().getBytes(), blocks.get(5).getNumber()), new BlockIdentifier(blocks.get(11).getHash().getBytes(), blocks.get(5).getNumber()) ) ), Arrays.asList(blocks.get(11)) ) }; for (int i = 0; i < testCases.length; i += 1) { final TestCase testCase = testCases[i]; final SimplePeer sender = new SimplePeer(); handler.processMessage(sender, testCase.message); if (testCase.expected == null) { Assert.assertTrue(sender.getMessages().isEmpty()); continue; } Assert.assertEquals(testCase.expected.size(), sender.getMessages().size()); Assert.assertTrue(sender.getMessages().stream().allMatch(m -> m.getMessageType() == MessageType.GET_BLOCK_MESSAGE)); List<Keccak256> msgs = sender.getMessages().stream() .map(m -> (GetBlockMessage) m) .map(m -> m.getBlockHash()) .map(h -> new Keccak256(h)) .collect(Collectors.toList()); Set<Keccak256> expected = testCase.expected.stream() .map(b -> b.getHash().getBytes()) .map(h -> new Keccak256(h)) .collect(Collectors.toSet()); for (Keccak256 h : msgs) { Assert.assertTrue(expected.contains(h)); } for (Keccak256 h : expected) { Assert.assertTrue( msgs.stream() .filter(h1 -> h.equals(h1)) .count() == 1 ); } } }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processNewBlockHashesMessageDoesNothingBecauseNodeIsSyncing() { BlockProcessor blockProcessor = mock(BlockProcessor.class); Mockito.when(blockProcessor.hasBetterBlockToSync()).thenReturn(true); final NodeMessageHandler handler = new NodeMessageHandler(config, blockProcessor, null, null, null, null, mock(StatusResolver.class)); Message message = mock(Message.class); Mockito.when(message.getMessageType()).thenReturn(MessageType.NEW_BLOCK_HASHES); handler.processMessage(null, message); verify(blockProcessor, never()).processNewBlockHashesMessage(any(), any()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processTransactionsMessage() throws UnknownHostException { PeerScoringManager scoring = createPeerScoringManager(); TransactionGateway transactionGateway = mock(TransactionGateway.class); BlockProcessor blockProcessor = mock(BlockProcessor.class); Mockito.when(blockProcessor.hasBetterBlockToSync()).thenReturn(false); final NodeMessageHandler handler = new NodeMessageHandler(config, blockProcessor, null, null, transactionGateway, scoring, mock(StatusResolver.class)); final SimplePeer sender = new SimplePeer(new NodeID(new byte[] {1})); final SimplePeer sender2 = new SimplePeer(new NodeID(new byte[] {2})); final List<Transaction> txs = TransactionUtils.getTransactions(10); final TransactionsMessage message = new TransactionsMessage(txs); handler.processMessage(sender, message); Mockito.verify(transactionGateway, times(1)).receiveTransactionsFrom(txs, Collections.singleton(sender.getPeerNodeID())); handler.processMessage(sender2, message); Mockito.verify(transactionGateway, times(1)).receiveTransactionsFrom(txs, Collections.singleton(sender2.getPeerNodeID())); Assert.assertFalse(scoring.isEmpty()); PeerScoring pscoring = scoring.getPeerScoring(sender.getPeerNodeID()); Assert.assertNotNull(pscoring); Assert.assertFalse(pscoring.isEmpty()); Assert.assertEquals(10, pscoring.getTotalEventCounter()); Assert.assertEquals(10, pscoring.getEventCounter(EventType.VALID_TRANSACTION)); pscoring = scoring.getPeerScoring(sender2.getPeerNodeID()); Assert.assertNotNull(pscoring); Assert.assertFalse(pscoring.isEmpty()); Assert.assertEquals(10, pscoring.getTotalEventCounter()); Assert.assertEquals(10, pscoring.getEventCounter(EventType.VALID_TRANSACTION)); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processRejectedTransactionsMessage() throws UnknownHostException { PeerScoringManager scoring = createPeerScoringManager(); final SimpleChannelManager channelManager = new SimpleChannelManager(); TransactionGateway transactionGateway = mock(TransactionGateway.class); BlockProcessor blockProcessor = mock(BlockProcessor.class); Mockito.when(blockProcessor.hasBetterBlockToSync()).thenReturn(false); final NodeMessageHandler handler = new NodeMessageHandler(config, blockProcessor, null, channelManager, transactionGateway, scoring, mock(StatusResolver.class)); final SimplePeer sender = new SimplePeer(); final List<Transaction> txs = TransactionUtils.getTransactions(0); final TransactionsMessage message = new TransactionsMessage(txs); handler.processMessage(sender, message); Assert.assertNotNull(channelManager.getTransactions()); Assert.assertEquals(0, channelManager.getTransactions().size()); Assert.assertTrue(scoring.isEmpty()); PeerScoring pscoring = scoring.getPeerScoring(sender.getPeerNodeID()); Assert.assertNotNull(pscoring); Assert.assertTrue(pscoring.isEmpty()); Assert.assertEquals(0, pscoring.getTotalEventCounter()); Assert.assertEquals(0, pscoring.getEventCounter(EventType.INVALID_TRANSACTION)); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processTooMuchGasTransactionMessage() throws UnknownHostException { PeerScoringManager scoring = createPeerScoringManager(); final SimpleChannelManager channelManager = new SimpleChannelManager(); TransactionGateway transactionGateway = mock(TransactionGateway.class); BlockProcessor blockProcessor = mock(BlockProcessor.class); Mockito.when(blockProcessor.hasBetterBlockToSync()).thenReturn(false); final NodeMessageHandler handler = new NodeMessageHandler(config, blockProcessor, null, channelManager, transactionGateway, scoring, mock(StatusResolver.class)); final SimplePeer sender = new SimplePeer(); final List<Transaction> txs = new ArrayList<>(); BigInteger value = BigInteger.ONE; BigInteger nonce = BigInteger.ZERO; BigInteger gasPrice = BigInteger.ONE; BigInteger gasLimit = BigDecimal.valueOf(Math.pow(2, 60)).add(BigDecimal.ONE).toBigInteger(); txs.add(TransactionUtils.createTransaction(TransactionUtils.getPrivateKeyBytes(), TransactionUtils.getAddress(), value, nonce, gasPrice, gasLimit)); final TransactionsMessage message = new TransactionsMessage(txs); handler.processMessage(sender, message); Assert.assertNotNull(channelManager.getTransactions()); Assert.assertEquals(0, channelManager.getTransactions().size()); Assert.assertFalse(scoring.isEmpty()); PeerScoring pscoring = scoring.getPeerScoring(sender.getPeerNodeID()); Assert.assertNotNull(pscoring); Assert.assertFalse(pscoring.isEmpty()); Assert.assertEquals(1, pscoring.getTotalEventCounter()); Assert.assertEquals(1, pscoring.getEventCounter(EventType.VALID_TRANSACTION)); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processTransactionsMessageUsingTransactionPool() throws UnknownHostException { TransactionGateway transactionGateway = mock(TransactionGateway.class); BlockProcessor blockProcessor = mock(BlockProcessor.class); Mockito.when(blockProcessor.hasBetterBlockToSync()).thenReturn(false); final NodeMessageHandler handler = new NodeMessageHandler(config, blockProcessor, null, null, transactionGateway, RskMockFactory.getPeerScoringManager(), mock(StatusResolver.class)); final SimplePeer sender = new SimplePeer(new NodeID(new byte[] {1})); final SimplePeer sender2 = new SimplePeer(new NodeID(new byte[] {2})); final List<Transaction> txs = TransactionUtils.getTransactions(10); final TransactionsMessage message = new TransactionsMessage(txs); handler.processMessage(sender, message); Mockito.verify(transactionGateway, times(1)).receiveTransactionsFrom(txs, Collections.singleton(sender.getPeerNodeID())); handler.processMessage(sender2, message); Mockito.verify(transactionGateway, times(1)).receiveTransactionsFrom(txs, Collections.singleton(sender2.getPeerNodeID())); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processBlockByHashRequestMessageUsingProcessor() throws UnknownHostException { SimpleBlockProcessor sbp = new SimpleBlockProcessor(); NodeMessageHandler processor = new NodeMessageHandler(config, sbp, null, null, null, null, mock(StatusResolver.class)); Block block = new BlockChainBuilder().ofSize(1, true).getBestBlock(); Message message = new BlockRequestMessage(100, block.getHash().getBytes()); processor.processMessage(new SimplePeer(), message); Assert.assertEquals(100, sbp.getRequestId()); Assert.assertArrayEquals(block.getHash().getBytes(), sbp.getHash()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void processBlockHeadersRequestMessageUsingProcessor() throws UnknownHostException { byte[] hash = HashUtil.randomHash(); SimpleBlockProcessor sbp = new SimpleBlockProcessor(); NodeMessageHandler processor = new NodeMessageHandler(config, sbp, null, null, null, null, mock(StatusResolver.class)); Message message = new BlockHeadersRequestMessage(100, hash, 50); processor.processMessage(new SimplePeer(), message); Assert.assertEquals(100, sbp.getRequestId()); Assert.assertArrayEquals(hash, sbp.getHash()); }
|
public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); }
|
NodeMessageHandler implements MessageHandler, InternalService, Runnable { public synchronized void processMessage(final Peer sender, @Nonnull final Message message) { long start = System.nanoTime(); MessageType messageType = message.getMessageType(); logger.trace("Process message type: {}", messageType); MessageVisitor mv = new MessageVisitor(config, blockProcessor, syncProcessor, transactionGateway, peerScoringManager, channelManager, sender); message.accept(mv); long processTime = System.nanoTime() - start; String timeInSeconds = FormatUtils.formatNanosecondsToSeconds(processTime); if ((messageType == MessageType.BLOCK_MESSAGE || messageType == MessageType.BODY_RESPONSE_MESSAGE) && BlockUtils.tooMuchProcessTime(processTime)) { loggerMessageProcess.warn("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } else { loggerMessageProcess.debug("Message[{}] processed after [{}] seconds.", message.getMessageType(), timeInSeconds); } } NodeMessageHandler(RskSystemProperties config,
final BlockProcessor blockProcessor,
final SyncProcessor syncProcessor,
@Nullable final ChannelManager channelManager,
@Nullable final TransactionGateway transactionGateway,
@Nullable final PeerScoringManager peerScoringManager,
StatusResolver statusResolver); synchronized void processMessage(final Peer sender, @Nonnull final Message message); @Override void postMessage(Peer sender, Message message); @Override void start(); @Override void stop(); @Override long getMessageQueueSize(); @Override void run(); static final int MAX_NUMBER_OF_MESSAGES_CACHED; static final long RECEIVED_MESSAGES_CACHE_DURATION; }
|
@Test public void startsSyncingWith5Peers() { SyncConfiguration syncConfiguration = SyncConfiguration.DEFAULT; SimpleSyncEventsHandler syncEventsHandler = new SimpleSyncEventsHandler(); PeersInformation peersInformation = mock(PeersInformation.class); when(peersInformation.count()).thenReturn(1,2,3,4,5); BlockStore blockStore = mock(BlockStore.class); Block bestBlock = mock(Block.class); when(blockStore.getBestBlock()).thenReturn(bestBlock); when(bestBlock.getNumber()).thenReturn(100L); SyncState syncState = new DecidingSyncState(syncConfiguration, syncEventsHandler, peersInformation, blockStore); when(peersInformation.getBestPeer()).thenReturn(Optional.of(mock(Peer.class))); Status status = mock(Status.class); SyncPeerStatus bpStatus = mock(SyncPeerStatus.class); when(bpStatus.getStatus()).thenReturn(status); when(peersInformation.getPeer(any())).thenReturn(bpStatus); for (int i = 0; i < 5; i++) { Assert.assertFalse(syncEventsHandler.startSyncingWasCalled()); syncState.newPeerStatus(); } Assert.assertTrue(syncEventsHandler.startSyncingWasCalled()); }
|
@Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
@Test public void testIsPubKeyCanonicalCorect() { byte[] canonicalPubkey1 = new byte[65]; canonicalPubkey1[0] = 0x04; assertTrue(ECKey.isPubKeyCanonical(canonicalPubkey1)); byte[] canonicalPubkey2 = new byte[33]; canonicalPubkey2[0] = 0x02; assertTrue(ECKey.isPubKeyCanonical(canonicalPubkey2)); byte[] canonicalPubkey3 = new byte[33]; canonicalPubkey3[0] = 0x03; assertTrue(ECKey.isPubKeyCanonical(canonicalPubkey3)); }
|
public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void doesntStartSyncingWithNoPeersAfter2Minutes() { SyncConfiguration syncConfiguration = SyncConfiguration.DEFAULT; SimpleSyncEventsHandler syncEventsHandler = new SimpleSyncEventsHandler(); PeersInformation knownPeers = mock(PeersInformation.class); when(knownPeers.count()).thenReturn(0); when(knownPeers.getBestPeer()).thenReturn(Optional.empty()); SyncState syncState = new DecidingSyncState(syncConfiguration, syncEventsHandler, knownPeers, mock(BlockStore.class)); syncState.tick(Duration.ofMinutes(2)); Assert.assertFalse(syncEventsHandler.startSyncingWasCalled()); }
|
@Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } }
|
DecidingSyncState extends BaseSyncState { @Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } } }
|
DecidingSyncState extends BaseSyncState { @Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); }
|
DecidingSyncState extends BaseSyncState { @Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
DecidingSyncState extends BaseSyncState { @Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
@Test public void startsSyncingWith1PeerAfter2Minutes() { SyncConfiguration syncConfiguration = SyncConfiguration.DEFAULT; SyncEventsHandler syncEventsHandler = mock(SyncEventsHandler.class); PeersInformation peersInformation = mock(PeersInformation.class); when(peersInformation.count()).thenReturn(1); when(peersInformation.getBestPeer()).thenReturn(Optional.of(mock(Peer.class))); Status status = mock(Status.class); SyncPeerStatus bpStatus = mock(SyncPeerStatus.class); when(bpStatus.getStatus()).thenReturn(status); when(peersInformation.getPeer(any())).thenReturn(bpStatus); BlockStore blockStore = mock(BlockStore.class); Block bestBlock = mock(Block.class); when(blockStore.getBestBlock()).thenReturn(bestBlock); when(bestBlock.getNumber()).thenReturn(100L); SyncState syncState = new DecidingSyncState( syncConfiguration, syncEventsHandler, peersInformation, blockStore); verify(syncEventsHandler, never()).startSyncing(any()); syncState.tick(Duration.ofMinutes(2)); verify(syncEventsHandler).startSyncing(any()); }
|
@Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } }
|
DecidingSyncState extends BaseSyncState { @Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } } }
|
DecidingSyncState extends BaseSyncState { @Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); }
|
DecidingSyncState extends BaseSyncState { @Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
DecidingSyncState extends BaseSyncState { @Override public void tick(Duration duration) { peersInformation.cleanExpired(); timeElapsed = timeElapsed.plus(duration); if (peersInformation.count() > 0 && timeElapsed.compareTo(syncConfiguration.getTimeoutWaitingPeers()) >= 0) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
@Test public void backwardsSynchronization() { SyncConfiguration syncConfiguration = SyncConfiguration.DEFAULT; PeersInformation peersInformation = mock(PeersInformation.class); SyncEventsHandler syncEventsHandler = mock(SyncEventsHandler.class); BlockStore blockStore = mock(BlockStore.class); SyncState syncState = new DecidingSyncState(syncConfiguration, syncEventsHandler, peersInformation, blockStore); when(peersInformation.count()).thenReturn(syncConfiguration.getExpectedPeers() + 1); Peer peer = mock(Peer.class); when(peersInformation.getBestPeer()).thenReturn(Optional.of(peer)); SyncPeerStatus syncPeerStatus = mock(SyncPeerStatus.class); Status status = mock(Status.class); when(syncPeerStatus.getStatus()).thenReturn(status); when(peersInformation.getPeer(peer)).thenReturn(syncPeerStatus); when(blockStore.getMinNumber()).thenReturn(1L); Block block = mock(Block.class); long myBestBlockNumber = 90L; when(block.getNumber()).thenReturn(myBestBlockNumber); when(blockStore.getBestBlock()).thenReturn(block); when(status.getBestBlockNumber()).thenReturn(myBestBlockNumber + syncConfiguration.getLongSyncLimit()); syncState.newPeerStatus(); verify(syncEventsHandler).backwardSyncing(peer); }
|
@Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
@Test public void forwardsSynchronization_genesisIsConnected() { SyncConfiguration syncConfiguration = SyncConfiguration.DEFAULT; PeersInformation peersInformation = mock(PeersInformation.class); SyncEventsHandler syncEventsHandler = mock(SyncEventsHandler.class); BlockStore blockStore = mock(BlockStore.class); SyncState syncState = new DecidingSyncState(syncConfiguration, syncEventsHandler, peersInformation, blockStore); when(peersInformation.count()).thenReturn(syncConfiguration.getExpectedPeers() + 1); Peer peer = mock(Peer.class); when(peersInformation.getBestPeer()).thenReturn(Optional.of(peer)); SyncPeerStatus syncPeerStatus = mock(SyncPeerStatus.class); Status status = mock(Status.class); when(syncPeerStatus.getStatus()).thenReturn(status); when(peersInformation.getPeer(peer)).thenReturn(syncPeerStatus); when(blockStore.getMinNumber()).thenReturn(0L); Block block = mock(Block.class); long myBestBlockNumber = 90L; when(block.getNumber()).thenReturn(myBestBlockNumber); when(blockStore.getBestBlock()).thenReturn(block); when(status.getBestBlockNumber()).thenReturn(myBestBlockNumber + 1); syncState.newPeerStatus(); verify(syncEventsHandler).startSyncing(peer); }
|
@Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
@Test public void forwardsSynchronization() { SyncConfiguration syncConfiguration = SyncConfiguration.DEFAULT; PeersInformation peersInformation = mock(PeersInformation.class); SyncEventsHandler syncEventsHandler = mock(SyncEventsHandler.class); BlockStore blockStore = mock(BlockStore.class); SyncState syncState = new DecidingSyncState(syncConfiguration, syncEventsHandler, peersInformation, blockStore); when(peersInformation.count()).thenReturn(syncConfiguration.getExpectedPeers() + 1); Peer peer = mock(Peer.class); when(peersInformation.getBestPeer()).thenReturn(Optional.of(peer)); SyncPeerStatus syncPeerStatus = mock(SyncPeerStatus.class); Status status = mock(Status.class); when(syncPeerStatus.getStatus()).thenReturn(status); when(peersInformation.getPeer(peer)).thenReturn(syncPeerStatus); Block block = mock(Block.class); long myBestBlockNumber = 90L; when(block.getNumber()).thenReturn(myBestBlockNumber); when(blockStore.getBestBlock()).thenReturn(block); when(blockStore.getMinNumber()).thenReturn(1L); when(status.getBestBlockNumber()) .thenReturn(myBestBlockNumber + 1 + syncConfiguration.getLongSyncLimit()); syncState.newPeerStatus(); verify(syncEventsHandler).startSyncing(peer); }
|
@Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
DecidingSyncState extends BaseSyncState { @Override public void newPeerStatus() { if (peersInformation.count() >= syncConfiguration.getExpectedPeers()) { tryStartSyncing(); } } DecidingSyncState(SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
BlockStore blockStore); @Override void newPeerStatus(); @Override void tick(Duration duration); }
|
@Test(expected = IllegalStateException.class) public void onEnter_connectGenesis_genesisIsNotChildsParent() { List<BlockHeader> toRequest = new LinkedList<>(); DownloadingBackwardsBodiesSyncState target = new DownloadingBackwardsBodiesSyncState( syncConfiguration, syncEventsHandler, peersInformation, genesis, blockFactory, blockStore, child, toRequest, peer); when(child.getNumber()).thenReturn(1L); when(genesis.isParentOf(child)).thenReturn(false); target.onEnter(); }
|
@Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } DownloadingBackwardsBodiesSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
Genesis genesis,
BlockFactory blockFactory,
BlockStore blockStore,
Block child,
List<BlockHeader> toRequest,
Peer peer); }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } DownloadingBackwardsBodiesSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
Genesis genesis,
BlockFactory blockFactory,
BlockStore blockStore,
Block child,
List<BlockHeader> toRequest,
Peer peer); @Override void newBody(BodyResponseMessage body, Peer peer); @Override void onEnter(); }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } DownloadingBackwardsBodiesSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
Genesis genesis,
BlockFactory blockFactory,
BlockStore blockStore,
Block child,
List<BlockHeader> toRequest,
Peer peer); @Override void newBody(BodyResponseMessage body, Peer peer); @Override void onEnter(); }
|
@Test(expected = IllegalStateException.class) public void onEnter_connectGenesis_difficultyDoesNotMatch() { List<BlockHeader> toRequest = new LinkedList<>(); DownloadingBackwardsBodiesSyncState target = new DownloadingBackwardsBodiesSyncState( syncConfiguration, syncEventsHandler, peersInformation, genesis, blockFactory, blockStore, child, toRequest, peer); Keccak256 childHash = new Keccak256(new byte[32]); when(child.getHash()).thenReturn(childHash); when(child.getNumber()).thenReturn(1L); when(genesis.isParentOf(child)).thenReturn(true); when(child.getCumulativeDifficulty()).thenReturn(new BlockDifficulty(BigInteger.valueOf(50))); when(genesis.getCumulativeDifficulty()).thenReturn(new BlockDifficulty(BigInteger.valueOf(50))); when(blockStore.getTotalDifficultyForHash(eq(childHash.getBytes()))) .thenReturn(new BlockDifficulty(BigInteger.valueOf(101))); target.onEnter(); }
|
@Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } DownloadingBackwardsBodiesSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
Genesis genesis,
BlockFactory blockFactory,
BlockStore blockStore,
Block child,
List<BlockHeader> toRequest,
Peer peer); }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } DownloadingBackwardsBodiesSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
Genesis genesis,
BlockFactory blockFactory,
BlockStore blockStore,
Block child,
List<BlockHeader> toRequest,
Peer peer); @Override void newBody(BodyResponseMessage body, Peer peer); @Override void onEnter(); }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } DownloadingBackwardsBodiesSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
Genesis genesis,
BlockFactory blockFactory,
BlockStore blockStore,
Block child,
List<BlockHeader> toRequest,
Peer peer); @Override void newBody(BodyResponseMessage body, Peer peer); @Override void onEnter(); }
|
@Test public void onEnter_connectGenesis() { List<BlockHeader> toRequest = new LinkedList<>(); DownloadingBackwardsBodiesSyncState target = new DownloadingBackwardsBodiesSyncState( syncConfiguration, syncEventsHandler, peersInformation, genesis, blockFactory, blockStore, child, toRequest, peer); Keccak256 childHash = new Keccak256(new byte[32]); when(child.getHash()).thenReturn(childHash); when(child.getNumber()).thenReturn(1L); when(genesis.isParentOf(child)).thenReturn(true); when(child.getCumulativeDifficulty()).thenReturn(new BlockDifficulty(BigInteger.valueOf(50))); BlockDifficulty cumulativeDifficulty = new BlockDifficulty(BigInteger.valueOf(50)); when(genesis.getCumulativeDifficulty()).thenReturn(cumulativeDifficulty); when(blockStore.getTotalDifficultyForHash(eq(childHash.getBytes()))) .thenReturn(new BlockDifficulty(BigInteger.valueOf(100))); target.onEnter(); verify(blockStore).saveBlock(eq(genesis), eq(cumulativeDifficulty), eq(true)); verify(blockStore).flush(); verify(syncEventsHandler).stopSyncing(); }
|
@Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } DownloadingBackwardsBodiesSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
Genesis genesis,
BlockFactory blockFactory,
BlockStore blockStore,
Block child,
List<BlockHeader> toRequest,
Peer peer); }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } DownloadingBackwardsBodiesSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
Genesis genesis,
BlockFactory blockFactory,
BlockStore blockStore,
Block child,
List<BlockHeader> toRequest,
Peer peer); @Override void newBody(BodyResponseMessage body, Peer peer); @Override void onEnter(); }
|
DownloadingBackwardsBodiesSyncState extends BaseSyncState { @Override public void onEnter() { if (child.getNumber() == 1L) { connectGenesis(child); blockStore.flush(); syncEventsHandler.stopSyncing(); return; } if (toRequest.isEmpty()) { syncEventsHandler.stopSyncing(); return; } while (!toRequest.isEmpty() && inTransit.size() < syncConfiguration.getMaxRequestedBodies()) { BlockHeader headerToRequest = toRequest.remove(); requestBodies(headerToRequest); } } DownloadingBackwardsBodiesSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
PeersInformation peersInformation,
Genesis genesis,
BlockFactory blockFactory,
BlockStore blockStore,
Block child,
List<BlockHeader> toRequest,
Peer peer); @Override void newBody(BodyResponseMessage body, Peer peer); @Override void onEnter(); }
|
@Test public void onEnter() { when(blockStore.getMinNumber()).thenReturn(50L); Block child = mock(Block.class); Keccak256 hash = new Keccak256(new byte[32]); when(child.getHash()).thenReturn(hash); when(blockStore.getChainBlockByNumber(50L)).thenReturn(child); DownloadingBackwardsHeadersSyncState target = new DownloadingBackwardsHeadersSyncState( syncConfiguration, syncEventsHandler, blockStore, selectedPeer); ArgumentCaptor<ChunkDescriptor> descriptorCaptor = ArgumentCaptor.forClass(ChunkDescriptor.class); target.onEnter(); verify(syncEventsHandler).sendBlockHeadersRequest(eq(selectedPeer), descriptorCaptor.capture()); verify(syncEventsHandler, never()).onSyncIssue(any(), any()); assertEquals(descriptorCaptor.getValue().getHash(), hash.getBytes()); assertEquals(descriptorCaptor.getValue().getCount(), syncConfiguration.getChunkSize()); }
|
@Override public void onEnter() { Keccak256 hashToRequest = child.getHash(); ChunkDescriptor chunkDescriptor = new ChunkDescriptor( hashToRequest.getBytes(), syncConfiguration.getChunkSize()); syncEventsHandler.sendBlockHeadersRequest(selectedPeer, chunkDescriptor); }
|
DownloadingBackwardsHeadersSyncState extends BaseSyncState { @Override public void onEnter() { Keccak256 hashToRequest = child.getHash(); ChunkDescriptor chunkDescriptor = new ChunkDescriptor( hashToRequest.getBytes(), syncConfiguration.getChunkSize()); syncEventsHandler.sendBlockHeadersRequest(selectedPeer, chunkDescriptor); } }
|
DownloadingBackwardsHeadersSyncState extends BaseSyncState { @Override public void onEnter() { Keccak256 hashToRequest = child.getHash(); ChunkDescriptor chunkDescriptor = new ChunkDescriptor( hashToRequest.getBytes(), syncConfiguration.getChunkSize()); syncEventsHandler.sendBlockHeadersRequest(selectedPeer, chunkDescriptor); } DownloadingBackwardsHeadersSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
BlockStore blockStore,
Peer peer); }
|
DownloadingBackwardsHeadersSyncState extends BaseSyncState { @Override public void onEnter() { Keccak256 hashToRequest = child.getHash(); ChunkDescriptor chunkDescriptor = new ChunkDescriptor( hashToRequest.getBytes(), syncConfiguration.getChunkSize()); syncEventsHandler.sendBlockHeadersRequest(selectedPeer, chunkDescriptor); } DownloadingBackwardsHeadersSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
BlockStore blockStore,
Peer peer); @Override void newBlockHeaders(List<BlockHeader> toRequest); @Override void onEnter(); }
|
DownloadingBackwardsHeadersSyncState extends BaseSyncState { @Override public void onEnter() { Keccak256 hashToRequest = child.getHash(); ChunkDescriptor chunkDescriptor = new ChunkDescriptor( hashToRequest.getBytes(), syncConfiguration.getChunkSize()); syncEventsHandler.sendBlockHeadersRequest(selectedPeer, chunkDescriptor); } DownloadingBackwardsHeadersSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
BlockStore blockStore,
Peer peer); @Override void newBlockHeaders(List<BlockHeader> toRequest); @Override void onEnter(); }
|
@Test public void newHeaders() { when(blockStore.getMinNumber()).thenReturn(50L); Block child = mock(Block.class); Keccak256 hash = new Keccak256(new byte[32]); when(child.getHash()).thenReturn(hash); when(blockStore.getChainBlockByNumber(50L)).thenReturn(child); DownloadingBackwardsHeadersSyncState target = new DownloadingBackwardsHeadersSyncState( syncConfiguration, syncEventsHandler, blockStore, selectedPeer); List<BlockHeader> receivedHeaders = new LinkedList<>(); target.newBlockHeaders(receivedHeaders); verify(syncEventsHandler).backwardDownloadBodies(eq(child), eq(receivedHeaders), eq(selectedPeer)); }
|
@Override public void newBlockHeaders(List<BlockHeader> toRequest) { syncEventsHandler.backwardDownloadBodies( child, toRequest.stream().skip(1).collect(Collectors.toList()), selectedPeer ); }
|
DownloadingBackwardsHeadersSyncState extends BaseSyncState { @Override public void newBlockHeaders(List<BlockHeader> toRequest) { syncEventsHandler.backwardDownloadBodies( child, toRequest.stream().skip(1).collect(Collectors.toList()), selectedPeer ); } }
|
DownloadingBackwardsHeadersSyncState extends BaseSyncState { @Override public void newBlockHeaders(List<BlockHeader> toRequest) { syncEventsHandler.backwardDownloadBodies( child, toRequest.stream().skip(1).collect(Collectors.toList()), selectedPeer ); } DownloadingBackwardsHeadersSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
BlockStore blockStore,
Peer peer); }
|
DownloadingBackwardsHeadersSyncState extends BaseSyncState { @Override public void newBlockHeaders(List<BlockHeader> toRequest) { syncEventsHandler.backwardDownloadBodies( child, toRequest.stream().skip(1).collect(Collectors.toList()), selectedPeer ); } DownloadingBackwardsHeadersSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
BlockStore blockStore,
Peer peer); @Override void newBlockHeaders(List<BlockHeader> toRequest); @Override void onEnter(); }
|
DownloadingBackwardsHeadersSyncState extends BaseSyncState { @Override public void newBlockHeaders(List<BlockHeader> toRequest) { syncEventsHandler.backwardDownloadBodies( child, toRequest.stream().skip(1).collect(Collectors.toList()), selectedPeer ); } DownloadingBackwardsHeadersSyncState(
SyncConfiguration syncConfiguration,
SyncEventsHandler syncEventsHandler,
BlockStore blockStore,
Peer peer); @Override void newBlockHeaders(List<BlockHeader> toRequest); @Override void onEnter(); }
|
@Test public void testIsPubKeyCanonicalWrongLength() { byte[] nonCanonicalPubkey1 = new byte[64]; nonCanonicalPubkey1[0] = 0x04; assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey1)); byte[] nonCanonicalPubkey2 = new byte[32]; nonCanonicalPubkey2[0] = 0x02; assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey2)); byte[] nonCanonicalPubkey3 = new byte[32]; nonCanonicalPubkey3[0] = 0x03; assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey3)); }
|
public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void getIsEmptyIfNotPresent() { final BlockNodeInformation nodeInformation = new BlockNodeInformation(); Assert.assertTrue(nodeInformation.getNodesByBlock(createBlockHash(0)).size() == 0); Assert.assertTrue(nodeInformation.getNodesByBlock(createBlockHash(0)).size() == 0); }
|
@Nonnull public synchronized Set<NodeID> getNodesByBlock(@Nonnull final Keccak256 blockHash) { Set<NodeID> result = nodesByBlock.get(blockHash); if (result == null) { result = new HashSet<>(); } return new HashSet<>(result); }
|
BlockNodeInformation { @Nonnull public synchronized Set<NodeID> getNodesByBlock(@Nonnull final Keccak256 blockHash) { Set<NodeID> result = nodesByBlock.get(blockHash); if (result == null) { result = new HashSet<>(); } return new HashSet<>(result); } }
|
BlockNodeInformation { @Nonnull public synchronized Set<NodeID> getNodesByBlock(@Nonnull final Keccak256 blockHash) { Set<NodeID> result = nodesByBlock.get(blockHash); if (result == null) { result = new HashSet<>(); } return new HashSet<>(result); } BlockNodeInformation(final int maxBlocks); BlockNodeInformation(); }
|
BlockNodeInformation { @Nonnull public synchronized Set<NodeID> getNodesByBlock(@Nonnull final Keccak256 blockHash) { Set<NodeID> result = nodesByBlock.get(blockHash); if (result == null) { result = new HashSet<>(); } return new HashSet<>(result); } BlockNodeInformation(final int maxBlocks); BlockNodeInformation(); synchronized void addBlockToNode(@Nonnull final Keccak256 blockHash, @Nonnull final NodeID nodeID); @Nonnull synchronized Set<NodeID> getNodesByBlock(@Nonnull final Keccak256 blockHash); @Nonnull Set<NodeID> getNodesByBlock(@Nonnull final byte[] blockHash); }
|
BlockNodeInformation { @Nonnull public synchronized Set<NodeID> getNodesByBlock(@Nonnull final Keccak256 blockHash) { Set<NodeID> result = nodesByBlock.get(blockHash); if (result == null) { result = new HashSet<>(); } return new HashSet<>(result); } BlockNodeInformation(final int maxBlocks); BlockNodeInformation(); synchronized void addBlockToNode(@Nonnull final Keccak256 blockHash, @Nonnull final NodeID nodeID); @Nonnull synchronized Set<NodeID> getNodesByBlock(@Nonnull final Keccak256 blockHash); @Nonnull Set<NodeID> getNodesByBlock(@Nonnull final byte[] blockHash); }
|
@Test public void sendSkeletonRequest() { Blockchain blockchain = new BlockChainBuilder().ofSize(100); SimplePeer sender = new SimplePeer(new byte[] { 0x01 }); final ChannelManager channelManager = mock(ChannelManager.class); Peer channel = mock(Peer.class); when(channel.getPeerNodeID()).thenReturn(sender.getPeerNodeID()); when(channelManager.getActivePeers()).thenReturn(Collections.singletonList(channel)); SyncProcessor processor = new SyncProcessor( blockchain, mock(org.ethereum.db.BlockStore.class), mock(ConsensusValidationMainchainView.class), null, SyncConfiguration.IMMEDIATE_FOR_TESTING, blockFactory, new ProofOfWorkRule(config).setFallbackMiningEnabled(false), new SyncBlockValidatorRule( new BlockUnclesHashValidationRule(), new BlockRootValidationRule(config.getActivationConfig()) ), DIFFICULTY_CALCULATOR, new PeersInformation(channelManager, SyncConfiguration.IMMEDIATE_FOR_TESTING, blockchain, RskMockFactory.getPeerScoringManager()), mock(Genesis.class)); processor.sendSkeletonRequest(sender, 0); Assert.assertFalse(sender.getMessages().isEmpty()); Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.SKELETON_REQUEST_MESSAGE, message.getMessageType()); SkeletonRequestMessage request = (SkeletonRequestMessage) message; Assert.assertNotEquals(0, request.getId()); Assert.assertEquals(0, request.getStartNumber()); Assert.assertEquals(1, processor.getExpectedResponses().size()); }
|
@Override public void sendSkeletonRequest(Peer peer, long height) { logger.debug("Send skeleton request to node {} height {}", peer.getPeerNodeID(), height); MessageWithId message = new SkeletonRequestMessage(++lastRequestId, height); sendMessage(peer, message); }
|
SyncProcessor implements SyncEventsHandler { @Override public void sendSkeletonRequest(Peer peer, long height) { logger.debug("Send skeleton request to node {} height {}", peer.getPeerNodeID(), height); MessageWithId message = new SkeletonRequestMessage(++lastRequestId, height); sendMessage(peer, message); } }
|
SyncProcessor implements SyncEventsHandler { @Override public void sendSkeletonRequest(Peer peer, long height) { logger.debug("Send skeleton request to node {} height {}", peer.getPeerNodeID(), height); MessageWithId message = new SkeletonRequestMessage(++lastRequestId, height); sendMessage(peer, message); } SyncProcessor(Blockchain blockchain,
BlockStore blockStore,
ConsensusValidationMainchainView consensusValidationMainchainView,
BlockSyncService blockSyncService,
SyncConfiguration syncConfiguration,
BlockFactory blockFactory,
BlockHeaderValidationRule blockHeaderValidationRule,
SyncBlockValidatorRule syncBlockValidatorRule,
DifficultyCalculator difficultyCalculator,
PeersInformation peersInformation,
Genesis genesis); }
|
SyncProcessor implements SyncEventsHandler { @Override public void sendSkeletonRequest(Peer peer, long height) { logger.debug("Send skeleton request to node {} height {}", peer.getPeerNodeID(), height); MessageWithId message = new SkeletonRequestMessage(++lastRequestId, height); sendMessage(peer, message); } SyncProcessor(Blockchain blockchain,
BlockStore blockStore,
ConsensusValidationMainchainView consensusValidationMainchainView,
BlockSyncService blockSyncService,
SyncConfiguration syncConfiguration,
BlockFactory blockFactory,
BlockHeaderValidationRule blockHeaderValidationRule,
SyncBlockValidatorRule syncBlockValidatorRule,
DifficultyCalculator difficultyCalculator,
PeersInformation peersInformation,
Genesis genesis); void processStatus(Peer sender, Status status); void processSkeletonResponse(Peer peer, SkeletonResponseMessage message); void processBlockHashResponse(Peer peer, BlockHashResponseMessage message); void processBlockHeadersResponse(Peer peer, BlockHeadersResponseMessage message); void processBodyResponse(Peer peer, BodyResponseMessage message); void processNewBlockHash(Peer peer, NewBlockHashMessage message); void processBlockResponse(Peer peer, BlockResponseMessage message); @Override void sendSkeletonRequest(Peer peer, long height); @Override void sendBlockHashRequest(Peer peer, long height); @Override void sendBlockHeadersRequest(Peer peer, ChunkDescriptor chunk); @Override long sendBodyRequest(Peer peer, @Nonnull BlockHeader header); Set<NodeID> getKnownPeersNodeIDs(); void onTimePassed(Duration timePassed); @Override void startSyncing(Peer peer); @Override void startDownloadingBodies(
List<Deque<BlockHeader>> pendingHeaders, Map<Peer, List<BlockIdentifier>> skeletons, Peer peer); @Override void startDownloadingHeaders(Map<Peer, List<BlockIdentifier>> skeletons, long connectionPoint, Peer peer); @Override void startDownloadingSkeleton(long connectionPoint, Peer peer); @Override void startFindingConnectionPoint(Peer peer); @Override void backwardSyncing(Peer peer); @Override void backwardDownloadBodies(Block child, List<BlockHeader> toRequest, Peer peer); @Override void stopSyncing(); @Override void onErrorSyncing(NodeID peerId, String message, EventType eventType, Object... arguments); @Override void onSyncIssue(String message, Object... arguments); @VisibleForTesting void registerExpectedMessage(MessageWithId message); @VisibleForTesting SyncState getSyncState(); @VisibleForTesting Map<Long, MessageType> getExpectedResponses(); }
|
SyncProcessor implements SyncEventsHandler { @Override public void sendSkeletonRequest(Peer peer, long height) { logger.debug("Send skeleton request to node {} height {}", peer.getPeerNodeID(), height); MessageWithId message = new SkeletonRequestMessage(++lastRequestId, height); sendMessage(peer, message); } SyncProcessor(Blockchain blockchain,
BlockStore blockStore,
ConsensusValidationMainchainView consensusValidationMainchainView,
BlockSyncService blockSyncService,
SyncConfiguration syncConfiguration,
BlockFactory blockFactory,
BlockHeaderValidationRule blockHeaderValidationRule,
SyncBlockValidatorRule syncBlockValidatorRule,
DifficultyCalculator difficultyCalculator,
PeersInformation peersInformation,
Genesis genesis); void processStatus(Peer sender, Status status); void processSkeletonResponse(Peer peer, SkeletonResponseMessage message); void processBlockHashResponse(Peer peer, BlockHashResponseMessage message); void processBlockHeadersResponse(Peer peer, BlockHeadersResponseMessage message); void processBodyResponse(Peer peer, BodyResponseMessage message); void processNewBlockHash(Peer peer, NewBlockHashMessage message); void processBlockResponse(Peer peer, BlockResponseMessage message); @Override void sendSkeletonRequest(Peer peer, long height); @Override void sendBlockHashRequest(Peer peer, long height); @Override void sendBlockHeadersRequest(Peer peer, ChunkDescriptor chunk); @Override long sendBodyRequest(Peer peer, @Nonnull BlockHeader header); Set<NodeID> getKnownPeersNodeIDs(); void onTimePassed(Duration timePassed); @Override void startSyncing(Peer peer); @Override void startDownloadingBodies(
List<Deque<BlockHeader>> pendingHeaders, Map<Peer, List<BlockIdentifier>> skeletons, Peer peer); @Override void startDownloadingHeaders(Map<Peer, List<BlockIdentifier>> skeletons, long connectionPoint, Peer peer); @Override void startDownloadingSkeleton(long connectionPoint, Peer peer); @Override void startFindingConnectionPoint(Peer peer); @Override void backwardSyncing(Peer peer); @Override void backwardDownloadBodies(Block child, List<BlockHeader> toRequest, Peer peer); @Override void stopSyncing(); @Override void onErrorSyncing(NodeID peerId, String message, EventType eventType, Object... arguments); @Override void onSyncIssue(String message, Object... arguments); @VisibleForTesting void registerExpectedMessage(MessageWithId message); @VisibleForTesting SyncState getSyncState(); @VisibleForTesting Map<Long, MessageType> getExpectedResponses(); }
|
@Test public void sendBlockHashRequest() { Blockchain blockchain = new BlockChainBuilder().ofSize(0); SimplePeer sender = new SimplePeer(new byte[] { 0x01 }); final ChannelManager channelManager = mock(ChannelManager.class); Peer channel = mock(Peer.class); when(channel.getPeerNodeID()).thenReturn(sender.getPeerNodeID()); when(channelManager.getActivePeers()).thenReturn(Collections.singletonList(channel)); SyncProcessor processor = new SyncProcessor( blockchain, mock(org.ethereum.db.BlockStore.class), mock(ConsensusValidationMainchainView.class), null, SyncConfiguration.IMMEDIATE_FOR_TESTING, blockFactory, new ProofOfWorkRule(config).setFallbackMiningEnabled(false), new SyncBlockValidatorRule( new BlockUnclesHashValidationRule(), new BlockRootValidationRule(config.getActivationConfig()) ), DIFFICULTY_CALCULATOR, new PeersInformation(channelManager, SyncConfiguration.IMMEDIATE_FOR_TESTING, blockchain, RskMockFactory.getPeerScoringManager()), mock(Genesis.class)); processor.sendBlockHashRequest(sender, 100); Assert.assertFalse(sender.getMessages().isEmpty()); Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_HASH_REQUEST_MESSAGE, message.getMessageType()); BlockHashRequestMessage request = (BlockHashRequestMessage) message; Assert.assertNotEquals(0, request.getId()); Assert.assertEquals(100, request.getHeight()); Assert.assertEquals(1, processor.getExpectedResponses().size()); }
|
@Override public void sendBlockHashRequest(Peer peer, long height) { logger.debug("Send hash request to node {} height {}", peer.getPeerNodeID(), height); BlockHashRequestMessage message = new BlockHashRequestMessage(++lastRequestId, height); sendMessage(peer, message); }
|
SyncProcessor implements SyncEventsHandler { @Override public void sendBlockHashRequest(Peer peer, long height) { logger.debug("Send hash request to node {} height {}", peer.getPeerNodeID(), height); BlockHashRequestMessage message = new BlockHashRequestMessage(++lastRequestId, height); sendMessage(peer, message); } }
|
SyncProcessor implements SyncEventsHandler { @Override public void sendBlockHashRequest(Peer peer, long height) { logger.debug("Send hash request to node {} height {}", peer.getPeerNodeID(), height); BlockHashRequestMessage message = new BlockHashRequestMessage(++lastRequestId, height); sendMessage(peer, message); } SyncProcessor(Blockchain blockchain,
BlockStore blockStore,
ConsensusValidationMainchainView consensusValidationMainchainView,
BlockSyncService blockSyncService,
SyncConfiguration syncConfiguration,
BlockFactory blockFactory,
BlockHeaderValidationRule blockHeaderValidationRule,
SyncBlockValidatorRule syncBlockValidatorRule,
DifficultyCalculator difficultyCalculator,
PeersInformation peersInformation,
Genesis genesis); }
|
SyncProcessor implements SyncEventsHandler { @Override public void sendBlockHashRequest(Peer peer, long height) { logger.debug("Send hash request to node {} height {}", peer.getPeerNodeID(), height); BlockHashRequestMessage message = new BlockHashRequestMessage(++lastRequestId, height); sendMessage(peer, message); } SyncProcessor(Blockchain blockchain,
BlockStore blockStore,
ConsensusValidationMainchainView consensusValidationMainchainView,
BlockSyncService blockSyncService,
SyncConfiguration syncConfiguration,
BlockFactory blockFactory,
BlockHeaderValidationRule blockHeaderValidationRule,
SyncBlockValidatorRule syncBlockValidatorRule,
DifficultyCalculator difficultyCalculator,
PeersInformation peersInformation,
Genesis genesis); void processStatus(Peer sender, Status status); void processSkeletonResponse(Peer peer, SkeletonResponseMessage message); void processBlockHashResponse(Peer peer, BlockHashResponseMessage message); void processBlockHeadersResponse(Peer peer, BlockHeadersResponseMessage message); void processBodyResponse(Peer peer, BodyResponseMessage message); void processNewBlockHash(Peer peer, NewBlockHashMessage message); void processBlockResponse(Peer peer, BlockResponseMessage message); @Override void sendSkeletonRequest(Peer peer, long height); @Override void sendBlockHashRequest(Peer peer, long height); @Override void sendBlockHeadersRequest(Peer peer, ChunkDescriptor chunk); @Override long sendBodyRequest(Peer peer, @Nonnull BlockHeader header); Set<NodeID> getKnownPeersNodeIDs(); void onTimePassed(Duration timePassed); @Override void startSyncing(Peer peer); @Override void startDownloadingBodies(
List<Deque<BlockHeader>> pendingHeaders, Map<Peer, List<BlockIdentifier>> skeletons, Peer peer); @Override void startDownloadingHeaders(Map<Peer, List<BlockIdentifier>> skeletons, long connectionPoint, Peer peer); @Override void startDownloadingSkeleton(long connectionPoint, Peer peer); @Override void startFindingConnectionPoint(Peer peer); @Override void backwardSyncing(Peer peer); @Override void backwardDownloadBodies(Block child, List<BlockHeader> toRequest, Peer peer); @Override void stopSyncing(); @Override void onErrorSyncing(NodeID peerId, String message, EventType eventType, Object... arguments); @Override void onSyncIssue(String message, Object... arguments); @VisibleForTesting void registerExpectedMessage(MessageWithId message); @VisibleForTesting SyncState getSyncState(); @VisibleForTesting Map<Long, MessageType> getExpectedResponses(); }
|
SyncProcessor implements SyncEventsHandler { @Override public void sendBlockHashRequest(Peer peer, long height) { logger.debug("Send hash request to node {} height {}", peer.getPeerNodeID(), height); BlockHashRequestMessage message = new BlockHashRequestMessage(++lastRequestId, height); sendMessage(peer, message); } SyncProcessor(Blockchain blockchain,
BlockStore blockStore,
ConsensusValidationMainchainView consensusValidationMainchainView,
BlockSyncService blockSyncService,
SyncConfiguration syncConfiguration,
BlockFactory blockFactory,
BlockHeaderValidationRule blockHeaderValidationRule,
SyncBlockValidatorRule syncBlockValidatorRule,
DifficultyCalculator difficultyCalculator,
PeersInformation peersInformation,
Genesis genesis); void processStatus(Peer sender, Status status); void processSkeletonResponse(Peer peer, SkeletonResponseMessage message); void processBlockHashResponse(Peer peer, BlockHashResponseMessage message); void processBlockHeadersResponse(Peer peer, BlockHeadersResponseMessage message); void processBodyResponse(Peer peer, BodyResponseMessage message); void processNewBlockHash(Peer peer, NewBlockHashMessage message); void processBlockResponse(Peer peer, BlockResponseMessage message); @Override void sendSkeletonRequest(Peer peer, long height); @Override void sendBlockHashRequest(Peer peer, long height); @Override void sendBlockHeadersRequest(Peer peer, ChunkDescriptor chunk); @Override long sendBodyRequest(Peer peer, @Nonnull BlockHeader header); Set<NodeID> getKnownPeersNodeIDs(); void onTimePassed(Duration timePassed); @Override void startSyncing(Peer peer); @Override void startDownloadingBodies(
List<Deque<BlockHeader>> pendingHeaders, Map<Peer, List<BlockIdentifier>> skeletons, Peer peer); @Override void startDownloadingHeaders(Map<Peer, List<BlockIdentifier>> skeletons, long connectionPoint, Peer peer); @Override void startDownloadingSkeleton(long connectionPoint, Peer peer); @Override void startFindingConnectionPoint(Peer peer); @Override void backwardSyncing(Peer peer); @Override void backwardDownloadBodies(Block child, List<BlockHeader> toRequest, Peer peer); @Override void stopSyncing(); @Override void onErrorSyncing(NodeID peerId, String message, EventType eventType, Object... arguments); @Override void onSyncIssue(String message, Object... arguments); @VisibleForTesting void registerExpectedMessage(MessageWithId message); @VisibleForTesting SyncState getSyncState(); @VisibleForTesting Map<Long, MessageType> getExpectedResponses(); }
|
@Test(expected = Exception.class) public void processBlockHashResponseWithUnknownHash() { Blockchain blockchain = new BlockChainBuilder().ofSize(0); SimplePeer sender = new SimplePeer(new byte[] { 0x01 }); SyncProcessor processor = new SyncProcessor( blockchain, mock(org.ethereum.db.BlockStore.class), mock(ConsensusValidationMainchainView.class), null, SyncConfiguration.IMMEDIATE_FOR_TESTING, blockFactory, new ProofOfWorkRule(config).setFallbackMiningEnabled(false), new SyncBlockValidatorRule( new BlockUnclesHashValidationRule(), new BlockRootValidationRule(config.getActivationConfig()) ), DIFFICULTY_CALCULATOR, new PeersInformation(getChannelManager(), SyncConfiguration.IMMEDIATE_FOR_TESTING, blockchain, RskMockFactory.getPeerScoringManager()), mock(Genesis.class)); processor.processStatus(sender, new Status(100, null)); }
|
public void processStatus(Peer sender, Status status) { logger.debug("Receiving syncState from node {} block {} {}", sender.getPeerNodeID(), status.getBestBlockNumber(), HashUtil.toPrintableHash(status.getBestBlockHash())); peersInformation.registerPeer(sender).setStatus(status); syncState.newPeerStatus(); }
|
SyncProcessor implements SyncEventsHandler { public void processStatus(Peer sender, Status status) { logger.debug("Receiving syncState from node {} block {} {}", sender.getPeerNodeID(), status.getBestBlockNumber(), HashUtil.toPrintableHash(status.getBestBlockHash())); peersInformation.registerPeer(sender).setStatus(status); syncState.newPeerStatus(); } }
|
SyncProcessor implements SyncEventsHandler { public void processStatus(Peer sender, Status status) { logger.debug("Receiving syncState from node {} block {} {}", sender.getPeerNodeID(), status.getBestBlockNumber(), HashUtil.toPrintableHash(status.getBestBlockHash())); peersInformation.registerPeer(sender).setStatus(status); syncState.newPeerStatus(); } SyncProcessor(Blockchain blockchain,
BlockStore blockStore,
ConsensusValidationMainchainView consensusValidationMainchainView,
BlockSyncService blockSyncService,
SyncConfiguration syncConfiguration,
BlockFactory blockFactory,
BlockHeaderValidationRule blockHeaderValidationRule,
SyncBlockValidatorRule syncBlockValidatorRule,
DifficultyCalculator difficultyCalculator,
PeersInformation peersInformation,
Genesis genesis); }
|
SyncProcessor implements SyncEventsHandler { public void processStatus(Peer sender, Status status) { logger.debug("Receiving syncState from node {} block {} {}", sender.getPeerNodeID(), status.getBestBlockNumber(), HashUtil.toPrintableHash(status.getBestBlockHash())); peersInformation.registerPeer(sender).setStatus(status); syncState.newPeerStatus(); } SyncProcessor(Blockchain blockchain,
BlockStore blockStore,
ConsensusValidationMainchainView consensusValidationMainchainView,
BlockSyncService blockSyncService,
SyncConfiguration syncConfiguration,
BlockFactory blockFactory,
BlockHeaderValidationRule blockHeaderValidationRule,
SyncBlockValidatorRule syncBlockValidatorRule,
DifficultyCalculator difficultyCalculator,
PeersInformation peersInformation,
Genesis genesis); void processStatus(Peer sender, Status status); void processSkeletonResponse(Peer peer, SkeletonResponseMessage message); void processBlockHashResponse(Peer peer, BlockHashResponseMessage message); void processBlockHeadersResponse(Peer peer, BlockHeadersResponseMessage message); void processBodyResponse(Peer peer, BodyResponseMessage message); void processNewBlockHash(Peer peer, NewBlockHashMessage message); void processBlockResponse(Peer peer, BlockResponseMessage message); @Override void sendSkeletonRequest(Peer peer, long height); @Override void sendBlockHashRequest(Peer peer, long height); @Override void sendBlockHeadersRequest(Peer peer, ChunkDescriptor chunk); @Override long sendBodyRequest(Peer peer, @Nonnull BlockHeader header); Set<NodeID> getKnownPeersNodeIDs(); void onTimePassed(Duration timePassed); @Override void startSyncing(Peer peer); @Override void startDownloadingBodies(
List<Deque<BlockHeader>> pendingHeaders, Map<Peer, List<BlockIdentifier>> skeletons, Peer peer); @Override void startDownloadingHeaders(Map<Peer, List<BlockIdentifier>> skeletons, long connectionPoint, Peer peer); @Override void startDownloadingSkeleton(long connectionPoint, Peer peer); @Override void startFindingConnectionPoint(Peer peer); @Override void backwardSyncing(Peer peer); @Override void backwardDownloadBodies(Block child, List<BlockHeader> toRequest, Peer peer); @Override void stopSyncing(); @Override void onErrorSyncing(NodeID peerId, String message, EventType eventType, Object... arguments); @Override void onSyncIssue(String message, Object... arguments); @VisibleForTesting void registerExpectedMessage(MessageWithId message); @VisibleForTesting SyncState getSyncState(); @VisibleForTesting Map<Long, MessageType> getExpectedResponses(); }
|
SyncProcessor implements SyncEventsHandler { public void processStatus(Peer sender, Status status) { logger.debug("Receiving syncState from node {} block {} {}", sender.getPeerNodeID(), status.getBestBlockNumber(), HashUtil.toPrintableHash(status.getBestBlockHash())); peersInformation.registerPeer(sender).setStatus(status); syncState.newPeerStatus(); } SyncProcessor(Blockchain blockchain,
BlockStore blockStore,
ConsensusValidationMainchainView consensusValidationMainchainView,
BlockSyncService blockSyncService,
SyncConfiguration syncConfiguration,
BlockFactory blockFactory,
BlockHeaderValidationRule blockHeaderValidationRule,
SyncBlockValidatorRule syncBlockValidatorRule,
DifficultyCalculator difficultyCalculator,
PeersInformation peersInformation,
Genesis genesis); void processStatus(Peer sender, Status status); void processSkeletonResponse(Peer peer, SkeletonResponseMessage message); void processBlockHashResponse(Peer peer, BlockHashResponseMessage message); void processBlockHeadersResponse(Peer peer, BlockHeadersResponseMessage message); void processBodyResponse(Peer peer, BodyResponseMessage message); void processNewBlockHash(Peer peer, NewBlockHashMessage message); void processBlockResponse(Peer peer, BlockResponseMessage message); @Override void sendSkeletonRequest(Peer peer, long height); @Override void sendBlockHashRequest(Peer peer, long height); @Override void sendBlockHeadersRequest(Peer peer, ChunkDescriptor chunk); @Override long sendBodyRequest(Peer peer, @Nonnull BlockHeader header); Set<NodeID> getKnownPeersNodeIDs(); void onTimePassed(Duration timePassed); @Override void startSyncing(Peer peer); @Override void startDownloadingBodies(
List<Deque<BlockHeader>> pendingHeaders, Map<Peer, List<BlockIdentifier>> skeletons, Peer peer); @Override void startDownloadingHeaders(Map<Peer, List<BlockIdentifier>> skeletons, long connectionPoint, Peer peer); @Override void startDownloadingSkeleton(long connectionPoint, Peer peer); @Override void startFindingConnectionPoint(Peer peer); @Override void backwardSyncing(Peer peer); @Override void backwardDownloadBodies(Block child, List<BlockHeader> toRequest, Peer peer); @Override void stopSyncing(); @Override void onErrorSyncing(NodeID peerId, String message, EventType eventType, Object... arguments); @Override void onSyncIssue(String message, Object... arguments); @VisibleForTesting void registerExpectedMessage(MessageWithId message); @VisibleForTesting SyncState getSyncState(); @VisibleForTesting Map<Long, MessageType> getExpectedResponses(); }
|
@Test public void emptyVotesConstructor() { ABICallElection electionBis = new ABICallElection(authorizer); Assert.assertEquals(0, electionBis.getVotes().size()); }
|
public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; }
|
ABICallElection { public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; } }
|
ABICallElection { public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; } ABICallElection(AddressBasedAuthorizer authorizer, Map<ABICallSpec, List<RskAddress>> votes); ABICallElection(AddressBasedAuthorizer authorizer); }
|
ABICallElection { public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; } ABICallElection(AddressBasedAuthorizer authorizer, Map<ABICallSpec, List<RskAddress>> votes); ABICallElection(AddressBasedAuthorizer authorizer); Map<ABICallSpec, List<RskAddress>> getVotes(); void clear(); boolean vote(ABICallSpec callSpec, RskAddress voter); ABICallSpec getWinner(); void clearWinners(); }
|
ABICallElection { public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; } ABICallElection(AddressBasedAuthorizer authorizer, Map<ABICallSpec, List<RskAddress>> votes); ABICallElection(AddressBasedAuthorizer authorizer); Map<ABICallSpec, List<RskAddress>> getVotes(); void clear(); boolean vote(ABICallSpec callSpec, RskAddress voter); ABICallSpec getWinner(); void clearWinners(); }
|
@Test public void getVotes() { Assert.assertSame(votes, election.getVotes()); }
|
public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; }
|
ABICallElection { public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; } }
|
ABICallElection { public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; } ABICallElection(AddressBasedAuthorizer authorizer, Map<ABICallSpec, List<RskAddress>> votes); ABICallElection(AddressBasedAuthorizer authorizer); }
|
ABICallElection { public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; } ABICallElection(AddressBasedAuthorizer authorizer, Map<ABICallSpec, List<RskAddress>> votes); ABICallElection(AddressBasedAuthorizer authorizer); Map<ABICallSpec, List<RskAddress>> getVotes(); void clear(); boolean vote(ABICallSpec callSpec, RskAddress voter); ABICallSpec getWinner(); void clearWinners(); }
|
ABICallElection { public Map<ABICallSpec, List<RskAddress>> getVotes() { return votes; } ABICallElection(AddressBasedAuthorizer authorizer, Map<ABICallSpec, List<RskAddress>> votes); ABICallElection(AddressBasedAuthorizer authorizer); Map<ABICallSpec, List<RskAddress>> getVotes(); void clear(); boolean vote(ABICallSpec callSpec, RskAddress voter); ABICallSpec getWinner(); void clearWinners(); }
|
@Test public void clear() { election.clear(); Assert.assertEquals(0, election.getVotes().size()); }
|
public void clear() { this.votes = new HashMap<>(); }
|
ABICallElection { public void clear() { this.votes = new HashMap<>(); } }
|
ABICallElection { public void clear() { this.votes = new HashMap<>(); } ABICallElection(AddressBasedAuthorizer authorizer, Map<ABICallSpec, List<RskAddress>> votes); ABICallElection(AddressBasedAuthorizer authorizer); }
|
ABICallElection { public void clear() { this.votes = new HashMap<>(); } ABICallElection(AddressBasedAuthorizer authorizer, Map<ABICallSpec, List<RskAddress>> votes); ABICallElection(AddressBasedAuthorizer authorizer); Map<ABICallSpec, List<RskAddress>> getVotes(); void clear(); boolean vote(ABICallSpec callSpec, RskAddress voter); ABICallSpec getWinner(); void clearWinners(); }
|
ABICallElection { public void clear() { this.votes = new HashMap<>(); } ABICallElection(AddressBasedAuthorizer authorizer, Map<ABICallSpec, List<RskAddress>> votes); ABICallElection(AddressBasedAuthorizer authorizer); Map<ABICallSpec, List<RskAddress>> getVotes(); void clear(); boolean vote(ABICallSpec callSpec, RskAddress voter); ABICallSpec getWinner(); void clearWinners(); }
|
@Test public void getFunction() { ABICallSpec spec = new ABICallSpec("a-function", new byte[][]{}); Assert.assertEquals("a-function", spec.getFunction()); }
|
public String getFunction() { return function; }
|
ABICallSpec { public String getFunction() { return function; } }
|
ABICallSpec { public String getFunction() { return function; } ABICallSpec(String function, byte[][] arguments); }
|
ABICallSpec { public String getFunction() { return function; } ABICallSpec(String function, byte[][] arguments); String getFunction(); byte[][] getArguments(); byte[] getEncoded(); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }
|
ABICallSpec { public String getFunction() { return function; } ABICallSpec(String function, byte[][] arguments); String getFunction(); byte[][] getArguments(); byte[] getEncoded(); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); static final Comparator<ABICallSpec> byBytesComparator; }
|
@Test public void getEncoded() { ABICallSpec spec = new ABICallSpec("a-function", new byte[][]{ Hex.decode("1122"), Hex.decode("334455"), }); StringBuilder expectedBuilder = new StringBuilder(); expectedBuilder.append(ByteUtil.toHexString("a-function".getBytes(StandardCharsets.UTF_8))); expectedBuilder.append("1122334455"); Assert.assertTrue(Arrays.equals(Hex.decode(expectedBuilder.toString()), spec.getEncoded())); }
|
public byte[] getEncoded() { byte[] functionBytes = function.getBytes(StandardCharsets.UTF_8); int totalLength = functionBytes.length; for (int i = 0; i < arguments.length; i++) { totalLength += arguments[i].length; } byte[] result = new byte[totalLength]; System.arraycopy(functionBytes, 0, result, 0, functionBytes.length); int offset = functionBytes.length; for (int i = 0; i < arguments.length; i++) { System.arraycopy(arguments[i], 0, result, offset, arguments[i].length); offset += arguments[i].length; } return result; }
|
ABICallSpec { public byte[] getEncoded() { byte[] functionBytes = function.getBytes(StandardCharsets.UTF_8); int totalLength = functionBytes.length; for (int i = 0; i < arguments.length; i++) { totalLength += arguments[i].length; } byte[] result = new byte[totalLength]; System.arraycopy(functionBytes, 0, result, 0, functionBytes.length); int offset = functionBytes.length; for (int i = 0; i < arguments.length; i++) { System.arraycopy(arguments[i], 0, result, offset, arguments[i].length); offset += arguments[i].length; } return result; } }
|
ABICallSpec { public byte[] getEncoded() { byte[] functionBytes = function.getBytes(StandardCharsets.UTF_8); int totalLength = functionBytes.length; for (int i = 0; i < arguments.length; i++) { totalLength += arguments[i].length; } byte[] result = new byte[totalLength]; System.arraycopy(functionBytes, 0, result, 0, functionBytes.length); int offset = functionBytes.length; for (int i = 0; i < arguments.length; i++) { System.arraycopy(arguments[i], 0, result, offset, arguments[i].length); offset += arguments[i].length; } return result; } ABICallSpec(String function, byte[][] arguments); }
|
ABICallSpec { public byte[] getEncoded() { byte[] functionBytes = function.getBytes(StandardCharsets.UTF_8); int totalLength = functionBytes.length; for (int i = 0; i < arguments.length; i++) { totalLength += arguments[i].length; } byte[] result = new byte[totalLength]; System.arraycopy(functionBytes, 0, result, 0, functionBytes.length); int offset = functionBytes.length; for (int i = 0; i < arguments.length; i++) { System.arraycopy(arguments[i], 0, result, offset, arguments[i].length); offset += arguments[i].length; } return result; } ABICallSpec(String function, byte[][] arguments); String getFunction(); byte[][] getArguments(); byte[] getEncoded(); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }
|
ABICallSpec { public byte[] getEncoded() { byte[] functionBytes = function.getBytes(StandardCharsets.UTF_8); int totalLength = functionBytes.length; for (int i = 0; i < arguments.length; i++) { totalLength += arguments[i].length; } byte[] result = new byte[totalLength]; System.arraycopy(functionBytes, 0, result, 0, functionBytes.length); int offset = functionBytes.length; for (int i = 0; i < arguments.length; i++) { System.arraycopy(arguments[i], 0, result, offset, arguments[i].length); offset += arguments[i].length; } return result; } ABICallSpec(String function, byte[][] arguments); String getFunction(); byte[][] getArguments(); byte[] getEncoded(); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); static final Comparator<ABICallSpec> byBytesComparator; }
|
@Test public void testEquals() { ABICallSpec specA = new ABICallSpec("function-a", new byte[][]{ Hex.decode("aabb"), Hex.decode("ccddee") }); ABICallSpec specB = new ABICallSpec("function-b", new byte[][]{ Hex.decode("aabb"), Hex.decode("ccddee") }); ABICallSpec specC = new ABICallSpec("function-a", new byte[][]{ Hex.decode("ccddee"), Hex.decode("aabb") }); ABICallSpec specD = new ABICallSpec("function-a", new byte[][]{ Hex.decode("aabb"), Hex.decode("ccdd") }); ABICallSpec specE = new ABICallSpec("function-a", new byte[][]{ Hex.decode("aabb") }); ABICallSpec specF = new ABICallSpec("function-a", new byte[][]{ Hex.decode("aabb"), Hex.decode("ccddee") }); Assert.assertEquals(specA, specF); Assert.assertNotEquals(specA, specB); Assert.assertNotEquals(specA, specC); Assert.assertNotEquals(specA, specD); Assert.assertNotEquals(specA, specE); }
|
@Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } ABICallSpec otherSpec = ((ABICallSpec) other); return otherSpec.getFunction().equals(getFunction()) && areEqual(arguments, otherSpec.arguments); }
|
ABICallSpec { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } ABICallSpec otherSpec = ((ABICallSpec) other); return otherSpec.getFunction().equals(getFunction()) && areEqual(arguments, otherSpec.arguments); } }
|
ABICallSpec { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } ABICallSpec otherSpec = ((ABICallSpec) other); return otherSpec.getFunction().equals(getFunction()) && areEqual(arguments, otherSpec.arguments); } ABICallSpec(String function, byte[][] arguments); }
|
ABICallSpec { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } ABICallSpec otherSpec = ((ABICallSpec) other); return otherSpec.getFunction().equals(getFunction()) && areEqual(arguments, otherSpec.arguments); } ABICallSpec(String function, byte[][] arguments); String getFunction(); byte[][] getArguments(); byte[] getEncoded(); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); }
|
ABICallSpec { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } ABICallSpec otherSpec = ((ABICallSpec) other); return otherSpec.getFunction().equals(getFunction()) && areEqual(arguments, otherSpec.arguments); } ABICallSpec(String function, byte[][] arguments); String getFunction(); byte[][] getArguments(); byte[] getEncoded(); @Override String toString(); @Override boolean equals(Object other); @Override int hashCode(); static final Comparator<ABICallSpec> byBytesComparator; }
|
@Test public void testIsPubKeyCanonicalWrongPrefix() { byte[] nonCanonicalPubkey4 = new byte[65]; assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey4)); byte[] nonCanonicalPubkey5 = new byte[33]; assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey5)); byte[] nonCanonicalPubkey6 = new byte[33]; assertFalse(ECKey.isPubKeyCanonical(nonCanonicalPubkey6)); }
|
public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { public boolean isPubKeyCanonical() { return isPubKeyCanonical(pub.getEncoded(false)); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void getDataWhenValueIsEmpty() throws Exception { Web3.CallArguments args = new Web3.CallArguments(); args.data = ""; CallArgumentsToByteArray byteArrayArgs = new CallArgumentsToByteArray(args); Assert.assertNull(byteArrayArgs.getData()); }
|
public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; }
|
CallArgumentsToByteArray { public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; } }
|
CallArgumentsToByteArray { public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; } CallArgumentsToByteArray(Web3.CallArguments args); }
|
CallArgumentsToByteArray { public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; } CallArgumentsToByteArray(Web3.CallArguments args); byte[] getGasPrice(); byte[] getGasLimit(); byte[] getToAddress(); byte[] getValue(); byte[] getData(); RskAddress getFromAddress(); }
|
CallArgumentsToByteArray { public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; } CallArgumentsToByteArray(Web3.CallArguments args); byte[] getGasPrice(); byte[] getGasLimit(); byte[] getToAddress(); byte[] getValue(); byte[] getData(); RskAddress getFromAddress(); }
|
@Test public void membersImmutable() { boolean exception = false; try { pendingFederation.getMembers().add(new FederationMember(new BtcECKey(), new ECKey(), new ECKey())); } catch (Exception e) { exception = true; } Assert.assertTrue(exception); exception = false; try { pendingFederation.getMembers().remove(0); } catch (Exception e) { exception = true; } Assert.assertTrue(exception); }
|
public List<FederationMember> getMembers() { return members; }
|
PendingFederation { public List<FederationMember> getMembers() { return members; } }
|
PendingFederation { public List<FederationMember> getMembers() { return members; } PendingFederation(List<FederationMember> members); }
|
PendingFederation { public List<FederationMember> getMembers() { return members; } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { public List<FederationMember> getMembers() { return members; } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void isComplete() { Assert.assertTrue(pendingFederation.isComplete()); }
|
public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; }
|
PendingFederation { public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; } }
|
PendingFederation { public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; } PendingFederation(List<FederationMember> members); }
|
PendingFederation { public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void isComplete_not() { PendingFederation otherPendingFederation = new PendingFederation(FederationTestUtils.getFederationMembersFromPks(200)); Assert.assertFalse(otherPendingFederation.isComplete()); }
|
public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; }
|
PendingFederation { public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; } }
|
PendingFederation { public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; } PendingFederation(List<FederationMember> members); }
|
PendingFederation { public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { public boolean isComplete() { return this.members.size() >= MIN_MEMBERS_REQUIRED; } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void testEquals_basic() { Assert.assertTrue(pendingFederation.equals(pendingFederation)); Assert.assertFalse(pendingFederation.equals(null)); Assert.assertFalse(pendingFederation.equals(new Object())); Assert.assertFalse(pendingFederation.equals("something else")); }
|
@Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void testEquals_differentNumberOfMembers() { PendingFederation otherPendingFederation = new PendingFederation(FederationTestUtils.getFederationMembersFromPks(100, 200, 300, 400, 500, 600, 700)); Assert.assertFalse(pendingFederation.equals(otherPendingFederation)); }
|
@Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void testEquals_differentMembers() { List<FederationMember> members = FederationTestUtils.getFederationMembersFromPks(100, 200, 300, 400, 500); members.add(new FederationMember(BtcECKey.fromPrivate(BigInteger.valueOf(610)), ECKey.fromPrivate(BigInteger.valueOf(600)), ECKey.fromPrivate(BigInteger.valueOf(620)))); PendingFederation otherPendingFederation = new PendingFederation(members); members.remove(members.size()-1); members.add(new FederationMember(BtcECKey.fromPrivate(BigInteger.valueOf(600)), ECKey.fromPrivate(BigInteger.valueOf(610)), ECKey.fromPrivate(BigInteger.valueOf(630)))); PendingFederation yetOtherPendingFederation = new PendingFederation(members); Assert.assertFalse(otherPendingFederation.equals(yetOtherPendingFederation)); Assert.assertFalse(pendingFederation.equals(otherPendingFederation)); Assert.assertFalse(pendingFederation.equals(yetOtherPendingFederation)); }
|
@Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
@Test public void testEquals_same() { PendingFederation otherPendingFederation = new PendingFederation(FederationTestUtils.getFederationMembersFromPks(100, 200, 300, 400, 500, 600)); Assert.assertTrue(pendingFederation.equals(otherPendingFederation)); }
|
@Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
PendingFederation { @Override public boolean equals(Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } return this.members.equals(((PendingFederation) other).members); } PendingFederation(List<FederationMember> members); List<FederationMember> getMembers(); List<BtcECKey> getBtcPublicKeys(); boolean isComplete(); PendingFederation addMember(FederationMember member); Federation buildFederation(Instant creationTime, long blockNumber, NetworkParameters btcParams); @Override String toString(); @Override boolean equals(Object other); Keccak256 getHash(); @Override int hashCode(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.