use of tech.pegasys.teku.networking.eth2.Eth2P2PNetworkFactory.Eth2P2PNetworkBuilder in project teku by ConsenSys.
the class TekuConfigurationTest method beaconChainControllerFactory_useCustomFactories.
@Test
void beaconChainControllerFactory_useCustomFactories() {
AtomicBoolean customDiscoveryBuilderMethodCalled = new AtomicBoolean();
AtomicBoolean customLibP2PBuilderMethodCalled = new AtomicBoolean();
AtomicBoolean customGossipNetworkBuilderCalled = new AtomicBoolean();
DiscoveryNetworkBuilder customDiscoveryNetworkBuilder = new DiscoveryNetworkBuilder() {
@Override
public DiscoveryNetwork<?> build() {
customDiscoveryBuilderMethodCalled.set(true);
return super.build();
}
};
LibP2PGossipNetworkBuilder customGossipNetworkBuilder = new LibP2PGossipNetworkBuilder() {
@Override
public LibP2PGossipNetwork build() {
customGossipNetworkBuilderCalled.set(true);
return super.build();
}
};
LibP2PNetworkBuilder customLibP2PNetworkBuilder = new LibP2PNetworkBuilder() {
@Override
public P2PNetwork<Peer> build() {
customLibP2PBuilderMethodCalled.set(true);
return super.build();
}
@Override
protected LibP2PGossipNetworkBuilder createLibP2PGossipNetworkBuilder() {
return customGossipNetworkBuilder;
}
};
Eth2P2PNetworkBuilder customEth2P2PNetworkBuilder = new Eth2P2PNetworkBuilder() {
@Override
protected DiscoveryNetworkBuilder createDiscoveryNetworkBuilder() {
return customDiscoveryNetworkBuilder;
}
@Override
protected LibP2PNetworkBuilder createLibP2PNetworkBuilder() {
return customLibP2PNetworkBuilder;
}
};
BeaconChainControllerFactory customControllerFactory = (serviceConfig, beaconConfig) -> new BeaconChainController(serviceConfig, beaconConfig) {
@Override
protected Eth2P2PNetworkBuilder createEth2P2PNetworkBuilder() {
return customEth2P2PNetworkBuilder;
}
};
TekuConfiguration tekuConfiguration = TekuConfiguration.builder().data(b -> b.dataBasePath(tempDir)).beaconChainControllerFactory(customControllerFactory).build();
try (BeaconNodeFacade beaconNode = TekuFacade.startBeaconNode(tekuConfiguration)) {
assertThat(beaconNode).isNotNull();
assertThat(customDiscoveryBuilderMethodCalled).isTrue();
assertThat(customLibP2PBuilderMethodCalled).isTrue();
assertThat(customGossipNetworkBuilderCalled).isTrue();
}
}
use of tech.pegasys.teku.networking.eth2.Eth2P2PNetworkFactory.Eth2P2PNetworkBuilder in project teku by ConsenSys.
the class GossipMessageHandlerIntegrationTest method shouldNotGossipAttestationsWhenPeerDeregistersFromTopic.
@Test
public void shouldNotGossipAttestationsWhenPeerDeregistersFromTopic() throws Exception {
final GossipEncoding gossipEncoding = GossipEncoding.SSZ_SNAPPY;
List<ValidateableAttestation> node2attestations = new ArrayList<>();
Subscribers<ProcessedAttestationListener> processedAttestationSubscribers = Subscribers.create(false);
final Consumer<Eth2P2PNetworkBuilder> networkBuilder1 = b -> {
b.gossipEncoding(gossipEncoding);
b.gossipedAttestationProcessor((__) -> SafeFuture.completedFuture(InternalValidationResult.ACCEPT));
b.processedAttestationSubscriptionProvider(processedAttestationSubscribers::subscribe);
};
final Consumer<Eth2P2PNetworkBuilder> networkBuilder2 = b -> {
b.gossipEncoding(gossipEncoding);
b.gossipedAttestationProcessor((attestation) -> {
node2attestations.add(attestation);
return SafeFuture.completedFuture(InternalValidationResult.ACCEPT);
});
};
// Setup network 1
final NodeManager node1 = createNodeManager(networkBuilder1);
final Eth2P2PNetwork network1 = node1.network();
// Setup network 2
final NodeManager node2 = createNodeManager(networkBuilder2);
final Eth2P2PNetwork network2 = node2.network();
// Connect networks 1 -> 2
waitFor(node1.connect(node2));
// Wait for connections to get set up
Waiter.waitFor(() -> {
assertThat(network1.getPeerCount()).isEqualTo(1);
assertThat(network2.getPeerCount()).isEqualTo(1);
});
// Propagate attestation from network 1
AttestationGenerator attestationGenerator = new AttestationGenerator(spec, validatorKeys);
final StateAndBlockSummary bestBlockAndState = getChainHead(node1);
Attestation attestation = attestationGenerator.validAttestation(bestBlockAndState);
final int subnetId = spec.computeSubnetForAttestation(bestBlockAndState.getState(), attestation);
ValidateableAttestation validAttestation = ValidateableAttestation.fromNetwork(spec, attestation, subnetId);
node1.network().subscribeToAttestationSubnetId(subnetId);
node2.network().subscribeToAttestationSubnetId(subnetId);
waitForTopicRegistration();
processedAttestationSubscribers.forEach(s -> s.accept(validAttestation));
waitForMessageToBeDelivered();
assertThat(node2attestations.size()).isEqualTo(1);
assertThat(node2attestations.get(0)).isEqualTo(validAttestation);
node1.network().unsubscribeFromAttestationSubnetId(subnetId);
node2.network().unsubscribeFromAttestationSubnetId(subnetId);
waitForTopicDeregistration();
processedAttestationSubscribers.forEach(s -> s.accept(validAttestation));
ensureConditionRemainsMet(() -> {
assertThat(node2attestations.size()).isEqualTo(1);
assertThat(node2attestations.get(0)).isEqualTo(validAttestation);
});
}
use of tech.pegasys.teku.networking.eth2.Eth2P2PNetworkFactory.Eth2P2PNetworkBuilder in project teku by ConsenSys.
the class GossipMessageHandlerIntegrationTest method shouldNotGossipAttestationsAcrossPeersThatAreNotOnTheSameSubnet.
@Test
public void shouldNotGossipAttestationsAcrossPeersThatAreNotOnTheSameSubnet() throws Exception {
final GossipEncoding gossipEncoding = GossipEncoding.SSZ_SNAPPY;
List<ValidateableAttestation> node2attestations = new ArrayList<>();
Subscribers<ProcessedAttestationListener> processedAttestationSubscribers = Subscribers.create(false);
final Consumer<Eth2P2PNetworkBuilder> networkBuilder1 = b -> {
b.gossipEncoding(gossipEncoding);
b.processedAttestationSubscriptionProvider(processedAttestationSubscribers::subscribe);
};
final Consumer<Eth2P2PNetworkBuilder> networkBuilder2 = b -> {
b.gossipEncoding(gossipEncoding);
b.gossipedAttestationProcessor((attestation) -> {
node2attestations.add(attestation);
return SafeFuture.completedFuture(InternalValidationResult.ACCEPT);
});
};
// Setup network 1
final NodeManager node1 = createNodeManager(networkBuilder1);
final Eth2P2PNetwork network1 = node1.network();
// Setup network 2
final NodeManager node2 = createNodeManager(networkBuilder2);
final Eth2P2PNetwork network2 = node2.network();
// Connect networks 1 -> 2
waitFor(node1.connect(node2));
// Wait for connections to get set up
Waiter.waitFor(() -> {
assertThat(network1.getPeerCount()).isEqualTo(1);
assertThat(network2.getPeerCount()).isEqualTo(1);
});
// Propagate attestation from network 1
AttestationGenerator attestationGenerator = new AttestationGenerator(spec, validatorKeys);
final StateAndBlockSummary bestBlockAndState = getChainHead(node1);
Attestation validAttestation = attestationGenerator.validAttestation(bestBlockAndState);
processedAttestationSubscribers.forEach(s -> s.accept(ValidateableAttestation.from(spec, validAttestation)));
ensureConditionRemainsMet(() -> assertThat(node2attestations).isEmpty());
}
use of tech.pegasys.teku.networking.eth2.Eth2P2PNetworkFactory.Eth2P2PNetworkBuilder in project teku by ConsenSys.
the class SyncingNodeManager method create.
@SuppressWarnings("FutureReturnValueIgnored")
public static SyncingNodeManager create(final AsyncRunner asyncRunner, Eth2P2PNetworkFactory networkFactory, final List<BLSKeyPair> validatorKeys, Consumer<Eth2P2PNetworkBuilder> configureNetwork) throws Exception {
final Spec spec = TestSpecFactory.createMinimalPhase0();
final EventChannels eventChannels = EventChannels.createSyncChannels(TEST_EXCEPTION_HANDLER, new NoOpMetricsSystem());
final RecentChainData recentChainData = MemoryOnlyRecentChainData.create(spec);
final BeaconChainUtil chainUtil = BeaconChainUtil.create(spec, recentChainData, validatorKeys);
chainUtil.initializeStorage();
final MergeTransitionBlockValidator transitionBlockValidator = new MergeTransitionBlockValidator(spec, recentChainData, ExecutionEngineChannel.NOOP);
ForkChoice forkChoice = new ForkChoice(spec, new InlineEventThread(), recentChainData, new StubForkChoiceNotifier(), transitionBlockValidator);
BlockImporter blockImporter = new BlockImporter(spec, eventChannels.getPublisher(BlockImportNotifications.class), recentChainData, forkChoice, WeakSubjectivityFactory.lenientValidator(), new StubExecutionEngineChannel(spec));
BlockValidator blockValidator = new BlockValidator(spec, recentChainData);
final PendingPool<SignedBeaconBlock> pendingBlocks = PendingPool.createForBlocks(spec);
final FutureItems<SignedBeaconBlock> futureBlocks = FutureItems.create(SignedBeaconBlock::getSlot);
BlockManager blockManager = new BlockManager(recentChainData, blockImporter, pendingBlocks, futureBlocks, blockValidator);
eventChannels.subscribe(SlotEventsChannel.class, blockManager).subscribe(BlockImportChannel.class, blockManager).subscribe(BlockImportNotifications.class, blockManager).subscribe(FinalizedCheckpointChannel.class, pendingBlocks);
final Eth2P2PNetworkBuilder networkBuilder = networkFactory.builder().spec(spec).eventChannels(eventChannels).recentChainData(recentChainData).gossipedBlockProcessor(blockManager::validateAndImportBlock);
configureNetwork.accept(networkBuilder);
final Eth2P2PNetwork eth2P2PNetwork = networkBuilder.startNetwork();
SyncManager syncManager = SyncManager.create(asyncRunner, eth2P2PNetwork, recentChainData, blockImporter, new NoOpMetricsSystem(), spec);
ForwardSyncService syncService = new SinglePeerSyncService(syncManager, recentChainData);
final FetchRecentBlocksService recentBlockFetcher = FetchRecentBlocksService.create(asyncRunner, eth2P2PNetwork, pendingBlocks, syncService);
recentBlockFetcher.subscribeBlockFetched(blockManager::importBlock);
blockManager.subscribeToReceivedBlocks((block, executionOptimistic) -> recentBlockFetcher.cancelRecentBlockRequest(block.getRoot()));
recentBlockFetcher.start().join();
blockManager.start().join();
syncService.start().join();
return new SyncingNodeManager(eventChannels, recentChainData, chainUtil, eth2P2PNetwork, syncService);
}
use of tech.pegasys.teku.networking.eth2.Eth2P2PNetworkFactory.Eth2P2PNetworkBuilder in project teku by ConsenSys.
the class ProposerSlashingGossipIntegrationTest method shouldGossipToPeers.
@Test
public void shouldGossipToPeers() throws Exception {
final GossipEncoding gossipEncoding = GossipEncoding.SSZ_SNAPPY;
// Set up publishers & consumers
Set<ProposerSlashing> receivedGossip = new HashSet<>();
final OperationProcessor<ProposerSlashing> operationProcessor = (slashing) -> {
receivedGossip.add(slashing);
return SafeFuture.completedFuture(InternalValidationResult.ACCEPT);
};
// Setup network 1
final Consumer<Eth2P2PNetworkBuilder> networkBuilder = b -> b.gossipEncoding(gossipEncoding);
NodeManager node1 = createNodeManager(networkBuilder);
// Setup network 2
final Consumer<Eth2P2PNetworkBuilder> networkBuilder2 = b -> b.gossipEncoding(gossipEncoding).gossipedProposerSlashingProcessor(operationProcessor);
NodeManager node2 = createNodeManager(networkBuilder2);
// Connect networks 1 -> 2
waitFor(node1.connect(node2));
// Wait for connections to get set up
Waiter.waitFor(() -> {
assertThat(node1.network().getPeerCount()).isEqualTo(1);
assertThat(node2.network().getPeerCount()).isEqualTo(1);
});
// Wait for subscriptions to complete (jvm-libp2p does this asynchronously)
Thread.sleep(2000);
// Create and publish slashing
final ProposerSlashing slashing = dataStructureUtil.randomProposerSlashing();
node1.network().publishProposerSlashing(slashing);
// Verify the slashing was gossiped across the network
Waiter.waitFor(() -> assertThat(receivedGossip).containsExactly(slashing));
}
Aggregations