CipherLabs
/
besu
mirror of https://github.com/hyperledger/besu
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[PAN-2325] Fix IndexOutOfBoundsException in DetermineCommonAncestorTask (#1038)

Browse Source 
Signed-off-by: Adrian Sutton <adrian.sutton@consensys.net>
pull/2/head
mbaxter 6 years ago committed by GitHub
parent 0c8f771cec
commit 21cea1b9a2
6 changed files with 165 additions and 196 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 13
      ethereum/core/src/main/java/tech/pegasys/pantheon/ethereum/chain/Blockchain.java
  2. 13
      ethereum/core/src/test-support/java/tech/pegasys/pantheon/ethereum/core/BlockDataGenerator.java
  3. 2
      ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/sync/SynchronizerConfiguration.java
  4. 28
      ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/sync/tasks/DetermineCommonAncestorTask.java
  5. 11
      ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/RespondingEthPeer.java
  6. 294
      ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/sync/tasks/DetermineCommonAncestorTaskTest.java

13
ethereum/core/src/main/java/tech/pegasys/pantheon/ethereum/chain/Blockchain.java
Unescape View File

@ -63,6 +63,19 @@ public interface Blockchain {
return new Block(header, body);
}
default Block getGenesisBlock() {
final Hash genesisHash =
getBlockHashByNumber(BlockHeader.GENESIS_BLOCK_NUMBER)
.orElseThrow(() -> new IllegalStateException("Missing genesis block."));
final BlockHeader header =
getBlockHeader(genesisHash)
.orElseThrow(() -> new IllegalStateException("Missing genesis block."));
final BlockBody body =
getBlockBody(genesisHash)
.orElseThrow(() -> new IllegalStateException("Missing genesis block."));
return new Block(header, body);
}
/**
* Checks whether the block corresponding to the given hash is on the canonical chain.
*

13
ethereum/core/src/test-support/java/tech/pegasys/pantheon/ethereum/core/BlockDataGenerator.java
Unescape View File

@ -137,6 +137,19 @@ public class BlockDataGenerator {
return blockSequence(count, worldState, Collections.emptyList(), Collections.emptyList());
}
public List<Block> blockSequence(final Block previousBlock, final int count) {
final WorldStateArchive worldState = createInMemoryWorldStateArchive();
Hash parentHash = previousBlock.getHeader().getHash();
long blockNumber = previousBlock.getHeader().getNumber() + 1;
return blockSequence(
count,
blockNumber,
parentHash,
worldState,
Collections.emptyList(),
Collections.emptyList());
}
public List<Block> blockSequence(
final int count,
final WorldStateArchive worldStateArchive,

2
ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/sync/SynchronizerConfiguration.java
Unescape View File

@ -220,7 +220,7 @@ public class SynchronizerConfiguration {
private Range<Long> blockPropagationRange = Range.closed(-10L, 30L);
private long downloaderChangeTargetThresholdByHeight = 20L;
private UInt256 downloaderChangeTargetThresholdByTd = UInt256.of(1_000_000_000L);
private int downloaderHeaderRequestSize = 10;
private int downloaderHeaderRequestSize = 200;
private int downloaderCheckpointTimeoutsPermitted = 5;
private int downloaderChainSegmentTimeoutsPermitted = 5;
private int downloaderChainSegmentSize = 200;

28
ethereum/eth/src/main/java/tech/pegasys/pantheon/ethereum/eth/sync/tasks/DetermineCommonAncestorTask.java
Unescape View File

@ -31,11 +31,17 @@ import com.google.common.annotations.VisibleForTesting;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class DetermineCommonAncestorTask<C> extends AbstractEthTask<BlockHeader> {
/**
* Finds the common ancestor with the given peer. It is assumed that the peer will at least share
* the same genesis block with this node. Running this task against a peer with a non-matching
* genesis block will result in undefined behavior: the task may complete exceptionally or in some
* cases this node's genesis block will be returned.
*/
public class DetermineCommonAncestorTask extends AbstractEthTask<BlockHeader> {
private static final Logger LOG = LogManager.getLogger();
private final EthContext ethContext;
private final ProtocolSchedule<C> protocolSchedule;
private final ProtocolContext<C> protocolContext;
private final ProtocolSchedule<?> protocolSchedule;
private final ProtocolContext<?> protocolContext;
private final EthPeer peer;
private final int headerRequestSize;
private final MetricsSystem metricsSystem;
@ -46,8 +52,8 @@ public class DetermineCommonAncestorTask<C> extends AbstractEthTask<BlockHeader>
private boolean initialQuery = true;
private DetermineCommonAncestorTask(
final ProtocolSchedule<C> protocolSchedule,
final ProtocolContext<C> protocolContext,
final ProtocolSchedule<?> protocolSchedule,
final ProtocolContext<?> protocolContext,
final EthContext ethContext,
final EthPeer peer,
final int headerRequestSize,
@ -66,14 +72,14 @@ public class DetermineCommonAncestorTask<C> extends AbstractEthTask<BlockHeader>
protocolContext.getBlockchain().getBlockHeader(BlockHeader.GENESIS_BLOCK_NUMBER).get();
}
public static <C> DetermineCommonAncestorTask<C> create(
final ProtocolSchedule<C> protocolSchedule,
final ProtocolContext<C> protocolContext,
public static DetermineCommonAncestorTask create(
final ProtocolSchedule<?> protocolSchedule,
final ProtocolContext<?> protocolContext,
final EthContext ethContext,
final EthPeer peer,
final int headerRequestSize,
final MetricsSystem metricsSystem) {
return new DetermineCommonAncestorTask<>(
return new DetermineCommonAncestorTask(
protocolSchedule, protocolContext, ethContext, peer, headerRequestSize, metricsSystem);
}
@ -144,6 +150,10 @@ public class DetermineCommonAncestorTask<C> extends AbstractEthTask<BlockHeader>
final AbstractPeerTask.PeerTaskResult<List<BlockHeader>> headersResult) {
initialQuery = false;
final List<BlockHeader> headers = headersResult.getResult();
if (headers.isEmpty()) {
// Nothing to do
return CompletableFuture.completedFuture(null);
}
final OptionalInt maybeAncestorNumber =
BlockchainUtil.findHighestKnownBlockIndex(protocolContext.getBlockchain(), headers, false);

11
ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/manager/RespondingEthPeer.java
Unescape View File

@ -32,6 +32,7 @@ import tech.pegasys.pantheon.ethereum.mainnet.ProtocolSchedule;
import tech.pegasys.pantheon.ethereum.p2p.api.MessageData;
import tech.pegasys.pantheon.ethereum.p2p.wire.Capability;
import tech.pegasys.pantheon.ethereum.p2p.wire.DefaultMessage;
import tech.pegasys.pantheon.ethereum.p2p.wire.messages.DisconnectMessage.DisconnectReason;
import tech.pegasys.pantheon.ethereum.worldstate.WorldStateArchive;
import tech.pegasys.pantheon.util.bytes.BytesValue;
import tech.pegasys.pantheon.util.uint.UInt256;
@ -82,6 +83,16 @@ public class RespondingEthPeer {
respondOnce(responder, Arrays.asList(peers));
}
public boolean disconnect(final DisconnectReason reason) {
if (ethPeer.isDisconnected()) {
return false;
}
ethPeer.disconnect(reason);
ethProtocolManager.handleDisconnect(getPeerConnection(), reason, true);
return true;
}
public MockPeerConnection getPeerConnection() {
return peerConnection;
}

294
ethereum/eth/src/test/java/tech/pegasys/pantheon/ethereum/eth/sync/tasks/DetermineCommonAncestorTaskTest.java
Unescape View File

@ -12,6 +12,7 @@
*/
package tech.pegasys.pantheon.ethereum.eth.sync.tasks;
import static com.google.common.base.Preconditions.checkArgument;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
@ -24,6 +25,7 @@ import static tech.pegasys.pantheon.ethereum.core.InMemoryStorageProvider.create
import static tech.pegasys.pantheon.ethereum.core.InMemoryStorageProvider.createInMemoryWorldStateArchive;
import tech.pegasys.pantheon.ethereum.ProtocolContext;
import tech.pegasys.pantheon.ethereum.chain.Blockchain;
import tech.pegasys.pantheon.ethereum.chain.MutableBlockchain;
import tech.pegasys.pantheon.ethereum.core.Block;
import tech.pegasys.pantheon.ethereum.core.BlockDataGenerator;
@ -45,7 +47,6 @@ import tech.pegasys.pantheon.ethereum.worldstate.WorldStateArchive;
import tech.pegasys.pantheon.metrics.MetricsSystem;
import tech.pegasys.pantheon.metrics.noop.NoOpMetricsSystem;
import tech.pegasys.pantheon.util.ExceptionUtils;
import tech.pegasys.pantheon.util.uint.UInt256;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@ -57,20 +58,20 @@ import org.junit.Test;
public class DetermineCommonAncestorTaskTest {
private final ProtocolSchedule<Void> protocolSchedule = MainnetProtocolSchedule.create();
private final ProtocolSchedule<?> protocolSchedule = MainnetProtocolSchedule.create();
private final BlockDataGenerator blockDataGenerator = new BlockDataGenerator();
private final MetricsSystem metricsSystem = new NoOpMetricsSystem();
private MutableBlockchain localBlockchain;
private final int defaultHeaderRequestSize = 10;
Block genesisBlock;
private MutableBlockchain localBlockchain;
private Block localGenesisBlock;
private EthProtocolManager ethProtocolManager;
private EthContext ethContext;
private ProtocolContext<Void> protocolContext;
private ProtocolContext<?> protocolContext;
@Before
public void setup() {
genesisBlock = blockDataGenerator.genesisBlock();
localBlockchain = createInMemoryBlockchain(genesisBlock);
localGenesisBlock = blockDataGenerator.genesisBlock();
localBlockchain = createInMemoryBlockchain(localGenesisBlock);
final WorldStateArchive worldStateArchive = createInMemoryWorldStateArchive();
ethProtocolManager = EthProtocolManagerTestUtil.create(localBlockchain, worldStateArchive);
ethContext = ethProtocolManager.ethContext();
@ -78,36 +79,13 @@ public class DetermineCommonAncestorTaskTest {
}
@Test
public void shouldThrowExceptionNoCommonBlock() {
// Populate local chain
for (long i = 1; i <= 9; i++) {
final BlockDataGenerator.BlockOptions options00 =
new BlockDataGenerator.BlockOptions()
.setBlockNumber(i)
.setParentHash(localBlockchain.getBlockHashByNumber(i - 1).get());
final Block block00 = blockDataGenerator.block(options00);
final List<TransactionReceipt> receipts00 = blockDataGenerator.receipts(block00);
localBlockchain.appendBlock(block00, receipts00);
}
// Populate remote chain
final Block remoteGenesisBlock = blockDataGenerator.genesisBlock();
final MutableBlockchain remoteBlockchain = createInMemoryBlockchain(remoteGenesisBlock);
for (long i = 1; i <= 9; i++) {
final BlockDataGenerator.BlockOptions options01 =
new BlockDataGenerator.BlockOptions()
.setDifficulty(UInt256.ONE)
.setBlockNumber(i)
.setParentHash(remoteBlockchain.getBlockHashByNumber(i - 1).get());
final Block block01 = blockDataGenerator.block(options01);
final List<TransactionReceipt> receipts01 = blockDataGenerator.receipts(block01);
remoteBlockchain.appendBlock(block01, receipts01);
}
public void shouldFailIfPeerDisconnects() {
final Block block = blockDataGenerator.nextBlock(localBlockchain.getChainHeadBlock());
localBlockchain.appendBlock(block, blockDataGenerator.receipts(block));
final RespondingEthPeer.Responder responder =
RespondingEthPeer.blockchainResponder(remoteBlockchain);
final RespondingEthPeer respondingEthPeer =
EthProtocolManagerTestUtil.createPeer(ethProtocolManager);
final EthTask<BlockHeader> task =
DetermineCommonAncestorTask.create(
protocolSchedule,
@ -117,34 +95,32 @@ public class DetermineCommonAncestorTaskTest {
defaultHeaderRequestSize,
metricsSystem);
final CompletableFuture<BlockHeader> future = task.run();
respondingEthPeer.respondWhile(responder, () -> !future.isDone());
final AtomicReference<Throwable> failure = new AtomicReference<>();
final CompletableFuture<BlockHeader> future = task.run();
future.whenComplete(
(response, error) -> {
failure.set(error);
});
// Disconnect the target peer
respondingEthPeer.disconnect(DisconnectReason.CLIENT_QUITTING);
assertThat(failure.get()).isNotNull();
final Throwable error = ExceptionUtils.rootCause(failure.get());
assertThat(error)
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("No common ancestor.");
assertThat(error).isInstanceOf(EthTaskException.class);
assertThat(((EthTaskException) error).reason()).isEqualTo(FailureReason.PEER_DISCONNECTED);
}
@Test
public void shouldFailIfPeerDisconnects() {
final Block block = blockDataGenerator.nextBlock(localBlockchain.getChainHeadBlock());
localBlockchain.appendBlock(block, blockDataGenerator.receipts(block));
public void shouldHandleEmptyResponses() {
final Blockchain remoteBlockchain = setupLocalAndRemoteChains(11, 11, 5);
final RespondingEthPeer.Responder responder =
RespondingEthPeer.blockchainResponder(localBlockchain);
final RespondingEthPeer.Responder emptyResponder = RespondingEthPeer.emptyResponder();
final RespondingEthPeer.Responder fullResponder =
RespondingEthPeer.blockchainResponder(remoteBlockchain);
final RespondingEthPeer respondingEthPeer =
EthProtocolManagerTestUtil.createPeer(ethProtocolManager);
// Disconnect the target peer
respondingEthPeer.getEthPeer().disconnect(DisconnectReason.BREACH_OF_PROTOCOL);
final EthTask<BlockHeader> task =
DetermineCommonAncestorTask.create(
protocolSchedule,
@ -154,23 +130,23 @@ public class DetermineCommonAncestorTaskTest {
defaultHeaderRequestSize,
metricsSystem);
// Execute task and wait for response
final AtomicReference<Throwable> failure = new AtomicReference<>();
// Empty response should be handled without any error
final CompletableFuture<BlockHeader> future = task.run();
respondingEthPeer.respondWhile(responder, () -> !future.isDone());
future.whenComplete(
(response, error) -> {
failure.set(error);
});
respondingEthPeer.respond(emptyResponder);
assertThat(future).isNotDone();
assertThat(failure.get()).isNotNull();
final Throwable error = ExceptionUtils.rootCause(failure.get());
assertThat(error).isInstanceOf(EthTaskException.class);
assertThat(((EthTaskException) error).reason()).isEqualTo(FailureReason.PEER_DISCONNECTED);
// Task should continue on and complete when valid responses are received
// Execute task and wait for response
respondingEthPeer.respondWhile(fullResponder, () -> !future.isDone());
assertThat(future).isDone();
assertThat(future).isNotCompletedExceptionally();
final BlockHeader expectedResult = remoteBlockchain.getBlockHeader(4).get();
assertThat(future).isCompletedWithValue(expectedResult);
}
@Test
public void shouldCorrectlyCalculateSkipIntervalAndCount() {
public void calculateSkipInterval() {
final long maximumPossibleCommonAncestorNumber = 100;
final long minimumPossibleCommonAncestorNumber = 0;
final int headerRequestSize = 10;
@ -184,96 +160,16 @@ public class DetermineCommonAncestorTaskTest {
assertThat(skipInterval).isEqualTo(9);
}
@Test
public void shouldGracefullyHandleExecutionsForNoCommonAncestor() {
// Populate local chain
for (long i = 1; i <= 99; i++) {
final BlockDataGenerator.BlockOptions options00 =
new BlockDataGenerator.BlockOptions()
.setBlockNumber(i)
.setParentHash(localBlockchain.getBlockHashByNumber(i - 1).get());
final Block block00 = blockDataGenerator.block(options00);
final List<TransactionReceipt> receipts00 = blockDataGenerator.receipts(block00);
localBlockchain.appendBlock(block00, receipts00);
}
// Populate remote chain
final Block remoteGenesisBlock = blockDataGenerator.genesisBlock();
final MutableBlockchain remoteBlockchain = createInMemoryBlockchain(remoteGenesisBlock);
for (long i = 1; i <= 99; i++) {
final BlockDataGenerator.BlockOptions options01 =
new BlockDataGenerator.BlockOptions()
.setDifficulty(UInt256.ONE)
.setBlockNumber(i)
.setParentHash(remoteBlockchain.getBlockHashByNumber(i - 1).get());
final Block block01 = blockDataGenerator.block(options01);
final List<TransactionReceipt> receipts01 = blockDataGenerator.receipts(block01);
remoteBlockchain.appendBlock(block01, receipts01);
}
final RespondingEthPeer.Responder responder =
RespondingEthPeer.blockchainResponder(remoteBlockchain);
final RespondingEthPeer respondingEthPeer =
EthProtocolManagerTestUtil.createPeer(ethProtocolManager);
final DetermineCommonAncestorTask<Void> task =
DetermineCommonAncestorTask.create(
protocolSchedule,
protocolContext,
ethContext,
respondingEthPeer.getEthPeer(),
defaultHeaderRequestSize,
metricsSystem);
final DetermineCommonAncestorTask<Void> spy = spy(task);
// Execute task
final CompletableFuture<BlockHeader> future = spy.run();
respondingEthPeer.respondWhile(responder, () -> !future.isDone());
final AtomicReference<BlockHeader> result = new AtomicReference<>();
future.whenComplete(
(response, error) -> {
result.set(response);
});
Assertions.assertThat(result.get().getHash())
.isEqualTo(MainnetBlockHashFunction.createHash(genesisBlock.getHeader()));
verify(spy, times(2)).requestHeaders();
}
@Test
public void shouldIssueConsistentNumberOfRequestsToPeer() {
// Populate local chain
for (long i = 1; i <= 100; i++) {
final BlockDataGenerator.BlockOptions options00 =
new BlockDataGenerator.BlockOptions()
.setBlockNumber(i)
.setParentHash(localBlockchain.getBlockHashByNumber(i - 1).get());
final Block block00 = blockDataGenerator.block(options00);
final List<TransactionReceipt> receipts00 = blockDataGenerator.receipts(block00);
localBlockchain.appendBlock(block00, receipts00);
}
// Populate remote chain
final MutableBlockchain remoteBlockchain = createInMemoryBlockchain(genesisBlock);
for (long i = 1; i <= 100; i++) {
final BlockDataGenerator.BlockOptions options01 =
new BlockDataGenerator.BlockOptions()
.setDifficulty(UInt256.ONE)
.setBlockNumber(i)
.setParentHash(remoteBlockchain.getBlockHashByNumber(i - 1).get());
final Block block01 = blockDataGenerator.block(options01);
final List<TransactionReceipt> receipts01 = blockDataGenerator.receipts(block01);
remoteBlockchain.appendBlock(block01, receipts01);
}
final Blockchain remoteBlockchain = setupLocalAndRemoteChains(101, 101, 1);
final RespondingEthPeer.Responder responder =
RespondingEthPeer.blockchainResponder(remoteBlockchain);
final RespondingEthPeer respondingEthPeer =
EthProtocolManagerTestUtil.createPeer(ethProtocolManager);
final DetermineCommonAncestorTask<Void> task =
final DetermineCommonAncestorTask task =
DetermineCommonAncestorTask.create(
protocolSchedule,
protocolContext,
@ -281,7 +177,7 @@ public class DetermineCommonAncestorTaskTest {
respondingEthPeer.getEthPeer(),
defaultHeaderRequestSize,
metricsSystem);
final DetermineCommonAncestorTask<Void> spy = spy(task);
final DetermineCommonAncestorTask spy = spy(task);
// Execute task
final CompletableFuture<BlockHeader> future = spy.run();
@ -294,66 +190,30 @@ public class DetermineCommonAncestorTaskTest {
});
Assertions.assertThat(result.get().getHash())
.isEqualTo(MainnetBlockHashFunction.createHash(genesisBlock.getHeader()));
.isEqualTo(MainnetBlockHashFunction.createHash(localGenesisBlock.getHeader()));
verify(spy, times(3)).requestHeaders();
}
@Test
public void shouldShortCircuitOnHeaderInInitialRequest() {
final MutableBlockchain remoteBlockchain = createInMemoryBlockchain(genesisBlock);
Block commonBlock = null;
// Populate common chain
for (long i = 1; i <= 95; i++) {
final BlockDataGenerator.BlockOptions options =
new BlockDataGenerator.BlockOptions()
.setBlockNumber(i)
.setParentHash(localBlockchain.getBlockHashByNumber(i - 1).get());
commonBlock = blockDataGenerator.block(options);
final List<TransactionReceipt> receipts = blockDataGenerator.receipts(commonBlock);
localBlockchain.appendBlock(commonBlock, receipts);
remoteBlockchain.appendBlock(commonBlock, receipts);
}
// Populate local chain
for (long i = 96; i <= 99; i++) {
final BlockDataGenerator.BlockOptions options00 =
new BlockDataGenerator.BlockOptions()
.setBlockNumber(i)
.setParentHash(localBlockchain.getBlockHashByNumber(i - 1).get());
final Block block00 = blockDataGenerator.block(options00);
final List<TransactionReceipt> receipts00 = blockDataGenerator.receipts(block00);
localBlockchain.appendBlock(block00, receipts00);
}
// Populate remote chain
for (long i = 96; i <= 99; i++) {
final BlockDataGenerator.BlockOptions options01 =
new BlockDataGenerator.BlockOptions()
.setDifficulty(UInt256.ONE)
.setBlockNumber(i)
.setParentHash(remoteBlockchain.getBlockHashByNumber(i - 1).get());
final Block block01 = blockDataGenerator.block(options01);
final List<TransactionReceipt> receipts01 = blockDataGenerator.receipts(block01);
remoteBlockchain.appendBlock(block01, receipts01);
}
final Blockchain remoteBlockchain = setupLocalAndRemoteChains(100, 100, 96);
final BlockHeader commonHeader = localBlockchain.getBlockHeader(95).get();
final RespondingEthPeer.Responder responder =
RespondingEthPeer.blockchainResponder(remoteBlockchain);
final RespondingEthPeer respondingEthPeer =
EthProtocolManagerTestUtil.createPeer(ethProtocolManager);
final DetermineCommonAncestorTask<Void> task =
final DetermineCommonAncestorTask task =
DetermineCommonAncestorTask.create(
protocolSchedule,
protocolContext,
ethContext,
respondingEthPeer.getEthPeer(),
defaultHeaderRequestSize,
10,
metricsSystem);
final DetermineCommonAncestorTask<Void> spy = spy(task);
final DetermineCommonAncestorTask spy = spy(task);
// Execute task
final CompletableFuture<BlockHeader> future = spy.run();
@ -366,7 +226,7 @@ public class DetermineCommonAncestorTaskTest {
});
Assertions.assertThat(result.get().getHash())
.isEqualTo(MainnetBlockHashFunction.createHash(commonBlock.getHeader()));
.isEqualTo(MainnetBlockHashFunction.createHash(commonHeader));
verify(spy, times(1)).requestHeaders();
}
@ -387,11 +247,73 @@ public class DetermineCommonAncestorTaskTest {
metricsSystem);
final CompletableFuture<BlockHeader> result = task.run();
assertThat(result).isCompletedWithValue(genesisBlock.getHeader());
assertThat(result).isCompletedWithValue(localGenesisBlock.getHeader());
// Make sure we didn't ask for any headers
verify(peer, times(0)).getHeadersByHash(any(), anyInt(), anyInt(), anyBoolean());
verify(peer, times(0)).getHeadersByNumber(anyLong(), anyInt(), anyInt(), anyBoolean());
verify(peer, times(0)).send(any());
}
/**
* @param localBlockCount The number of local blocks to create. Highest block will be: {@code
* localBlockHeight} - 1.
* @param remoteBlockCount The number of remote blocks to create. Highest block will be: {@code
* remoteBlockCount} - 1.
* @param blocksInCommon The number of blocks shared between local and remote. If a common
* ancestor exists, its block number will be: {@code blocksInCommon} - 1
* @return
*/
private Blockchain setupLocalAndRemoteChains(
final int localBlockCount, final int remoteBlockCount, final int blocksInCommon) {
checkArgument(localBlockCount >= 1);
checkArgument(remoteBlockCount >= 1);
checkArgument(blocksInCommon >= 0);
checkArgument(blocksInCommon <= Math.min(localBlockCount, remoteBlockCount));
final Block remoteGenesis =
(blocksInCommon > 0) ? localGenesisBlock : blockDataGenerator.genesisBlock();
MutableBlockchain remoteChain = createInMemoryBlockchain(remoteGenesis);
// Build common chain
if (blocksInCommon > 1) {
List<Block> commonBlocks =
blockDataGenerator.blockSequence(remoteGenesis, blocksInCommon - 1);
for (Block commonBlock : commonBlocks) {
List<TransactionReceipt> receipts = blockDataGenerator.receipts(commonBlock);
localBlockchain.appendBlock(commonBlock, receipts);
remoteChain.appendBlock(commonBlock, receipts);
}
}
// Build divergent local blocks
if (localBlockCount > blocksInCommon) {
Block localChainHead = localBlockchain.getChainHeadBlock();
final int currentHeight =
Math.toIntExact(
localBlockchain.getChainHeadBlockNumber() - BlockHeader.GENESIS_BLOCK_NUMBER + 1);
List<Block> localBlocks =
blockDataGenerator.blockSequence(localChainHead, localBlockCount - currentHeight);
for (Block localBlock : localBlocks) {
List<TransactionReceipt> receipts = blockDataGenerator.receipts(localBlock);
localBlockchain.appendBlock(localBlock, receipts);
}
}
// Build divergent remote blocks
if (remoteBlockCount > blocksInCommon) {
Block remoteChainHead = remoteChain.getChainHeadBlock();
final int currentHeight =
Math.toIntExact(
remoteChain.getChainHeadBlockNumber() - BlockHeader.GENESIS_BLOCK_NUMBER + 1);
List<Block> remoteBlocks =
blockDataGenerator.blockSequence(remoteChainHead, remoteBlockCount - currentHeight);
for (Block remoteBlock : remoteBlocks) {
List<TransactionReceipt> receipts = blockDataGenerator.receipts(remoteBlock);
remoteChain.appendBlock(remoteBlock, receipts);
}
}
return remoteChain;
}
}

Write Preview
Loading…
Cancel
Save