async def test_header_gap_fill_detects_invalid_attempt(caplog,
event_loop,
event_bus,
chaindb_with_gaps,
chaindb_1000,
chaindb_uncle):
client_context = ChainContextFactory(headerdb__db=chaindb_with_gaps.db)
server_context = ChainContextFactory(headerdb__db=chaindb_uncle.db)
peer_pair = LatestETHPeerPairFactory(
alice_peer_context=client_context,
bob_peer_context=server_context,
event_bus=event_bus,
)
async with peer_pair as (client_peer, server_peer):
client = SequentialHeaderChainGapSyncer(
LatestTestChain(chaindb_with_gaps.db),
chaindb_with_gaps,
MockPeerPoolWithConnectedPeers([client_peer], event_bus=event_bus)
)
server_peer_pool = MockPeerPoolWithConnectedPeers([server_peer], event_bus=event_bus)
uncle_chaindb = AsyncChainDB(chaindb_uncle.db)
async with run_peer_pool_event_server(
event_bus, server_peer_pool, handler_type=ETHPeerPoolEventServer
), background_asyncio_service(ETHRequestServer(
event_bus, TO_NETWORKING_BROADCAST_CONFIG, uncle_chaindb,
)):
server_peer.logger.info("%s is serving 1000 blocks", server_peer)
client_peer.logger.info("%s is syncing up 1000", client_peer)
# We check for 499 because 500 exists from the very beginning (the checkpoint)
expected_block_number = 499
async with background_asyncio_service(client):
try:
await wait_for_head(
chaindb_with_gaps,
chaindb_1000.get_canonical_block_header_by_number(expected_block_number),
sync_timeout=5,
)
except asyncio.TimeoutError:
assert "Attempted to fill gap with invalid header" in caplog.text
# Monkey patch the uncle chaindb to effectively make the attacker peer
# switch to the correct chain.
uncle_chaindb.db = chaindb_1000.db
await wait_for_head(
chaindb_with_gaps,
chaindb_1000.get_canonical_block_header_by_number(expected_block_number)
)
else:
raise AssertionError("Succeeded when it was expected to fail")
async def test_sequential_header_gapfill_syncer(request,
event_loop,
event_bus,
chaindb_with_gaps,
chaindb_1000):
client_context = ChainContextFactory(headerdb__db=chaindb_with_gaps.db)
server_context = ChainContextFactory(headerdb__db=chaindb_1000.db)
peer_pair = LatestETHPeerPairFactory(
alice_peer_context=client_context,
bob_peer_context=server_context,
event_bus=event_bus,
)
async with peer_pair as (client_peer, server_peer):
chain_with_gaps = LatestTestChain(chaindb_with_gaps.db)
client = SequentialHeaderChainGapSyncer(
chain_with_gaps,
chaindb_with_gaps,
MockPeerPoolWithConnectedPeers([client_peer], event_bus=event_bus)
)
server_peer_pool = MockPeerPoolWithConnectedPeers([server_peer], event_bus=event_bus)
async with run_peer_pool_event_server(
event_bus, server_peer_pool, handler_type=ETHPeerPoolEventServer
), background_asyncio_service(ETHRequestServer(
event_bus, TO_NETWORKING_BROADCAST_CONFIG, AsyncChainDB(chaindb_1000.db),
)):
server_peer.logger.info("%s is serving 1000 blocks", server_peer)
client_peer.logger.info("%s is syncing up 1000", client_peer)
async with background_asyncio_service(client):
await wait_for_head(
# We check for 499 because 500 is there from the very beginning (the checkpoint)
chaindb_with_gaps, chaindb_1000.get_canonical_block_header_by_number(499)
)
# This test is supposed to only fill in headers, so the following should fail.
# If this ever succeeds it probably means the fixture was re-created with trivial
# blocks and the test will fail and remind us what kind of fixture we want here.
with pytest.raises(BlockNotFound):
chain_with_gaps.get_canonical_block_by_number(499)
def __init__(
self,
chain: AsyncChainAPI,
db: AtomicDatabaseAPI,
chain_db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
event_bus: EndpointAPI,
metrics_registry: MetricsRegistry,
checkpoint: Checkpoint = None,
force_beam_block_number: BlockNumber = None,
enable_backfill: bool = True,
enable_state_backfill: bool = True) -> None:
self.logger = get_logger('trinity.sync.beam.chain.BeamSyncer')
self.metrics_registry = metrics_registry
self._body_for_header_exists = body_for_header_exists(chain_db, chain)
if checkpoint is None:
self._launch_strategy: SyncLaunchStrategyAPI = FromGenesisLaunchStrategy(chain_db)
else:
self._launch_strategy = FromCheckpointLaunchStrategy(
chain_db,
chain,
checkpoint,
peer_pool,
)
self._header_syncer = ETHHeaderChainSyncer(
chain,
chain_db,
peer_pool,
self._launch_strategy,
)
self._header_persister = HeaderOnlyPersist(
self._header_syncer,
chain_db,
force_beam_block_number,
self._launch_strategy,
)
self._backfiller = BeamStateBackfill(db, peer_pool)
if enable_state_backfill:
self._queen_queue: QueenTrackerAPI = self._backfiller
else:
self._queen_queue = QueeningQueue(peer_pool)
self._state_downloader = BeamDownloader(
db,
peer_pool,
self._queen_queue,
event_bus,
)
self._data_hunter = MissingDataEventHandler(
self._state_downloader,
event_bus,
self.metrics_registry,
)
self._block_importer = BeamBlockImporter(
chain,
db,
self._state_downloader,
self._backfiller,
event_bus,
self.metrics_registry,
)
self._launchpoint_header_syncer = HeaderLaunchpointSyncer(self._header_syncer)
self._body_syncer = RegularChainBodySyncer(
chain,
chain_db,
peer_pool,
self._launchpoint_header_syncer,
self._block_importer,
)
self._manual_header_syncer = ManualHeaderSyncer()
self._fast_syncer = RigorousFastChainBodySyncer(
chain,
chain_db,
peer_pool,
self._manual_header_syncer,
)
self._header_backfill = SequentialHeaderChainGapSyncer(chain, chain_db, peer_pool)
self._block_backfill = BodyChainGapSyncer(chain, chain_db, peer_pool)
self._chain = chain
self._enable_backfill = enable_backfill
self._enable_state_backfill = enable_state_backfill
async def test_header_gap_fill_detects_invalid_attempt(caplog, event_loop,
event_bus,
chaindb_with_gaps,
chaindb_1000,
chaindb_uncle):
client_context = ChainContextFactory(headerdb__db=chaindb_with_gaps.db)
server_context = ChainContextFactory(headerdb__db=chaindb_uncle.db)
peer_pair = LatestETHPeerPairFactory(
alice_peer_context=client_context,
bob_peer_context=server_context,
event_bus=event_bus,
)
async with peer_pair as (client_peer, server_peer):
client_peer_pool = MockPeerPoolWithConnectedPeers([client_peer],
event_bus=event_bus)
client = SequentialHeaderChainGapSyncer(
LatestTestChain(chaindb_with_gaps.db), chaindb_with_gaps,
client_peer_pool)
server_peer_pool = MockPeerPoolWithConnectedPeers([server_peer],
event_bus=event_bus)
uncle_chaindb = AsyncChainDB(chaindb_uncle.db)
async with run_peer_pool_event_server(
event_bus, server_peer_pool,
handler_type=ETHPeerPoolEventServer
), background_asyncio_service(
ETHRequestServer(
event_bus,
TO_NETWORKING_BROADCAST_CONFIG,
uncle_chaindb,
)):
server_peer.logger.info("%s is serving 1000 blocks", server_peer)
client_peer.logger.info("%s is syncing up 1000", client_peer)
# We check for 499 because 500 exists from the very beginning (the checkpoint)
expected_block_number = 499
final_header = chaindb_1000.get_canonical_block_header_by_number(
expected_block_number)
async with background_asyncio_service(client):
try:
await wait_for_head(
chaindb_with_gaps,
final_header,
sync_timeout=5,
)
except asyncio.TimeoutError:
assert "Attempted to fill gap with invalid header" in caplog.text
# Monkey patch the uncle chaindb to effectively make the attacker peer
# switch to the correct chain.
uncle_chaindb.db = chaindb_1000.db
# The hack goes on: Now that our attacker peer turned friendly we may be stuck
# waiting for a new skeleton peer forever. This isn't a real life scenario
# because: a.) an attacker probably won't turn friendly and b.) new blocks and
# peers will constantly yield new skeleton peers.
# This ugly hack will tick the chain tip monitor as we simulate a joining peer.
for subscriber in client_peer_pool._subscribers:
subscriber.register_peer(client_peer)
await wait_for_head(
chaindb_with_gaps,
final_header,
sync_timeout=20,
)
else:
raise AssertionError(
"Succeeded when it was expected to fail")
async def test_sequential_header_gapfill_syncer(request, event_loop, event_bus,
chaindb_with_gaps,
chaindb_1000):
client_context = ChainContextFactory(headerdb__db=chaindb_with_gaps.db)
server_context = ChainContextFactory(headerdb__db=chaindb_1000.db)
peer_pair = LatestETHPeerPairFactory(
alice_peer_context=client_context,
bob_peer_context=server_context,
event_bus=event_bus,
)
async with peer_pair as (client_peer, server_peer):
chain_with_gaps = LatestTestChain(chaindb_with_gaps.db)
client = SequentialHeaderChainGapSyncer(
chain_with_gaps, chaindb_with_gaps,
MockPeerPoolWithConnectedPeers([client_peer], event_bus=event_bus))
# Ensure we use small chunks to be able to test pause/resume properly
client._max_backfill_header_at_once = 100
server_peer_pool = MockPeerPoolWithConnectedPeers([server_peer],
event_bus=event_bus)
async with run_peer_pool_event_server(
event_bus, server_peer_pool,
handler_type=ETHPeerPoolEventServer
), background_asyncio_service(
ETHRequestServer(
event_bus,
TO_NETWORKING_BROADCAST_CONFIG,
AsyncChainDB(chaindb_1000.db),
)):
server_peer.logger.info("%s is serving 1000 blocks", server_peer)
client_peer.logger.info("%s is syncing up 1000", client_peer)
async with background_asyncio_service(client):
# We intentionally only sync up to a block *below* the first gap to have a more
# difficult scenario for pause/resume. We want to make sure we not only can pause
# at the times where we synced up to an actual gap. Instead we want to be sure
# we can pause after we synced up to the `_max_backfill_header_at_once` limit which
# may be shorter than the actual gap in the chain.
await wait_for_head(
chaindb_with_gaps,
chaindb_1000.get_canonical_block_header_by_number(100))
# Pause the syncer for a moment and check if it continued syncing (it should not!)
client.pause()
# Verify that we stopped the chain fast enough, before the gap was fully filled
# This is a potential source of test flakiness
with pytest.raises(HeaderNotFound):
chaindb_with_gaps.get_canonical_block_header_by_number(249)
await asyncio.sleep(1)
# Make sure that the gap filling doesn't complete for a while. We could
# theoretically get false positives if it's not paused but very slow to fill headers
with pytest.raises(HeaderNotFound):
chaindb_with_gaps.get_canonical_block_header_by_number(249)
# Now resume syncing
client.resume()
await wait_for_head(
# We check for 499 because 500 is there from the very beginning (the checkpoint)
chaindb_with_gaps,
chaindb_1000.get_canonical_block_header_by_number(499))
# This test is supposed to only fill in headers, so the following should fail.
# If this ever succeeds it probably means the fixture was re-created with trivial
# blocks and the test will fail and remind us what kind of fixture we want here.
with pytest.raises(BlockNotFound):
chain_with_gaps.get_canonical_block_by_number(499)