async def _setup_for_next_gap(self) -> None:
gap_start, gap_end = self._get_next_gap()
fill_start = BlockNumber(max(
gap_start,
gap_end - self._max_backfill_block_bodies_at_once,
))
start_num = BlockNumber(fill_start - 1)
_starting_tip = await self._db.coro_get_canonical_block_header_by_number(start_num)
if self._pauser.is_paused:
# If the syncer was paused while we were busy setting it up throw the current setup
# away. A new setup will be performed as soon as `resume()` was called again.
raise ValidationError("Syncer was paused by the user")
async def _get_launch_header() -> BlockHeaderAPI:
return _starting_tip
self.logger.debug("Starting to sync missing blocks from #%s to #%s", fill_start, gap_end)
self._body_syncer = FastChainBodySyncer(
self._chain,
self._db,
self._peer_pool,
DatabaseBlockRangeHeaderSyncer(self._db, (fill_start, gap_end,)),
launch_header_fn=_get_launch_header,
should_skip_header_fn=body_for_header_exists(self._db, self._chain)
)
self._body_syncer.logger = self.logger
def __init__(self, chain: AsyncChainAPI, db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
header_syncer: HeaderSyncerAPI) -> None:
self._body_syncer = FastChainBodySyncer(
chain,
db,
peer_pool,
header_syncer,
launch_header_fn=self._sync_from,
should_skip_header_fn=body_for_header_exists(db, chain))
async def _setup_for_next_gap(self) -> None:
gap_start, gap_end = self._get_next_gap()
start_num = BlockNumber(gap_start - 1)
_starting_tip = await self._db.coro_get_canonical_block_header_by_number(start_num)
async def _get_launch_header() -> BlockHeaderAPI:
return _starting_tip
self.logger.debug("Starting to sync missing blocks from #%s to #%s", gap_start, gap_end)
self._body_syncer = FastChainBodySyncer(
self._chain,
self._db,
self._peer_pool,
DatabaseBlockRangeHeaderSyncer(self._db, (gap_start, gap_end,)),
launch_header_fn=_get_launch_header,
should_skip_header_fn=body_for_header_exists(self._db, self._chain)
)
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
