def __init__(self,
chain: AsyncChainAPI,
db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
enable_backfill: bool = True,
checkpoint: Checkpoint = None) -> None:
self.logger = get_logger('trinity.sync.header.chain.HeaderChainSyncer')
self._db = db
self._checkpoint = checkpoint
self._enable_backfill = enable_backfill
self._chain = chain
self._peer_pool = peer_pool
if checkpoint is None:
self._launch_strategy: SyncLaunchStrategyAPI = FromGenesisLaunchStrategy(
db)
else:
self._launch_strategy = FromCheckpointLaunchStrategy(
db,
chain,
checkpoint,
peer_pool,
)
self._header_syncer = ETHHeaderChainSyncer(chain, db, peer_pool,
self._launch_strategy)
def __init__(self, chain, db, peer_pool, token=None) -> None:
super().__init__(token=token)
self._chain = chain
self._header_syncer = ETHHeaderChainSyncer(chain,
db,
peer_pool,
token=self.cancel_token)
self._single_header_syncer = self.HeaderSyncer_OnlyOne(
self._header_syncer)
self._paused_header_syncer = self.HeaderSyncer_PauseThenRest(
self._header_syncer)
self._draining_syncer = RegularChainBodySyncer(
chain,
db,
peer_pool,
self._single_header_syncer,
SimpleBlockImporter(chain),
self.cancel_token,
)
self._body_syncer = RegularChainBodySyncer(
chain,
db,
peer_pool,
self._paused_header_syncer,
SimpleBlockImporter(chain),
self.cancel_token,
)
async def run(self) -> None:
available_gaps, _ = self._db.get_header_chain_gaps()
if len(available_gaps):
gap = available_gaps[0]
else:
self.logger.debug("No gaps to fill. Stopping")
return
launch_block_number = BlockNumber(
max(0, gap[0] - MAX_SKELETON_REORG_DEPTH))
self.logger.info(f"Launching from %s", launch_block_number)
launch_strategy = FromBlockNumberLaunchStrategy(
self._db, launch_block_number)
gap_length = gap[1] - gap[0]
if self._max_headers and gap_length > self._max_headers:
final_block_number = BlockNumber(gap[0] + self._max_headers)
else:
final_block_number = gap[1]
self._header_syncer = ETHHeaderChainSyncer(self._chain, self._db,
self._peer_pool,
launch_strategy)
await launch_strategy.fulfill_prerequisites()
self.logger.info("Initializing gap-fill header-sync; filling gap: %s",
(gap[0], final_block_number))
self.manager.run_child_service(self._header_syncer)
self.manager.run_task(self._persist_headers, final_block_number)
# run sync until cancelled
await self.manager.wait_finished()
def __init__(self,
chain: BaseAsyncChain,
db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
token: CancelToken = None) -> None:
super().__init__(token=token)
self._header_syncer = ETHHeaderChainSyncer(chain, db, peer_pool, self.cancel_token)
self._body_syncer = RegularChainBodySyncer(
chain,
db,
peer_pool,
self._header_syncer,
self.cancel_token,
)
def __init__(self,
chain: BaseAsyncChain,
db: BaseAsyncDB,
chain_db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
event_bus: EndpointAPI,
force_beam_block_number: int = None,
token: CancelToken = None) -> None:
super().__init__(token=token)
self._header_syncer = ETHHeaderChainSyncer(chain, chain_db, peer_pool,
self.cancel_token)
self._header_persister = HeaderOnlyPersist(
self._header_syncer,
chain_db,
force_beam_block_number,
self.cancel_token,
)
self._state_downloader = BeamDownloader(db, peer_pool, event_bus,
self.cancel_token)
self._data_hunter = MissingDataEventHandler(
self._state_downloader,
event_bus,
token=self.cancel_token,
)
self._block_importer = BeamBlockImporter(chain, self._state_downloader,
event_bus)
self._checkpoint_header_syncer = HeaderCheckpointSyncer(
self._header_syncer)
self._body_syncer = RegularChainBodySyncer(
chain,
chain_db,
peer_pool,
self._checkpoint_header_syncer,
self._block_importer,
self.cancel_token,
)
self._manual_header_syncer = ManualHeaderSyncer()
self._fast_syncer = RigorousFastChainBodySyncer(
chain,
chain_db,
peer_pool,
self._manual_header_syncer,
self.cancel_token,
)
self._chain = 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
def __init__(self,
chain: AsyncChainAPI,
db: AtomicDatabaseAPI,
chain_db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
event_bus: EndpointAPI,
checkpoint: Checkpoint = None,
force_beam_block_number: BlockNumber = None,
token: CancelToken = None) -> None:
super().__init__(token=token)
if checkpoint is None:
self._launch_strategy: SyncLaunchStrategyAPI = FromGenesisLaunchStrategy(
chain_db, chain)
else:
self._launch_strategy = FromCheckpointLaunchStrategy(
chain_db,
chain,
checkpoint,
peer_pool,
)
self._header_syncer = ETHHeaderChainSyncer(chain, chain_db, peer_pool,
self._launch_strategy,
self.cancel_token)
self._header_persister = HeaderOnlyPersist(
self._header_syncer,
chain_db,
force_beam_block_number,
self._launch_strategy,
self.cancel_token,
)
self._backfiller = BeamStateBackfill(db,
peer_pool,
token=self.cancel_token)
self._state_downloader = BeamDownloader(
db,
peer_pool,
self._backfiller,
event_bus,
self.cancel_token,
)
self._data_hunter = MissingDataEventHandler(
self._state_downloader,
event_bus,
token=self.cancel_token,
)
self._block_importer = BeamBlockImporter(
chain,
db,
self._state_downloader,
self._backfiller,
event_bus,
self.cancel_token,
)
self._checkpoint_header_syncer = HeaderCheckpointSyncer(
self._header_syncer)
self._body_syncer = RegularChainBodySyncer(
chain,
chain_db,
peer_pool,
self._checkpoint_header_syncer,
self._block_importer,
self.cancel_token,
)
self._manual_header_syncer = ManualHeaderSyncer()
self._fast_syncer = RigorousFastChainBodySyncer(
chain,
chain_db,
peer_pool,
self._manual_header_syncer,
self.cancel_token,
)
self._chain = chain