def __init__(self, peer_pool: ETHPeerPool) -> None:
self.logger = get_logger('trinity.sync.beam.queen.QueeningQueue')
self._peer_pool = peer_pool
self._knights = WaitingPeers(NodeDataV65)
self._peasants = WaitingPeers(NodeDataV65)
self._queen_updated = asyncio.Event()
self._desired_knights = 0
self._num_peers = 0
def __init__(self,
chain: BaseAsyncChain,
db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
header_syncer: HeaderSyncerAPI,
token: CancelToken = None) -> None:
super().__init__(chain, db, peer_pool, token)
# queue up any idle peers, in order of how fast they return receipts
self._receipt_peers: WaitingPeers[ETHPeer] = WaitingPeers(
commands.Receipts)
self._header_syncer = header_syncer
# Track receipt download tasks
# - arbitrarily allow several requests-worth of headers queued up
# - try to get receipts from lower block numbers first
buffer_size = MAX_RECEIPTS_FETCH * REQUEST_BUFFER_MULTIPLIER
self._receipt_tasks = TaskQueue(buffer_size,
attrgetter('block_number'))
# track when both bodies and receipts are collected, so that blocks can be persisted
self._block_persist_tracker = OrderedTaskPreparation(
BlockPersistPrereqs,
id_extractor=attrgetter('hash'),
# make sure that a block is not persisted until the parent block is persisted
dependency_extractor=attrgetter('parent_hash'),
)
# Track whether the fast chain syncer completed its goal
self.is_complete = False
def __init__(self,
chain: BaseAsyncChain,
db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
header_syncer: HeaderSyncerAPI,
token: CancelToken = None) -> None:
super().__init__(token=token)
self.chain = chain
self.db = db
self._peer_pool = peer_pool
self._pending_bodies = {}
self._header_syncer = header_syncer
# queue up any idle peers, in order of how fast they return block bodies
self._body_peers: WaitingPeers[ETHPeer] = WaitingPeers(
commands.BlockBodies)
# Track incomplete block body download tasks
# - arbitrarily allow several requests-worth of headers queued up
# - try to get bodies from lower block numbers first
buffer_size = MAX_BODIES_FETCH * REQUEST_BUFFER_MULTIPLIER
self._block_body_tasks = TaskQueue(buffer_size,
attrgetter('block_number'))
# Track if there is capacity for more block importing
self._db_buffer_capacity = asyncio.Event()
self._db_buffer_capacity.set() # start with capacity
# Track if any headers have been received yet
self._got_first_header = asyncio.Event()
def __init__(self,
chain: AsyncChainAPI,
db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
header_syncer: HeaderSyncerAPI,
token: CancelToken = None) -> None:
super().__init__(token=token)
self.chain = chain
self.db = db
self._peer_pool = peer_pool
self._pending_bodies = {}
self._header_syncer = header_syncer
# queue up any idle peers, in order of how fast they return block bodies
self._body_peers: WaitingPeers[ETHPeer] = WaitingPeers(commands.BlockBodies)
# Track incomplete block body download tasks
# - arbitrarily allow several requests-worth of headers queued up
# - try to get bodies from lower block numbers first
buffer_size = MAX_BODIES_FETCH * REQUEST_BUFFER_MULTIPLIER
self._block_body_tasks = TaskQueue(buffer_size, attrgetter('block_number'))
# Track if there is capacity for more block importing
self._db_buffer_capacity = asyncio.Event()
self._db_buffer_capacity.set() # start with capacity
# Track if any headers have been received yet
self._got_first_header = asyncio.Event()
# Keep a copy of old state roots to use when previewing transactions
# Preview needs a header's *parent's* state root. Sometimes the parent
# header isn't in the database yet, so must be looked up here.
self._block_hash_to_state_root: Dict[Hash32, Hash32] = {}
def __init__(self, chain: BaseAsyncChain, peer_pool: BaseChainPeerPool,
stitcher: HeaderStitcher, token: CancelToken) -> None:
super().__init__(token=token)
self._chain = chain
self._stitcher = stitcher
max_pending_fillers = 50
self._filler_header_tasks = TaskQueue(
max_pending_fillers,
# order by block number of the parent header
compose(attrgetter('block_number'), itemgetter(0)),
)
# queue up idle peers, ordered by speed that they return block bodies
self._waiting_peers: WaitingPeers[TChainPeer] = WaitingPeers(
BaseBlockHeaders)
self._peer_pool = peer_pool
def __init__(self, chain: AsyncChainAPI, peer_pool: BaseChainPeerPool,
stitcher: HeaderStitcher) -> None:
self.logger = get_logger('trinity.sync.common.headers.SkeletonSyncer')
self._chain = chain
self._stitcher = stitcher
max_pending_fillers = 50
self._filler_header_tasks = TaskQueue(
max_pending_fillers,
# order by block number of the parent header
compose(attrgetter('block_number'), itemgetter(0)),
)
# queue up idle peers, ordered by speed that they return block bodies
self._waiting_peers: WaitingPeers[TChainPeer] = WaitingPeers(
(ETHBlockHeaders, LESBlockHEaders), )
self._peer_pool = peer_pool
self.sync_progress: SyncProgress = None
def __init__(self,
chain: BaseAsyncChain,
db: BaseAsyncChainDB,
peer_pool: ETHPeerPool,
token: CancelToken = None) -> None:
super().__init__(token=token)
self.chain = chain
self.db = db
self._peer_pool = peer_pool
self._pending_bodies = {}
# queue up any idle peers, in order of how fast they return block bodies
self._body_peers: WaitingPeers[ETHPeer] = WaitingPeers(commands.BlockBodies)
# Track incomplete block body download tasks
# - arbitrarily allow several requests-worth of headers queued up
# - try to get bodies from lower block numbers first
buffer_size = MAX_BODIES_FETCH * REQUEST_BUFFER_MULTIPLIER
self._block_body_tasks = TaskQueue(buffer_size, attrgetter('block_number'))
def __init__(self, peer_pool: ETHPeerPool, token: CancelToken = None) -> None:
super().__init__(token=token)
self._peer_pool = peer_pool
self._waiting_peers = WaitingPeers(NodeData)
def __init__(self, peer_pool: ETHPeerPool) -> None:
self.logger = get_logger('trinity.sync.beam.queen.QueeningQueue')
self._peer_pool = peer_pool
self._waiting_peers = WaitingPeers(NodeDataV65)